Prefix resolution_types with Resolution.

pkg/compiler/lib/src/serialization/equivalence.dart

 // Copyright (c) 2016, 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.
 
 /// Functions for asserting equivalence across serialization.
 
 library dart2js.serialization.equivalence;
 
 import '../closure.dart';
 import '../common/resolution.dart';
@@ skipping 79 matching lines @@
 }
 
 /// Returns `true` if elements [a] and [b] are equivalent.
 bool areElementsEquivalent(Element a, Element b) {
   if (identical(a, b)) return true;
   if (a == null || b == null) return false;
   return const ElementIdentityEquivalence().visit(a, b);
 }
 
 /// Returns `true` if types [a] and [b] are equivalent.
-bool areTypesEquivalent(DartType a, DartType b) {
+bool areTypesEquivalent(ResolutionDartType a, ResolutionDartType b) {
   if (identical(a, b)) return true;
   if (a == null || b == null) return false;
   return const TypeEquivalence().visit(a, b);
 }
 
 /// Returns `true` if constants [exp1] and [exp2] are equivalent.
 bool areConstantsEquivalent(ConstantExpression exp1, ConstantExpression exp2) {
   if (identical(exp1, exp2)) return true;
   if (exp1 == null || exp2 == null) return false;
   return const ConstantEquivalence().visit(exp1, exp2);
 }
 
 /// Returns `true` if constant values [value1] and [value2] are equivalent.
 bool areConstantValuesEquivalent(ConstantValue value1, ConstantValue value2) {
   if (identical(value1, value2)) return true;
   if (value1 == null || value2 == null) return false;
   return const ConstantValueEquivalence().visit(value1, value2);
 }
 
 /// Returns `true` if the lists of elements, [a] and [b], are equivalent.
 bool areElementListsEquivalent(List<Element> a, List<Element> b) {
   return areListsEquivalent(a, b, areElementsEquivalent);
 }
 
 /// Returns `true` if the lists of types, [a] and [b], are equivalent.
-bool areTypeListsEquivalent(List<DartType> a, List<DartType> b) {
+bool areTypeListsEquivalent(
+    List<ResolutionDartType> a, List<ResolutionDartType> b) {
   return areListsEquivalent(a, b, areTypesEquivalent);
 }
 
 /// Returns `true` if the lists of constants, [a] and [b], are equivalent.
 bool areConstantListsEquivalent(
     List<ConstantExpression> a, List<ConstantExpression> b) {
   return areListsEquivalent(a, b, areConstantsEquivalent);
 }
 
 /// Returns `true` if the lists of constant values, [a] and [b], are equivalent.
@@ skipping 215 matching lines @@
       bool valueEquivalence(a, b) = equality]) {
     return areMapsEquivalent(map1, map2, keyEquivalence, valueEquivalence);
   }
 
   bool testElements(Object object1, Object object2, String property,
       Element element1, Element element2) {
     return areElementsEquivalent(element1, element2);
   }
 
   bool testTypes(Object object1, Object object2, String property,
-      DartType type1, DartType type2) {
+      ResolutionDartType type1, ResolutionDartType type2) {
     return areTypesEquivalent(type1, type2);
   }
 
   bool testConstants(Object object1, Object object2, String property,
       ConstantExpression exp1, ConstantExpression exp2) {
     return areConstantsEquivalent(exp1, exp2);
   }
 
   bool testConstantValues(Object object1, Object object2, String property,
       ConstantValue value1, ConstantValue value2) {
     return areConstantValuesEquivalent(value1, value2);
   }
 
   bool testTypeLists(Object object1, Object object2, String property,
-      List<DartType> list1, List<DartType> list2) {
+      List<ResolutionDartType> list1, List<ResolutionDartType> list2) {
     return areTypeListsEquivalent(list1, list2);
   }
 
   bool testConstantLists(Object object1, Object object2, String property,
       List<ConstantExpression> list1, List<ConstantExpression> list2) {
     return areConstantListsEquivalent(list1, list2);
   }
 
   bool testConstantValueLists(Object object1, Object object2, String property,
       List<ConstantValue> list1, List<ConstantValue> list2) {
@@ skipping 197 matching lines @@
   }
 
   @override
   bool visitWarnOnUseElement(
       WarnOnUseElement element1, WarnOnUseElement element2) {
     return strategy.testElements(element1, element2, 'wrappedElement',
         element1.wrappedElement, element2.wrappedElement);
   }
 }
 
