dartfmt pkg/compiler

pkg/compiler/lib/src/ssa/nodes.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.
 
-
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
@@ skipping 129 matching lines @@
         assert(instruction != list.first);
       }
     }
 
     currentBlock = node;
     visitInstructionList(node);
   }
 }
 
 class HGraph {
-  Element element;  // Used for debug printing.
+  Element element; // Used for debug printing.
   HBasicBlock entry;
   HBasicBlock exit;
   HThis thisInstruction;
+
   /// Receiver parameter, set for methods using interceptor calling convention.
   HParameterValue explicitReceiverParameter;
   bool isRecursiveMethod = false;
   bool calledInLoop = false;
   final List<HBasicBlock> blocks = <HBasicBlock>[];
   SourceInformation sourceInformation;
 
   // We canonicalize all constants used within a graph so we do not
   // have to worry about them for global value numbering.
   Map<ConstantValue, HConstant> constants = new Map<ConstantValue, HConstant>();
@@ skipping 11 matching lines @@
     blocks.add(block);
     assert(identical(blocks[id], block));
   }
 
   HBasicBlock addNewBlock() {
     HBasicBlock result = new HBasicBlock();
     addBlock(result);
     return result;
   }
 
-  HBasicBlock addNewLoopHeaderBlock(JumpTarget target,
-                                    List<LabelDefinition> labels) {
+  HBasicBlock addNewLoopHeaderBlock(
+      JumpTarget target, List<LabelDefinition> labels) {
     HBasicBlock result = addNewBlock();
-    result.loopInformation =
-        new HLoopInformation(result, target, labels);
+    result.loopInformation = new HLoopInformation(result, target, labels);
     return result;
   }
 
   HConstant addConstant(ConstantValue constant, Compiler compiler,
-                        {SourceInformation sourceInformation}) {
+      {SourceInformation sourceInformation}) {
     HConstant result = constants[constant];
     // TODO(johnniwinther): Support source information per constant reference.
     if (result == null) {
       TypeMask type = computeTypeMask(compiler, constant);
       result = new HConstant.internal(constant, type)
-          ..sourceInformation = sourceInformation;
+        ..sourceInformation = sourceInformation;
       entry.addAtExit(result);
       constants[constant] = result;
     } else if (result.block == null) {
       // The constant was not used anymore.
       entry.addAtExit(result);
     }
     return result;
   }
 
   HConstant addDeferredConstant(ConstantValue constant, PrefixElement prefix,
-                                SourceInformation sourceInformation,
-                                Compiler compiler) {
+      SourceInformation sourceInformation, Compiler compiler) {
     // TODO(sigurdm,johnniwinter): These deferred constants should be created
     // by the constant evaluator.
     ConstantValue wrapper = new DeferredConstantValue(constant, prefix);
     compiler.deferredLoadTask.registerConstantDeferredUse(wrapper, prefix);
     return addConstant(wrapper, compiler, sourceInformation: sourceInformation);
   }
 
   HConstant addConstantInt(int i, Compiler compiler) {
     return addConstant(compiler.backend.constantSystem.createInt(i), compiler);
   }
 
   HConstant addConstantDouble(double d, Compiler compiler) {
     return addConstant(
         compiler.backend.constantSystem.createDouble(d), compiler);
   }
 
-  HConstant addConstantString(ast.DartString str,
-                              Compiler compiler) {
+  HConstant addConstantString(ast.DartString str, Compiler compiler) {
     return addConstant(
-        compiler.backend.constantSystem.createString(str),
+        compiler.backend.constantSystem.createString(str), compiler);
+  }
+
+  HConstant addConstantStringFromName(js.Name name, Compiler compiler) {
+    return addConstant(
+        new SyntheticConstantValue(
+            SyntheticConstantKind.NAME, js.quoteName(name)),
         compiler);
   }
 
-  HConstant addConstantStringFromName(js.Name name,
-                                      Compiler compiler) {
-    return addConstant(
-        new SyntheticConstantValue(SyntheticConstantKind.NAME,
-                                   js.quoteName(name)),
-        compiler);
-  }
-
   HConstant addConstantBool(bool value, Compiler compiler) {
     return addConstant(
         compiler.backend.constantSystem.createBool(value), compiler);
   }
 
   HConstant addConstantNull(Compiler compiler) {
     return addConstant(compiler.backend.constantSystem.createNull(), compiler);
   }
 
   void finalize() {
@@ skipping 75 matching lines @@
   visitForeignCode(HForeignCode node) => visitInstruction(node);
   visitForeignNew(HForeignNew node) => visitInstruction(node);
   visitGoto(HGoto node) => visitControlFlow(node);
   visitGreater(HGreater node) => visitRelational(node);
   visitGreaterEqual(HGreaterEqual node) => visitRelational(node);
   visitIdentity(HIdentity node) => visitRelational(node);
   visitIf(HIf node) => visitConditionalBranch(node);
   visitIndex(HIndex node) => visitInstruction(node);
   visitIndexAssign(HIndexAssign node) => visitInstruction(node);
   visitInterceptor(HInterceptor node) => visitInstruction(node);
-  visitInvokeClosure(HInvokeClosure node)
-      => visitInvokeDynamic(node);
-  visitInvokeConstructorBody(HInvokeConstructorBody node)
-      => visitInvokeStatic(node);
-  visitInvokeDynamicMethod(HInvokeDynamicMethod node)
-      => visitInvokeDynamic(node);
-  visitInvokeDynamicGetter(HInvokeDynamicGetter node)
-      => visitInvokeDynamicField(node);
-  visitInvokeDynamicSetter(HInvokeDynamicSetter node)
-      => visitInvokeDynamicField(node);
+  visitInvokeClosure(HInvokeClosure node) => visitInvokeDynamic(node);
+  visitInvokeConstructorBody(HInvokeConstructorBody node) =>
+      visitInvokeStatic(node);
+  visitInvokeDynamicMethod(HInvokeDynamicMethod node) =>
+      visitInvokeDynamic(node);
+  visitInvokeDynamicGetter(HInvokeDynamicGetter node) =>
+      visitInvokeDynamicField(node);
+  visitInvokeDynamicSetter(HInvokeDynamicSetter node) =>
+      visitInvokeDynamicField(node);
   visitInvokeStatic(HInvokeStatic node) => visitInvoke(node);
   visitInvokeSuper(HInvokeSuper node) => visitInvokeStatic(node);
   visitJump(HJump node) => visitControlFlow(node);
   visitLazyStatic(HLazyStatic node) => visitInstruction(node);
   visitLess(HLess node) => visitRelational(node);
   visitLessEqual(HLessEqual node) => visitRelational(node);
   visitLiteralList(HLiteralList node) => visitInstruction(node);
   visitLocalAccess(HLocalAccess node) => visitInstruction(node);
   visitLocalGet(HLocalGet node) => visitLocalAccess(node);
   visitLocalSet(HLocalSet node) => visitLocalAccess(node);
   visitLocalValue(HLocalValue node) => visitInstruction(node);
   visitLoopBranch(HLoopBranch node) => visitConditionalBranch(node);
   visitNegate(HNegate node) => visitInvokeUnary(node);
   visitNot(HNot node) => visitInstruction(node);
-  visitOneShotInterceptor(HOneShotInterceptor node)
-      => visitInvokeDynamic(node);
+  visitOneShotInterceptor(HOneShotInterceptor node) => visitInvokeDynamic(node);
   visitPhi(HPhi node) => visitInstruction(node);
   visitMultiply(HMultiply node) => visitBinaryArithmetic(node);
   visitParameterValue(HParameterValue node) => visitLocalValue(node);
   visitRangeConversion(HRangeConversion node) => visitCheck(node);
   visitReadModifyWrite(HReadModifyWrite node) => visitInstruction(node);
   visitRef(HRef node) => node.value.accept(this);
   visitReturn(HReturn node) => visitControlFlow(node);
   visitShiftLeft(HShiftLeft node) => visitBinaryBitOp(node);
   visitShiftRight(HShiftRight node) => visitBinaryBitOp(node);
   visitSubtract(HSubtract node) => visitBinaryArithmetic(node);
@@ skipping 29 matching lines @@
 
   bool contains(HBasicBlock block) {
     assert(start != null);
     assert(end != null);
     assert(block != null);
     return start.id <= block.id && block.id <= end.id;
   }
 }
 
 class SubExpression extends SubGraph {
-  const SubExpression(HBasicBlock start, HBasicBlock end)
-      : super(start, end);
+  const SubExpression(HBasicBlock start, HBasicBlock end) : super(start, end);
 
   /** Find the condition expression if this sub-expression is a condition. */
   HInstruction get conditionExpression {
     HInstruction last = end.last;
     if (last is HConditionalBranch || last is HSwitch) return last.inputs[0];
     return null;
   }
 }
 
 class HInstructionList {
@@ skipping 107 matching lines @@
 
   bool isLoopHeader() {
     return loopInformation != null;
   }
 
   void setBlockFlow(HBlockInformation blockInfo, HBasicBlock continuation) {
     blockFlow = new HBlockFlow(blockInfo, continuation);
   }
 
   bool isLabeledBlock() =>
-    blockFlow != null &&
-    blockFlow.body is HLabeledBlockInformation;
+      blockFlow != null && blockFlow.body is HLabeledBlockInformation;
 
   HBasicBlock get enclosingLoopHeader {
     if (isLoopHeader()) return this;
     return parentLoopHeader;
   }
 
   void open() {
     assert(isNew());
     status = STATUS_OPEN;
   }
 
   void close(HControlFlow end) {
     assert(isOpen());
     addAfter(last, end);
     status = STATUS_CLOSED;
   }
 
   void addAtEntry(HInstruction instruction) {
-    assert(instruction is !HPhi);
+    assert(instruction is! HPhi);
     internalAddBefore(first, instruction);
     instruction.notifyAddedToBlock(this);
   }
 
   void addAtExit(HInstruction instruction) {
     assert(isClosed());
     assert(last is HControlFlow);
-    assert(instruction is !HPhi);
+    assert(instruction is! HPhi);
     internalAddBefore(last, instruction);
     instruction.notifyAddedToBlock(this);
   }
 
   void moveAtExit(HInstruction instruction) {
-    assert(instruction is !HPhi);
+    assert(instruction is! HPhi);
     assert(instruction.isInBasicBlock());
     assert(isClosed());
     assert(last is HControlFlow);
     internalAddBefore(last, instruction);
     instruction.block = this;
     assert(isValid());
   }
 
   void add(HInstruction instruction) {
-    assert(instruction is !HControlFlow);
-    assert(instruction is !HPhi);
+    assert(instruction is! HControlFlow);
+    assert(instruction is! HPhi);
     internalAddAfter(last, instruction);
     instruction.notifyAddedToBlock(this);
   }
 
   void addPhi(HPhi phi) {
     assert(phi.inputs.length == 0 || phi.inputs.length == predecessors.length);
     assert(phi.block == null);
     phis.internalAddAfter(phis.last, phi);
     phi.notifyAddedToBlock(this);
   }
 
   void removePhi(HPhi phi) {
     phis.remove(phi);
     assert(phi.block == this);
     phi.notifyRemovedFromBlock();
   }
 
   void addAfter(HInstruction cursor, HInstruction instruction) {
-    assert(cursor is !HPhi);
-    assert(instruction is !HPhi);
+    assert(cursor is! HPhi);
+    assert(instruction is! HPhi);
     assert(isOpen() || isClosed());
     internalAddAfter(cursor, instruction);
     instruction.notifyAddedToBlock(this);
   }
 
   void addBefore(HInstruction cursor, HInstruction instruction) {
-    assert(cursor is !HPhi);
-    assert(instruction is !HPhi);
+    assert(cursor is! HPhi);
+    assert(instruction is! HPhi);
     assert(isOpen() || isClosed());
     internalAddBefore(cursor, instruction);
     instruction.notifyAddedToBlock(this);
   }
 
   void remove(HInstruction instruction) {
     assert(isOpen() || isClosed());
-    assert(instruction is !HPhi);
+    assert(instruction is! HPhi);
     super.remove(instruction);
     assert(instruction.block == this);
     instruction.notifyRemovedFromBlock();
   }
 
   void addSuccessor(HBasicBlock block) {
     if (successors.isEmpty) {
       successors = [block];
     } else {
       successors.add(block);
@@ skipping 213 matching lines @@
   static const int SHIFT_RIGHT_TYPECODE = 30;
   static const int READ_TYPE_VARIABLE_TYPECODE = 31;
   static const int FUNCTION_TYPE_TYPECODE = 32;
   static const int VOID_TYPE_TYPECODE = 33;
   static const int INTERFACE_TYPE_TYPECODE = 34;
   static const int DYNAMIC_TYPE_TYPECODE = 35;
   static const int TRUNCATING_DIVIDE_TYPECODE = 36;
   static const int IS_VIA_INTERCEPTOR_TYPECODE = 37;
 
   HInstruction(this.inputs, this.instructionType)
-      : id = idCounter++, usedBy = <HInstruction>[] {
+      : id = idCounter++,
+        usedBy = <HInstruction>[] {
     assert(inputs.every((e) => e != null));
   }
 
   int get hashCode => id;
 
   bool useGvn() => _useGvn;
-  void setUseGvn() { _useGvn = true; }
+  void setUseGvn() {
+    _useGvn = true;
+  }
 
   bool get isMovable => useGvn();
 
   /**
    * A pure instruction is an instruction that does not have any side
    * effect, nor any dependency. They can be moved anywhere in the
    * graph.
    */
   bool isPure() {
-    return !sideEffects.hasSideEffects()
-        && !sideEffects.dependsOnSomething()
-        && !canThrow();
+    return !sideEffects.hasSideEffects() &&
+        !sideEffects.dependsOnSomething() &&
+        !canThrow();
   }
 
   /// An instruction is an 'allocation' is it is the sole alias for an object.
   /// This applies to to instructions that allocate new objects and can be
   /// extended to methods that return other allocations without escaping them.
   bool get isAllocation => false;
 
   /// Overridden by [HCheck] to return the actual non-[HCheck]
   /// instruction it checks against.
   HInstruction nonCheck() => this;
 
   /// Can this node throw an exception?
   bool canThrow() => false;
 
   /// Does this node potentially affect control flow.
   bool isControlFlow() => false;
 
   bool isExact() => instructionType.isExact || isNull();
 
   bool isValue() => instructionType.isValue;
 
   bool canBeNull() => instructionType.isNullable;
 
   bool isNull() => instructionType.isNull;
 
   bool isConflicting() => instructionType.isEmpty;
 
   /// Returns `true` if [typeMask] contains [cls].
   static bool containsType(
-      TypeMask typeMask,
-      ClassElement cls,
-      ClassWorld classWorld) {
+      TypeMask typeMask, ClassElement cls, ClassWorld classWorld) {
     return classWorld.isInstantiated(cls) && typeMask.contains(cls, classWorld);
   }
 
   /// Returns `true` if [typeMask] contains only [cls].
   static bool containsOnlyType(
-      TypeMask typeMask,
-      ClassElement cls,
-      ClassWorld classWorld) {
-    return classWorld.isInstantiated(cls) &&
-        typeMask.containsOnly(cls);
+      TypeMask typeMask, ClassElement cls, ClassWorld classWorld) {
+    return classWorld.isInstantiated(cls) && typeMask.containsOnly(cls);
   }
 
   /// Returns `true` if [typeMask] is an instance of [cls].
   static bool isInstanceOf(
-      TypeMask typeMask,
-      ClassElement cls,
-      ClassWorld classWorld) {
-    return classWorld.isImplemented(cls) &&
-        typeMask.satisfies(cls, classWorld);
+      TypeMask typeMask, ClassElement cls, ClassWorld classWorld) {
+    return classWorld.isImplemented(cls) && typeMask.satisfies(cls, classWorld);
   }
 
   bool canBePrimitive(Compiler compiler) {
-    return canBePrimitiveNumber(compiler)
-        || canBePrimitiveArray(compiler)
-        || canBePrimitiveBoolean(compiler)
-        || canBePrimitiveString(compiler)
-        || isNull();
+    return canBePrimitiveNumber(compiler) ||
+        canBePrimitiveArray(compiler) ||
+        canBePrimitiveBoolean(compiler) ||
+        canBePrimitiveString(compiler) ||
+        isNull();
   }
 
   bool canBePrimitiveNumber(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
     // TODO(sra): It should be possible to test only jsDoubleClass and
     // jsUInt31Class, since all others are superclasses of these two.
-    return containsType(instructionType, helpers.jsNumberClass, classWorld)
-        || containsType(instructionType, helpers.jsIntClass, classWorld)
-        || containsType(instructionType, helpers.jsPositiveIntClass, classWorld)
-        || containsType(instructionType, helpers.jsUInt32Class, classWorld)
-        || containsType(instructionType, helpers.jsUInt31Class, classWorld)
-        || containsType(instructionType, helpers.jsDoubleClass, classWorld);
+    return containsType(instructionType, helpers.jsNumberClass, classWorld) ||
+        containsType(instructionType, helpers.jsIntClass, classWorld) ||
+        containsType(instructionType, helpers.jsPositiveIntClass, classWorld) ||
+        containsType(instructionType, helpers.jsUInt32Class, classWorld) ||
+        containsType(instructionType, helpers.jsUInt31Class, classWorld) ||
+        containsType(instructionType, helpers.jsDoubleClass, classWorld);
   }
 
   bool canBePrimitiveBoolean(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
     return containsType(instructionType, helpers.jsBoolClass, classWorld);
   }
 
   bool canBePrimitiveArray(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
-    return containsType(instructionType, helpers.jsArrayClass, classWorld)
-        || containsType(instructionType, helpers.jsFixedArrayClass, classWorld)
-        || containsType(
-            instructionType, helpers.jsExtendableArrayClass, classWorld)
-        || containsType(instructionType,
-            helpers.jsUnmodifiableArrayClass, classWorld);
+    return containsType(instructionType, helpers.jsArrayClass, classWorld) ||
+        containsType(instructionType, helpers.jsFixedArrayClass, classWorld) ||
+        containsType(
+            instructionType, helpers.jsExtendableArrayClass, classWorld) ||
+        containsType(
+            instructionType, helpers.jsUnmodifiableArrayClass, classWorld);
   }
 
   bool isIndexablePrimitive(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
-    return instructionType.containsOnlyString(classWorld)
-        || isInstanceOf(instructionType, helpers.jsIndexableClass, classWorld);
+    return instructionType.containsOnlyString(classWorld) ||
+        isInstanceOf(instructionType, helpers.jsIndexableClass, classWorld);
   }
 
   bool isFixedArray(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
     // TODO(sra): Recognize the union of these types as well.
     return containsOnlyType(
-            instructionType, helpers.jsFixedArrayClass, classWorld)
-        || containsOnlyType(
+            instructionType, helpers.jsFixedArrayClass, classWorld) ||
+        containsOnlyType(
             instructionType, helpers.jsUnmodifiableArrayClass, classWorld);
   }
 
   bool isExtendableArray(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
     return containsOnlyType(
         instructionType, helpers.jsExtendableArrayClass, classWorld);
   }
@@ skipping 10 matching lines @@
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
     return isInstanceOf(instructionType, helpers.jsArrayClass, classWorld);
   }
 
   bool isMutableIndexable(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
-    return isInstanceOf(instructionType,
-        helpers.jsMutableIndexableClass, classWorld);
+    return isInstanceOf(
+        instructionType, helpers.jsMutableIndexableClass, classWorld);
   }
 
   bool isArray(Compiler compiler) => isReadableArray(compiler);
 
   bool canBePrimitiveString(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
     return containsType(instructionType, helpers.jsStringClass, classWorld);
   }
 
   bool isInteger(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
-    return instructionType.containsOnlyInt(classWorld)
-        && !instructionType.isNullable;
+    return instructionType.containsOnlyInt(classWorld) &&
+        !instructionType.isNullable;
   }
 
   bool isUInt32(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
-    return !instructionType.isNullable
-        && isInstanceOf(instructionType, helpers.jsUInt32Class, classWorld);
+    return !instructionType.isNullable &&
+        isInstanceOf(instructionType, helpers.jsUInt32Class, classWorld);
   }
 
   bool isUInt31(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
-    return !instructionType.isNullable
-        && isInstanceOf(instructionType, helpers.jsUInt31Class, classWorld);
+    return !instructionType.isNullable &&
+        isInstanceOf(instructionType, helpers.jsUInt31Class, classWorld);
   }
 
   bool isPositiveInteger(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
     return !instructionType.isNullable &&
         isInstanceOf(instructionType, helpers.jsPositiveIntClass, classWorld);
   }
 
   bool isPositiveIntegerOrNull(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
     return isInstanceOf(
         instructionType, helpers.jsPositiveIntClass, classWorld);
   }
 
   bool isIntegerOrNull(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     return instructionType.containsOnlyInt(classWorld);
   }
 
   bool isNumber(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
-    return instructionType.containsOnlyNum(classWorld)
-        && !instructionType.isNullable;
+    return instructionType.containsOnlyNum(classWorld) &&
+        !instructionType.isNullable;
   }
 
   bool isNumberOrNull(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     return instructionType.containsOnlyNum(classWorld);
   }
 
   bool isDouble(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
-    return instructionType.containsOnlyDouble(classWorld)
-        && !instructionType.isNullable;
+    return instructionType.containsOnlyDouble(classWorld) &&
+        !instructionType.isNullable;
   }
 
   bool isDoubleOrNull(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     return instructionType.containsOnlyDouble(classWorld);
   }
 
   bool isBoolean(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
-    return instructionType.containsOnlyBool(classWorld)
-        && !instructionType.isNullable;
+    return instructionType.containsOnlyBool(classWorld) &&
+        !instructionType.isNullable;
   }
 
   bool isBooleanOrNull(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     return instructionType.containsOnlyBool(classWorld);
   }
 
   bool isString(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
-    return instructionType.containsOnlyString(classWorld)
-        && !instructionType.isNullable;
+    return instructionType.containsOnlyString(classWorld) &&
+        !instructionType.isNullable;
   }
 
   bool isStringOrNull(Compiler compiler) {
     ClassWorld classWorld = compiler.world;
     return instructionType.containsOnlyString(classWorld);
   }
 
   bool isPrimitive(Compiler compiler) {
-    return (isPrimitiveOrNull(compiler) && !instructionType.isNullable)
-        || isNull();
+    return (isPrimitiveOrNull(compiler) && !instructionType.isNullable) ||
+        isNull();
   }
 
   bool isPrimitiveOrNull(Compiler compiler) {
-    return isIndexablePrimitive(compiler)
-        || isNumberOrNull(compiler)
-        || isBooleanOrNull(compiler)
-        || isNull();
+    return isIndexablePrimitive(compiler) ||
+        isNumberOrNull(compiler) ||
+        isBooleanOrNull(compiler) ||
+        isNull();
   }
 
   /**
    * Type of the instruction.
    */
   TypeMask instructionType;
 
   Selector get selector => null;
   HInstruction getDartReceiver(Compiler compiler) => null;
   bool onlyThrowsNSM() => false;
@@ skipping 142 matching lines @@
           users.remove(current);
           if (--usersInCurrentBlock == 0) break;
         }
         current = current.next;
       }
     }
 
     return users;
   }
 
-  void replaceAllUsersDominatedBy(HInstruction cursor,
-                                  HInstruction newInstruction) {
+  void replaceAllUsersDominatedBy(
+      HInstruction cursor, HInstruction newInstruction) {
     Setlet<HInstruction> users = dominatedUsers(cursor);
     for (HInstruction user in users) {
       user.changeUse(this, newInstruction);
     }
   }
 
   void moveBefore(HInstruction other) {
-    assert(this is !HControlFlow);
-    assert(this is !HPhi);
-    assert(other is !HPhi);
+    assert(this is! HControlFlow);
+    assert(this is! HPhi);
+    assert(other is! HPhi);
     block.detach(this);
     other.block.internalAddBefore(other, this);
     block = other.block;
   }
 
   bool isConstant() => false;
   bool isConstantBoolean() => false;
   bool isConstantNull() => false;
   bool isConstantNumber() => false;
   bool isConstantInteger() => false;
@@ skipping 43 matching lines @@
     Element element = type.element;
     JavaScriptBackend backend = compiler.backend;
     if (type.kind != TypeKind.INTERFACE) {
       return new HTypeConversion(type, kind, backend.dynamicType, this);
     } else if (kind == HTypeConversion.BOOLEAN_CONVERSION_CHECK) {
       // Boolean conversion checks work on non-nullable booleans.
       return new HTypeConversion(type, kind, backend.boolType, this);
     } else if (kind == HTypeConversion.CHECKED_MODE_CHECK && !type.treatAsRaw) {
       throw 'creating compound check to $type (this = ${this})';
     } else {
-      TypeMask subtype = new TypeMask.subtype(element.declaration,
-                                              compiler.world);
+      TypeMask subtype =
+          new TypeMask.subtype(element.declaration, compiler.world);
       return new HTypeConversion(type, kind, subtype, this);
     }
   }
 
   /**
    * Return whether the instructions do not belong to a loop or
    * belong to the same loop.
    */
   bool hasSameLoopHeaderAs(HInstruction other) {
     return block.enclosingLoopHeader == other.block.enclosingLoopHeader;
@@ skipping 121 matching lines @@
   static const int ARGUMENTS_OFFSET = 1;
   bool canThrow() => true;
 
   /**
    * Returns whether this call is on an intercepted method.
    */
   bool get isInterceptedCall {
     // We know it's a selector call if it follows the interceptor
     // calling convention, which adds the actual receiver as a
     // parameter to the call.
-    return (selector != null) &&
-           (inputs.length - 2 == selector.argumentCount);
+    return (selector != null) && (inputs.length - 2 == selector.argumentCount);
   }
 }
 
 abstract class HInvokeDynamic extends HInvoke {
   final InvokeDynamicSpecializer specializer;
   Selector selector;
   TypeMask mask;
   Element element;
 
-  HInvokeDynamic(Selector selector,
-                 this.mask,
-                 this.element,
-                 List<HInstruction> inputs,
-                 TypeMask type,
-                 [bool isIntercepted = false])
-    : super(inputs, type),
-      this.selector = selector,
-      specializer = isIntercepted
-          ? InvokeDynamicSpecializer.lookupSpecializer(selector)
-          : const InvokeDynamicSpecializer();
+  HInvokeDynamic(Selector selector, this.mask, this.element,
+      List<HInstruction> inputs, TypeMask type,
+      [bool isIntercepted = false])
+      : super(inputs, type),
+        this.selector = selector,
+        specializer = isIntercepted
+            ? InvokeDynamicSpecializer.lookupSpecializer(selector)
+            : const InvokeDynamicSpecializer();
   toString() => 'invoke dynamic: selector=$selector, mask=$mask';
   HInstruction get receiver => inputs[0];
   HInstruction getDartReceiver(Compiler compiler) {
     return isCallOnInterceptor(compiler) ? inputs[1] : inputs[0];
   }
 
   /**
    * Returns whether this call is on an interceptor object.
    */
   bool isCallOnInterceptor(Compiler compiler) {
     return isInterceptedCall && receiver.isInterceptor(compiler);
   }
 
   int typeCode() => HInstruction.INVOKE_DYNAMIC_TYPECODE;
   bool typeEquals(other) => other is HInvokeDynamic;
   bool dataEquals(HInvokeDynamic other) {
     // Use the name and the kind instead of [Selector.operator==]
     // because we don't need to check the arity (already checked in
     // [gvnEquals]), and the receiver types may not be in sync.
-    return selector.name == other.selector.name
-        && selector.kind == other.selector.kind;
+    return selector.name == other.selector.name &&
+        selector.kind == other.selector.kind;
   }
 }
 
 class HInvokeClosure extends HInvokeDynamic {
-  HInvokeClosure(Selector selector,
-                 List<HInstruction> inputs,
-                 TypeMask type)
+  HInvokeClosure(Selector selector, List<HInstruction> inputs, TypeMask type)
       : super(selector, null, null, inputs, type) {
     assert(selector.isClosureCall);
   }
   accept(HVisitor visitor) => visitor.visitInvokeClosure(this);
 }
 
 class HInvokeDynamicMethod extends HInvokeDynamic {
-  HInvokeDynamicMethod(Selector selector,
-                       TypeMask mask,
-                       List<HInstruction> inputs,
-                       TypeMask type,
-                       [bool isIntercepted = false])
-    : super(selector, mask, null, inputs, type, isIntercepted);
+  HInvokeDynamicMethod(Selector selector, TypeMask mask,
+      List<HInstruction> inputs, TypeMask type,
+      [bool isIntercepted = false])
+      : super(selector, mask, null, inputs, type, isIntercepted);
 
   String toString() => 'invoke dynamic method: selector=$selector, mask=$mask';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicMethod(this);
 }
 
 abstract class HInvokeDynamicField extends HInvokeDynamic {
-  HInvokeDynamicField(
-      Selector selector, TypeMask mask,
-      Element element, List<HInstruction> inputs,
-      TypeMask type)
+  HInvokeDynamicField(Selector selector, TypeMask mask, Element element,
+      List<HInstruction> inputs, TypeMask type)
       : super(selector, mask, element, inputs, type);
   toString() => 'invoke dynamic field: selector=$selector, mask=$mask';
 }
 
 class HInvokeDynamicGetter extends HInvokeDynamicField {
-  HInvokeDynamicGetter(Selector selector, TypeMask mask,
-      Element element, List<HInstruction> inputs, TypeMask type)
-    : super(selector, mask, element, inputs, type);
+  HInvokeDynamicGetter(Selector selector, TypeMask mask, Element element,
+      List<HInstruction> inputs, TypeMask type)
+      : super(selector, mask, element, inputs, type);
   toString() => 'invoke dynamic getter: selector=$selector, mask=$mask';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicGetter(this);
 }
 
 class HInvokeDynamicSetter extends HInvokeDynamicField {
-  HInvokeDynamicSetter(Selector selector, TypeMask mask,
-      Element element, List<HInstruction> inputs, TypeMask type)
-    : super(selector, mask, element, inputs, type);
+  HInvokeDynamicSetter(Selector selector, TypeMask mask, Element element,
+      List<HInstruction> inputs, TypeMask type)
+      : super(selector, mask, element, inputs, type);
   toString() => 'invoke dynamic setter: selector=$selector, mask=$mask';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicSetter(this);
 }
 
 class HInvokeStatic extends HInvoke {
   final Element element;
 
   final bool targetCanThrow;
 
   bool canThrow() => targetCanThrow;
 
   /// If this instruction is a call to a constructor, [instantiatedTypes]
   /// contains the type(s) used in the (Dart) `New` expression(s). The
   /// [instructionType] of this node is not enough, because we also need the
   /// type arguments. See also [SsaFromAstMixin.currentInlinedInstantiations].
   List<DartType> instantiatedTypes;
 
   /** The first input must be the target. */
   HInvokeStatic(this.element, inputs, TypeMask type,
-                {this.targetCanThrow: true})
-    : super(inputs, type);
+      {this.targetCanThrow: true})
+      : super(inputs, type);
 
   toString() => 'invoke static: $element';
   accept(HVisitor visitor) => visitor.visitInvokeStatic(this);
   int typeCode() => HInstruction.INVOKE_STATIC_TYPECODE;
 }
 
 class HInvokeSuper extends HInvokeStatic {
   /** The class where the call to super is being done. */
   final ClassElement caller;
   final bool isSetter;
   final Selector selector;
 
-  HInvokeSuper(Element element,
-               this.caller,
-               this.selector,
-               inputs,
-               type,
-               SourceInformation sourceInformation,
-               {this.isSetter})
+  HInvokeSuper(Element element, this.caller, this.selector, inputs, type,
+      SourceInformation sourceInformation,
+      {this.isSetter})
       : super(element, inputs, type) {
     this.sourceInformation = sourceInformation;
   }
 
   HInstruction get receiver => inputs[0];
   HInstruction getDartReceiver(Compiler compiler) {
     return isCallOnInterceptor(compiler) ? inputs[1] : inputs[0];
   }
 
   /**
@@ skipping 10 matching lines @@
     assert(isSetter);
     // The 'inputs' are [receiver, value] or [interceptor, receiver, value].
     return inputs.last;
   }
 }
 
 class HInvokeConstructorBody extends HInvokeStatic {
   // The 'inputs' are
   //     [receiver, arg1, ..., argN] or
   //     [interceptor, receiver, arg1, ... argN].
-  HInvokeConstructorBody(element, inputs, type)
-      : super(element, inputs, type);
+  HInvokeConstructorBody(element, inputs, type) : super(element, inputs, type);
 
   String toString() => 'invoke constructor body: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeConstructorBody(this);
 }
 
 abstract class HFieldAccess extends HInstruction {
   final Element element;
 
   HFieldAccess(Element element, List<HInstruction> inputs, TypeMask type)
-      : this.element = element, super(inputs, type);
+      : this.element = element,
+        super(inputs, type);
 
   HInstruction get receiver => inputs[0];
 }
 
 class HFieldGet extends HFieldAccess {
   final bool isAssignable;
 
-  HFieldGet(Element element,
-            HInstruction receiver,
-            TypeMask type,
-            {bool isAssignable})
-      : this.isAssignable = (isAssignable != null)
-            ? isAssignable
-            : element.isAssignable,
+  HFieldGet(Element element, HInstruction receiver, TypeMask type,
+      {bool isAssignable})
+      : this.isAssignable =
+            (isAssignable != null) ? isAssignable : element.isAssignable,
         super(element, <HInstruction>[receiver], type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     setUseGvn();
     if (this.isAssignable) {
       sideEffects.setDependsOnInstancePropertyStore();
     }
   }
 
   bool isInterceptor(Compiler compiler) {
@@ skipping 17 matching lines @@
 
   accept(HVisitor visitor) => visitor.visitFieldGet(this);
 
   int typeCode() => HInstruction.FIELD_GET_TYPECODE;
   bool typeEquals(other) => other is HFieldGet;
   bool dataEquals(HFieldGet other) => element == other.element;
   String toString() => "FieldGet $element";
 }
 
 class HFieldSet extends HFieldAccess {
-  HFieldSet(Element element,
-            HInstruction receiver,
-            HInstruction value)
+  HFieldSet(Element element, HInstruction receiver, HInstruction value)
       : super(element, <HInstruction>[receiver, value],
-              const TypeMask.nonNullEmpty()) {
+            const TypeMask.nonNullEmpty()) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     sideEffects.setChangesInstanceProperty();
   }
 
   bool canThrow() => receiver.canBeNull();
 
   HInstruction getDartReceiver(Compiler compiler) => receiver;
   bool onlyThrowsNSM() => true;
 
   HInstruction get value => inputs[1];
   accept(HVisitor visitor) => visitor.visitFieldSet(this);
 
   bool isJsStatement() => true;
   String toString() => "FieldSet $element";
 }
 
 /**
  * HReadModifyWrite is a late stage instruction for a field (property) update
  * via an assignment operation or pre- or post-increment.
  */
 class HReadModifyWrite extends HLateInstruction {
   static const ASSIGN_OP = 0;
   static const PRE_OP = 1;
   static const POST_OP = 2;
   final Element element;
   final String jsOp;
   final int opKind;
 
-   HReadModifyWrite._(Element this.element, this.jsOp, this.opKind,
+  HReadModifyWrite._(Element this.element, this.jsOp, this.opKind,
       List<HInstruction> inputs, TypeMask type)
       : super(inputs, type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     sideEffects.setChangesInstanceProperty();
     sideEffects.setDependsOnInstancePropertyStore();
   }
 
-  HReadModifyWrite.assignOp(Element element, String jsOp,
-      HInstruction receiver, HInstruction operand, TypeMask type)
-      : this._(element, jsOp, ASSIGN_OP,
-               <HInstruction>[receiver, operand], type);
+  HReadModifyWrite.assignOp(Element element, String jsOp, HInstruction receiver,
+      HInstruction operand, TypeMask type)
+      : this._(
+            element, jsOp, ASSIGN_OP, <HInstruction>[receiver, operand], type);
 
-  HReadModifyWrite.preOp(Element element, String jsOp,
-      HInstruction receiver, TypeMask type)
+  HReadModifyWrite.preOp(
+      Element element, String jsOp, HInstruction receiver, TypeMask type)
       : this._(element, jsOp, PRE_OP, <HInstruction>[receiver], type);
 
-  HReadModifyWrite.postOp(Element element, String jsOp,
-      HInstruction receiver, TypeMask type)
+  HReadModifyWrite.postOp(
+      Element element, String jsOp, HInstruction receiver, TypeMask type)
       : this._(element, jsOp, POST_OP, <HInstruction>[receiver], type);
 
   HInstruction get receiver => inputs[0];
 
   bool get isPreOp => opKind == PRE_OP;
   bool get isPostOp => opKind == POST_OP;
   bool get isAssignOp => opKind == ASSIGN_OP;
 
   bool canThrow() => receiver.canBeNull();
 
@@ skipping 13 matching lines @@
   HLocalAccess(this.variable, List<HInstruction> inputs, TypeMask type)
       : super(inputs, type);
 
   HInstruction get receiver => inputs[0];
 }
 
 class HLocalGet extends HLocalAccess {
   // No need to use GVN for a [HLocalGet], it is just a local
   // access.
   HLocalGet(Local variable, HLocalValue local, TypeMask type,
-            SourceInformation sourceInformation)
+      SourceInformation sourceInformation)
       : super(variable, <HInstruction>[local], type) {
     this.sourceInformation = sourceInformation;
   }
 
   accept(HVisitor visitor) => visitor.visitLocalGet(this);
 
   HLocalValue get local => inputs[0];
 }
 
 class HLocalSet extends HLocalAccess {
   HLocalSet(Local variable, HLocalValue local, HInstruction value)
       : super(variable, <HInstruction>[local, value],
-              const TypeMask.nonNullEmpty());
+            const TypeMask.nonNullEmpty());
 
   accept(HVisitor visitor) => visitor.visitLocalSet(this);
 
   HLocalValue get local => inputs[0];
   HInstruction get value => inputs[1];
   bool isJsStatement() => true;
 }
 
 abstract class HForeign extends HInstruction {
   HForeign(TypeMask type, List<HInstruction> inputs) : super(inputs, type);
 
   bool get isStatement => false;
   native.NativeBehavior get nativeBehavior => null;
 
   bool canThrow() {
-    return sideEffects.hasSideEffects()
-        || sideEffects.dependsOnSomething();
+    return sideEffects.hasSideEffects() || sideEffects.dependsOnSomething();
   }
 }
 
 class HForeignCode extends HForeign {
   final js.Template codeTemplate;
   final bool isStatement;
   final native.NativeBehavior nativeBehavior;
   native.NativeThrowBehavior throwBehavior;
 
-  HForeignCode(this.codeTemplate,
-      TypeMask type,
-      List<HInstruction> inputs,
+  HForeignCode(this.codeTemplate, TypeMask type, List<HInstruction> inputs,
       {this.isStatement: false,
-       SideEffects effects,
-       native.NativeBehavior nativeBehavior,
-       native.NativeThrowBehavior throwBehavior})
+      SideEffects effects,
+      native.NativeBehavior nativeBehavior,
+      native.NativeThrowBehavior throwBehavior})
       : this.nativeBehavior = nativeBehavior,
         this.throwBehavior = throwBehavior,
         super(type, inputs) {
     assert(codeTemplate != null);
     if (effects == null && nativeBehavior != null) {
       effects = nativeBehavior.sideEffects;
     }
     if (this.throwBehavior == null) {
       this.throwBehavior = (nativeBehavior == null)
           ? native.NativeThrowBehavior.MAY
           : nativeBehavior.throwBehavior;
     }
     assert(this.throwBehavior != null);
 
     if (effects != null) sideEffects.add(effects);
   }
 
   HForeignCode.statement(js.Template codeTemplate, List<HInstruction> inputs,
-      SideEffects effects,
-      native.NativeBehavior nativeBehavior,
-      TypeMask type)
-      : this(codeTemplate, type, inputs, isStatement: true,
-             effects: effects, nativeBehavior: nativeBehavior);
+      SideEffects effects, native.NativeBehavior nativeBehavior, TypeMask type)
+      : this(codeTemplate, type, inputs,
+            isStatement: true,
+            effects: effects,
+            nativeBehavior: nativeBehavior);
 
   accept(HVisitor visitor) => visitor.visitForeignCode(this);
 
   bool isJsStatement() => isStatement;
