dartfmt pkg/compiler

pkg/compiler/lib/src/compile_time_constants.dart

 // Copyright (c) 2012, 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.compile_time_constant_evaluator;
 
 import 'common.dart';
-import 'common/resolution.dart' show
-    Resolution;
-import 'common/tasks.dart' show
-    CompilerTask;
-import 'compiler.dart' show
-    Compiler;
+import 'common/resolution.dart' show Resolution;
+import 'common/tasks.dart' show CompilerTask;
+import 'compiler.dart' show Compiler;
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
 import 'constants/evaluation.dart';
 import 'constants/expressions.dart';
 import 'constants/values.dart';
-import 'core_types.dart' show
-    CoreTypes;
+import 'core_types.dart' show CoreTypes;
 import 'dart_types.dart';
 import 'elements/elements.dart';
-import 'elements/modelx.dart' show
-    FunctionElementX;
-import 'resolution/tree_elements.dart' show
-    TreeElements;
+import 'elements/modelx.dart' show FunctionElementX;
+import 'resolution/tree_elements.dart' show TreeElements;
 import 'resolution/operators.dart';
 import 'tree/tree.dart';
-import 'util/util.dart' show
-    Link;
-import 'universe/call_structure.dart' show
-    CallStructure;
+import 'util/util.dart' show Link;
+import 'universe/call_structure.dart' show CallStructure;
 
 /// A [ConstantEnvironment] provides access for constants compiled for variable
 /// initializers.
 abstract class ConstantEnvironment {
   /// The [ConstantSystem] used by this environment.
   ConstantSystem get constantSystem;
 
   /// Returns the constant value computed for [expression].
   // TODO(johnniwinther): Support directly evaluation of [expression].
   ConstantValue getConstantValue(ConstantExpression expression);
@@ skipping 37 matching lines @@
   ConstantExpression compileNode(Node node, TreeElements elements,
       {bool enforceConst: true});
 
   /// Compiles the compile-time constant for the value [metadata], or reports an
   /// error if the value is not a compile-time constant.
   ///
   /// Depending on implementation, the constant compiler might also compute
   /// the compile-time constant for the backend interpretation of constants.
   ///
   /// The returned constant is always of the frontend interpretation.
-  ConstantExpression compileMetadata(MetadataAnnotation metadata,
-                                     Node node,
-                                     TreeElements elements);
+  ConstantExpression compileMetadata(
+      MetadataAnnotation metadata, Node node, TreeElements elements);
 
   /// Evaluates [constant] and caches the result.
   // TODO(johnniwinther): Remove when all constants are evaluated.
   void evaluate(ConstantExpression constant);
 }
 
 /// A [BackendConstantEnvironment] provides access to constants needed for
 /// backend implementation.
 abstract class BackendConstantEnvironment extends ConstantEnvironment {
   /// Returns the compile-time constant value associated with [node].
@@ skipping 72 matching lines @@
   }
 
   ConstantExpression compileConstant(VariableElement element) {
     return internalCompileVariable(element, true, true);
   }
 
   @override
   void evaluate(ConstantExpression constant) {
     constantValueMap.putIfAbsent(constant, () {
       return constant.evaluate(
-          new _CompilerEnvironment(compiler),
-          constantSystem);
+          new _CompilerEnvironment(compiler), constantSystem);
     });
   }
 
   ConstantExpression compileVariable(VariableElement element) {
     return internalCompileVariable(element, false, true);
   }
 
   /// Compile [element] into a constant expression. If [isConst] is true,
   /// then [element] is a constant variable. If [checkType] is true, then
   /// report an error if [element] does not typecheck.
