Prefix resolution_types with Resolution.

pkg/compiler/lib/src/serialization/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;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../constants/expressions.dart';
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../library_loader.dart' show LibraryProvider;
 import '../util/enumset.dart';
 import 'constant_serialization.dart';
 import 'element_serialization.dart';
 import 'json_serializer.dart';
 import 'keys.dart';
 import 'type_serialization.dart';
 import 'values.dart';
 
 export 'task.dart' show LibraryDeserializer;
 
 /// An object that supports the encoding an [ObjectValue] for serialization.
 ///
 /// The [ObjectEncoder] ensures that nominality and circularities of
-/// non-primitive values like [Element], [DartType] and [ConstantExpression] are
-/// handled.
+/// non-primitive values like [Element], [ResolutionDartType] and
+/// [ConstantExpression] are handled.
 class ObjectEncoder extends AbstractEncoder<Key> {
   /// Creates an [ObjectEncoder] in the scope of [serializer] that uses [map]
   /// as its internal storage.
   ObjectEncoder(Serializer serializer, Map<dynamic, Value> map)
       : super(serializer, map);
 
   String get _name => 'Object';
 }
 
 /// An object that supports the encoding a [MapValue] for serialization.
 ///
 /// The [MapEncoder] ensures that nominality and circularities of
-/// non-primitive values like [Element], [DartType] and [ConstantExpression] are
-/// handled.
+/// non-primitive values like [Element], [ResolutionDartType] and
+/// [ConstantExpression] are handled.
 class MapEncoder extends AbstractEncoder<String> {
   /// Creates an [MapEncoder] in the scope of [serializer] that uses [map]
   /// as its internal storage.
   MapEncoder(Serializer serializer, Map<String, Value> map)
       : super(serializer, map);
 
   String get _name => 'Map';
 }
 
 /// An object that supports the encoding a [ListValue] containing [ObjectValue]s
 /// or [MapValue]s.
 ///
 /// The [ListEncoder] ensures that nominality and circularities of