-  bool canThrow() => canBeNull()
-      ? throwBehavior.canThrow
-      : throwBehavior.onNonNull.canThrow;
+  bool canThrow() =>
+      canBeNull() ? throwBehavior.canThrow : throwBehavior.onNonNull.canThrow;
 
   bool onlyThrowsNSM() => throwBehavior.isOnlyNullNSMGuard;
 
-  bool get isAllocation => nativeBehavior != null &&
-      nativeBehavior.isAllocation &&
-      !canBeNull();
+  bool get isAllocation =>
+      nativeBehavior != null && nativeBehavior.isAllocation && !canBeNull();
 
   String toString() => 'HForeignCode("${codeTemplate.source}",$inputs)';
 }
 
 class HForeignNew extends HForeign {
   ClassElement element;
 
   /// If this field is not `null`, this call is from an inlined constructor and
   /// we have to register the instantiated type in the code generator. The
   /// [instructionType] of this node is not enough, because we also need the
   /// type arguments. See also [SsaFromAstMixin.currentInlinedInstantiations].
   List<DartType> instantiatedTypes;
 
   HForeignNew(this.element, TypeMask type, List<HInstruction> inputs,
-              [this.instantiatedTypes])
+      [this.instantiatedTypes])
       : super(type, inputs);
 
   accept(HVisitor visitor) => visitor.visitForeignNew(this);
 
   bool get isAllocation => true;
 
   String toString() => 'HForeignNew($element)';
 }
 
 abstract class HInvokeBinary extends HInstruction {
@@ skipping 17 matching lines @@
       HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   BinaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HAdd extends HBinaryArithmetic {
   HAdd(HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitAdd(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.add;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.add;
   int typeCode() => HInstruction.ADD_TYPECODE;
   bool typeEquals(other) => other is HAdd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HDivide extends HBinaryArithmetic {
   HDivide(
       HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitDivide(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.divide;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.divide;
   int typeCode() => HInstruction.DIVIDE_TYPECODE;
   bool typeEquals(other) => other is HDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HMultiply extends HBinaryArithmetic {
   HMultiply(
       HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitMultiply(this);
 
-  BinaryOperation operation(ConstantSystem operations)
-      => operations.multiply;
+  BinaryOperation operation(ConstantSystem operations) => operations.multiply;
   int typeCode() => HInstruction.MULTIPLY_TYPECODE;
   bool typeEquals(other) => other is HMultiply;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HSubtract extends HBinaryArithmetic {
   HSubtract(
       HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitSubtract(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.subtract;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.subtract;
   int typeCode() => HInstruction.SUBTRACT_TYPECODE;
   bool typeEquals(other) => other is HSubtract;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HTruncatingDivide extends HBinaryArithmetic {
   HTruncatingDivide(
       HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitTruncatingDivide(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.truncatingDivide;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.truncatingDivide;
   int typeCode() => HInstruction.TRUNCATING_DIVIDE_TYPECODE;
   bool typeEquals(other) => other is HTruncatingDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
  * An [HSwitch] instruction has one input for the incoming
  * value, and one input per constant that it can switch on.
  * Its block has one successor per constant, and one for the default.
  */
@@ skipping 20 matching lines @@
       HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
 }
 
 class HShiftLeft extends HBinaryBitOp {
   HShiftLeft(
       HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitShiftLeft(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.shiftLeft;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.shiftLeft;
   int typeCode() => HInstruction.SHIFT_LEFT_TYPECODE;
   bool typeEquals(other) => other is HShiftLeft;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HShiftRight extends HBinaryBitOp {
   HShiftRight(
       HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitShiftRight(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.shiftRight;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.shiftRight;
   int typeCode() => HInstruction.SHIFT_RIGHT_TYPECODE;
   bool typeEquals(other) => other is HShiftRight;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitOr extends HBinaryBitOp {
   HBitOr(
       HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitBitOr(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.bitOr;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.bitOr;
   int typeCode() => HInstruction.BIT_OR_TYPECODE;
   bool typeEquals(other) => other is HBitOr;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitAnd extends HBinaryBitOp {
   HBitAnd(
       HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitBitAnd(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.bitAnd;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.bitAnd;
   int typeCode() => HInstruction.BIT_AND_TYPECODE;
   bool typeEquals(other) => other is HBitAnd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitXor extends HBinaryBitOp {
   HBitXor(
       HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitBitXor(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.bitXor;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.bitXor;
   int typeCode() => HInstruction.BIT_XOR_TYPECODE;
   bool typeEquals(other) => other is HBitXor;
   bool dataEquals(HInstruction other) => true;
 }
 
 abstract class HInvokeUnary extends HInstruction {
   final Selector selector;
   HInvokeUnary(HInstruction input, this.selector, type)
       : super(<HInstruction>[input], type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     setUseGvn();
   }
 
   HInstruction get operand => inputs[0];
 
   UnaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HNegate extends HInvokeUnary {
   HNegate(HInstruction input, Selector selector, TypeMask type)
       : super(input, selector, type);
   accept(HVisitor visitor) => visitor.visitNegate(this);
 
-  UnaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.negate;
+  UnaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.negate;
   int typeCode() => HInstruction.NEGATE_TYPECODE;
   bool typeEquals(other) => other is HNegate;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitNot extends HInvokeUnary {
   HBitNot(HInstruction input, Selector selector, TypeMask type)
       : super(input, selector, type);
   accept(HVisitor visitor) => visitor.visitBitNot(this);
 
-  UnaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.bitNot;
+  UnaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.bitNot;
   int typeCode() => HInstruction.BIT_NOT_TYPECODE;
   bool typeEquals(other) => other is HBitNot;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HExit extends HControlFlow {
   HExit() : super(const <HInstruction>[]);
   toString() => 'exit';
   accept(HVisitor visitor) => visitor.visitExit(this);
 }
 
 class HGoto extends HControlFlow {
   HGoto() : super(const <HInstruction>[]);
   toString() => 'goto';
   accept(HVisitor visitor) => visitor.visitGoto(this);
 }
 
 abstract class HJump extends HControlFlow {
   final JumpTarget target;
   final LabelDefinition label;
-  HJump(this.target) : label = null, super(const <HInstruction>[]);
+  HJump(this.target)
+      : label = null,
+        super(const <HInstruction>[]);
   HJump.toLabel(LabelDefinition label)
-      : label = label, target = label.target, super(const <HInstruction>[]);
+      : label = label,
+        target = label.target,
+        super(const <HInstruction>[]);
 }
 
 class HBreak extends HJump {
   /**
    * Signals that this is a special break instruction for the synthetic loop
    * generatedfor a switch statement with continue statements. See
    * [SsaFromAstMixin.buildComplexSwitchStatement] for detail.
    */
   final bool breakSwitchContinueLoop;
   HBreak(JumpTarget target, {bool this.breakSwitchContinueLoop: false})
       : super(target);
   HBreak.toLabel(LabelDefinition label)
-      : breakSwitchContinueLoop = false, super.toLabel(label);
+      : breakSwitchContinueLoop = false,
+        super.toLabel(label);
   toString() => (label != null) ? 'break ${label.labelName}' : 'break';
   accept(HVisitor visitor) => visitor.visitBreak(this);
 }
 
 class HContinue extends HJump {
   HContinue(JumpTarget target) : super(target);
   HContinue.toLabel(LabelDefinition label) : super.toLabel(label);
   toString() => (label != null) ? 'continue ${label.labelName}' : 'continue';
   accept(HVisitor visitor) => visitor.visitContinue(this);
 }
@@ skipping 93 matching lines @@
   bool typeEquals(other) => other is HNot;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
   * An [HLocalValue] represents a local. Unlike [HParameterValue]s its
   * first use must be in an HLocalSet. That is, [HParameterValue]s have a
   * value from the start, whereas [HLocalValue]s need to be initialized first.
   */
 class HLocalValue extends HInstruction {
-  HLocalValue(Entity variable, TypeMask type)
-      : super(<HInstruction>[], type) {
+  HLocalValue(Entity variable, TypeMask type) : super(<HInstruction>[], type) {
     sourceElement = variable;
   }
 
   toString() => 'local ${sourceElement.name}';
   accept(HVisitor visitor) => visitor.visitLocalValue(this);
 }
 
 class HParameterValue extends HLocalValue {
   HParameterValue(Entity variable, type) : super(variable, type);
 
@@ skipping 29 matching lines @@
   // predecessor-edges. That is if an input comes from the first predecessor
   // of the surrounding block, then the input must be the first in the [HPhi].
   HPhi(Local variable, List<HInstruction> inputs, TypeMask type)
       : super(inputs, type) {
     sourceElement = variable;
   }
   HPhi.noInputs(Local variable, TypeMask type)
       : this(variable, <HInstruction>[], type);
   HPhi.singleInput(Local variable, HInstruction input, TypeMask type)
       : this(variable, <HInstruction>[input], type);
-  HPhi.manyInputs(Local variable,
-                  List<HInstruction> inputs,
-                  TypeMask type)
+  HPhi.manyInputs(Local variable, List<HInstruction> inputs, TypeMask type)
       : this(variable, inputs, type);
 
   void addInput(HInstruction input) {
     assert(isInBasicBlock());
     inputs.add(input);
     assert(inputs.length <= block.predecessors.length);
     input.usedBy.add(this);
   }
 
   toString() => 'phi $id';
   accept(HVisitor visitor) => visitor.visitPhi(this);
 }
 
 abstract class HRelational extends HInvokeBinary {
   bool usesBoolifiedInterceptor = false;
   HRelational(left, right, selector, type) : super(left, right, selector, type);
 }
 
 class HIdentity extends HRelational {
   // Cached codegen decision.
-  String singleComparisonOp;  // null, '===', '=='
+  String singleComparisonOp; // null, '===', '=='
 
   HIdentity(left, right, selector, type) : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitIdentity(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.identity;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.identity;
   int typeCode() => HInstruction.IDENTITY_TYPECODE;
   bool typeEquals(other) => other is HIdentity;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HGreater extends HRelational {
   HGreater(left, right, selector, type) : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitGreater(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.greater;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.greater;
   int typeCode() => HInstruction.GREATER_TYPECODE;
   bool typeEquals(other) => other is HGreater;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HGreaterEqual extends HRelational {
   HGreaterEqual(left, right, selector, type)
       : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitGreaterEqual(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.greaterEqual;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.greaterEqual;
   int typeCode() => HInstruction.GREATER_EQUAL_TYPECODE;
   bool typeEquals(other) => other is HGreaterEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HLess extends HRelational {
   HLess(left, right, selector, type) : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitLess(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.less;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.less;
   int typeCode() => HInstruction.LESS_TYPECODE;
   bool typeEquals(other) => other is HLess;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HLessEqual extends HRelational {
   HLessEqual(left, right, selector, type) : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitLessEqual(this);
 
-  BinaryOperation operation(ConstantSystem constantSystem)
-      => constantSystem.lessEqual;
+  BinaryOperation operation(ConstantSystem constantSystem) =>
+      constantSystem.lessEqual;
   int typeCode() => HInstruction.LESS_EQUAL_TYPECODE;
   bool typeEquals(other) => other is HLessEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HReturn extends HControlFlow {
   HReturn(HInstruction value, SourceInformation sourceInformation)
       : super(<HInstruction>[value]) {
     this.sourceInformation = sourceInformation;
   }
@@ skipping 26 matching lines @@
       : super(<HInstruction>[value], const TypeMask.nonNullEmpty());
   bool hasStar;
   toString() => 'yield';
   accept(HVisitor visitor) => visitor.visitYield(this);
   bool canThrow() => false;
   SideEffects sideEffects = new SideEffects();
 }
 
 class HThrow extends HControlFlow {
   final bool isRethrow;
-  HThrow(HInstruction value,
-         SourceInformation sourceInformation,
-         {this.isRethrow: false})
+  HThrow(HInstruction value, SourceInformation sourceInformation,
+      {this.isRethrow: false})
       : super(<HInstruction>[value]) {
     this.sourceInformation = sourceInformation;
   }
   toString() => 'throw';
   accept(HVisitor visitor) => visitor.visitThrow(this);
 }
 
 class HStatic extends HInstruction {
   final Element element;
   HStatic(this.element, type) : super(<HInstruction>[], type) {
@@ skipping 23 matching lines @@
 
   // inputs[0] is initially the only input, the receiver.
 
   // inputs[1] is a constant interceptor when the interceptor is a constant
   // except for a `null` receiver.  This is used when the receiver can't be
   // falsy, except for `null`, allowing the generation of code like
   //
   //     (a && C.JSArray_methods).get$first(a)
   //
 
-  HInterceptor(HInstruction receiver,
-               TypeMask type)
+  HInterceptor(HInstruction receiver, TypeMask type)
       : super(<HInstruction>[receiver], type) {
     this.sourceInformation = receiver.sourceInformation;
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     setUseGvn();
   }
 
   String toString() => 'interceptor on $interceptedClasses';
   accept(HVisitor visitor) => visitor.visitInterceptor(this);
   HInstruction get receiver => inputs[0];
 
   bool get isConditionalConstantInterceptor => inputs.length == 2;
   HInstruction get conditionalConstantInterceptor => inputs[1];
   void set conditionalConstantInterceptor(HConstant constant) {
     assert(!isConditionalConstantInterceptor);
     inputs.add(constant);
   }
 
   bool isInterceptor(Compiler compiler) => true;
 
   int typeCode() => HInstruction.INTERCEPTOR_TYPECODE;
   bool typeEquals(other) => other is HInterceptor;
   bool dataEquals(HInterceptor other) {
-    return interceptedClasses == other.interceptedClasses
-        || (interceptedClasses.length == other.interceptedClasses.length
-            && interceptedClasses.containsAll(other.interceptedClasses));
+    return interceptedClasses == other.interceptedClasses ||
+        (interceptedClasses.length == other.interceptedClasses.length &&
+            interceptedClasses.containsAll(other.interceptedClasses));
   }
 }
 
 /**
  * A "one-shot" interceptor is a call to a synthetized method that
  * will fetch the interceptor of its first parameter, and make a call
  * on a given selector with the remaining parameters.
  *
  * In order to share the same optimizations with regular interceptor
  * calls, this class extends [HInvokeDynamic] and also has the null
  * constant as the first input.
  */
 class HOneShotInterceptor extends HInvokeDynamic {
   Set<ClassElement> interceptedClasses;
-  HOneShotInterceptor(Selector selector,
-                      TypeMask mask,
-                      List<HInstruction> inputs,
-                      TypeMask type,
-                      this.interceptedClasses)
+  HOneShotInterceptor(Selector selector, TypeMask mask,
+      List<HInstruction> inputs, TypeMask type, this.interceptedClasses)
       : super(selector, mask, null, inputs, type, true) {
     assert(inputs[0] is HConstant);
     assert(inputs[0].isNull());
   }
   bool isCallOnInterceptor(Compiler compiler) => true;
 
   String toString() => 'one shot interceptor: selector=$selector, mask=$mask';
   accept(HVisitor visitor) => visitor.visitOneShotInterceptor(this);
 }
 
@@ skipping 40 matching lines @@
 
   bool get isAllocation => true;
 }
 
 /**
  * The primitive array indexing operation. Note that this instruction
  * does not throw because we generate the checks explicitly.
  */
 class HIndex extends HInstruction {
   final Selector selector;
-  HIndex(HInstruction receiver,
-         HInstruction index,
-         this.selector,
-         TypeMask type)
+  HIndex(
+      HInstruction receiver, HInstruction index, this.selector, TypeMask type)
       : super(<HInstruction>[receiver, index], type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     sideEffects.setDependsOnIndexStore();
     setUseGvn();
   }
 
   String toString() => 'index operator';
   accept(HVisitor visitor) => visitor.visitIndex(this);
 
   HInstruction get receiver => inputs[0];
   HInstruction get index => inputs[1];
 
   HInstruction getDartReceiver(Compiler compiler) => receiver;
   bool onlyThrowsNSM() => true;
   bool canThrow() => receiver.canBeNull();
 
   int typeCode() => HInstruction.INDEX_TYPECODE;
   bool typeEquals(HInstruction other) => other is HIndex;
   bool dataEquals(HIndex other) => true;
 }
 
 /**
  * The primitive array assignment operation. Note that this instruction
  * does not throw because we generate the checks explicitly.
  */
 class HIndexAssign extends HInstruction {
   final Selector selector;
-  HIndexAssign(HInstruction receiver,
-               HInstruction index,
-               HInstruction value,
-               this.selector)
+  HIndexAssign(HInstruction receiver, HInstruction index, HInstruction value,
+      this.selector)
       : super(<HInstruction>[receiver, index, value],
-              const TypeMask.nonNullEmpty()) {
+            const TypeMask.nonNullEmpty()) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     sideEffects.setChangesIndex();
   }
   String toString() => 'index assign operator';
   accept(HVisitor visitor) => visitor.visitIndexAssign(this);
 
   HInstruction get receiver => inputs[0];
   HInstruction get index => inputs[1];
   HInstruction get value => inputs[2];
 
   HInstruction getDartReceiver(Compiler compiler) => receiver;
   bool onlyThrowsNSM() => true;
   bool canThrow() => receiver.canBeNull();
 }
 
 class HIs extends HInstruction {
   /// A check against a raw type: 'o is int', 'o is A'.
   static const int RAW_CHECK = 0;
+
   /// A check against a type with type arguments: 'o is List<int>', 'o is C<T>'.
   static const int COMPOUND_CHECK = 1;
+
   /// A check against a single type variable: 'o is T'.
   static const int VARIABLE_CHECK = 2;
 
   final DartType typeExpression;
   final int kind;
   final bool useInstanceOf;
 
-  HIs.direct(DartType typeExpression,
-             HInstruction expression,
-             TypeMask type)
+  HIs.direct(DartType typeExpression, HInstruction expression, TypeMask type)
       : this.internal(typeExpression, [expression], RAW_CHECK, type);
 
   // Pre-verified that the check can be done using 'instanceof'.
-  HIs.instanceOf(DartType typeExpression,
-                 HInstruction expression,
-                 TypeMask type)
+  HIs.instanceOf(
+      DartType typeExpression, HInstruction expression, TypeMask type)
       : this.internal(typeExpression, [expression], RAW_CHECK, type,
-          useInstanceOf: true);
+            useInstanceOf: true);
 
-  HIs.raw(DartType typeExpression,
-          HInstruction expression,
-          HInterceptor interceptor,
-          TypeMask type)
+  HIs.raw(DartType typeExpression, HInstruction expression,
+      HInterceptor interceptor, TypeMask type)
       : this.internal(
             typeExpression, [expression, interceptor], RAW_CHECK, type);
 
-  HIs.compound(DartType typeExpression,
-               HInstruction expression,
-               HInstruction call,
-               TypeMask type)
+  HIs.compound(DartType typeExpression, HInstruction expression,
+      HInstruction call, TypeMask type)
       : this.internal(typeExpression, [expression, call], COMPOUND_CHECK, type);
 
-  HIs.variable(DartType typeExpression,
-               HInstruction expression,
-               HInstruction call,
-               TypeMask type)
+  HIs.variable(DartType typeExpression, HInstruction expression,
+      HInstruction call, TypeMask type)
       : this.internal(typeExpression, [expression, call], VARIABLE_CHECK, type);
 
-  HIs.internal(this.typeExpression, List<HInstruction> inputs, this.kind,
-      TypeMask type, {bool this.useInstanceOf: false})
+  HIs.internal(
+      this.typeExpression, List<HInstruction> inputs, this.kind, TypeMask type,
+      {bool this.useInstanceOf: false})
       : super(inputs, type) {
     assert(kind >= RAW_CHECK && kind <= VARIABLE_CHECK);
     setUseGvn();
   }
 
   HInstruction get expression => inputs[0];
 
   HInstruction get interceptor {
     assert(kind == RAW_CHECK);
     return inputs.length > 1 ? inputs[1] : null;
@@ skipping 10 matching lines @@
 
   accept(HVisitor visitor) => visitor.visitIs(this);
 
   toString() => "$expression is $typeExpression";
 
   int typeCode() => HInstruction.IS_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HIs;
 
   bool dataEquals(HIs other) {
-    return typeExpression == other.typeExpression
-        && kind == other.kind;
+    return typeExpression == other.typeExpression && kind == other.kind;
   }
 }
 
 /**
  * HIsViaInterceptor is a late-stage instruction for a type test that can be
  * done entirely on an interceptor.  It is not a HCheck because the checked
  * input is not one of the inputs.
  */
 class HIsViaInterceptor extends HLateInstruction {
   final DartType typeExpression;
-   HIsViaInterceptor(this.typeExpression, HInstruction interceptor,
-                     TypeMask type)
-       : super(<HInstruction>[interceptor], type) {
+  HIsViaInterceptor(
+      this.typeExpression, HInstruction interceptor, TypeMask type)
+      : super(<HInstruction>[interceptor], type) {
     setUseGvn();
   }
 
   HInstruction get interceptor => inputs[0];
 
   accept(HVisitor visitor) => visitor.visitIsViaInterceptor(this);
   toString() => "$interceptor is $typeExpression";
   int typeCode() => HInstruction.IS_VIA_INTERCEPTOR_TYPECODE;
   bool typeEquals(HInstruction other) => other is HIsViaInterceptor;
   bool dataEquals(HIs other) {
     return typeExpression == other.typeExpression;
   }
 }
 
 class HTypeConversion extends HCheck {
   final DartType typeExpression;
   final int kind;
   final Selector receiverTypeCheckSelector;
   final bool contextIsTypeArguments;
-  TypeMask checkedType;  // Not final because we refine it.
+  TypeMask checkedType; // Not final because we refine it.
 
   static const int CHECKED_MODE_CHECK = 0;
   static const int ARGUMENT_TYPE_CHECK = 1;
   static const int CAST_TYPE_CHECK = 2;
   static const int BOOLEAN_CONVERSION_CHECK = 3;
   static const int RECEIVER_TYPE_CHECK = 4;
 
-  HTypeConversion(this.typeExpression, this.kind,
-                  TypeMask type, HInstruction input,
-                  [this.receiverTypeCheckSelector])
+  HTypeConversion(
+      this.typeExpression, this.kind, TypeMask type, HInstruction input,
+      [this.receiverTypeCheckSelector])
       : contextIsTypeArguments = false,
         checkedType = type,
         super(<HInstruction>[input], type) {
     assert(!isReceiverTypeCheck || receiverTypeCheckSelector != null);
-    assert(typeExpression == null ||
-           typeExpression.kind != TypeKind.TYPEDEF);
+    assert(typeExpression == null || typeExpression.kind != TypeKind.TYPEDEF);
     sourceElement = input.sourceElement;
   }
 
   HTypeConversion.withTypeRepresentation(this.typeExpression, this.kind,
-                                         TypeMask type, HInstruction input,
-                                         HInstruction typeRepresentation)
+      TypeMask type, HInstruction input, HInstruction typeRepresentation)
       : contextIsTypeArguments = false,
         checkedType = type,
-        super(<HInstruction>[input, typeRepresentation],type),
+        super(<HInstruction>[input, typeRepresentation], type),
         receiverTypeCheckSelector = null {
     assert(typeExpression.kind != TypeKind.TYPEDEF);
     sourceElement = input.sourceElement;
   }
 
-  HTypeConversion.withContext(this.typeExpression, this.kind,
-                              TypeMask type, HInstruction input,
-                              HInstruction context,
-                              {bool this.contextIsTypeArguments})
+  HTypeConversion.withContext(this.typeExpression, this.kind, TypeMask type,
+      HInstruction input, HInstruction context,
+      {bool this.contextIsTypeArguments})
       : super(<HInstruction>[input, context], type),
         checkedType = type,
         receiverTypeCheckSelector = null {
     assert(typeExpression.kind != TypeKind.TYPEDEF);
     sourceElement = input.sourceElement;
   }
 
   bool get hasTypeRepresentation {
     return typeExpression.isInterfaceType && inputs.length > 1;
   }
+
   HInstruction get typeRepresentation => inputs[1];
 
   bool get hasContext {
     return typeExpression.isFunctionType && inputs.length > 1;
   }
+
   HInstruction get context => inputs[1];
 
   HInstruction convertType(Compiler compiler, DartType type, int kind) {
     if (typeExpression == type) {
       // Don't omit a boolean conversion (which doesn't allow `null`) unless
       // this type conversion is already a boolean conversion.
-      if (kind != BOOLEAN_CONVERSION_CHECK ||
-          isBooleanConversionCheck) {
+      if (kind != BOOLEAN_CONVERSION_CHECK || isBooleanConversionCheck) {
         return this;
       }
     }
     return super.convertType(compiler, type, kind);
   }
 
   bool get isCheckedModeCheck {
-    return kind == CHECKED_MODE_CHECK
-        || kind == BOOLEAN_CONVERSION_CHECK;
+    return kind == CHECKED_MODE_CHECK || kind == BOOLEAN_CONVERSION_CHECK;
   }
+
   bool get isArgumentTypeCheck => kind == ARGUMENT_TYPE_CHECK;
   bool get isReceiverTypeCheck => kind == RECEIVER_TYPE_CHECK;
   bool get isCastTypeCheck => kind == CAST_TYPE_CHECK;
   bool get isBooleanConversionCheck => kind == BOOLEAN_CONVERSION_CHECK;
 
   accept(HVisitor visitor) => visitor.visitTypeConversion(this);
 
   bool isJsStatement() => isControlFlow();
   bool isControlFlow() => isArgumentTypeCheck || isReceiverTypeCheck;
 
   int typeCode() => HInstruction.TYPE_CONVERSION_TYPECODE;
   bool typeEquals(HInstruction other) => other is HTypeConversion;
   bool isCodeMotionInvariant() => false;
 
   bool dataEquals(HTypeConversion other) {
-    return kind == other.kind
-        && typeExpression == other.typeExpression
-        && checkedType == other.checkedType
-        && receiverTypeCheckSelector == other.receiverTypeCheckSelector;
+    return kind == other.kind &&
+        typeExpression == other.typeExpression &&
+        checkedType == other.checkedType &&
+        receiverTypeCheckSelector == other.receiverTypeCheckSelector;
   }
 }
 
 /// The [HTypeKnown] instruction marks a value with a refined type.
 class HTypeKnown extends HCheck {
   TypeMask knownType;
   bool _isMovable;
 
   HTypeKnown.pinned(TypeMask knownType, HInstruction input)
       : this.knownType = knownType,
         this._isMovable = false,
         super(<HInstruction>[input], knownType);
 
-  HTypeKnown.witnessed(TypeMask knownType, HInstruction input,
-                       HInstruction witness)
+  HTypeKnown.witnessed(
+      TypeMask knownType, HInstruction input, HInstruction witness)
       : this.knownType = knownType,
         this._isMovable = true,
         super(<HInstruction>[input, witness], knownType);
 
   toString() => 'TypeKnown $knownType';
   accept(HVisitor visitor) => visitor.visitTypeKnown(this);
 
   bool isJsStatement() => false;
   bool isControlFlow() => false;
   bool canThrow() => false;
 
   HInstruction get witness => inputs.length == 2 ? inputs[1] : null;
 
   int typeCode() => HInstruction.TYPE_KNOWN_TYPECODE;
   bool typeEquals(HInstruction other) => other is HTypeKnown;
   bool isCodeMotionInvariant() => true;
   bool get isMovable => _isMovable && useGvn();
 
   bool dataEquals(HTypeKnown other) {
-    return knownType == other.knownType
-        && instructionType == other.instructionType;
+    return knownType == other.knownType &&
+        instructionType == other.instructionType;
   }
 }
 
 class HRangeConversion extends HCheck {
   HRangeConversion(HInstruction input, type)
       : super(<HInstruction>[input], type) {
     sourceElement = input.sourceElement;
   }
 
   bool get isMovable => false;
@@ skipping 66 matching lines @@
     } else if (parentHeader != null) {
       workQueue.add(parentHeader);
     } else {
       block.parentLoopHeader = header;
       blocks.add(block);
       workQueue.addAll(block.predecessors);
     }
   }
 }
 
-
 /**
  * Embedding of a [HBlockInformation] for block-structure based traversal
  * in a dominator based flow traversal by attaching it to a basic block.
  * To go back to dominator-based traversal, a [HSubGraphBlockInformation]
  * structure can be added in the block structure.
  */
 class HBlockFlow {
   final HBlockInformation body;
   final HBasicBlock continuation;
   HBlockFlow(this.body, this.continuation);
 }
 
-
 /**
  * Information about a syntactic-like structure.
  */
 abstract class HBlockInformation {
   HBasicBlock get start;
   HBasicBlock get end;
   bool accept(HBlockInformationVisitor visitor);
 }
 
-
 /**
  * Information about a statement-like structure.
  */
 abstract class HStatementInformation extends HBlockInformation {
   bool accept(HStatementInformationVisitor visitor);
 }
 
-
 /**
  * Information about an expression-like structure.
  */
 abstract class HExpressionInformation extends HBlockInformation {
   bool accept(HExpressionInformationVisitor visitor);
   HInstruction get conditionExpression;
 }
 
-
 abstract class HStatementInformationVisitor {
   bool visitLabeledBlockInfo(HLabeledBlockInformation info);
   bool visitLoopInfo(HLoopBlockInformation info);
   bool visitIfInfo(HIfBlockInformation info);
   bool visitTryInfo(HTryBlockInformation info);
   bool visitSwitchInfo(HSwitchBlockInformation info);
   bool visitSequenceInfo(HStatementSequenceInformation info);
   // Pseudo-structure embedding a dominator-based traversal into
   // the block-structure traversal. This will eventually go away.
   bool visitSubGraphInfo(HSubGraphBlockInformation info);
 }
 
-
 abstract class HExpressionInformationVisitor {
   bool visitAndOrInfo(HAndOrBlockInformation info);
   bool visitSubExpressionInfo(HSubExpressionBlockInformation info);
 }
 
-
 abstract class HBlockInformationVisitor
-    implements HStatementInformationVisitor, HExpressionInformationVisitor {
-}
-
+    implements HStatementInformationVisitor, HExpressionInformationVisitor {}
 
 /**
  * Generic class wrapping a [SubGraph] as a block-information until
  * all structures are handled properly.
  */
 class HSubGraphBlockInformation implements HStatementInformation {
   final SubGraph subGraph;
   HSubGraphBlockInformation(this.subGraph);
 
   HBasicBlock get start => subGraph.start;
   HBasicBlock get end => subGraph.end;
 
   bool accept(HStatementInformationVisitor visitor) =>
-    visitor.visitSubGraphInfo(this);
+      visitor.visitSubGraphInfo(this);
 }
 
 /**
  * Generic class wrapping a [SubExpression] as a block-information until
  * expressions structures are handled properly.
  */
 class HSubExpressionBlockInformation implements HExpressionInformation {
   final SubExpression subExpression;
   HSubExpressionBlockInformation(this.subExpression);
 
   HBasicBlock get start => subExpression.start;
   HBasicBlock get end => subExpression.end;
 
   HInstruction get conditionExpression => subExpression.conditionExpression;
 
   bool accept(HExpressionInformationVisitor visitor) =>
-    visitor.visitSubExpressionInfo(this);
+      visitor.visitSubExpressionInfo(this);
 }
 
 /** A sequence of separate statements. */
 class HStatementSequenceInformation implements HStatementInformation {
   final List<HStatementInformation> statements;
   HStatementSequenceInformation(this.statements);
 
   HBasicBlock get start => statements[0].start;
   HBasicBlock get end => statements.last.end;
 
   bool accept(HStatementInformationVisitor visitor) =>
-    visitor.visitSequenceInfo(this);
+      visitor.visitSequenceInfo(this);
 }
 
 class HLabeledBlockInformation implements HStatementInformation {
   final HStatementInformation body;
   final List<LabelDefinition> labels;
   final JumpTarget target;
   final bool isContinue;
 
-  HLabeledBlockInformation(this.body,
-                           List<LabelDefinition> labels,
-                           {this.isContinue: false}) :
-      this.labels = labels, this.target = labels[0].target;
+  HLabeledBlockInformation(this.body, List<LabelDefinition> labels,
+      {this.isContinue: false})
+      : this.labels = labels,
+        this.target = labels[0].target;
 
-  HLabeledBlockInformation.implicit(this.body,
-                                    this.target,
-                                    {this.isContinue: false})
-      : this.labels = const<LabelDefinition>[];
+  HLabeledBlockInformation.implicit(this.body, this.target,
+      {this.isContinue: false})
+      : this.labels = const <LabelDefinition>[];
 
   HBasicBlock get start => body.start;
   HBasicBlock get end => body.end;
 
   bool accept(HStatementInformationVisitor visitor) =>
-    visitor.visitLabeledBlockInfo(this);
+      visitor.visitLabeledBlockInfo(this);
 }
 
 class HLoopBlockInformation implements HStatementInformation {
   static const int WHILE_LOOP = 0;
   static const int FOR_LOOP = 1;
   static const int DO_WHILE_LOOP = 2;
   static const int FOR_IN_LOOP = 3;
   static const int SWITCH_CONTINUE_LOOP = 4;
   static const int NOT_A_LOOP = -1;
 
   final int kind;
   final HExpressionInformation initializer;
   final HExpressionInformation condition;
   final HStatementInformation body;
   final HExpressionInformation updates;
   final JumpTarget target;
   final List<LabelDefinition> labels;
   final SourceInformation sourceInformation;
 
-  HLoopBlockInformation(this.kind,
-                        this.initializer,
-                        this.condition,
-                        this.body,
-                        this.updates,
-                        this.target,
-                        this.labels,
-                        this.sourceInformation) {
+  HLoopBlockInformation(this.kind, this.initializer, this.condition, this.body,
+      this.updates, this.target, this.labels, this.sourceInformation) {
     assert(
         (kind == DO_WHILE_LOOP ? body.start : condition.start).isLoopHeader());
   }
 
   HBasicBlock get start {
     if (initializer != null) return initializer.start;
     if (kind == DO_WHILE_LOOP) {
       return body.start;
     }
     return condition.start;
   }
 
   HBasicBlock get loopHeader {
     return kind == DO_WHILE_LOOP ? body.start : condition.start;
   }
 
   HBasicBlock get end {
     if (updates != null) return updates.end;
     if (kind == DO_WHILE_LOOP && condition != null) {
       return condition.end;
     }
     return body.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
-    visitor.visitLoopInfo(this);
+      visitor.visitLoopInfo(this);
 }
 
 class HIfBlockInformation implements HStatementInformation {
   final HExpressionInformation condition;
   final HStatementInformation thenGraph;
   final HStatementInformation elseGraph;
-  HIfBlockInformation(this.condition,
-                      this.thenGraph,
-                      this.elseGraph);
+  HIfBlockInformation(this.condition, this.thenGraph, this.elseGraph);
 
   HBasicBlock get start => condition.start;
   HBasicBlock get end => elseGraph == null ? thenGraph.end : elseGraph.end;
 
   bool accept(HStatementInformationVisitor visitor) =>
-    visitor.visitIfInfo(this);
+      visitor.visitIfInfo(this);
 }
 
 class HAndOrBlockInformation implements HExpressionInformation {
   final bool isAnd;
   final HExpressionInformation left;
   final HExpressionInformation right;
-  HAndOrBlockInformation(this.isAnd,
-                         this.left,
-                         this.right);
+  HAndOrBlockInformation(this.isAnd, this.left, this.right);
 
   HBasicBlock get start => left.start;
   HBasicBlock get end => right.end;
 
   // We don't currently use HAndOrBlockInformation.
   HInstruction get conditionExpression {
     return null;
   }
+
   bool accept(HExpressionInformationVisitor visitor) =>
-    visitor.visitAndOrInfo(this);
+      visitor.visitAndOrInfo(this);
 }
 
 class HTryBlockInformation implements HStatementInformation {
   final HStatementInformation body;
   final HLocalValue catchVariable;
   final HStatementInformation catchBlock;
   final HStatementInformation finallyBlock;
-  HTryBlockInformation(this.body,
-                       this.catchVariable,
-                       this.catchBlock,
-                       this.finallyBlock);
+  HTryBlockInformation(
+      this.body, this.catchVariable, this.catchBlock, this.finallyBlock);
 
   HBasicBlock get start => body.start;
   HBasicBlock get end =>
       finallyBlock == null ? catchBlock.end : finallyBlock.end;
 
   bool accept(HStatementInformationVisitor visitor) =>
-    visitor.visitTryInfo(this);
+      visitor.visitTryInfo(this);
 }
 
 class HSwitchBlockInformation implements HStatementInformation {
   final HExpressionInformation expression;
   final List<HStatementInformation> statements;
   final JumpTarget target;
   final List<LabelDefinition> labels;
 
-  HSwitchBlockInformation(this.expression,
-                          this.statements,
-                          this.target,
-                          this.labels);
+  HSwitchBlockInformation(
+      this.expression, this.statements, this.target, this.labels);
 
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty);
     return statements.last.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }
 
 class HReadTypeVariable extends HInstruction {
   /// The type variable being read.
   final TypeVariableType dartType;
 
   final bool hasReceiver;
 
-  HReadTypeVariable(this.dartType,
-                    HInstruction receiver,
-                    TypeMask instructionType)
+  HReadTypeVariable(
+      this.dartType, HInstruction receiver, TypeMask instructionType)
       : hasReceiver = true,
         super(<HInstruction>[receiver], instructionType) {
     setUseGvn();
   }
 
-  HReadTypeVariable.noReceiver(this.dartType,
-                               HInstruction typeArgument,
-                               TypeMask instructionType)
+  HReadTypeVariable.noReceiver(
+      this.dartType, HInstruction typeArgument, TypeMask instructionType)
       : hasReceiver = false,
         super(<HInstruction>[typeArgument], instructionType) {
     setUseGvn();
   }
 
   accept(HVisitor visitor) => visitor.visitReadTypeVariable(this);
 
   bool canThrow() => false;
 
   int typeCode() => HInstruction.READ_TYPE_VARIABLE_TYPECODE;
   bool typeEquals(HInstruction other) => other is HReadTypeVariable;
 
   bool dataEquals(HReadTypeVariable other) {
-    return dartType.element == other.dartType.element
-        && hasReceiver == other.hasReceiver;
+    return dartType.element == other.dartType.element &&
+        hasReceiver == other.hasReceiver;
   }
 }
 
 abstract class HRuntimeType extends HInstruction {
   final DartType dartType;
 
-  HRuntimeType(List<HInstruction> inputs,
-               this.dartType,
-               TypeMask instructionType)
+  HRuntimeType(
+      List<HInstruction> inputs, this.dartType, TypeMask instructionType)
       : super(inputs, instructionType) {
     setUseGvn();
   }
 
   bool canThrow() => false;
 
   int typeCode() {
     throw 'abstract method';
   }
 
   bool typeEquals(HInstruction other) {
     throw 'abstract method';
   }
 
   bool dataEquals(HRuntimeType other) {
     return dartType == other.dartType;
   }
 }
 
 class HFunctionType extends HRuntimeType {
-  HFunctionType(List<HInstruction> inputs,
-                FunctionType dartType,
-                TypeMask instructionType)
+  HFunctionType(List<HInstruction> inputs, FunctionType dartType,
+      TypeMask instructionType)
       : super(inputs, dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitFunctionType(this);
 
   int typeCode() => HInstruction.FUNCTION_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HFunctionType;
 }
 
 class HVoidType extends HRuntimeType {
   HVoidType(VoidType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitVoidType(this);
 
   int typeCode() => HInstruction.VOID_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HVoidType;
 }
 
 class HInterfaceType extends HRuntimeType {
-  HInterfaceType(List<HInstruction> inputs,
-                 InterfaceType dartType,
-                 TypeMask instructionType)
+  HInterfaceType(List<HInstruction> inputs, InterfaceType dartType,
+      TypeMask instructionType)
       : super(inputs, dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitInterfaceType(this);
 
   int typeCode() => HInstruction.INTERFACE_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HInterfaceType;
 }
 
 class HDynamicType extends HRuntimeType {
   HDynamicType(DynamicType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitDynamicType(this);
 
   int typeCode() => HInstruction.DYNAMIC_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HDynamicType;
 }