Fix break implementation.

frog/leg/ssa/nodes.dart

 // Copyright (c) 2011, 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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
@@ skipping 1335 matching lines @@
   HInstruction get right() => inputs[2];
 
   HType computeInputsType() {
     HType leftType = left.type;
     HType rightType = right.type;
     if (leftType.isUnknown() || rightType.isUnknown()) {
       return HType.UNKNOWN;
     }
     return leftType.combine(rightType);
   }
-  
+
   abstract HInstruction fold(HGraph graph);
   abstract evaluate(num a, num b);
 }
 
 class HBinaryArithmetic extends HInvokeBinary {
   HBinaryArithmetic(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
   void prepareGvn() {
     // An arithmetic expression can take part in global value
@@ skipping 416 matching lines @@
     if (hasElse) {
       if (dominated.length > 2) return dominated[2];
     } else {
       if (dominated.length > 1) return dominated[1];
     }
     return null;
   }
 }
 
 class HLoopBranch extends HConditionalBranch {
-  HLoopBranch(HInstruction condition) : super(<HInstruction>[condition]);
+  static final int CONDITION_FIRST_LOOP = 0;
+  static final int DO_WHILE_LOOP = 1;
+
+  final int kind;
+  HLoopBranch(HInstruction condition, [this.kind = CONDITION_FIRST_LOOP])
+      : super(<HInstruction>[condition]);
   toString() => 'loop-branch';
   accept(HVisitor visitor) => visitor.visitLoopBranch(this);
 
   bool isDoWhile() {
-    bool result = block.dominatedBlocks.length == 1;
-    if (result) {
-      // The first successor is the loop-body and thus a back-edge.
-      assert(block.successors[0].id < block.id);
-      assert(block.dominatedBlocks[0] === block.successors[1]);
-    } else {
-      assert(block.dominatedBlocks[0] === block.successors[0]);
-      assert(block.dominatedBlocks[1] === block.successors[1]);;
-    }
-    return result;
+    return kind === DO_WHILE_LOOP;
   }
 }
 
 class HLiteral extends HInstruction {
   final value;
   HLiteral.internal(this.value, HType type) : super(<HInstruction>[]) {
     this.type = type;
     tryGenerateAtUseSite();  // Maybe avoid this if the literal is big?
   }
 
@@ skipping 60 matching lines @@
 
   static final IS_NOT_LOGICAL_OPERATOR = 0;
   static final IS_AND = 1;
   static final IS_OR = 2;
 
   int logicalOperatorType = IS_NOT_LOGICAL_OPERATOR;
 
   // The order of the [inputs] must correspond to the order of the
   // 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.singleInput(this.element, HInstruction input)
-      : super(<HInstruction>[input]);
-  HPhi.manyInputs(this.element, List<HInstruction> inputs)
-      : super(inputs);
+  HPhi(this.element, List<HInstruction> inputs) : super(inputs);
+  HPhi.noInputs(Element element) : this(element, <HInstruction>[]);
+  HPhi.singleInput(Element element, HInstruction input)
+      : this(element, <HInstruction>[input]);
+  HPhi.manyInputs(Element element, List<HInstruction> inputs)
+      : this(element, inputs);
 
   void addInput(HInstruction input) {
     assert(isInBasicBlock());
     inputs.add(input);
     input.usedBy.add(this);
   }
 
   // Compute the (shared) type of the inputs if any. If all inputs
   // have the same known type return it. If any two inputs have
   // different known types, we'll return a conflict -- otherwise we'll
@@ skipping 353 matching lines @@
 
   HInstruction get expression() => inputs[0];
 
   HType computeType() => HType.BOOLEAN;
   bool hasExpectedType() => true;
 
   accept(HVisitor visitor) => visitor.visitIs(this);
 
   toString() => "$expression is $typeExpression";
 }