-/// Visitor that checks for equivalence of [DartType]s.
-class TypeEquivalence implements DartTypeVisitor<bool, DartType> {
+/// Visitor that checks for equivalence of [ResolutionDartType]s.
+class TypeEquivalence implements DartTypeVisitor<bool, ResolutionDartType> {
   final TestStrategy strategy;
 
   const TypeEquivalence([this.strategy = const TestStrategy()]);
 
-  bool visit(DartType type1, DartType type2) {
+  bool visit(ResolutionDartType type1, ResolutionDartType type2) {
     return strategy.test(type1, type2, 'kind', type1.kind, type2.kind) &&
         type1.accept(this, type2);
   }
 
   @override
-  bool visitDynamicType(DynamicType type, DynamicType other) => true;
+  bool visitDynamicType(
+          ResolutionDynamicType type, ResolutionDynamicType other) =>
+      true;
 
   @override
-  bool visitFunctionType(FunctionType type, FunctionType other) {
+  bool visitFunctionType(
+      ResolutionFunctionType type, ResolutionFunctionType other) {
     return strategy.testTypeLists(type, other, 'parameterTypes',
             type.parameterTypes, other.parameterTypes) &&
         strategy.testTypeLists(type, other, 'optionalParameterTypes',
             type.optionalParameterTypes, other.optionalParameterTypes) &&
         strategy.testTypeLists(type, other, 'namedParameterTypes',
             type.namedParameterTypes, other.namedParameterTypes) &&
         strategy.testLists(type, other, 'namedParameters', type.namedParameters,
             other.namedParameters);
   }
 
   bool visitGenericType(GenericType type, GenericType other) {
     return strategy.testElements(
             type, other, 'element', type.element, other.element) &&
         strategy.testTypeLists(type, other, 'typeArguments', type.typeArguments,
             other.typeArguments);
   }
 
   @override
   bool visitMalformedType(MalformedType type, MalformedType other) => true;
 
   @override
-  bool visitTypeVariableType(TypeVariableType type, TypeVariableType other) {
+  bool visitTypeVariableType(
+      ResolutionTypeVariableType type, ResolutionTypeVariableType other) {
     return strategy.testElements(
             type, other, 'element', type.element, other.element) &&
         strategy.test(type, other, 'is MethodTypeVariableType',
             type is MethodTypeVariableType, other is MethodTypeVariableType);
   }
 
   @override
-  bool visitVoidType(VoidType type, VoidType argument) => true;
+  bool visitVoidType(ResolutionVoidType type, ResolutionVoidType argument) =>
+      true;
 
   @override
-  bool visitInterfaceType(InterfaceType type, InterfaceType other) {
+  bool visitInterfaceType(
+      ResolutionInterfaceType type, ResolutionInterfaceType other) {
     return visitGenericType(type, other);
   }
 
   @override
-  bool visitTypedefType(TypedefType type, TypedefType other) {
+  bool visitTypedefType(
+      ResolutionTypedefType type, ResolutionTypedefType other) {
     return visitGenericType(type, other);
   }
 }
 
 /// Visitor that checks for structural equivalence of [ConstantExpression]s.
 class ConstantEquivalence
     implements ConstantExpressionVisitor<bool, ConstantExpression> {
   final TestStrategy strategy;
 
   const ConstantEquivalence([this.strategy = const TestStrategy()]);
@@ skipping 1370 matching lines @@
 }
 
 bool areMetadataAnnotationsEquivalent(
     MetadataAnnotation metadata1, MetadataAnnotation metadata2) {
   if (metadata1 == metadata2) return true;
   if (metadata1 == null || metadata2 == null) return false;
   return areElementsEquivalent(
           metadata1.annotatedElement, metadata2.annotatedElement) &&
       areConstantsEquivalent(metadata1.constant, metadata2.constant);
 }