-/// non-primitive values like [Element], [DartType] and [ConstantExpression] are
-/// handled.
+/// non-primitive values like [Element], [ResolutionDartType] and
+/// [ConstantExpression] are handled.
 class ListEncoder {
   final Serializer _serializer;
   final List<Value> _list;
 
   /// Creates an [ListEncoder] in the scope of [_serializer] that uses [_list]
   /// as its internal storage.
   ListEncoder(this._serializer, this._list);
 
   /// Creates an [ObjectEncoder] and adds it to the encoded list.
   ObjectEncoder createObject() {
@@ skipping 77 matching lines @@
   /// If [constants] is empty, it is skipped.
   void setConstants(K key, Iterable<ConstantExpression> constants) {
     _checkKey(key);
     if (constants.isNotEmpty) {
       _map[key] = new ListValue(
           constants.map(_serializer.createConstantValue).toList());
     }
   }
 
   /// Maps the [key] entry to the [type] in the encoded object.
-  void setType(K key, DartType type) {
+  void setType(K key, ResolutionDartType type) {
     _checkKey(key);
     _map[key] = _serializer.createTypeValue(type);
   }
 
   /// Maps the [key] entry to the [types] in the encoded object.
   ///
   /// If [types] is empty, it is skipped.
-  void setTypes(K key, Iterable<DartType> types) {
+  void setTypes(K key, Iterable<ResolutionDartType> types) {
     _checkKey(key);
     if (types.isNotEmpty) {
       _map[key] =
           new ListValue(types.map(_serializer.createTypeValue).toList());
     }
   }
 
   /// Maps the [key] entry to the [uri] in the encoded object using [baseUri] to
   /// relatives the encoding.
   ///
@@ skipping 232 matching lines @@
     List list = _map[_getKeyValue(key)];
     if (list == null) {
       if (isOptional) {
         return const [];
       }
       throw new StateError("Constants value '$key' not found in $_map.");
     }
     return list.map(_deserializer.deserializeConstant).toList();
   }
 
-  /// Returns the [DartType] value associated with [key] in the decoded object.
+  /// Returns the [ResolutionDartType] value associated with [key] in the
+  /// decoded object.
   ///
   /// If no value is associated with [key], then if [isOptional] is `true`,
   /// `null` is returned, otherwise an exception is thrown.
-  DartType getType(K key, {bool isOptional: false}) {
+  ResolutionDartType getType(K key, {bool isOptional: false}) {
     int id = _map[_getKeyValue(key)];
     if (id == null) {
       if (isOptional) {
         return null;
       }
       throw new StateError("Type value '$key' not found in $_map.");
     }
     return _deserializer.deserializeType(id);
   }
 
-  /// Returns the list of [DartType] values associated with [key] in the decoded
-  /// object.
+  /// Returns the list of [ResolutionDartType] values associated with [key] in
+  /// the decoded object.
   ///
   /// If no value is associated with [key], then if [isOptional] is `true`,
   /// and empty [List] is returned, otherwise an exception is thrown.
-  List<DartType> getTypes(K key, {bool isOptional: false}) {
+  List<ResolutionDartType> getTypes(K key, {bool isOptional: false}) {
     List list = _map[_getKeyValue(key)];
     if (list == null) {
       if (isOptional) {
         return const [];
       }
       throw new StateError("Types value '$key' not found in $_map.");
     }
     return list.map(_deserializer.deserializeType).toList();
   }
 
@@ skipping 177 matching lines @@
   Map<Key, Value> get map => objectValue.map;
 }
 
 /// Function used to filter which element serialized.
 typedef bool ElementMatcher(Element element);
 
 bool includeAllElements(Element element) => true;
 
 /// Serializer for the transitive closure of a collection of libraries.
 ///
-/// The serializer creates an [ObjectValue] model of the [Element], [DartType]
-/// and [ConstantExpression] values in the transitive closure of the serialized
-/// libraries.
+/// The serializer creates an [ObjectValue] model of the [Element],
+/// [ResolutionDartType] and [ConstantExpression] values in the transitive
+/// closure of the serialized libraries.
 ///
 /// The model layout of the produced [objectValue] is:
 ///
 ///     { // Header object
 ///       Key.ELEMENTS: [
 ///         {...}, // [ObjectValue] of the 0th [Element].
 ///         ...
 ///         {...}, // [ObjectValue] of the n-th [Element].
 ///       ],
 ///       Key.TYPES: [
 ///         {...}, // [ObjectValue] of the 0th [DartType].
 ///         ...
 ///         {...}, // [ObjectValue] of the n-th [DartType].
 ///       ],
 ///       Key.CONSTANTS: [
 ///         {...}, // [ObjectValue] of the 0th [ConstantExpression].
 ///         ...
 ///         {...}, // [ObjectValue] of the n-th [ConstantExpression].
 ///       ],
 ///     }
 ///
 // TODO(johnniwinther): Support dependencies between serialized subcomponent.
 class Serializer {
   List<SerializerPlugin> plugins = <SerializerPlugin>[];
 
   Map<Uri, dynamic> _dependencyMap = <Uri, dynamic>{};
   Map<Element, DataObject> _elementMap = <Element, DataObject>{};
   Map<ConstantExpression, DataObject> _constantMap =
       <ConstantExpression, DataObject>{};
-  Map<DartType, DataObject> _typeMap = <DartType, DataObject>{};
+  Map<ResolutionDartType, DataObject> _typeMap =
+      <ResolutionDartType, DataObject>{};
   List _pendingList = [];
   ElementMatcher shouldInclude;
 
   // TODO(johnniwinther): Replace [includeElement] with a general strategy.
   Serializer({this.shouldInclude: includeAllElements});
 
   /// Add the transitive closure of [library] to this serializer.
   void serialize(LibraryElement library) {
     // Call [_getElementId] for its side-effect: To create a
     // [DataObject] for [library]. If not already created, this will
@@ skipping 165 matching lines @@
   /// queue of this serializer.
   ConstantValue createConstantValue(ConstantExpression constant) {
     return new ConstantValue(constant, _getConstantId(constant));
   }
 
   /// Returns the id [Value] for [type].
   ///
   /// If [type] has no [DataObject], a new [DataObject] is created and
   /// encoding the [ObjectValue] for [type] is put into the work queue of this
   /// serializer.
-  Value _getTypeId(DartType type) {
+  Value _getTypeId(ResolutionDartType type) {
     DataObject dataObject = _typeMap[type];
     if (dataObject == null) {
       _typeMap[type] = dataObject = new DataObject(
           new IntValue(_typeMap.length), new EnumValue(type.kind));
       // Delay the serialization of the type itself to avoid loops, and to keep
       // the call stack small.
       _pendingList.add(() => _encodeType(type, dataObject));
     }
     return dataObject.id;
   }
 
   /// Encodes [type] into the [ObjectValue] of [dataObject].
-  void _encodeType(DartType type, DataObject dataObject) {
+  void _encodeType(ResolutionDartType type, DataObject dataObject) {
     const TypeSerializer().visit(type, new ObjectEncoder(this, dataObject.map));
   }
 
   /// Creates the [TypeValue] for [type].
   ///
   /// If [type] has not already been serialized, it is added to the work
   /// queue of this serializer.
-  TypeValue createTypeValue(DartType type) {
+  TypeValue createTypeValue(ResolutionDartType type) {
     return new TypeValue(type, _getTypeId(type));
   }
 
   ObjectValue get objectValue {
     _emptyWorklist();
 
     Map<Key, Value> map = <Key, Value>{};
     map[Key.ELEMENTS] =
         new ListValue(_elementMap.values.map((l) => l.objectValue).toList());
     if (_typeMap.isNotEmpty) {
@@ skipping 92 matching lines @@
 // between deserialized subcomponent.
 class Deserializer {
   final DeserializationContext context;
   final SerializationDecoder decoder;
   final Uri sourceUri;
   ObjectDecoder _headerObject;
   ListDecoder _elementList;
   ListDecoder _typeList;
   ListDecoder _constantList;
   Map<int, Element> _elementMap = {};
-  Map<int, DartType> _typeMap = {};
+  Map<int, ResolutionDartType> _typeMap = {};
   Map<int, ConstantExpression> _constantMap = {};
 
   Deserializer.fromText(
       this.context, this.sourceUri, String text, this.decoder) {
     _headerObject = new ObjectDecoder(this, decoder.decode(text));
   }
 
   /// Returns the [ListDecoder] for the [Element]s in this deserializer.
   ListDecoder get elements {
     if (_elementList == null) {
       _elementList = _headerObject.getList(Key.ELEMENTS);
     }
     return _elementList;
   }
 
-  /// Returns the [ListDecoder] for the [DartType]s in this deserializer.
+  /// Returns the [ListDecoder] for the [ResolutionDartType]s in this
+  /// deserializer.
   ListDecoder get types {
     if (_typeList == null) {
       _typeList = _headerObject.getList(Key.TYPES);
     }
     return _typeList;
   }
 
   /// Returns the [ListDecoder] for the [ConstantExpression]s in this
   /// deserializer.
   ListDecoder get constants {
@@ skipping 86 matching lines @@
       // Call plugins even when there is no data, so they can take action in
       // this case.
       for (DeserializerPlugin plugin in context.plugins) {
         plugin.onElement(element,
             (String tag) => pluginData?.getObject(tag, isOptional: true));
       }
     }
     return element;
   }
 
-  /// Returns the deserialized [DartType] for [id].
-  DartType deserializeType(int id) {
+  /// Returns the deserialized [ResolutionDartType] for [id].
+  ResolutionDartType deserializeType(int id) {
     if (id == null) throw new ArgumentError('Deserializer.getType(null)');
     return _typeMap.putIfAbsent(id, () {
       return TypeDeserializer.deserialize(types.getObject(id));
     });
   }
 
   /// Returns the deserialized [ConstantExpression] for [id].
   ConstantExpression deserializeConstant(int id) {
     if (id == null) throw new ArgumentError('Deserializer.getConstant(null)');
     return _constantMap.putIfAbsent(id, () {
@@ skipping 17 matching lines @@
 
   /// Returns the value used to store [key] as a property in the encoding an
   /// [ObjectValue].
   ///
   /// Different encodings have different restrictions and capabilities as how
   /// to store a [Key] value. For instance: A JSON encoding needs to convert
   /// [Key] to a [String] to store it in a JSON object; a Dart encoding can
   /// choose to store a [Key] as an [int] or as the [Key] itself.
   getObjectPropertyValue(Key key);
 }