Implement constant switch as JS switch.

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 34 matching lines @@
   R visitNegate(HNegate node);
   R visitNot(HNot node);
   R visitParameterValue(HParameterValue node);
   R visitPhi(HPhi node);
   R visitReturn(HReturn node);
   R visitShiftLeft(HShiftLeft node);
   R visitShiftRight(HShiftRight node);
   R visitStatic(HStatic node);
   R visitStaticStore(HStaticStore node);
   R visitSubtract(HSubtract node);
+  R visitSwitch(HSwitch node);
   R visitThis(HThis node);
   R visitThrow(HThrow node);
   R visitTruncatingDivide(HTruncatingDivide node);
   R visitTry(HTry node);
   R visitTypeGuard(HTypeGuard node);
   R visitTypeConversion(HTypeConversion node);
 }
 
 class HGraphVisitor {
   visitDominatorTree(HGraph graph) {
@@ skipping 228 matching lines @@
   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);
   visitReturn(HReturn node) => visitControlFlow(node);
   visitShiftRight(HShiftRight node) => visitBinaryBitOp(node);
   visitShiftLeft(HShiftLeft node) => visitBinaryBitOp(node);
   visitSubtract(HSubtract node) => visitBinaryArithmetic(node);
+  visitSwitch(HSwitch node) => visitControlFlow(node);
   visitStatic(HStatic node) => visitInstruction(node);
   visitStaticStore(HStaticStore node) => visitInstruction(node);
   visitThis(HThis node) => visitParameterValue(node);
   visitThrow(HThrow node) => visitControlFlow(node);
   visitTry(HTry node) => visitControlFlow(node);
   visitTruncatingDivide(HTruncatingDivide node) => visitBinaryArithmetic(node);
   visitTypeGuard(HTypeGuard node) => visitCheck(node);
   visitIs(HIs node) => visitInstruction(node);
   visitTypeConversion(HTypeConversion node) => visitCheck(node);
 }
@@ skipping 13 matching lines @@
   }
 }
 
 class SubExpression extends SubGraph {
   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) return last.inputs[0];
+    if (last is HConditionalBranch || last is HSwitch) return last.inputs[0];
     return null;
   }
 }
 
 class HInstructionList {
   HInstruction first = null;
   HInstruction last = null;
 
   bool isEmpty() {
     return first === null;
@@ skipping 1124 matching lines @@
   HSubtract(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitSubtract(this);
 
   SubtractOperation get operation() => const SubtractOperation();
   int typeCode() => 9;
   bool typeEquals(other) => other is HSubtract;
   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.
+ * If the switch didn't have a default case, the last successor is
+ * the join block.
+ */
+class HSwitch extends HControlFlow {
+  HSwitch(List<HInstruction> inputs) : super(inputs);
+
+  HConstant constant(int index) => inputs[index + 1];
+  HInstruction get expression() => inputs[0];
+
+  HBasicBlock get defaultTarget() => block.successors.last();
+
+  accept(HVisitor visitor) => visitor.visitSwitch(this);
+
+  String toString() => "HSwitch cases = $inputs";
+}
+
 class HTruncatingDivide extends HBinaryArithmetic {
   HTruncatingDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitTruncatingDivide(this);
 
   TruncatingDivideOperation get operation()
       => const TruncatingDivideOperation();
   int typeCode() => 10;
   bool typeEquals(other) => other is HTruncatingDivide;
   bool dataEquals(HInstruction other) => true;
@@ skipping 810 matching lines @@
   bool accept(HExpressionInformationVisitor visitor);
   HInstruction get conditionExpression();
 }
 
 
 interface 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);
 }
 
 
 interface HExpressionInformationVisitor {
   bool visitAndOrInfo(HAndOrBlockInformation info);
   bool visitSubExpressionInfo(HSubExpressionBlockInformation info);
@@ skipping 175 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);
 }
+
+
+
+class HSwitchBlockInformation implements HStatementInformation {
+  final HExpressionInformation expression;
+  final List<List<Constant>> matchExpressions;
+  final List<HStatementInformation> statements;
+  // If the switch has a default, it's the last statement block, which
+  // may or may not have other expresions.
+  final bool hasDefault;
+  final TargetElement target;
+  final List<LabelElement> labels;
+
+  HSwitchBlockInformation(this.expression,
+                          this.matchExpressions,
+                          this.statements,
+                          this.hasDefault,
+                          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);
+}