kernel -> ssa: implement if-statements

pkg/compiler/lib/src/ssa/builder.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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 20 matching lines @@
 import '../resolution/semantic_visitor.dart';
 import '../resolution/tree_elements.dart' show TreeElements;
 import '../tree/tree.dart' as ast;
 import '../types/types.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
 import '../universe/use.dart' show DynamicUse, StaticUse, TypeUse;
 import '../util/util.dart';
 import '../world.dart' show ClassWorld;
+
 import 'graph_builder.dart';
 import 'locals_handler.dart';
 import 'nodes.dart';
 import 'optimize.dart';
+import 'ssa_branch_builder.dart';
 import 'types.dart';
 
 /// A synthetic local variable only used with the SSA graph.
 ///
 /// For instance used for holding return value of function or the exception of a
 /// try-catch statement.
 class SyntheticLocal extends Local {
   final String name;
   final ExecutableElement executableContext;
 
@@ skipping 349 matching lines @@
    * account.
    */
   int loopNesting = 0;
 
   /**
    * This stack contains declaration elements of the functions being built
    * or inlined by this builder.
    */
   final List<Element> sourceElementStack = <Element>[];
 
-  LocalsHandler localsHandler;
-
   HInstruction rethrowableException;
 
   Map<JumpTarget, JumpHandler> jumpTargets = <JumpTarget, JumpHandler>{};
 
   /// Returns `true` if the current element is an `async` function.
   bool get isBuildingAsyncFunction {
     Element element = sourceElement;
     return (element is FunctionElement &&
         element.asyncMarker == AsyncMarker.ASYNC);
   }
@@ skipping 1474 matching lines @@
     // TODO(kasperl): Make this goto an implicit return.
     if (!isAborted()) closeAndGotoExit(new HGoto());
     graph.finalize();
     return graph;
   }
 
   void pushWithPosition(HInstruction instruction, ast.Node node) {
     push(attachPosition(instruction, node));
   }
 
+  @override
   HInstruction popBoolified() {
     HInstruction value = pop();
     if (_checkOrTrustTypes) {
       return potentiallyCheckOrTrustType(value, compiler.coreTypes.boolType,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value, backend.boolType);
     add(result);
     return result;
   }
@@ skipping 610 matching lines @@
         visitThen: () => visit(node.thenPart),
         visitElse: node.elsePart != null ? () => visit(node.elsePart) : null,
         sourceInformation: sourceInformationBuilder.buildIf(node));
   }
 
   void handleIf(ast.Node diagnosticNode,
       {void visitCondition(),
       void visitThen(),
       void visitElse(),
       SourceInformation sourceInformation}) {
-    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, diagnosticNode);
+    SsaBranchBuilder branchBuilder =
+        new SsaBranchBuilder(this, compiler, diagnosticNode);
     branchBuilder.handleIf(visitCondition, visitThen, visitElse,
         sourceInformation: sourceInformation);
   }
 
   @override
   void visitIfNull(ast.Send node, ast.Node left, ast.Node right, _) {
-    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
     brancher.handleIfNull(() => visit(left), () => visit(right));
   }
 
