Implement switch statement, without the "complex switch statement" (aka switch statement with conti…

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 650 matching lines @@
   // TODO(karlklose): consider removing this and keeping the (substituted) types
   // of the type variables in an environment (like the [LocalsHandler]).
   final List<ResolutionDartType> currentInlinedInstantiations =
       <ResolutionDartType>[];
 
   final List<AstInliningState> inliningStack = <AstInliningState>[];
 
   Local returnLocal;
   ResolutionDartType returnType;
 
-  bool inTryStatement = false;
-
   ConstantValue getConstantForNode(ast.Node node) {
     ConstantValue constantValue =
         backend.constants.getConstantValueForNode(node, elements);
     assert(invariant(node, constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
   }
 
   HInstruction addConstant(ast.Node node) {
     return graph.addConstant(getConstantForNode(node), closedWorld);
@@ skipping 1221 matching lines @@
 
   visitIdentifier(ast.Identifier node) {
     if (node.isThis()) {
       visitThisGet(node);
     } else {
       reporter.internalError(
           node, "SsaFromAstMixin.visitIdentifier on non-this.");
     }
   }
 
+  void handleIf(
+      {ast.Node node,
+      void visitCondition(),
+      void visitThen(),
+      void visitElse(),
+      SourceInformation sourceInformation}) {
+    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, compiler, node);
+    branchBuilder.handleIf(visitCondition, visitThen, visitElse,
+        sourceInformation: sourceInformation);
+  }
+
   visitIf(ast.If node) {
     assert(isReachable);
     handleIf(
         node: node,
         visitCondition: () => visit(node.condition),
         visitThen: () => visit(node.thenPart),
         visitElse: node.elsePart != null ? () => visit(node.elsePart) : null,
         sourceInformation: sourceInformationBuilder.buildIf(node));
   }
 
@@ skipping 3123 matching lines @@
     visit(node.expression);
     // Remove the result and reveal the duplicated receiver on the stack.
     pop();
   }
 
   visitCascadeReceiver(ast.CascadeReceiver node) {
     visit(node.expression);
     dup();
   }
 
-  void handleInTryStatement() {
-    if (!inTryStatement) return;
-    HBasicBlock block = close(new HExitTry());
-    HBasicBlock newBlock = graph.addNewBlock();
-    block.addSuccessor(newBlock);
-    open(newBlock);
-  }
-
   visitRethrow(ast.Rethrow node) {
     HInstruction exception = rethrowableException;
     if (exception == null) {
       exception = graph.addConstantNull(closedWorld);
       reporter.internalError(node, 'rethrowableException should not be null.');
     }
     handleInTryStatement();
     closeAndGotoExit(new HThrow(
         exception, sourceInformationBuilder.buildThrow(node),
         isRethrow: true));
@@ skipping 904 matching lines @@
   }
 
   /**
    * Creates a switch statement.
    *
    * [jumpHandler] is the [JumpHandler] for the created switch statement.
    * [buildExpression] creates the switch expression.
    * [switchCases] must be either an [Iterable] of [ast.SwitchCase] nodes or
    *   a [Link] or a [ast.NodeList] of [ast.SwitchCase] nodes.
    * [getConstants] returns the set of constants for a switch case.
-   * [isDefaultCase] returns [:true:] if the provided switch case should be
+   * [isDefaultCase] returns true if the provided switch case should be
    *   considered default for the created switch statement.
    * [buildSwitchCase] creates the statements for the switch case.
    */
   void handleSwitch(
       ast.Node errorNode,
       JumpHandler jumpHandler,
       HInstruction buildExpression(),
       var switchCases,
       Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase),
       bool isDefaultCase(ast.SwitchCase switchCase),
@@ skipping 771 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }