dartfmt pkg/compiler

pkg/compiler/lib/src/inferrer/inferrer_visitor.dart

 // Copyright (c) 2013, 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 inferrer_visitor;
 
-import 'dart:collection' show
-    IterableMixin;
+import 'dart:collection' show IterableMixin;
 
 import '../common.dart';
-import '../compiler.dart' show
-    Compiler;
+import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../resolution/operators.dart';
 import '../resolution/semantic_visitor.dart';
-import '../resolution/tree_elements.dart' show
-    TreeElements;
+import '../resolution/tree_elements.dart' show TreeElements;
 import '../tree/tree.dart';
-import '../types/types.dart' show
-    TypeMask;
-import '../types/constants.dart' show
-    computeTypeMask;
-import '../universe/call_structure.dart' show
-    CallStructure;
-import '../universe/selector.dart' show
-    Selector;
+import '../types/types.dart' show TypeMask;
+import '../types/constants.dart' show computeTypeMask;
+import '../universe/call_structure.dart' show CallStructure;
+import '../universe/selector.dart' show Selector;
 import '../util/util.dart';
-import '../world.dart' show
-    ClassWorld;
+import '../world.dart' show ClassWorld;
 
 /**
  * The interface [InferrerVisitor] will use when working on types.
  */
 abstract class TypeSystem<T> {
   T get dynamicType;
   T get nullType;
   T get intType;
   T get uint31Type;
   T get uint32Type;
@@ skipping 17 matching lines @@
   T stringLiteralType(DartString value);
   T boolLiteralType(LiteralBool value);
 
   T nonNullSubtype(ClassElement type);
   T nonNullSubclass(ClassElement type);
   T nonNullExact(ClassElement type);
   T nonNullEmpty();
   bool isNull(T type);
   TypeMask newTypedSelector(T receiver, TypeMask mask);
 
-  T allocateList(T type,
-                 Node node,
-                 Element enclosing,
-                 [T elementType, int length]);
+  T allocateList(T type, Node node, Element enclosing,
+      [T elementType, int length]);
 
-  T allocateMap(T type, Node node, Element element, [List<T> keyType,
-                                                     List<T> valueType]);
+  T allocateMap(T type, Node node, Element element,
+      [List<T> keyType, List<T> valueType]);
 
   T allocateClosure(Node node, Element element);
 
   /**
    * Returns the least upper bound between [firstType] and
    * [secondType].
    */
   T computeLUB(T firstType, T secondType);
 
   /**
@@ skipping 12 matching lines @@
    * Returns a new type that unions [firstInput] and [secondInput].
    */
   T allocateDiamondPhi(T firstInput, T secondInput);
 
   /**
    * Returns a new type for holding the potential types of [element].
    * [inputType] is the first incoming type of the phi.
    */
   T allocatePhi(Node node, Local variable, T inputType);
 
-
   /**
    * Returns a new type for holding the potential types of [element].
    * [inputType] is the first incoming type of the phi. [allocateLoopPhi]
    * only differs from [allocatePhi] in that it allows the underlying
    * implementation of [TypeSystem] to differentiate Phi nodes due to loops
    * from other merging uses.
    */
   T allocateLoopPhi(Node node, Local variable, T inputType);
 
   /**
@@ skipping 16 matching lines @@
   bool selectorNeedsUpdate(T receiverType, TypeMask mask);
 
   /**
    * Returns a new receiver type for this [selector] applied to
    * [receiverType].
    *
    * The option [isConditional] is true when [selector] was seen in a
    * conditional send (e.g.  `a?.selector`), in which case the returned type may
    * be null.
    */
-  T refineReceiver(Selector selector,
-                   TypeMask mask,
-                   T receiverType,
-                   bool isConditional);
+  T refineReceiver(
+      Selector selector, TypeMask mask, T receiverType, bool isConditional);
 
   /**
    * Returns the internal inferrer representation for [mask].
    */
   T getConcreteTypeFor(TypeMask mask);
 }
 
 /**
  * A variable scope holds types for variables. It has a link to a
  * parent scope, but never changes the types in that parent. Instead,
@@ skipping 44 matching lines @@
       variables = new Map<Local, T>();
     }
     variables[variable] = mask;
   }
 
   void forEachOwnLocal(void f(Local variable, T type)) {
     if (variables == null) return;
     variables.forEach(f);
   }
 
-  void forEachLocalUntilNode(Node node,
-                             void f(Local variable, T type),
-                             [Setlet<Local> seenLocals]) {
+  void forEachLocalUntilNode(Node node, void f(Local variable, T type),
+      [Setlet<Local> seenLocals]) {
     if (seenLocals == null) seenLocals = new Setlet<Local>();
     if (variables != null) {
       variables.forEach((variable, type) {
         if (seenLocals.contains(variable)) return;
         seenLocals.add(variable);
         f(variable, type);
       });
     }
     if (block == node) return;
     if (parent != null) parent.forEachLocalUntilNode(node, f, seenLocals);
@@ skipping 39 matching lines @@
   T readField(Element field) {
     return fields == null ? null : fields[field];
   }
 
   void forEach(void f(Element element, T type)) {
     if (fields == null) return;
     fields.forEach(f);
   }
 
   void mergeDiamondFlow(FieldInitializationScope<T> thenScope,
-                        FieldInitializationScope<T> elseScope) {
+      FieldInitializationScope<T> elseScope) {
     // Quick bailout check. If [isThisExposed] is true, we know the
     // code following won't do anything.
     if (isThisExposed) return;
     if (elseScope == null || elseScope.fields == null) {
       elseScope = this;
     }
 
     thenScope.forEach((Element field, T type) {
       T otherType = elseScope.readField(field);
       if (otherType == null) return;
       updateField(field, types.allocateDiamondPhi(type, otherType));
     });
     isThisExposed = thenScope.isThisExposed || elseScope.isThisExposed;
   }
 }
 
 /**
  * Placeholder for inferred arguments types on sends.
  */
 class ArgumentsTypes<T> extends IterableMixin<T> {
   final List<T> positional;
   final Map<String, T> named;
   ArgumentsTypes(this.positional, named)
-    : this.named = (named == null || named.isEmpty) ? const {} : named {
+      : this.named = (named == null || named.isEmpty) ? const {} : named {
     assert(this.positional.every((T type) => type != null));
     assert(this.named.values.every((T type) => type != null));
   }
 
-  ArgumentsTypes.empty() : positional = const [], named = const {};
+  ArgumentsTypes.empty()
+      : positional = const [],
+        named = const {};
 
   int get length => positional.length + named.length;
 
   Iterator<T> get iterator => new ArgumentsTypesIterator(this);
 
   String toString() => "{ positional = $positional, named = $named }";
 
-  bool operator==(other) {
+  bool operator ==(other) {
     if (positional.length != other.positional.length) return false;
     if (named.length != other.named.length) return false;
     for (int i = 0; i < positional.length; i++) {
       if (positional[i] != other.positional[i]) return false;
     }
     named.forEach((name, type) {
       if (other.named[name] != type) return false;
     });
     return true;
   }
@@ skipping 35 matching lines @@
 
   bool moveNext() {
     if (_iteratePositional && positional.moveNext()) {
       return true;
     }
     _iteratePositional = false;
     return named.moveNext();
   }
 }
 
-
 abstract class MinimalInferrerEngine<T> {
   /**
    * Returns the type of [element].
    */
   T typeOfElement(Element element);
 
   /**
    * Records that [node] sets non-final field [element] to be of type
    * [type].
    */
@@ skipping 21 matching lines @@
   final Map<Local, Element> captured;
   final Map<Local, Element> capturedAndBoxed;
   final FieldInitializationScope<T> fieldScope;
   LocalsHandler<T> tryBlock;
   bool seenReturnOrThrow = false;
   bool seenBreakOrContinue = false;
 
   bool get aborts {
     return seenReturnOrThrow || seenBreakOrContinue;
   }
+
   bool get inTryBlock => tryBlock != null;
 
-  LocalsHandler(this.inferrer,
-                this.types,
-                this.compiler,
-                Node block,
-                [this.fieldScope])
+  LocalsHandler(this.inferrer, this.types, this.compiler, Node block,
+      [this.fieldScope])
       : locals = new VariableScope<T>(block),
         captured = new Map<Local, Element>(),
         capturedAndBoxed = new Map<Local, Element>(),
         tryBlock = null;
 
-  LocalsHandler.from(LocalsHandler<T> other,
-                     Node block,
-                     {bool useOtherTryBlock: true})
+  LocalsHandler.from(LocalsHandler<T> other, Node block,
+      {bool useOtherTryBlock: true})
       : locals = new VariableScope<T>(block, other.locals),
         fieldScope = new FieldInitializationScope<T>.from(other.fieldScope),
         captured = other.captured,
         capturedAndBoxed = other.capturedAndBoxed,
         types = other.types,
         inferrer = other.inferrer,
         compiler = other.compiler {
     tryBlock = useOtherTryBlock ? other.tryBlock : this;
   }
 
@@ skipping 36 matching lines @@
     }
     updateLocal() {
       T currentType = locals[local];
 
       SendSet send = node != null ? node.asSendSet() : null;
       if (send != null && send.isIfNullAssignment && currentType != null) {
         // If-null assignments may return either the new or the original value
         // narrowed to non-null.
         type = types.addPhiInput(
             local,
-            types.allocatePhi(locals.block, local,
-                              types.narrowNotNull(currentType)),
+            types.allocatePhi(
+                locals.block, local, types.narrowNotNull(currentType)),
             type);
       }
       locals[local] = type;
       if (currentType != type) {
         inferrer.recordLocalUpdate(local, type);
       }
     }
     if (capturedAndBoxed.containsKey(local)) {
-      inferrer.recordTypeOfNonFinalField(
-          node, capturedAndBoxed[local], type);
+      inferrer.recordTypeOfNonFinalField(node, capturedAndBoxed[local], type);
     } else if (inTryBlock) {
       // We don't know if an assignment in a try block
       // will be executed, so all assigments in that block are
       // potential types after we have left it. We update the parent
       // of the try block so that, at exit of the try block, we get
       // the right phi for it.
       T existing = tryBlock.locals.parent[local];
       if (existing != null) {
         T phiType = types.allocatePhi(tryBlock.locals.block, local, existing);
         T inputType = types.addPhiInput(local, phiType, type);
         tryBlock.locals.parent[local] = inputType;
       }
       // Update the current handler unconditionnally with the new
       // type.
       updateLocal();
     } else {
       updateLocal();
     }
   }
 
   void setCaptured(Local local, Element field) {
     captured[local] = field;
   }
 
   void setCapturedAndBoxed(Local local, Element field) {
     capturedAndBoxed[local] = field;
   }
 
-  void mergeDiamondFlow(LocalsHandler<T> thenBranch,
-                        LocalsHandler<T> elseBranch) {
+  void mergeDiamondFlow(
+      LocalsHandler<T> thenBranch, LocalsHandler<T> elseBranch) {
     if (fieldScope != null && elseBranch != null) {
       fieldScope.mergeDiamondFlow(thenBranch.fieldScope, elseBranch.fieldScope);
     }
-    seenReturnOrThrow = thenBranch.seenReturnOrThrow
-        && elseBranch != null
-        && elseBranch.seenReturnOrThrow;
-    seenBreakOrContinue = thenBranch.seenBreakOrContinue
-        && elseBranch != null
-        && elseBranch.seenBreakOrContinue;
+    seenReturnOrThrow = thenBranch.seenReturnOrThrow &&
+        elseBranch != null &&
+        elseBranch.seenReturnOrThrow;
+    seenBreakOrContinue = thenBranch.seenBreakOrContinue &&
+        elseBranch != null &&
+        elseBranch.seenBreakOrContinue;
     if (aborts) return;
 
     void mergeOneBranch(LocalsHandler<T> other) {
       other.locals.forEachOwnLocal((Local local, T type) {
         T myType = locals[local];
         if (myType == null) return; // Variable is only defined in [other].
         if (type == myType) return;
         locals[local] = types.allocateDiamondPhi(myType, type);
       });
     }
@@ skipping 62 matching lines @@
    * [: L: {
    *      if (...) break;
    *      ...
    *    }
    * :]
    *
    * where [:this:] is the [LocalsHandler] for the paths through the
    * labeled statement that do not break out.
    */
   void mergeAfterBreaks(List<LocalsHandler<T>> handlers,
-                        {bool keepOwnLocals: true}) {
+      {bool keepOwnLocals: true}) {
     Node level = locals.block;
     // Use a separate locals handler to perform the merge in, so that Phi
     // creation does not invalidate previous type knowledge while we might
     // still look it up.
     LocalsHandler merged = new LocalsHandler.from(this, level);
     Set<Local> seenLocals = new Setlet<Local>();
     bool allBranchesAbort = true;
     // Merge all other handlers.
     for (LocalsHandler handler in handlers) {
       allBranchesAbort = allBranchesAbort && handler.seenReturnOrThrow;
       merged.mergeHandler(handler, seenLocals);
     }
     // If we want to keep own locals, we merge [seenLocals] from [this] into
     // [merged] to update the Phi nodes with original values.
     if (keepOwnLocals && !seenReturnOrThrow) {
       for (Local variable in seenLocals) {
         T originalType = locals[variable];
         if (originalType != null) {
-          merged.locals[variable] = types.addPhiInput(variable,
-                                                      merged.locals[variable],
-                                                      originalType);
+          merged.locals[variable] = types.addPhiInput(
+              variable, merged.locals[variable], originalType);
         }
       }
     }
     // Clean up Phi nodes with single input and store back result into
     // actual locals handler.
     merged.locals.forEachOwnLocal((Local variable, T type) {
       locals[variable] = types.simplifyPhi(level, variable, type);
     });
-    seenReturnOrThrow = allBranchesAbort &&
-                        (!keepOwnLocals || seenReturnOrThrow);
+    seenReturnOrThrow =
+        allBranchesAbort && (!keepOwnLocals || seenReturnOrThrow);
   }
 
   /**
    * Merge [other] into this handler. Returns whether a local in this
    * has changed. If [seen] is not null, we allocate new Phi nodes
    * unless the local is already present in the set [seen]. This effectively
    * overwrites the current type knowledge in this handler.
    */
   bool mergeHandler(LocalsHandler<T> other, [Set<Local> seen]) {
     if (other.seenReturnOrThrow) return false;
@@ skipping 47 matching lines @@
     });
   }
 
   void updateField(Element element, T type) {
     fieldScope.updateField(element, type);
   }
 }
 
 abstract class InferrerVisitor<T, E extends MinimalInferrerEngine<T>>
     extends Visitor<T>