+  /// Optimizes logical binary where the left is also a logical binary.
+  ///
+  /// This method transforms the operator by optimizing the case where [left] is
+  /// a logical "and" or logical "or". Then it uses [branchBuilder] to build the
+  /// graph for the optimized expression.
+  ///
+  /// For example, `(x && y) && z` is transformed into `x && (y && z)`:
+  ///
+  ///     t0 = boolify(x);
+  ///     if (t0) {
+  ///       t1 = boolify(y);
+  ///       if (t1) {
+  ///         t2 = boolify(z);
+  ///       }
+  ///       t3 = phi(t2, false);
+  ///     }
+  ///     result = phi(t3, false);
+  void handleLogicalBinaryWithLeftNode(
+      ast.Node left, void visitRight(), SsaBranchBuilder branchBuilder,
+      {bool isAnd}) {
+    ast.Send send = left.asSend();
+    if (send != null && (isAnd ? send.isLogicalAnd : send.isLogicalOr)) {
+      ast.Node newLeft = send.receiver;
+      Link<ast.Node> link = send.argumentsNode.nodes;
+      assert(link.tail.isEmpty);
+      ast.Node middle = link.head;
+      handleLogicalBinaryWithLeftNode(
+          newLeft,
+          () => handleLogicalBinaryWithLeftNode(
+              middle, visitRight, branchBuilder,
+              isAnd: isAnd),
+          branchBuilder,
+          isAnd: isAnd);
+    } else {
+      branchBuilder.handleLogicalBinary(() => visit(left), visitRight,
+          isAnd: isAnd);
+    }
+  }
+
   @override
   void visitLogicalAnd(ast.Send node, ast.Node left, ast.Node right, _) {
-    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
-    branchBuilder.handleLogicalAndOrWithLeftNode(left, () {
-      visit(right);
-    }, isAnd: true);
+    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, compiler, node);
+    handleLogicalBinaryWithLeftNode(left, () => visit(right), branchBuilder,
+        isAnd: true);
   }
 
   @override
   void visitLogicalOr(ast.Send node, ast.Node left, ast.Node right, _) {
-    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
-    branchBuilder.handleLogicalAndOrWithLeftNode(left, () {
-      visit(right);
-    }, isAnd: false);
+    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, compiler, node);
+    handleLogicalBinaryWithLeftNode(left, () => visit(right), branchBuilder,
+        isAnd: false);
   }
 
   @override
   void visitNot(ast.Send node, ast.Node expression, _) {
     assert(node.argumentsNode is ast.Prefix);
     visit(expression);
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGeneric(node);
     push(new HNot(popBoolified(), backend.boolType)
       ..sourceInformation = sourceInformation);
@@ skipping 237 matching lines @@
   @override
   void visitIfNotNullDynamicPropertyGet(
       ast.Send node, ast.Node receiver, Name name, _) {
     // exp?.x compiled as:
     //   t1 = exp;
     //   result = t1 == null ? t1 : t1.x;
     // This is equivalent to t1 == null ? null : t1.x, but in the current form
     // we will be able to later compress it as:
     //   t1 || t1.x
     HInstruction expression;
-    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
     brancher.handleConditional(
         () {
           expression = visitAndPop(receiver);
           pushCheckNull(expression);
         },
         () => stack.add(expression),
         () {
           generateInstanceGetterWithCompiledReceiver(
               node,
               elements.getSelector(node),
               elements.getTypeMask(node),
               expression);
         });
   }
 
-  /// Pushes a boolean checking [expression] against null.
+  @override
   pushCheckNull(HInstruction expression) {
     push(new HIdentity(
         expression, graph.addConstantNull(compiler), null, backend.boolType));
   }
 
   @override
   void visitLocalVariableGet(ast.Send node, LocalVariableElement variable, _) {
     handleLocalGet(node, variable);
   }
 
@@ skipping 346 matching lines @@
   visitDynamicPropertyInvoke(ast.Send node, ast.Node receiver,
       ast.NodeList arguments, Selector selector, _) {
     generateDynamicSend(node);
   }
 
   @override
   visitIfNotNullDynamicPropertyInvoke(ast.Send node, ast.Node receiver,
       ast.NodeList arguments, Selector selector, _) {
     /// Desugar `exp?.m()` to `(t1 = exp) == null ? t1 : t1.m()`
     HInstruction receiver;
-    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
     brancher.handleConditional(() {
       receiver = generateInstanceSendReceiver(node);
       pushCheckNull(receiver);
     }, () => stack.add(receiver), () => _generateDynamicSend(node, receiver));
   }
 
   @override
   visitThisPropertyInvoke(
       ast.Send node, ast.NodeList arguments, Selector selector, _) {
     generateDynamicSend(node);
@@ skipping 1785 matching lines @@
       if (Elements.isUnresolved(getter)) {
         generateSuperNoSuchMethodSend(node, getterSelector, getterInputs);
         getterInstruction = pop();
       } else {
         getterInstruction =
             buildInvokeSuper(getterSelector, getter, getterInputs);
         add(getterInstruction);
       }
 
       if (node.isIfNullAssignment) {
-        SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+        SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
         brancher.handleIfNull(() => stack.add(getterInstruction), () {
           addDynamicSendArgumentsToList(node, setterInputs);
           generateSuperSendSet();
           stack.add(setterInputs.last);
         });
       } else {
         handleComplexOperatorSend(node, getterInstruction, arguments);
         setterInputs.add(pop());
         generateSuperSendSet();
         stack.add(node.isPostfix ? getterInstruction : setterInputs.last);
@@ skipping 299 matching lines @@
 
       pushInvokeDynamic(node, elements.getGetterSelectorInComplexSendSet(node),
           elements.getGetterTypeMaskInComplexSendSet(node), [receiver, index]);
       HInstruction getterInstruction = pop();
       if (node.isIfNullAssignment) {
         // Compile x[i] ??= e as:
         //   t1 = x[i]
         //   if (t1 == null)
         //      t1 = x[i] = e;
         //   result = t1
-        SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+        SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
         brancher.handleIfNull(() => stack.add(getterInstruction), () {
           visit(arguments.head);
           HInstruction value = pop();
           pushInvokeDynamic(node, elements.getSelector(node),
               elements.getTypeMask(node), [receiver, index, value]);
           pop();
           stack.add(value);
         });
       } else {
         handleComplexOperatorSend(node, getterInstruction, arguments);
@@ skipping 27 matching lines @@
   void visitIfNotNullDynamicPropertySet(
       ast.SendSet node, ast.Node receiver, Name name, ast.Node rhs, _) {
     // compile e?.x = e2 to:
     //
     // t1 = e
     // if (t1 == null)
     //   result = t1 // same as result = null
     // else
     //   result = e.x = e2
     HInstruction receiverInstruction;
-    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
     brancher.handleConditional(
         () {
           receiverInstruction = generateInstanceSendReceiver(node);
           pushCheckNull(receiverInstruction);
         },
         () => stack.add(receiverInstruction),
         () {
           generateInstanceSetterWithCompiledReceiver(
               node, receiverInstruction, visitAndPop(rhs));
         });
@@ skipping 152 matching lines @@
     if (Elements.isInstanceSend(node, elements)) {
       void generateAssignment(HInstruction receiver) {
         // desugars `e.x op= e2` to `e.x = e.x op e2`
         generateInstanceGetterWithCompiledReceiver(
             node,
             elements.getGetterSelectorInComplexSendSet(node),
             elements.getGetterTypeMaskInComplexSendSet(node),
             receiver);
         HInstruction getterInstruction = pop();
         if (node.isIfNullAssignment) {
-          SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+          SsaBranchBuilder brancher =
+              new SsaBranchBuilder(this, compiler, node);
           brancher.handleIfNull(() => stack.add(getterInstruction), () {
             visit(node.arguments.head);
             generateInstanceSetterWithCompiledReceiver(node, receiver, pop());
           });
         } else {
           handleComplexOperatorSend(node, getterInstruction, node.arguments);
           HInstruction value = pop();
           generateInstanceSetterWithCompiledReceiver(node, receiver, value);
         }
         if (node.isPostfix) {
           pop();
           stack.add(getterInstruction);
         }
       }
 
       if (node.isConditional) {
         // generate `e?.x op= e2` as:
         //   t1 = e
         //   t1 == null ? t1 : (t1.x = t1.x op e2);
         HInstruction receiver;
-        SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+        SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
         brancher.handleConditional(() {
           receiver = generateInstanceSendReceiver(node);
           pushCheckNull(receiver);
         }, () => stack.add(receiver), () => generateAssignment(receiver));
       } else {
         generateAssignment(generateInstanceSendReceiver(node));
       }
       return;
     }
 
     if (getter.isMalformed) {
       generateStaticUnresolvedGet(node, getter);
     } else if (getter.isField) {
       generateStaticFieldGet(node, getter);
     } else if (getter.isGetter) {
       generateStaticGetterGet(node, getter);
     } else if (getter.isFunction) {
       generateStaticFunctionGet(node, getter);
     } else if (getter.isLocal) {
       handleLocalGet(node, getter);
     } else {
       internalError(node, "Unexpected getter: $getter");
     }
     HInstruction getterInstruction = pop();
     if (node.isIfNullAssignment) {
-      SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+      SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
       brancher.handleIfNull(() => stack.add(getterInstruction), () {
         visit(node.arguments.head);
         generateNonInstanceSetter(node, element, pop());
       });
     } else {
       handleComplexOperatorSend(node, getterInstruction, node.arguments);
       HInstruction value = pop();
       generateNonInstanceSetter(node, element, value);
     }
     if (node.isPostfix) {
@@ skipping 389 matching lines @@
       instruction = setRtiIfNeeded(instruction, node);
     }
 
     TypeMask type =
         TypeMaskFactory.inferredForNode(sourceElement, node, compiler);
     if (!type.containsAll(compiler.world)) instruction.instructionType = type;
     stack.add(instruction);
   }
 
   visitConditional(ast.Conditional node) {
-    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
     brancher.handleConditional(() => visit(node.condition),
         () => visit(node.thenExpression), () => visit(node.elseExpression));
   }
 
   visitStringInterpolation(ast.StringInterpolation node) {
     StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node);
     stringBuilder.visit(node);
     stack.add(stringBuilder.result);
   }
 
@@ skipping 1451 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce)
       : super(function);
 }
 
-class SsaBranch {
-  final SsaBranchBuilder branchBuilder;
-  final HBasicBlock block;
-  LocalsHandler startLocals;
-  LocalsHandler exitLocals;
-  SubGraph graph;
-
-  SsaBranch(this.branchBuilder) : block = new HBasicBlock();
-}
-
-class SsaBranchBuilder {
-  final SsaBuilder builder;
-  final ast.Node diagnosticNode;
-
-  SsaBranchBuilder(this.builder, [this.diagnosticNode]);
-
-  Compiler get compiler => builder.compiler;
-
-  void checkNotAborted() {
-    if (builder.isAborted()) {
-      compiler.unimplemented(diagnosticNode, "aborted control flow");
-    }
-  }
-
-  void buildCondition(
-      void visitCondition(),
-      SsaBranch conditionBranch,
-      SsaBranch thenBranch,
-      SsaBranch elseBranch,
-      SourceInformation sourceInformation) {
-    startBranch(conditionBranch);
-    visitCondition();
-    checkNotAborted();
-    assert(identical(builder.current, builder.lastOpenedBlock));
-    HInstruction conditionValue = builder.popBoolified();
-    HIf branch = new HIf(conditionValue)..sourceInformation = sourceInformation;
-    HBasicBlock conditionExitBlock = builder.current;
-    builder.close(branch);
-    conditionBranch.exitLocals = builder.localsHandler;
-    conditionExitBlock.addSuccessor(thenBranch.block);
-    conditionExitBlock.addSuccessor(elseBranch.block);
-    bool conditionBranchLocalsCanBeReused =
-        mergeLocals(conditionBranch, thenBranch, mayReuseFromLocals: true);
-    mergeLocals(conditionBranch, elseBranch,
-        mayReuseFromLocals: conditionBranchLocalsCanBeReused);
-
-    conditionBranch.graph =
-        new SubExpression(conditionBranch.block, conditionExitBlock);
-  }
-
-  /**
-   * Returns true if the locals of the [fromBranch] may be reused. A [:true:]
-   * return value implies that [mayReuseFromLocals] was set to [:true:].
-   */
-  bool mergeLocals(SsaBranch fromBranch, SsaBranch toBranch,
-      {bool mayReuseFromLocals}) {
-    LocalsHandler fromLocals = fromBranch.exitLocals;
-    if (toBranch.startLocals == null) {
-      if (mayReuseFromLocals) {
-        toBranch.startLocals = fromLocals;
-        return false;
-      } else {
-        toBranch.startLocals = new LocalsHandler.from(fromLocals);
-        return true;
-      }
-    } else {
-      toBranch.startLocals.mergeWith(fromLocals, toBranch.block);
-      return true;
-    }
-  }
-
-  void startBranch(SsaBranch branch) {
-    builder.graph.addBlock(branch.block);
-    builder.localsHandler = branch.startLocals;
-    builder.open(branch.block);
-  }
-
-  HInstruction buildBranch(SsaBranch branch, void visitBranch(),
-      SsaBranch joinBranch, bool isExpression) {
-    startBranch(branch);
-    visitBranch();
-    branch.graph = new SubGraph(branch.block, builder.lastOpenedBlock);
-    branch.exitLocals = builder.localsHandler;
-    if (!builder.isAborted()) {
-      builder.goto(builder.current, joinBranch.block);
-      mergeLocals(branch, joinBranch, mayReuseFromLocals: true);
-    }
-    if (isExpression) {
-      checkNotAborted();
-      return builder.pop();
-    }
-    return null;
-  }
-
-  handleIf(void visitCondition(), void visitThen(), void visitElse(),
-      {SourceInformation sourceInformation}) {
-    if (visitElse == null) {
-      // Make sure to have an else part to avoid a critical edge. A
-      // critical edge is an edge that connects a block with multiple
-      // successors to a block with multiple predecessors. We avoid
-      // such edges because they prevent inserting copies during code
-      // generation of phi instructions.
-      visitElse = () {};
-    }
-
-    _handleDiamondBranch(visitCondition, visitThen, visitElse,
-        isExpression: false, sourceInformation: sourceInformation);
-  }
-
-  handleConditional(void visitCondition(), void visitThen(), void visitElse()) {
-    assert(visitElse != null);
-    _handleDiamondBranch(visitCondition, visitThen, visitElse,
-        isExpression: true);
-  }
-
-  handleIfNull(void left(), void right()) {
-    // x ?? y is transformed into: x == null ? y : x
-    HInstruction leftExpression;
-    handleConditional(() {
-      left();
-      leftExpression = builder.pop();
-      builder.pushCheckNull(leftExpression);
-    }, right, () => builder.stack.add(leftExpression));
-  }
-
-  void handleLogicalAndOr(void left(), void right(), {bool isAnd}) {
-    // x && y is transformed into:
-    //   t0 = boolify(x);
-    //   if (t0) {
-    //     t1 = boolify(y);
-    //   }
-    //   result = phi(t1, false);
-    //
-    // x || y is transformed into:
-    //   t0 = boolify(x);
-    //   if (not(t0)) {
-    //     t1 = boolify(y);
-    //   }
-    //   result = phi(t1, true);
-    HInstruction boolifiedLeft;
-    HInstruction boolifiedRight;
-
-    void visitCondition() {
-      left();
-      boolifiedLeft = builder.popBoolified();
-      builder.stack.add(boolifiedLeft);
-      if (!isAnd) {
-        builder.push(new HNot(builder.pop(), builder.backend.boolType));
-      }
-    }
-
-    void visitThen() {
-      right();
-      boolifiedRight = builder.popBoolified();
-    }
-
-    handleIf(visitCondition, visitThen, null);
-    HConstant notIsAnd =
-        builder.graph.addConstantBool(!isAnd, builder.compiler);
-    JavaScriptBackend backend = builder.backend;
-    HPhi result = new HPhi.manyInputs(
-        null, <HInstruction>[boolifiedRight, notIsAnd], backend.dynamicType);
-    builder.current.addPhi(result);
-    builder.stack.add(result);
-  }
-
-  void handleLogicalAndOrWithLeftNode(ast.Node left, void visitRight(),
-      {bool isAnd}) {
-    // This method is similar to [handleLogicalAndOr] but optimizes the case
-    // where left is a logical "and" or logical "or".
-    //
-    // For example (x && y) && z is transformed into x && (y && z):
-    //   t0 = boolify(x);
-    //   if (t0) {
-    //     t1 = boolify(y);
-    //     if (t1) {
-    //       t2 = boolify(z);
-    //     }
-    //     t3 = phi(t2, false);
-    //   }
-    //   result = phi(t3, false);
-
-    ast.Send send = left.asSend();
-    if (send != null && (isAnd ? send.isLogicalAnd : send.isLogicalOr)) {
-      ast.Node newLeft = send.receiver;
-      Link<ast.Node> link = send.argumentsNode.nodes;
-      assert(link.tail.isEmpty);
-      ast.Node middle = link.head;
-      handleLogicalAndOrWithLeftNode(
-          newLeft,
-          () =>
-              handleLogicalAndOrWithLeftNode(middle, visitRight, isAnd: isAnd),
-          isAnd: isAnd);
-    } else {
-      handleLogicalAndOr(() => builder.visit(left), visitRight, isAnd: isAnd);
-    }
-  }
-
-  void _handleDiamondBranch(
-      void visitCondition(), void visitThen(), void visitElse(),
-      {bool isExpression, SourceInformation sourceInformation}) {
-    SsaBranch conditionBranch = new SsaBranch(this);
-    SsaBranch thenBranch = new SsaBranch(this);
-    SsaBranch elseBranch = new SsaBranch(this);
-    SsaBranch joinBranch = new SsaBranch(this);
-
-    conditionBranch.startLocals = builder.localsHandler;
-    builder.goto(builder.current, conditionBranch.block);
-
-    buildCondition(visitCondition, conditionBranch, thenBranch, elseBranch,
-        sourceInformation);
-    HInstruction thenValue =
-        buildBranch(thenBranch, visitThen, joinBranch, isExpression);
-    HInstruction elseValue =
-        buildBranch(elseBranch, visitElse, joinBranch, isExpression);
-
-    if (isExpression) {
-      assert(thenValue != null && elseValue != null);
-      JavaScriptBackend backend = builder.backend;
-      HPhi phi = new HPhi.manyInputs(
-          null, <HInstruction>[thenValue, elseValue], backend.dynamicType);
-      joinBranch.block.addPhi(phi);
-      builder.stack.add(phi);
-    }
-
-    HBasicBlock joinBlock;
-    // If at least one branch did not abort, open the joinBranch.
-    if (!joinBranch.block.predecessors.isEmpty) {
-      startBranch(joinBranch);
-      joinBlock = joinBranch.block;
-    }
-
-    HIfBlockInformation info = new HIfBlockInformation(
-        new HSubExpressionBlockInformation(conditionBranch.graph),
-        new HSubGraphBlockInformation(thenBranch.graph),
-        new HSubGraphBlockInformation(elseBranch.graph));
-
-    HBasicBlock conditionStartBlock = conditionBranch.block;
-    conditionStartBlock.setBlockFlow(info, joinBlock);
-    SubGraph conditionGraph = conditionBranch.graph;
-    HIf branch = conditionGraph.end.last;
-    assert(branch is HIf);
-    branch.blockInformation = conditionStartBlock.blockFlow;
-  }
-}
-
 class TypeBuilder implements DartTypeVisitor<dynamic, SsaBuilder> {
   final ClassWorld classWorld;
 
   TypeBuilder(this.classWorld);
 
   void visit(DartType type, SsaBuilder builder) => type.accept(this, builder);
 
   void visitVoidType(VoidType type, SsaBuilder builder) {
     ClassElement cls = builder.backend.helpers.VoidRuntimeType;
     builder.push(new HVoidType(type, new TypeMask.exact(cls, classWorld)));
@@ skipping 86 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }