dartfmt pkg/compiler

pkg/compiler/lib/src/serialization/constant_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.constants;
 
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
-import '../elements/elements.dart' show
-    FieldElement;
+import '../elements/elements.dart' show FieldElement;
 import '../resolution/operators.dart';
-import '../universe/call_structure.dart' show
-    CallStructure;
+import '../universe/call_structure.dart' show CallStructure;
 import 'serialization.dart';
 import 'keys.dart';
 
 /// Visitor that serializes a [ConstantExpression] by encoding it into an
 /// [ObjectEncoder].
 ///
 /// This class is called from the [Serializer] when a [ConstantExpression] needs
 /// serialization. The [ObjectEncoder] ensures that any [Element], [DartType],
 /// and other [ConstantExpression] that the serialized [ConstantExpression]
 /// depends upon are also serialized.
 class ConstantSerializer
     extends ConstantExpressionVisitor<dynamic, ObjectEncoder> {
   const ConstantSerializer();
 
   @override
-  void visitBinary(BinaryConstantExpression exp,
-                   ObjectEncoder encoder) {
+  void visitBinary(BinaryConstantExpression exp, ObjectEncoder encoder) {
     encoder.setEnum(Key.OPERATOR, exp.operator.kind);
     encoder.setConstant(Key.LEFT, exp.left);
     encoder.setConstant(Key.RIGHT, exp.right);
   }
 
   @override
-  void visitConcatenate(ConcatenateConstantExpression exp,
-                        ObjectEncoder encoder) {
+  void visitConcatenate(
+      ConcatenateConstantExpression exp, ObjectEncoder encoder) {
     encoder.setConstants(Key.ARGUMENTS, exp.expressions);
   }
 
   @override
-  void visitConditional(ConditionalConstantExpression exp,
-                        ObjectEncoder encoder) {
+  void visitConditional(
+      ConditionalConstantExpression exp, ObjectEncoder encoder) {
     encoder.setConstant(Key.CONDITION, exp.condition);
     encoder.setConstant(Key.TRUE, exp.trueExp);
     encoder.setConstant(Key.FALSE, exp.falseExp);
   }
 
   @override
-  void visitConstructed(ConstructedConstantExpression exp,
-                        ObjectEncoder encoder) {
+  void visitConstructed(
+      ConstructedConstantExpression exp, ObjectEncoder encoder) {
     encoder.setElement(Key.ELEMENT, exp.target);
     encoder.setType(Key.TYPE, exp.type);
     encoder.setStrings(Key.NAMES, exp.callStructure.namedArguments);
     encoder.setConstants(Key.ARGUMENTS, exp.arguments);
   }
 
   @override
-  void visitFunction(FunctionConstantExpression exp,
-                     ObjectEncoder encoder) {
+  void visitFunction(FunctionConstantExpression exp, ObjectEncoder encoder) {
     encoder.setElement(Key.ELEMENT, exp.element);
   }
 
   @override
-  void visitIdentical(IdenticalConstantExpression exp,
-                      ObjectEncoder encoder) {
+  void visitIdentical(IdenticalConstantExpression exp, ObjectEncoder encoder) {
     encoder.setConstant(Key.LEFT, exp.left);
     encoder.setConstant(Key.RIGHT, exp.right);
   }
 
   @override
   void visitList(ListConstantExpression exp, ObjectEncoder encoder) {
     encoder.setType(Key.TYPE, exp.type);
     encoder.setConstants(Key.VALUES, exp.values);
   }
 
@@ skipping 23 matching lines @@
   void visitString(StringConstantExpression exp, ObjectEncoder encoder) {
     encoder.setString(Key.VALUE, exp.primitiveValue);
   }
 
   @override
   void visitNull(NullConstantExpression exp, ObjectEncoder encoder) {
     // No additional data needed.
   }
 
   @override
-  void visitSymbol(SymbolConstantExpression exp,
-                   ObjectEncoder encoder) {
+  void visitSymbol(SymbolConstantExpression exp, ObjectEncoder encoder) {
     throw new UnsupportedError(
         "ConstantSerializer.visitSymbol: ${exp.getText()}");
   }
 
   @override
-  void visitType(TypeConstantExpression exp,
-                 ObjectEncoder encoder) {
+  void visitType(TypeConstantExpression exp, ObjectEncoder encoder) {
     encoder.setType(Key.TYPE, exp.type);
   }
 
   @override
-  void visitUnary(UnaryConstantExpression exp,
-                  ObjectEncoder encoder) {
+  void visitUnary(UnaryConstantExpression exp, ObjectEncoder encoder) {
     encoder.setEnum(Key.OPERATOR, exp.operator.kind);
     encoder.setConstant(Key.EXPRESSION, exp.expression);
   }
 
   @override
-  void visitVariable(VariableConstantExpression exp,
-                     ObjectEncoder encoder) {
+  void visitVariable(VariableConstantExpression exp, ObjectEncoder encoder) {
     encoder.setElement(Key.ELEMENT, exp.element);
   }
 
   @override
-  void visitPositional(PositionalArgumentReference exp,
-                       ObjectEncoder encoder) {
+  void visitPositional(PositionalArgumentReference exp, ObjectEncoder encoder) {
     encoder.setInt(Key.INDEX, exp.index);
   }
 
   @override
   void visitNamed(NamedArgumentReference exp, ObjectEncoder encoder) {
     encoder.setString(Key.NAME, exp.name);
   }
 
   @override
-  void visitBoolFromEnvironment(BoolFromEnvironmentConstantExpression exp,
-                                ObjectEncoder encoder) {
+  void visitBoolFromEnvironment(
+      BoolFromEnvironmentConstantExpression exp, ObjectEncoder encoder) {
     encoder.setConstant(Key.NAME, exp.name);
     if (exp.defaultValue != null) {
       encoder.setConstant(Key.DEFAULT, exp.defaultValue);
     }
   }
 
   @override
-  void visitIntFromEnvironment(IntFromEnvironmentConstantExpression exp,
-                               ObjectEncoder encoder) {
+  void visitIntFromEnvironment(
+      IntFromEnvironmentConstantExpression exp, ObjectEncoder encoder) {
     encoder.setConstant(Key.NAME, exp.name);
     if (exp.defaultValue != null) {
       encoder.setConstant(Key.DEFAULT, exp.defaultValue);
     }
   }
 
   @override
-  void visitStringFromEnvironment(StringFromEnvironmentConstantExpression exp,
-                                  ObjectEncoder encoder) {
+  void visitStringFromEnvironment(
+      StringFromEnvironmentConstantExpression exp, ObjectEncoder encoder) {
     encoder.setConstant(Key.NAME, exp.name);
     if (exp.defaultValue != null) {
       encoder.setConstant(Key.DEFAULT, exp.defaultValue);
     }
   }
 
   @override
-  void visitStringLength(StringLengthConstantExpression exp,
-                         ObjectEncoder encoder) {
+  void visitStringLength(
+      StringLengthConstantExpression exp, ObjectEncoder encoder) {
     encoder.setConstant(Key.EXPRESSION, exp.expression);
   }
 
-
   @override
-  void visitDeferred(DeferredConstantExpression exp,
-                     ObjectEncoder encoder) {
+  void visitDeferred(DeferredConstantExpression exp, ObjectEncoder encoder) {
     throw new UnsupportedError(
         "ConstantSerializer.visitDeferred: ${exp.getText()}");
   }
 }
 
 /// Utility class for deserializing [ConstantExpression]s.
 ///
 /// This is used by the [Deserializer].
 class ConstantDeserializer {
-
   /// Deserializes a [ConstantExpression] from an [ObjectDecoder].
   ///
   /// The class is called from the [Deserializer] when a [ConstantExpression]
   /// needs deserialization. The [ObjectDecoder] ensures that any [Element],
   /// [DartType], and other [ConstantExpression] that the deserialized
   /// [ConstantExpression] depends upon are available.
   static ConstantExpression deserialize(ObjectDecoder decoder) {
     ConstantExpressionKind kind =
         decoder.getEnum(Key.KIND, ConstantExpressionKind.values);
     switch (kind) {
       case ConstantExpressionKind.BINARY:
-        BinaryOperator operator = BinaryOperator.fromKind(decoder.getEnum(
-            Key.OPERATOR, BinaryOperatorKind.values));
-        return new BinaryConstantExpression(
-            decoder.getConstant(Key.LEFT),
-            operator,
-            decoder.getConstant(Key.RIGHT));
+        BinaryOperator operator = BinaryOperator
+            .fromKind(decoder.getEnum(Key.OPERATOR, BinaryOperatorKind.values));
+        return new BinaryConstantExpression(decoder.getConstant(Key.LEFT),
+            operator, decoder.getConstant(Key.RIGHT));
       case ConstantExpressionKind.BOOL:
-        return new BoolConstantExpression(
-            decoder.getBool(Key.VALUE));
+        return new BoolConstantExpression(decoder.getBool(Key.VALUE));
       case ConstantExpressionKind.BOOL_FROM_ENVIRONMENT:
         return new BoolFromEnvironmentConstantExpression(
             decoder.getConstant(Key.NAME),
             decoder.getConstant(Key.DEFAULT, isOptional: true));
       case ConstantExpressionKind.CONCATENATE:
         return new ConcatenateConstantExpression(
             decoder.getConstants(Key.ARGUMENTS));
       case ConstantExpressionKind.CONDITIONAL:
         return new ConditionalConstantExpression(
             decoder.getConstant(Key.CONDITION),
             decoder.getConstant(Key.TRUE),
             decoder.getConstant(Key.FALSE));
       case ConstantExpressionKind.CONSTRUCTED:
-        List<String> names =
-            decoder.getStrings(Key.NAMES, isOptional: true);
+        List<String> names = decoder.getStrings(Key.NAMES, isOptional: true);
         List<ConstantExpression> arguments =
-              decoder.getConstants(Key.ARGUMENTS, isOptional: true);
+            decoder.getConstants(Key.ARGUMENTS, isOptional: true);
         return new ConstructedConstantExpression(
             decoder.getType(Key.TYPE),
             decoder.getElement(Key.ELEMENT),
             new CallStructure(arguments.length, names),
             arguments);
       case ConstantExpressionKind.DOUBLE:
         return new DoubleConstantExpression(decoder.getDouble(Key.VALUE));
       case ConstantExpressionKind.ERRONEOUS:
         break;
       case ConstantExpressionKind.FUNCTION:
-        return new FunctionConstantExpression(
-            decoder.getElement(Key.ELEMENT));
+        return new FunctionConstantExpression(decoder.getElement(Key.ELEMENT));
       case ConstantExpressionKind.IDENTICAL:
         return new IdenticalConstantExpression(
-            decoder.getConstant(Key.LEFT),
-            decoder.getConstant(Key.RIGHT));
+            decoder.getConstant(Key.LEFT), decoder.getConstant(Key.RIGHT));
       case ConstantExpressionKind.INT:
         return new IntConstantExpression(decoder.getInt(Key.VALUE));
       case ConstantExpressionKind.INT_FROM_ENVIRONMENT:
         return new IntFromEnvironmentConstantExpression(
             decoder.getConstant(Key.NAME),
             decoder.getConstant(Key.DEFAULT, isOptional: true));
       case ConstantExpressionKind.LIST:
         return new ListConstantExpression(
-            decoder.getType(Key.TYPE),
-            decoder.getConstants(Key.VALUES));
+            decoder.getType(Key.TYPE), decoder.getConstants(Key.VALUES));
       case ConstantExpressionKind.MAP:
-        return new MapConstantExpression(
-            decoder.getType(Key.TYPE),
-            decoder.getConstants(Key.KEYS),
-            decoder.getConstants(Key.VALUES));
+        return new MapConstantExpression(decoder.getType(Key.TYPE),
+            decoder.getConstants(Key.KEYS), decoder.getConstants(Key.VALUES));
       case ConstantExpressionKind.NULL:
         return new NullConstantExpression();
       case ConstantExpressionKind.STRING:
-        return new StringConstantExpression(
-            decoder.getString(Key.VALUE));
+        return new StringConstantExpression(decoder.getString(Key.VALUE));
       case ConstantExpressionKind.STRING_FROM_ENVIRONMENT:
         return new StringFromEnvironmentConstantExpression(
             decoder.getConstant(Key.NAME),
             decoder.getConstant(Key.DEFAULT, isOptional: true));
       case ConstantExpressionKind.STRING_LENGTH:
         return new StringLengthConstantExpression(
             decoder.getConstant(Key.EXPRESSION));
       case ConstantExpressionKind.SYMBOL:
         break;
       case ConstantExpressionKind.TYPE:
         return new TypeConstantExpression(decoder.getType(Key.TYPE));
       case ConstantExpressionKind.UNARY:
-        UnaryOperator operator = UnaryOperator.fromKind(
-            decoder.getEnum(Key.OPERATOR, UnaryOperatorKind.values));
+        UnaryOperator operator = UnaryOperator
+            .fromKind(decoder.getEnum(Key.OPERATOR, UnaryOperatorKind.values));
         return new UnaryConstantExpression(
-            operator,
-            decoder.getConstant(Key.EXPRESSION));
+            operator, decoder.getConstant(Key.EXPRESSION));
       case ConstantExpressionKind.VARIABLE:
-        return new VariableConstantExpression(
-            decoder.getElement(Key.ELEMENT));
+        return new VariableConstantExpression(decoder.getElement(Key.ELEMENT));
 
       case ConstantExpressionKind.POSITIONAL_REFERENCE:
-        return new PositionalArgumentReference(
-            decoder.getInt(Key.INDEX));
+        return new PositionalArgumentReference(decoder.getInt(Key.INDEX));
       case ConstantExpressionKind.NAMED_REFERENCE:
-        return new NamedArgumentReference(
-            decoder.getString(Key.NAME));
+        return new NamedArgumentReference(decoder.getString(Key.NAME));
       case ConstantExpressionKind.DEFERRED:
       case ConstantExpressionKind.SYNTHETIC:
     }
-    throw new UnsupportedError(
-        "Unexpected constant kind: ${kind} in $decoder");
+    throw new UnsupportedError("Unexpected constant kind: ${kind} in $decoder");
   }
 }
 
 /// Visitor that serializes a [ConstantConstructor] by encoding it into an
 /// [ObjectEncoder].
 ///
 /// This class is called from the [ConstructorSerializer] when the [Serializer]
 /// is serializing constant constructor. The [ObjectEncoder] ensures that any
 /// [Element], [DartType], and [ConstantExpression] that the serialized
 /// [ConstantConstructor] depends upon are also serialized.
 class ConstantConstructorSerializer
     extends ConstantConstructorVisitor<dynamic, ObjectEncoder> {
   const ConstantConstructorSerializer();
 
   @override
-  void visit(ConstantConstructor constantConstructor,
-             ObjectEncoder encoder) {
+  void visit(ConstantConstructor constantConstructor, ObjectEncoder encoder) {
     encoder.setEnum(Key.KIND, constantConstructor.kind);
     constantConstructor.accept(this, encoder);
   }
 
   @override
   void visitGenerative(
-      GenerativeConstantConstructor constructor,
-      ObjectEncoder encoder) {
+      GenerativeConstantConstructor constructor, ObjectEncoder encoder) {
     encoder.setType(Key.TYPE, constructor.type);
     MapEncoder defaults = encoder.createMap(Key.DEFAULTS);
     constructor.defaultValues.forEach((key, e) {
       defaults.setConstant('$key', e);
     });
     ListEncoder fields = encoder.createList(Key.FIELDS);
     constructor.fieldMap.forEach((FieldElement f, ConstantExpression e) {
       ObjectEncoder fieldSerializer = fields.createObject();
       fieldSerializer.setElement(Key.FIELD, f);
       fieldSerializer.setConstant(Key.CONSTANT, e);
     });
     if (constructor.superConstructorInvocation != null) {
-      encoder.setConstant(Key.CONSTRUCTOR,
-          constructor.superConstructorInvocation);
+      encoder.setConstant(
+          Key.CONSTRUCTOR, constructor.superConstructorInvocation);
     }
   }
 
   @override
   void visitRedirectingFactory(
       RedirectingFactoryConstantConstructor constructor,
       ObjectEncoder encoder) {
-    encoder.setConstant(Key.CONSTRUCTOR,
-        constructor.targetConstructorInvocation);
+    encoder.setConstant(
+        Key.CONSTRUCTOR, constructor.targetConstructorInvocation);
   }
 
   @override
   void visitRedirectingGenerative(
       RedirectingGenerativeConstantConstructor constructor,
       ObjectEncoder encoder) {
     MapEncoder defaults = encoder.createMap(Key.DEFAULTS);
     constructor.defaultValues.forEach((key, ConstantExpression e) {
       defaults.setConstant('$key', e);
     });
-    encoder.setConstant(Key.CONSTRUCTOR,
-        constructor.thisConstructorInvocation);
+    encoder.setConstant(Key.CONSTRUCTOR, constructor.thisConstructorInvocation);
   }
 }
+
 /// Utility class for deserializing [ConstantConstructor]s.
 ///
 /// This is used by the [ConstructorElementZ].
 class ConstantConstructorDeserializer {
   /// Deserializes a [ConstantConstructor] from an [ObjectDecoder].
   ///
   /// The class is called from the [Deserializer] when a constant constructor
   /// needs deserialization. The [ObjectDecoder] ensures that any [Element],
   /// [DartType], and [ConstantExpression] that the deserialized
   /// [ConstantConstructor] depends upon are available.
   static ConstantConstructor deserialize(ObjectDecoder decoder) {
-
     ConstantConstructorKind kind =
         decoder.getEnum(Key.KIND, ConstantConstructorKind.values);
 
     DartType readType() {
       return decoder.getType(Key.TYPE);
     }
 
-    Map<dynamic/*int|String*/, ConstantExpression> readDefaults() {
+    Map<dynamic /*int|String*/, ConstantExpression> readDefaults() {
       Map<dynamic, ConstantExpression> defaultValues =
           <dynamic, ConstantExpression>{};
       if (decoder.containsKey(Key.DEFAULTS)) {
         MapDecoder defaultsMap = decoder.getMap(Key.DEFAULTS);
         defaultsMap.forEachKey((String key) {
           int index = int.parse(key, onError: (_) => null);
           if (index != null) {
             defaultValues[index] = defaultsMap.getConstant(key);
           } else {
             defaultValues[key] = defaultsMap.getConstant(key);
@@ skipping 17 matching lines @@
       }
       return fieldMap;
     }
 
     ConstructedConstantExpression readConstructorInvocation() {
       return decoder.getConstant(Key.CONSTRUCTOR, isOptional: true);
     }
 
     switch (kind) {
       case ConstantConstructorKind.GENERATIVE:
-        return new GenerativeConstantConstructor(
-            readType(),
-            readDefaults(),
-            readFields(),
-            readConstructorInvocation());
+        return new GenerativeConstantConstructor(readType(), readDefaults(),
+            readFields(), readConstructorInvocation());
       case ConstantConstructorKind.REDIRECTING_GENERATIVE:
         return new RedirectingGenerativeConstantConstructor(
-            readDefaults(),
-            readConstructorInvocation());
+            readDefaults(), readConstructorInvocation());
       case ConstantConstructorKind.REDIRECTING_FACTORY:
         return new RedirectingFactoryConstantConstructor(
             readConstructorInvocation());
     }
   }
 }