-    with SemanticSendResolvedMixin<T, dynamic>,
-         CompoundBulkMixin<T, dynamic>,
-         SetIfNullBulkMixin<T, dynamic>,
-         PrefixBulkMixin<T, dynamic>,
-         PostfixBulkMixin<T, dynamic>,
-         ErrorBulkMixin<T, dynamic>,
-         NewBulkMixin<T, dynamic>,
-         SetBulkMixin<T, dynamic>
+    with
+        SemanticSendResolvedMixin<T, dynamic>,
+        CompoundBulkMixin<T, dynamic>,
+        SetIfNullBulkMixin<T, dynamic>,
+        PrefixBulkMixin<T, dynamic>,
+        PostfixBulkMixin<T, dynamic>,
+        ErrorBulkMixin<T, dynamic>,
+        NewBulkMixin<T, dynamic>,
+        SetBulkMixin<T, dynamic>
     implements SemanticSendVisitor<T, dynamic> {
   final Compiler compiler;
   final AstElement analyzedElement;
   final TypeSystem<T> types;
   final E inferrer;
   final Map<JumpTarget, List<LocalsHandler<T>>> breaksFor =
       new Map<JumpTarget, List<LocalsHandler<T>>>();
   final Map<JumpTarget, List<LocalsHandler>> continuesFor =
       new Map<JumpTarget, List<LocalsHandler<T>>>();
   LocalsHandler<T> locals;
   final List<T> cascadeReceiverStack = new List<T>();
   final TreeElements elements;
 
   bool accumulateIsChecks = false;
   bool conditionIsSimple = false;
   List<Send> isChecks;
   int loopLevel = 0;
 
   bool get inLoop => loopLevel > 0;
   bool get isThisExposed {
     return analyzedElement.isGenerativeConstructor
         ? locals.fieldScope.isThisExposed
         : true;
   }
+
   void set isThisExposed(value) {
     if (analyzedElement.isGenerativeConstructor) {
       locals.fieldScope.isThisExposed = value;
     }
   }
 
-  InferrerVisitor(AstElement analyzedElement,
-                  this.inferrer,
-                  this.types,
-                  this.compiler,
-                  [LocalsHandler<T> handler])
-    : this.analyzedElement = analyzedElement,
-      this.locals = handler,
-      this.elements = analyzedElement.resolvedAst.elements {
+  InferrerVisitor(
+      AstElement analyzedElement, this.inferrer, this.types, this.compiler,
+      [LocalsHandler<T> handler])
+      : this.analyzedElement = analyzedElement,
+        this.locals = handler,
+        this.elements = analyzedElement.resolvedAst.elements {
     if (handler != null) return;
     Node node = analyzedElement.node;
     FieldInitializationScope<T> fieldScope =
         analyzedElement.isGenerativeConstructor
             ? new FieldInitializationScope<T>(types)
             : null;
     locals = new LocalsHandler<T>(inferrer, types, compiler, node, fieldScope);
   }
 
   DiagnosticReporter get reporter => compiler.reporter;
@@ skipping 128 matching lines @@
   }
 
   T handleTypeLiteralGet() {
     return types.typeType;
   }
 
   T handleTypeLiteralInvoke(NodeList arguments) {
     return types.dynamicType;
   }
 
-
   @override
   T bulkHandleNode(Node node, String message, _) {
     return internalError(node, message.replaceAll('#', '$node'));
   }
 
   @override
-  T visitConstantGet(
-      Send node,
-      ConstantExpression constant,
-      _) {
+  T visitConstantGet(Send node, ConstantExpression constant, _) {
     return bulkHandleNode(node, "Constant read `#` unhandled.", _);
   }
 
   @override
-  T visitConstantInvoke(
-      Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  T visitConstantInvoke(Send node, ConstantExpression constant,
+      NodeList arguments, CallStructure callStructure, _) {
     return bulkHandleNode(node, "Constant invoke `#` unhandled.", _);
   }
 
-  T visitClassTypeLiteralGet(
-      Send node,
-      ConstantExpression constant,
-      _) {
+  T visitClassTypeLiteralGet(Send node, ConstantExpression constant, _) {
     return handleTypeLiteralGet();
   }
 
-  T visitClassTypeLiteralInvoke(
-      Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  T visitClassTypeLiteralInvoke(Send node, ConstantExpression constant,
+      NodeList arguments, CallStructure callStructure, _) {
     return handleTypeLiteralInvoke(arguments);
   }
 
-  T visitTypedefTypeLiteralGet(
-      Send node,
-      ConstantExpression constant,
-      _) {
+  T visitTypedefTypeLiteralGet(Send node, ConstantExpression constant, _) {
     return handleTypeLiteralGet();
   }
 
-  T visitTypedefTypeLiteralInvoke(
-      Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  T visitTypedefTypeLiteralInvoke(Send node, ConstantExpression constant,
+      NodeList arguments, CallStructure callStructure, _) {
     return handleTypeLiteralInvoke(arguments);
   }
 
-  T visitTypeVariableTypeLiteralGet(
-      Send node,
-      TypeVariableElement element,
-      _) {
+  T visitTypeVariableTypeLiteralGet(Send node, TypeVariableElement element, _) {
     return handleTypeLiteralGet();
   }
 
-  T visitTypeVariableTypeLiteralInvoke(
-      Send node,
-      TypeVariableElement element,
-      NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  T visitTypeVariableTypeLiteralInvoke(Send node, TypeVariableElement element,
+      NodeList arguments, CallStructure callStructure, _) {
     return handleTypeLiteralInvoke(arguments);
   }
 
-  T visitDynamicTypeLiteralGet(
-      Send node,
-      ConstantExpression constant,
-      _) {
+  T visitDynamicTypeLiteralGet(Send node, ConstantExpression constant, _) {
     return handleTypeLiteralGet();
   }
 
-  T visitDynamicTypeLiteralInvoke(
-      Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  T visitDynamicTypeLiteralInvoke(Send node, ConstantExpression constant,
+      NodeList arguments, CallStructure callStructure, _) {
     return handleTypeLiteralInvoke(arguments);
   }
 
   bool isThisOrSuper(Node node) => node.isThis() || node.isSuper();
 
   Element get outermostElement {
     return analyzedElement.outermostEnclosingMemberOrTopLevel.implementation;
   }
 
   T _thisType;
   T get thisType {
     if (_thisType != null) return _thisType;
     ClassElement cls = outermostElement.enclosingClass;
     ClassWorld classWorld = compiler.world;
     if (classWorld.isUsedAsMixin(cls)) {
       return _thisType = types.nonNullSubtype(cls);
     } else {
       return _thisType = types.nonNullSubclass(cls);
     }
   }
 
   T _superType;
   T get superType {
     if (_superType != null) return _superType;
-    return _superType = types.nonNullExact(
-        outermostElement.enclosingClass.superclass);
+    return _superType =
+        types.nonNullExact(outermostElement.enclosingClass.superclass);
   }
 
   @override
   T visitThisGet(Identifier node, _) {
     return thisType;
   }
 
   T visitIdentifier(Identifier node) {
     if (node.isThis()) {
       return thisType;
@@ skipping 37 matching lines @@
           if (usePositive) continue;
         } else {
           if (!usePositive) continue;
         }
         DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
         narrow(elements[node.receiver], type, node);
       } else {
         Element receiverElement = elements[node.receiver];
         Element argumentElement = elements[node.arguments.first];
         String operator = node.selector.asOperator().source;
-        if ((operator == '==' && usePositive)
-            || (operator == '!=' && !usePositive)) {
+        if ((operator == '==' && usePositive) ||
+            (operator == '!=' && !usePositive)) {
           // Type the elements as null.
           if (Elements.isLocal(receiverElement)) {
             locals.update(receiverElement, types.nullType, node);
           }
           if (Elements.isLocal(argumentElement)) {
             locals.update(argumentElement, types.nullType, node);
           }
         } else {
           // Narrow the elements to a non-null type.
           DartType objectType = compiler.coreTypes.objectType;
           if (Elements.isLocal(receiverElement)) {
             narrow(receiverElement, objectType, node);
           }
           if (Elements.isLocal(argumentElement)) {
             narrow(argumentElement, objectType, node);
           }
         }
       }
     }
   }
 
   @override
   T visitIndex(Send node, Node receiver, Node index, _) {
     return handleDynamicInvoke(node);
   }
 
   @override
   T visitDynamicPropertyInvoke(
-      Send node,
-      Node receiver,
-      NodeList arguments,
-      Selector selector,
-      _) {
+      Send node, Node receiver, NodeList arguments, Selector selector, _) {
     return handleDynamicInvoke(node);
   }
 
   @override
   T visitIfNotNullDynamicPropertyInvoke(
-      Send node,
-      Node receiver,
-      NodeList arguments,
-      Selector selector,
-      _) {
+      Send node, Node receiver, NodeList arguments, Selector selector, _) {
     return handleDynamicInvoke(node);
   }
 
   @override
   T visitThisPropertyInvoke(
-      Send node,
-      NodeList arguments,
-      Selector selector,
-      _) {
+      Send node, NodeList arguments, Selector selector, _) {
     return handleDynamicInvoke(node);
   }
 
   @override
   T visitIfNull(Send node, Node left, Node right, _) {
     T firstType = visit(left);
     T secondType = visit(right);
     return types.allocateDiamondPhi(types.narrowNotNull(firstType), secondType);
   }
 
@@ skipping 12 matching lines @@
     updateIsChecks(isChecks, usePositive: true);
     LocalsHandler<T> narrowed;
     if (oldAccumulateIsChecks) {
       narrowed = new LocalsHandler<T>.topLevelCopyOf(locals);
     } else {
       accumulateIsChecks = false;
       isChecks = oldIsChecks;
     }
     visit(right);
     if (oldAccumulateIsChecks) {
-
-      bool invalidatedInRightHandSide (Send test) {
+      bool invalidatedInRightHandSide(Send test) {
         Element receiver = elements[test.receiver];
         if (receiver is LocalElement) {
           return narrowed.locals[receiver] != locals.locals[receiver];
         }
         return false;
       }
 
       isChecks.removeWhere(invalidatedInRightHandSide);
     }
     saved.mergeDiamondFlow(locals, null);
@@ skipping 86 matching lines @@
     if (simpleCondition) updateIsChecks(tests, usePositive: false);
     T secondType = visit(node.elseExpression);
     saved.mergeDiamondFlow(thenLocals, locals);
     locals = saved;
     T type = types.allocateDiamondPhi(firstType, secondType);
     return type;
   }
 
   T visitVariableDefinitions(VariableDefinitions node) {
     for (Link<Node> link = node.definitions.nodes;
-         !link.isEmpty;
-         link = link.tail) {
+        !link.isEmpty;
+        link = link.tail) {
       Node definition = link.head;
       if (definition is Identifier) {
         locals.update(elements[definition], types.nullType, node);
       } else {
         assert(definition.asSendSet() != null);
         handleSendSet(definition);
       }
     }
     return null;
   }
@@ skipping 64 matching lines @@
       // Setup (and clear in case of multiple iterations of the loop)
       // the lists of breaks and continues seen in the loop.
       setupBreaksAndContinues(target);
       locals = new LocalsHandler<T>.from(saved, node);
       logic();
       changed = saved.mergeAll(getLoopBackEdges(target));
     } while (changed);
     loopLevel--;
     saved.endLoop(node);
     bool keepOwnLocals = node.asDoWhile() == null;
-    saved.mergeAfterBreaks(
-        getBreaks(target), keepOwnLocals: keepOwnLocals);
+    saved.mergeAfterBreaks(getBreaks(target), keepOwnLocals: keepOwnLocals);
     locals = saved;
     clearBreaksAndContinues(target);
     return null;
   }
 
   T visitWhile(While node) {
     return handleLoop(node, () {
       List<Send> tests = <Send>[];
       handleCondition(node.condition, tests);
       updateIsChecks(tests, usePositive: true);
@@ skipping 16 matching lines @@
       List<Send> tests = <Send>[];
       handleCondition(node.condition, tests);
       updateIsChecks(tests, usePositive: true);
       visit(node.body);
       visit(node.update);
     });
   }
 
   T visitTryStatement(TryStatement node) {
     LocalsHandler<T> saved = locals;
-    locals = new LocalsHandler<T>.from(
-        locals, node, useOtherTryBlock: false);
+    locals = new LocalsHandler<T>.from(locals, node, useOtherTryBlock: false);
     visit(node.tryBlock);
     saved.mergeDiamondFlow(locals, null);
     locals = saved;
     for (Node catchBlock in node.catchBlocks) {
       saved = locals;
       locals = new LocalsHandler<T>.from(locals, catchBlock);
       visit(catchBlock);
       saved.mergeDiamondFlow(locals, null);
       locals = saved;
     }
     visit(node.finallyBlock);
     return null;
   }
 
   T visitThrow(Throw node) {
     node.visitChildren(this);
     locals.seenReturnOrThrow = true;
     return types.nonNullEmpty();
   }
 
   T visitCatchBlock(CatchBlock node) {
     Node exception = node.exception;
     if (exception != null) {
       DartType type = elements.getType(node.type);
-      T mask = type == null ||
-               type.treatAsDynamic ||
-               type.isTypeVariable
+      T mask = type == null || type.treatAsDynamic || type.isTypeVariable
           ? types.dynamicType
           : types.nonNullSubtype(type.element);
       locals.update(elements[exception], mask, node);
     }
     Node trace = node.trace;
     if (trace != null) {
       locals.update(elements[trace], types.dynamicType, node);
     }
     visit(node.block);
     return null;
   }
 
   T visitParenthesizedExpression(ParenthesizedExpression node) {
     return visit(node.expression);
   }
 
   T visitBlock(Block node) {
     if (node.statements != null) {
       for (Node statement in node.statements) {
         visit(statement);
         if (locals.aborts) break;
       }
     }
     return null;
   }
 
   T visitLabeledStatement(LabeledStatement node) {
     Statement body = node.statement;
-    if (body is Loop
-        || body is SwitchStatement
-        || Elements.isUnusedLabel(node, elements)) {
+    if (body is Loop ||
+        body is SwitchStatement ||
+        Elements.isUnusedLabel(node, elements)) {
       // Loops and switches handle their own labels.
       visit(body);
     } else {
       JumpTarget targetElement = elements.getTargetDefinition(body);
       setupBreaksAndContinues(targetElement);
       visit(body);
       locals.mergeAfterBreaks(getBreaks(targetElement));
       clearBreaksAndContinues(targetElement);
     }
     return null;
@@ skipping 89 matching lines @@
     return type;
   }
 
   T visitCascade(Cascade node) {
     // Ignore the result of the cascade send and return the type of the cascade
     // receiver.
     visit(node.expression);
     return cascadeReceiverStack.removeLast();
   }
 }