Make HBreak and HContinue not extend HGoto. They now extend HJump which is independent of HGoto. To…

lib/compiler/implementation/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 visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 236 matching lines @@
   visitControlFlow(HControlFlow node) => visitInstruction(node);
   visitRelational(HRelational node) => visitInvokeBinary(node);
 
   visitAdd(HAdd node) => visitBinaryArithmetic(node);
   visitBitAnd(HBitAnd node) => visitBinaryBitOp(node);
   visitBitNot(HBitNot node) => visitInvokeUnary(node);
   visitBitOr(HBitOr node) => visitBinaryBitOp(node);
   visitBitXor(HBitXor node) => visitBinaryBitOp(node);
   visitBoolify(HBoolify node) => visitInstruction(node);
   visitBoundsCheck(HBoundsCheck node) => visitCheck(node);
-  visitBreak(HBreak node) => visitGoto(node);
-  visitContinue(HContinue node) => visitGoto(node);
+  visitBreak(HBreak node) => visitJump(node);
+  visitContinue(HContinue node) => visitJump(node);
   visitCheck(HCheck node) => visitInstruction(node);
   visitConstant(HConstant node) => visitInstruction(node);
   visitDivide(HDivide node) => visitBinaryArithmetic(node);
   visitEquals(HEquals node) => visitRelational(node);
   visitExit(HExit node) => visitControlFlow(node);
   visitFieldGet(HFieldGet node) => visitInstruction(node);
   visitFieldSet(HFieldSet node) => visitInstruction(node);
   visitForeign(HForeign node) => visitInstruction(node);
   visitForeignNew(HForeignNew node) => visitForeign(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) => visitInvokeStatic(node);
   visitIndexAssign(HIndexAssign node) => visitInvokeStatic(node);
   visitIntegerCheck(HIntegerCheck node) => visitCheck(node);
   visitInvokeClosure(HInvokeClosure node)
       => visitInvokeDynamic(node);
   visitInvokeDynamicMethod(HInvokeDynamicMethod node)
       => visitInvokeDynamic(node);
   visitInvokeDynamicGetter(HInvokeDynamicGetter node)
       => visitInvokeDynamicField(node);
   visitInvokeDynamicSetter(HInvokeDynamicSetter node)
       => visitInvokeDynamicField(node);
   visitInvokeInterceptor(HInvokeInterceptor node)
       => visitInvokeStatic(node);
   visitInvokeStatic(HInvokeStatic node) => visitInvoke(node);
   visitInvokeSuper(HInvokeSuper node) => visitInvoke(node);
+  visitJump(HJump node) => visitControlFlow(node);
   visitLess(HLess node) => visitRelational(node);
   visitLessEqual(HLessEqual node) => visitRelational(node);
   visitLiteralList(HLiteralList node) => visitInstruction(node);
   visitLoopBranch(HLoopBranch node) => visitConditionalBranch(node);
   visitModulo(HModulo node) => visitBinaryArithmetic(node);
   visitNegate(HNegate node) => visitInvokeUnary(node);
   visitNot(HNot node) => visitInstruction(node);
   visitPhi(HPhi node) => visitInstruction(node);
   visitMultiply(HMultiply node) => visitBinaryArithmetic(node);
   visitParameterValue(HParameterValue node) => visitInstruction(node);
@@ skipping 1356 matching lines @@
   toString() => 'exit';
   accept(HVisitor visitor) => visitor.visitExit(this);
 }
 
 class HGoto extends HControlFlow {
   HGoto() : super(const <HInstruction>[]);
   toString() => 'goto';
   accept(HVisitor visitor) => visitor.visitGoto(this);
 }
 
-class HBreak extends HGoto {
+abstract class HJump extends HControlFlow {
   final TargetElement target;
   final LabelElement label;
-  HBreak(this.target) : label = null;
-  HBreak.toLabel(LabelElement label) : label = label, target = label.target;
+  HJump(this.target) : label = null, super(const <HInstruction>[]);
+  HJump.toLabel(LabelElement label)
+      : label = label, target = label.target, super(const <HInstruction>[]);
+}
+
+class HBreak extends HJump {
+  HBreak(TargetElement target) : super(target);
+  HBreak.toLabel(LabelElement label) : super.toLabel(label);
   toString() => (label !== null) ? 'break ${label.labelName}' : 'break';
   accept(HVisitor visitor) => visitor.visitBreak(this);
 }
 
-class HContinue extends HGoto {
-  final TargetElement target;
-  final LabelElement label;
-  HContinue(this.target) : label = null;
-  HContinue.toLabel(LabelElement label) : label = label, target = label.target;
+class HContinue extends HJump {
+  HContinue(TargetElement target) : super(target);
+  HContinue.toLabel(LabelElement label) : super.toLabel(label);
   toString() => (label !== null) ? 'continue ${label.labelName}' : 'continue';
   accept(HVisitor visitor) => visitor.visitContinue(this);
 }
 
 class HTry extends HControlFlow {
   HParameterValue exception;
   HBasicBlock catchBlock;
   HBasicBlock finallyBlock;
   HTry() : super(const <HInstruction>[]);
   toString() => 'try';
@@ skipping 802 matching lines @@
                        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);
 }