dartfmt pkg/compiler

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 '../elements/elements.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 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.
 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);
+      : 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.
 class MapEncoder extends AbstractEncoder<String> {
@@ skipping 49 matching lines @@
       throw new StateError("$_name value '$key' already in $_map.");
     }
   }
 
   /// Maps the [key] entry to the [value] in the encoded object.
   void setValue(K key, Value value) {
     _checkKey(key);
     _map[key] = value;
   }
 
-
   /// Maps the [key] entry to the enum [value] in the encoded object.
   void setEnum(K key, var value) {
     _checkKey(key);
     _map[key] = new EnumValue(value);
   }
 
   /// Maps the [key] entry to the set of enum [values] in the encoded object.
   void setEnums(K key, Iterable values) {
     setEnumSet(key, new EnumSet.fromValues(values));
   }
 
   /// Maps the [key] entry to the enum [set] in the encoded object.
   void setEnumSet(K key, EnumSet set) {
     _checkKey(key);
     _map[key] = new IntValue(set.value);
   }
 
   /// Maps the [key] entry to the [element] in the encoded object.
   void setElement(K key, Element element) {
     _checkKey(key);
     _map[key] = _serializer.createElementValue(element);
   }
 
   /// Maps the [key] entry to the [elements] in the encoded object.
   ///
   /// If [elements] is empty, it is skipped.
   void setElements(K key, Iterable<Element> elements) {
     _checkKey(key);
     if (elements.isNotEmpty) {
-      _map[key] = new ListValue(
-          elements.map(_serializer.createElementValue).toList());
+      _map[key] =
+          new ListValue(elements.map(_serializer.createElementValue).toList());
     }
   }
 
   /// Maps the [key] entry to the [constant] in the encoded object.
   void setConstant(K key, ConstantExpression constant) {
     _checkKey(key);
     _map[key] = _serializer.createConstantValue(constant);
   }
 
   /// Maps the [key] entry to the [constants] in the encoded object.
@@ skipping 103 matching lines @@
   }
 
   String toString() => _map.toString();
 }
 
 /// [ObjectDecoder] reads serialized values from a [Map] encoded from an
 /// [ObjectValue] where properties are stored using [Key] values as keys.
 class ObjectDecoder extends AbstractDecoder<Key> {
   /// Creates an [ObjectDecoder] that decodes [map] into deserialized values
   /// using [deserializer] to create canonicalized values.
-  ObjectDecoder(Deserializer deserializer, Map map)
-      : super(deserializer, map);
+  ObjectDecoder(Deserializer deserializer, Map map) : super(deserializer, map);
 
   @override
   _getKeyValue(Key key) => _deserializer.decoder.getObjectPropertyValue(key);
 }
 
 /// [MapDecoder] reads serialized values from a [Map] encoded from an
 /// [MapValue] where entries are stored using [String] values as keys.
 class MapDecoder extends AbstractDecoder<String> {
   /// Creates an [MapDecoder] that decodes [map] into deserialized values
   /// using [deserializer] to create canonicalized values.
@@ skipping 421 matching lines @@
     if (dataObject == null) {
       if (!shouldInclude(element)) {
         if (element.isLibrary) {
           LibraryElement library = element;
           _elementMap[element] = dataObject = new DataObject(
               new IntValue(_elementMap.length),
               new EnumValue(SerializedElementKind.EXTERNAL_LIBRARY));
           ObjectEncoder encoder = new ObjectEncoder(this, dataObject.map);
           encoder.setUri(Key.URI, library.canonicalUri, library.canonicalUri);
         } else if (element.isStatic) {
-          Value classId =_getElementId(element.enclosingClass);
+          Value classId = _getElementId(element.enclosingClass);
           _elementMap[element] = dataObject = new DataObject(
               new IntValue(_elementMap.length),
               new EnumValue(SerializedElementKind.EXTERNAL_STATIC_MEMBER));
           ObjectEncoder encoder = new ObjectEncoder(this, dataObject.map);
           encoder.setValue(Key.CLASS, classId);
           encoder.setString(Key.NAME, element.name);
         } else if (element.isConstructor) {
-          Value classId =_getElementId(element.enclosingClass);
+          Value classId = _getElementId(element.enclosingClass);
           _elementMap[element] = dataObject = new DataObject(
               new IntValue(_elementMap.length),
               new EnumValue(SerializedElementKind.EXTERNAL_CONSTRUCTOR));
           ObjectEncoder encoder = new ObjectEncoder(this, dataObject.map);
           encoder.setValue(Key.CLASS, classId);
           encoder.setString(Key.NAME, element.name);
         } else {
-          Value libraryId =_getElementId(element.library);
+          Value libraryId = _getElementId(element.library);
           _elementMap[element] = dataObject = new DataObject(
               new IntValue(_elementMap.length),
               new EnumValue(SerializedElementKind.EXTERNAL_LIBRARY_MEMBER));
           ObjectEncoder encoder = new ObjectEncoder(this, dataObject.map);
           encoder.setValue(Key.LIBRARY, libraryId);
           encoder.setString(Key.NAME, element.name);
         }
       } else {
         // Run through [ELEMENT_SERIALIZERS] sequentially to find the one that
         // deals with [element].
@@ skipping 48 matching lines @@
           new IntValue(_constantMap.length), new EnumValue(constant.kind));
       // Delay the serialization of the constant itself to avoid loops, and to
       // keep the call stack small.
       _pendingList.add(() => _encodeConstant(constant, dataObject));
       return dataObject;
     }).id;
   }
 
   /// Encodes [constant] into the [ObjectValue] of [dataObject].
   void _encodeConstant(ConstantExpression constant, DataObject dataObject) {
-    const ConstantSerializer().visit(constant,
-        new ObjectEncoder(this, dataObject.map));
+    const ConstantSerializer()
+        .visit(constant, new ObjectEncoder(this, dataObject.map));
   }
 
   /// Creates the [ConstantValue] for [constant].
   ///
   /// If [constant] has not already been serialized, it is added to the work
   /// queue of this serializer.
   ConstantValue createConstantValue(ConstantExpression constant) {
     return new ConstantValue(constant, _getConstantId(constant));
   }
 
@@ skipping 195 matching lines @@
       } else {
         element = ElementDeserializer.deserialize(decoder, elementKind);
       }
       _elementMap[id] = element;
 
       MapDecoder pluginData = decoder.getMap(Key.DATA, isOptional: true);
       // Call plugins even when there is no data, so they can take action in
       // this case.
       for (DeserializerPlugin plugin in plugins) {
         plugin.onElement(element,
-          (String tag) => pluginData?.getObject(tag, isOptional: true));
+            (String tag) => pluginData?.getObject(tag, isOptional: true));
       }
     }
     return element;
   }
 
   /// Returns the deserialized [DartType] for [id].
   DartType deserializeType(int id) {
     if (id == null) throw new ArgumentError('Deserializer.getType(null)');
     return _typeMap.putIfAbsent(id, () {
       return TypeDeserializer.deserialize(types.getObject(id));
@@ skipping 24 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);
 }