@@ skipping 59 matching lines @@
                 node, element.messageKind, element.messageArguments);
           } else {
             // We need to throw an exception at runtime.
             expression = null;
           }
         } else {
           DartType constantType = value.getType(coreTypes);
           if (!constantSystem.isSubtype(
               compiler.types, constantType, elementType)) {
             if (isConst) {
-              reporter.reportErrorMessage(
-                  node,
-                  MessageKind.NOT_ASSIGNABLE,
-                  {'fromType': constantType,
-                   'toType': elementType});
+              reporter.reportErrorMessage(node, MessageKind.NOT_ASSIGNABLE,
+                  {'fromType': constantType, 'toType': elementType});
             } else {
               // If the field cannot be lazily initialized, we will throw
               // the exception at runtime.
               expression = null;
             }
           }
         }
       }
     }
     if (expression != null) {
       initialVariableValues[element.declaration] = expression;
     } else {
       assert(invariant(element, !isConst,
           message: "Variable $element does not compile to a constant."));
     }
     pendingVariables.remove(element);
     return expression;
   }
 
   void cacheConstantValue(ConstantExpression expression, ConstantValue value) {
     constantValueMap[expression] = value;
   }
 
   ConstantExpression compileNodeWithDefinitions(
-      Node node, TreeElements definitions, {bool isConst: true}) {
+      Node node, TreeElements definitions,
+      {bool isConst: true}) {
     assert(node != null);
     CompileTimeConstantEvaluator evaluator = new CompileTimeConstantEvaluator(
-        this, definitions, compiler, isConst: isConst);
+        this, definitions, compiler,
+        isConst: isConst);
     AstConstant constant = evaluator.evaluate(node);
     if (constant != null) {
       cacheConstantValue(constant.expression, constant.value);
       return constant.expression;
     }
     return null;
   }
 
   ConstantValue getConstantValue(ConstantExpression expression) {
     return constantValueMap[expression];
@@ skipping 24 matching lines @@
 /// constant evaluation.
 class DartConstantCompiler extends ConstantCompilerBase {
   DartConstantCompiler(Compiler compiler)
       : super(compiler, const DartConstantSystem());
 
   ConstantExpression getConstantForNode(Node node, TreeElements definitions) {
     return definitions.getConstant(node);
   }
 
   ConstantExpression compileNodeWithDefinitions(
-      Node node, TreeElements definitions, {bool isConst: true}) {
+      Node node, TreeElements definitions,
+      {bool isConst: true}) {
     ConstantExpression constant = definitions.getConstant(node);
     if (constant != null && getConstantValue(constant) != null) {
       return constant;
     }
     constant =
         super.compileNodeWithDefinitions(node, definitions, isConst: isConst);
     if (constant != null) {
       definitions.setConstant(node, constant);
     }
     return constant;
@@ skipping 32 matching lines @@
     isEvaluatingConstant = oldIsEvaluatingConstant;
     assert(result != null);
     return result;
   }
 
   AstConstant visitNode(Node node) {
     return signalNotCompileTimeConstant(node);
   }
 
   AstConstant visitLiteralBool(LiteralBool node) {
-    return new AstConstant(context, node,
+    return new AstConstant(
+        context,
+        node,
         new BoolConstantExpression(node.value),
         constantSystem.createBool(node.value));
   }
 
   AstConstant visitLiteralDouble(LiteralDouble node) {
-    return new AstConstant(context, node,
+    return new AstConstant(
+        context,
+        node,
         new DoubleConstantExpression(node.value),
         constantSystem.createDouble(node.value));
   }
 
   AstConstant visitLiteralInt(LiteralInt node) {
     return new AstConstant(context, node, new IntConstantExpression(node.value),
         constantSystem.createInt(node.value));
   }
 
   AstConstant visitLiteralList(LiteralList node) {
     if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
     }
     List<ConstantExpression> argumentExpressions = <ConstantExpression>[];
     List<ConstantValue> argumentValues = <ConstantValue>[];
     for (Link<Node> link = node.elements.nodes;
         !link.isEmpty;
         link = link.tail) {
       AstConstant argument = evaluateConstant(link.head);
       if (argument == null) {
         return null;
       }
       argumentExpressions.add(argument.expression);
       argumentValues.add(argument.value);
     }
     DartType type = elements.getType(node);
-    return new AstConstant(context, node,
+    return new AstConstant(
+        context,
+        node,
         new ListConstantExpression(type, argumentExpressions),
         constantSystem.createList(type, argumentValues));
   }
 
   AstConstant visitLiteralMap(LiteralMap node) {
     if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
     }
     List<ConstantExpression> keyExpressions = <ConstantExpression>[];
     List<ConstantExpression> valueExpressions = <ConstantExpression>[];
@@ skipping 15 matching lines @@
         keyValues.add(key.value);
       } else {
         reporter.reportWarningMessage(
             entry.key, MessageKind.EQUAL_MAP_ENTRY_KEY);
       }
       keyExpressions.add(key.expression);
       valueExpressions.add(value.expression);
       map[key.value] = value.value;
     }
     InterfaceType type = elements.getType(node);
-    return new AstConstant(context, node,
+    return new AstConstant(
+        context,
+        node,
         new MapConstantExpression(type, keyExpressions, valueExpressions),
         constantSystem.createMap(
             compiler, type, keyValues, map.values.toList()));
   }
 
   AstConstant visitLiteralNull(LiteralNull node) {
     return new AstConstant(context, node, new NullConstantExpression(),
         constantSystem.createNull());
   }
 
   AstConstant visitLiteralString(LiteralString node) {
-    return new AstConstant(context, node,
+    return new AstConstant(
+        context,
+        node,
         new StringConstantExpression(node.dartString.slowToString()),
         constantSystem.createString(node.dartString));
   }
 
   AstConstant visitStringJuxtaposition(StringJuxtaposition node) {
     AstConstant left = evaluate(node.first);
     AstConstant right = evaluate(node.second);
     if (left == null || right == null) return null;
     StringConstantValue leftValue = left.value;
     StringConstantValue rightValue = right.value;
-    return new AstConstant(context, node,
+    return new AstConstant(
+        context,
+        node,
         new ConcatenateConstantExpression([left.expression, right.expression]),
         constantSystem.createString(new DartString.concat(
             leftValue.primitiveValue, rightValue.primitiveValue)));
   }
 
   AstConstant visitStringInterpolation(StringInterpolation node) {
     List<ConstantExpression> subexpressions = <ConstantExpression>[];
     AstConstant initialString = evaluate(node.string);
     if (initialString == null) {
       return null;
@@ skipping 23 matching lines @@
       }
       accumulator = new DartString.concat(accumulator, expressionString);
       AstConstant partString = evaluate(part.string);
       if (partString == null) return null;
       subexpressions.add(partString.expression);
       StringConstantValue partStringValue = partString.value;
       accumulator =
           new DartString.concat(accumulator, partStringValue.primitiveValue);
     }
     ;
-    return new AstConstant(context, node,
+    return new AstConstant(
+        context,
+        node,
         new ConcatenateConstantExpression(subexpressions),
         constantSystem.createString(accumulator));
   }
 
   AstConstant visitLiteralSymbol(LiteralSymbol node) {
     InterfaceType type = coreTypes.symbolType;
     String text = node.slowNameString;
     List<AstConstant> arguments = <AstConstant>[
       new AstConstant(context, node, new StringConstantExpression(text),
           constantSystem.createString(new LiteralDartString(text)))
@@ skipping 30 matching lines @@
   }
 
   // TODO(floitsch): provide better error-messages.
   AstConstant visitSend(Send send) {
     Element element = elements[send];
     if (send.isPropertyAccess) {
       AstConstant result;
       if (Elements.isStaticOrTopLevelFunction(element)) {
         FunctionElementX function = element;
         function.computeType(resolution);
-        result = new AstConstant(context, send,
+        result = new AstConstant(
+            context,
+            send,
             new FunctionConstantExpression(function),
             new FunctionConstantValue(function));
       } else if (Elements.isStaticOrTopLevelField(element)) {
         ConstantExpression elementExpression;
         if (element.isConst) {
           elementExpression = handler.compileConstant(element);
         } else if (element.isFinal && !isEvaluatingConstant) {
           elementExpression = handler.compileVariable(element);
         }
         if (elementExpression != null) {
-          result = new AstConstant(context, send,
+          result = new AstConstant(
+              context,
+              send,
               new VariableConstantExpression(element),
               handler.getConstantValue(elementExpression));
         }
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
         assert(elements.isTypeLiteral(send));
         DartType elementType = elements.getTypeLiteralType(send);
-        result = new AstConstant(context, send,
+        result = new AstConstant(
+            context,
+            send,
             new TypeConstantExpression(elementType),
             makeTypeConstant(elementType));
       } else if (send.receiver != null) {
         if (send.selector.asIdentifier().source == "length") {
           AstConstant left = evaluate(send.receiver);
           if (left != null && left.value.isString) {
             StringConstantValue stringConstantValue = left.value;
             DartString string = stringConstantValue.primitiveValue;
             IntConstantValue length = constantSystem.createInt(string.length);
             result = new AstConstant(context, send,
                 new StringLengthConstantExpression(left.expression), length);
           }
         }
         // Fall through to error handling.
       } else if (!Elements.isUnresolved(element) &&
           element.isVariable &&
           element.isConst) {
         ConstantExpression variableExpression =
             handler.compileConstant(element);
         if (variableExpression != null) {
-          result = new AstConstant(context, send,
+          result = new AstConstant(
+              context,
+              send,
               new VariableConstantExpression(element),
               handler.getConstantValue(variableExpression));
         }
       }
       if (result == null) {
         return signalNotCompileTimeConstant(send);
       }
       if (isDeferredUse(send)) {
         if (isEvaluatingConstant) {
           reporter.reportErrorMessage(
               send, MessageKind.DEFERRED_COMPILE_TIME_CONSTANT);
         }
         PrefixElement prefix =
             compiler.deferredLoadTask.deferredPrefixElement(send, elements);
-        result = new AstConstant(context, send,
+        result = new AstConstant(
+            context,
+            send,
             new DeferredConstantExpression(result.expression, prefix),
             new DeferredConstantValue(result.value, prefix));
-        compiler.deferredLoadTask.registerConstantDeferredUse(
-            result.value, prefix);
+        compiler.deferredLoadTask
+            .registerConstantDeferredUse(result.value, prefix);
       }
       return result;
     } else if (send.isCall) {
       if (element == compiler.identicalFunction && send.argumentCount() == 2) {
         AstConstant left = evaluate(send.argumentsNode.nodes.head);
         AstConstant right = evaluate(send.argumentsNode.nodes.tail.head);
         if (left == null || right == null) {
           return null;
         }
         ConstantValue result =
             constantSystem.identity.fold(left.value, right.value);
         if (result != null) {
-          return new AstConstant(context, send, new IdenticalConstantExpression(
-              left.expression, right.expression), result);
+          return new AstConstant(
+              context,
+              send,
+              new IdenticalConstantExpression(
+                  left.expression, right.expression),
+              result);
         }
       }
       return signalNotCompileTimeConstant(send);
     } else if (send.isPrefix) {
       assert(send.isOperator);
       AstConstant receiverConstant = evaluate(send.receiver);
       if (receiverConstant == null) {
         return null;
       }
       Operator node = send.selector;
       UnaryOperator operator = UnaryOperator.parse(node.source);
       UnaryOperation operation = constantSystem.lookupUnary(operator);
       if (operation == null) {
         reporter.internalError(send.selector, "Unexpected operator.");
       }
       ConstantValue folded = operation.fold(receiverConstant.value);
       if (folded == null) {
         return signalNotCompileTimeConstant(send);
       }
-      return new AstConstant(context, send,
+      return new AstConstant(
+          context,
+          send,
           new UnaryConstantExpression(operator, receiverConstant.expression),
           folded);
     } else if (send.isOperator && !send.isPostfix) {
       assert(send.argumentCount() == 1);
       AstConstant left = evaluate(send.receiver);
       AstConstant right = evaluate(send.argumentsNode.nodes.head);
       if (left == null || right == null) {
         return null;
       }
       ConstantValue leftValue = left.value;
@@ skipping 23 matching lines @@
           default:
             BinaryOperation operation = constantSystem.lookupBinary(operator);
             if (operation != null) {
               folded = operation.fold(leftValue, rightValue);
             }
         }
       }
       if (folded == null) {
         return signalNotCompileTimeConstant(send);
       }
-      return new AstConstant(context, send, new BinaryConstantExpression(
-          left.expression, operator, right.expression), folded);
+      return new AstConstant(
+          context,
+          send,
+          new BinaryConstantExpression(
+              left.expression, operator, right.expression),
+          folded);
     }
     return signalNotCompileTimeConstant(send);
   }
 
   AstConstant visitConditional(Conditional node) {
     AstConstant condition = evaluate(node.condition);
     if (condition == null) {
       return null;
     } else if (!condition.value.isBool) {
       DartType conditionType = condition.value.getType(coreTypes);
       if (isEvaluatingConstant) {
-        reporter.reportErrorMessage(
-            node.condition,
-            MessageKind.NOT_ASSIGNABLE,
-            {'fromType': conditionType,
-             'toType': coreTypes.boolType});
+        reporter.reportErrorMessage(node.condition, MessageKind.NOT_ASSIGNABLE,
+            {'fromType': conditionType, 'toType': coreTypes.boolType});
         return new ErroneousAstConstant(context, node);
       }
       return null;
     }
     AstConstant thenExpression = evaluate(node.thenExpression);
     AstConstant elseExpression = evaluate(node.elseExpression);
     if (thenExpression == null || elseExpression == null) {
       return null;
     }
     BoolConstantValue boolCondition = condition.value;
-    return new AstConstant(context, node, new ConditionalConstantExpression(
-        condition.expression, thenExpression.expression,
-        elseExpression.expression), boolCondition.primitiveValue
-        ? thenExpression.value
-        : elseExpression.value);
+    return new AstConstant(
+        context,
+        node,
+        new ConditionalConstantExpression(condition.expression,
+            thenExpression.expression, elseExpression.expression),
+        boolCondition.primitiveValue
+            ? thenExpression.value
+            : elseExpression.value);
   }
 
   AstConstant visitSendSet(SendSet node) {
     return signalNotCompileTimeConstant(node);
   }
 
   /**
    * Returns the normalized list of constant arguments that are passed to the
    * constructor including both the concrete arguments and default values for
    * omitted optional arguments.
    *
    * Invariant: [target] must be an implementation element.
    */
-  List<AstConstant> evaluateArgumentsToConstructor(Node node,
-      CallStructure callStructure, Link<Node> arguments,
-      ConstructorElement target, {AstConstant compileArgument(Node node)}) {
+  List<AstConstant> evaluateArgumentsToConstructor(
+      Node node,
+      CallStructure callStructure,
+      Link<Node> arguments,
+      ConstructorElement target,
+      {AstConstant compileArgument(Node node)}) {
     assert(invariant(node, target.isImplementation));
 
     AstConstant compileDefaultValue(VariableElement element) {
       ConstantExpression constant = handler.compileConstant(element);
       return new AstConstant.fromDefaultValue(
           element, constant, handler.getConstantValue(constant));
     }
     target.computeType(resolution);
 
     FunctionSignature signature = target.functionSignature;
     if (!callStructure.signatureApplies(signature)) {
       String name = Elements.constructorNameForDiagnostics(
           target.enclosingClass.name, target.name);
-      reporter.reportErrorMessage(
-          node, MessageKind.INVALID_CONSTRUCTOR_ARGUMENTS,
-          {'constructorName': name});
+      reporter.reportErrorMessage(node,
+          MessageKind.INVALID_CONSTRUCTOR_ARGUMENTS, {'constructorName': name});
 
       return new List<AstConstant>.filled(
           target.functionSignature.parameterCount,
           new ErroneousAstConstant(context, node));
     }
     return callStructure.makeArgumentsList(
         arguments, target, compileArgument, compileDefaultValue);
   }
 
   AstConstant visitNewExpression(NewExpression node) {
@@ skipping 33 matching lines @@
     // a post-process action, so we have to make sure it is done here.
     compiler.resolver.resolveRedirectionChain(constructor, node);
 
     bool isInvalid = false;
     InterfaceType constructedType = type;
     ConstructorElement implementation;
     if (constructor.isRedirectingFactory) {
       if (constructor.isEffectiveTargetMalformed) {
         isInvalid = true;
       } else {
-        constructedType =
-            constructor.computeEffectiveTargetType(type);
+        constructedType = constructor.computeEffectiveTargetType(type);
         ConstructorElement target = constructor.effectiveTarget;
         // The constructor must be an implementation to ensure that field
         // initializers are handled correctly.
         implementation = target.implementation;
       }
     } else {
       // The constructor must be an implementation to ensure that field
       // initializers are handled correctly.
       implementation = constructor.implementation;
       isInvalid = implementation.isMalformed;
@@ skipping 26 matching lines @@
       assert(normalizedArguments != null);
       concreteArguments = normalizedArguments;
     }
 
     if (constructor == compiler.intEnvironment ||
         constructor == compiler.boolEnvironment ||
         constructor == compiler.stringEnvironment) {
       return createFromEnvironmentConstant(node, constructedType, constructor,
           callStructure, normalizedArguments, concreteArguments);
     } else {
-      return makeConstructedConstant(compiler, handler, context, node, type,
-          constructor, constructedType, implementation, callStructure,
-          concreteArguments, normalizedArguments);
+      return makeConstructedConstant(
+          compiler,
+          handler,
+          context,
+          node,
+          type,
+          constructor,
+          constructedType,
+          implementation,
+          callStructure,
+          concreteArguments,
+          normalizedArguments);
     }
   }
 
-  AstConstant createFromEnvironmentConstant(Node node, InterfaceType type,
-      ConstructorElement constructor, CallStructure callStructure,
+  AstConstant createFromEnvironmentConstant(
+      Node node,
+      InterfaceType type,
+      ConstructorElement constructor,
+      CallStructure callStructure,
       List<AstConstant> normalizedArguments,
       List<AstConstant> concreteArguments) {
     var firstArgument = normalizedArguments[0].value;
     ConstantValue defaultValue = normalizedArguments[1].value;
 
     if (firstArgument.isNull) {
       reporter.reportErrorMessage(
           normalizedArguments[0].node, MessageKind.NULL_NOT_ALLOWED);
       return null;
     }
 
     if (!firstArgument.isString) {
       DartType type = defaultValue.getType(coreTypes);
       reporter.reportErrorMessage(
           normalizedArguments[0].node,
           MessageKind.NOT_ASSIGNABLE,
-          {'fromType': type,
-           'toType': coreTypes.stringType});
+          {'fromType': type, 'toType': coreTypes.stringType});
       return null;
     }
 
     if (constructor == compiler.intEnvironment &&
         !(defaultValue.isNull || defaultValue.isInt)) {
       DartType type = defaultValue.getType(coreTypes);
       reporter.reportErrorMessage(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
-          {'fromType': type,
-           'toType': coreTypes.intType});
+          {'fromType': type, 'toType': coreTypes.intType});
       return null;
     }
 
     if (constructor == compiler.boolEnvironment &&
         !(defaultValue.isNull || defaultValue.isBool)) {
       DartType type = defaultValue.getType(coreTypes);
       reporter.reportErrorMessage(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
-          {'fromType': type,
-           'toType': coreTypes.boolType});
+          {'fromType': type, 'toType': coreTypes.boolType});
       return null;
     }
 
     if (constructor == compiler.stringEnvironment &&
         !(defaultValue.isNull || defaultValue.isString)) {
       DartType type = defaultValue.getType(coreTypes);
       reporter.reportErrorMessage(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
-          {'fromType': type,
-           'toType': coreTypes.stringType});
+          {'fromType': type, 'toType': coreTypes.stringType});
       return null;
     }
 
     String name = firstArgument.primitiveValue.slowToString();
     String value = compiler.fromEnvironment(name);
 
     AstConstant createEvaluatedConstant(ConstantValue value) {
       ConstantExpression expression;
       ConstantExpression name = concreteArguments[0].expression;
       ConstantExpression defaultValue;
@@ skipping 28 matching lines @@
       } else {
         return createEvaluatedConstant(defaultValue);
       }
     } else {
       assert(constructor == compiler.stringEnvironment);
       return createEvaluatedConstant(
           constantSystem.createString(new DartString.literal(value)));
     }
   }
 
-  static AstConstant makeConstructedConstant(Compiler compiler,
-      ConstantCompilerBase handler, Element context, Node node,
-      InterfaceType type, ConstructorElement constructor,
-      InterfaceType constructedType, ConstructorElement target,
-      CallStructure callStructure, List<AstConstant> concreteArguments,
+  static AstConstant makeConstructedConstant(
+      Compiler compiler,
+      ConstantCompilerBase handler,
+      Element context,
+      Node node,
+      InterfaceType type,
+      ConstructorElement constructor,
+      InterfaceType constructedType,
+      ConstructorElement target,
+      CallStructure callStructure,
+      List<AstConstant> concreteArguments,
       List<AstConstant> normalizedArguments) {
     if (target.isRedirectingFactory) {
       // This happens is case of cyclic redirection.
       assert(invariant(node, compiler.compilationFailed,
           message: "makeConstructedConstant can only be called with the "
-          "effective target: $constructor"));
+              "effective target: $constructor"));
       return new ErroneousAstConstant(context, node);
     }
-    assert(invariant(node,
+    assert(invariant(
+        node,
         callStructure.signatureApplies(constructor.functionSignature) ||
             compiler.compilationFailed,
         message: "Call structure $callStructure does not apply to constructor "
-        "$constructor."));
+            "$constructor."));
 
     ConstructorEvaluator evaluator =
         new ConstructorEvaluator(constructedType, target, handler, compiler);
     evaluator.evaluateConstructorFieldValues(normalizedArguments);
     Map<FieldElement, AstConstant> fieldConstants =
         evaluator.buildFieldConstants(target.enclosingClass);
     Map<FieldElement, ConstantValue> fieldValues =
         <FieldElement, ConstantValue>{};
     fieldConstants.forEach((FieldElement field, AstConstant astConstant) {
       fieldValues[field] = astConstant.value;
     });
-    return new AstConstant(context, node, new ConstructedConstantExpression(
-            type, constructor, callStructure,
+    return new AstConstant(
+        context,
+        node,
+        new ConstructedConstantExpression(type, constructor, callStructure,
             concreteArguments.map((e) => e.expression).toList()),
         new ConstructedConstantValue(constructedType, fieldValues));
   }
 
   AstConstant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   AstConstant signalNotCompileTimeConstant(Node node,
       {MessageKind message: MessageKind.NOT_A_COMPILE_TIME_CONSTANT}) {
@@ skipping 45 matching lines @@
     return super.visitSend(send);
   }
 
   void potentiallyCheckType(TypedElement element, AstConstant constant) {
     if (compiler.options.enableTypeAssertions) {
       DartType elementType = element.type.substByContext(constructedType);
       DartType constantType = constant.value.getType(coreTypes);
       if (!constantSystem.isSubtype(
           compiler.types, constantType, elementType)) {
         reporter.withCurrentElement(constant.element, () {
-          reporter.reportErrorMessage(
-              constant.node,
-              MessageKind.NOT_ASSIGNABLE,
-              {'fromType': constantType,
-               'toType': elementType});
+          reporter.reportErrorMessage(constant.node, MessageKind.NOT_ASSIGNABLE,
+              {'fromType': constantType, 'toType': elementType});
         });
       }
     }
   }
 
   void updateFieldValue(Node node, TypedElement element, AstConstant constant) {
     potentiallyCheckType(element, constant);
     fieldValues[element] = constant;
   }
 
@@ skipping 17 matching lines @@
         potentiallyCheckType(parameter, argument);
         definitions[parameter] = argument;
       }
     });
   }
 
   void evaluateSuperOrRedirectSend(
       List<AstConstant> compiledArguments, FunctionElement targetConstructor) {
     ConstructorEvaluator evaluator = new ConstructorEvaluator(
         constructedType.asInstanceOf(targetConstructor.enclosingClass),
-        targetConstructor, handler, compiler);
+        targetConstructor,
+        handler,
+        compiler);
     evaluator.evaluateConstructorFieldValues(compiledArguments);
     // Copy over the fieldValues from the super/redirect-constructor.
     // No need to go through [updateFieldValue] because the
     // assignments have already been checked in checked mode.
     evaluator.fieldValues.forEach((key, value) => fieldValues[key] = value);
   }
 
   /**
    * Runs through the initializers of the given [constructor] and updates
    * the [fieldValues] map.
@@ skipping 20 matching lines @@
           !link.isEmpty;
           link = link.tail) {
         assert(link.head is Send);
         if (link.head is! SendSet) {
           // A super initializer or constructor redirection.
           Send call = link.head;
           FunctionElement target = elements[call];
           if (!target.isMalformed) {
             List<AstConstant> compiledArguments =
                 evaluateArgumentsToConstructor(
-                  call,
-                  elements.getSelector(call).callStructure,
-                  call.arguments,
-                  target,
-                  compileArgument: evaluateConstant);
+                    call,
+                    elements.getSelector(call).callStructure,
+                    call.arguments,
+                    target,
+                    compileArgument: evaluateConstant);
             evaluateSuperOrRedirectSend(compiledArguments, target);
           }
           foundSuperOrRedirect = true;
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> initArguments = init.arguments;
           assert(!initArguments.isEmpty && initArguments.tail.isEmpty);
           AstConstant fieldValue = evaluate(initArguments.head);
           updateFieldValue(init, elements[init], fieldValue);
         }
       }
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
       ClassElement enclosingClass = constructor.enclosingClass;
       ClassElement superClass = enclosingClass.superclass;
       if (!enclosingClass.isObject) {
         assert(superClass != null);
         assert(superClass.isResolved);
 
         FunctionElement targetConstructor =
             superClass.lookupDefaultConstructor();
         // If we do not find a default constructor, an error was reported
         // already and compilation will fail anyway. So just ignore that case.
         if (targetConstructor != null) {
           List<AstConstant> compiledArguments = evaluateArgumentsToConstructor(
-              functionNode, CallStructure.NO_ARGS, const Link<Node>(),
+              functionNode,
+              CallStructure.NO_ARGS,
+              const Link<Node>(),
               targetConstructor);
           evaluateSuperOrRedirectSend(compiledArguments, targetConstructor);
         }
       }
     }
   }
 
   /**
    * Simulates the execution of the [constructor] with the given
    * [arguments] to obtain the field values that need to be passed to the
    * native JavaScript constructor.
    */
   void evaluateConstructorFieldValues(List<AstConstant> arguments) {
     if (constructor.isMalformed) return;
     reporter.withCurrentElement(constructor, () {
       assignArgumentsToParameters(arguments);
       evaluateConstructorInitializers();
     });
   }
 
   /// Builds a normalized list of the constant values for each field in the
   /// inheritance chain of [classElement].
   Map<FieldElement, AstConstant> buildFieldConstants(
       ClassElement classElement) {
-    Map<FieldElement, AstConstant> fieldConstants = <FieldElement, AstConstant>{
-    };
-    classElement.implementation
-        .forEachInstanceField((ClassElement enclosing, FieldElement field) {
+    Map<FieldElement, AstConstant> fieldConstants =
+        <FieldElement, AstConstant>{};
+    classElement.implementation.forEachInstanceField(
+        (ClassElement enclosing, FieldElement field) {
       AstConstant fieldValue = fieldValues[field];
       if (fieldValue == null) {
         // Use the default value.
         ConstantExpression fieldExpression =
             handler.internalCompileVariable(field, true, false);
         fieldValue = new AstConstant.fromDefaultValue(
             field, fieldExpression, handler.getConstantValue(fieldExpression));
         // TODO(het): If the field value doesn't typecheck due to the type
         // variable in the constructor invocation, then report the error on the
         // invocation rather than the field.
@@ skipping 17 matching lines @@
 class AstConstant {
   final Element element;
   final Node node;
   final ConstantExpression expression;
   final ConstantValue value;
 
   AstConstant(this.element, this.node, this.expression, this.value);
 
   factory AstConstant.fromDefaultValue(VariableElement element,
       ConstantExpression constant, ConstantValue value) {
-    return new AstConstant(element, element.initializer != null
-        ? element.initializer
-        : element.node, constant, value);
+    return new AstConstant(
+        element,
+        element.initializer != null ? element.initializer : element.node,
+        constant,
+        value);
   }
 
   String toString() => expression.toString();
 }
 
 /// A synthetic constant used to recover from errors.
 class ErroneousAstConstant extends AstConstant {
-  ErroneousAstConstant(Element element, Node node) : super(element, node,
-          // TODO(johnniwinther): Return a [NonConstantValue] instead.
-          new ErroneousConstantExpression(), new NullConstantValue());
+  ErroneousAstConstant(Element element, Node node)
+      : super(
+            element,
+            node,
+            // TODO(johnniwinther): Return a [NonConstantValue] instead.
+            new ErroneousConstantExpression(),
+            new NullConstantValue());
 }
 
 // TODO(johnniwinther): Clean this up.
 TreeElements _analyzeElementEagerly(Compiler compiler, AstElement element) {
   compiler.resolution.computeWorldImpact(element.declaration);
   return element.resolvedAst.elements;
 }
 
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
 }