Prefix resolution_types with Resolution.

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

 // Copyright (c) 2015, 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.serialization.elements;
 
 import '../common.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../elements/resolution_types.dart';
@@ skipping 53 matching lines @@
   EXTERNAL_LIBRARY,
   EXTERNAL_LIBRARY_MEMBER,
   EXTERNAL_CLASS_MEMBER,
   EXTERNAL_CONSTRUCTOR,
 }
 
 /// Set of serializers used to serialize different kinds of elements by
 /// encoding into them into [ObjectEncoder]s.
 ///
 /// This class is called from the [Serializer] when an [Element] needs
-/// serialization. The [ObjectEncoder] ensures that any [Element], [DartType],
-/// and [ConstantExpression] that the serialized [Element] depends upon are also
-/// serialized.
+/// serialization. The [ObjectEncoder] ensures that any [Element],
+/// [ResolutionDartType], and [ConstantExpression] that the serialized [Element]
+/// depends upon are also serialized.
 const List<ElementSerializer> ELEMENT_SERIALIZERS = const [
   const ErrorSerializer(),
   const LibrarySerializer(),
   const CompilationUnitSerializer(),
   const PrefixSerializer(),
   const DeferredLoadLibrarySerializer(),
   const ClassSerializer(),
   const ConstructorSerializer(),
   const FieldSerializer(),
   const FunctionSerializer(),
@@ skipping 85 matching lines @@
       }
     } else {
       encoder.setElement(Key.LIBRARY, element.library);
       encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
     }
   }
 
   /// Serialize the parameters of [element] into [encoder].
   static void serializeParameters(
       FunctionElement element, ObjectEncoder encoder) {
-    FunctionType type = element.type;
+    ResolutionFunctionType type = element.type;
     encoder.setType(Key.RETURN_TYPE, type.returnType);
     encoder.setElements(Key.PARAMETERS, element.parameters);
   }
 
   /// Returns a function that adds the underlying declared elements for a
   /// particular element into [set].
   ///
   /// For instance, for an [AbstractFieldElement] the getter and setter elements
   /// are added, if available.
   static flattenElements(Set<Element> set) {
@@ skipping 220 matching lines @@
     encoder.setBool(Key.IS_ABSTRACT, element.isAbstract);
     SerializerUtil.serializeMembers(getMembers(element), encoder);
     encoder.setBool(Key.IS_PROXY, element.isProxy);
     encoder.setBool(Key.IS_INJECTED, element.isInjected);
     if (kind == SerializedElementKind.ENUM) {
       EnumClassElement enumClass = element;
       encoder.setElements(Key.FIELDS, enumClass.enumValues);
     }
     if (element.isObject) return;
 
-    List<InterfaceType> mixins = <InterfaceType>[];
+    List<ResolutionInterfaceType> mixins = <ResolutionInterfaceType>[];
     ClassElement superclass = element.superclass;
     while (superclass.isUnnamedMixinApplication) {
       MixinApplicationElement mixinElement = superclass;
       mixins.add(element.thisType.asInstanceOf(mixinElement.mixin));
       superclass = mixinElement.superclass;
     }
     mixins = mixins.reversed.toList();
-    InterfaceType supertype = element.thisType.asInstanceOf(superclass);
+    ResolutionInterfaceType supertype =
+        element.thisType.asInstanceOf(superclass);
 
     encoder.setType(Key.SUPERTYPE, supertype);
     encoder.setTypes(Key.MIXINS, mixins);
     encoder.setTypes(Key.INTERFACES, element.interfaces.toList());
-    FunctionType callType = element.declaration.callType;
+    ResolutionFunctionType callType = element.declaration.callType;
     if (callType != null) {
       encoder.setType(Key.CALL_TYPE, element.callType);
     }
 
     if (element.isMixinApplication) {
       MixinApplicationElement mixinElement = element;
       encoder.setType(Key.MIXIN, mixinElement.mixinType);
     }
   }
 }
@@ skipping 394 matching lines @@
 }
 
 /// Utility class for deserializing [Element]s.
 ///
 /// This is used by the [Deserializer].
 class ElementDeserializer {
   /// Deserializes an [Element] from an [ObjectDecoder].
   ///
   /// The class is called from the [Deserializer] when an [Element]
   /// needs deserialization. The [ObjectDecoder] ensures that any [Element],
-  /// [DartType], and [ConstantExpression] that the deserialized [Element]
-  /// depends upon are available.
+  /// [ResolutionDartType], and [ConstantExpression] that the deserialized
+  /// [Element] depends upon are available.
   static Element deserialize(
       ObjectDecoder decoder, SerializedElementKind elementKind) {
     switch (elementKind) {
       case SerializedElementKind.ERROR:
         Element enclosing = decoder.getElement(Key.ENCLOSING);
         String name = decoder.getString(Key.NAME);
         MessageKind messageKind =
             decoder.getEnum(Key.MESSAGE_KIND, MessageKind.values);
         Map<String, String> arguments =
             deserializeMessageArguments(decoder, Key.ARGUMENTS);
@@ skipping 86 matching lines @@
             enclosingElement, existingElement, newElement);
       case SerializedElementKind.EXTERNAL_LIBRARY:
       case SerializedElementKind.EXTERNAL_LIBRARY_MEMBER:
       case SerializedElementKind.EXTERNAL_CLASS_MEMBER:
       case SerializedElementKind.EXTERNAL_CONSTRUCTOR:
         break;
     }
     throw new UnsupportedError("Unexpected element kind '${elementKind}.");
   }
 }