Add support for rethrow and start treating throw <expr> as an expression.

sdk/lib/_internal/compiler/implementation/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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 3933 matching lines @@
   }
 
   void handleInTryStatement() {
     if (!inTryStatement) return;
     HBasicBlock block = close(new HExitTry());
     HBasicBlock newBlock = graph.addNewBlock();
     block.addSuccessor(newBlock);
     open(newBlock);
   }
 
+  visitRethrow(Rethrow node) {
+    HInstruction exception = rethrowableException;
+    if (exception == null) {
+      exception = graph.addConstantNull(constantSystem);
+      compiler.internalError(
+          'rethrowableException should not be null', node: node);
+    }
+    handleInTryStatement();
+    closeAndGotoExit(new HThrow(exception, isRethrow: true));
+  }
+
   visitReturn(Return node) {
     if (identical(node.getBeginToken().stringValue, 'native')) {
       native.handleSsaNative(this, node.expression);
       return;
     }
     assert(invariant(node, !node.isRedirectingFactoryBody));
     HInstruction value;
     if (node.expression == null) {
       value = graph.addConstantNull(constantSystem);
     } else {
       visit(node.expression);
       value = pop();
       value = potentiallyCheckType(value, returnType);
     }
 
     handleInTryStatement();
 
     if (!inliningStack.isEmpty) {
       localsHandler.updateLocal(returnElement, value);
     } else {
       closeAndGotoExit(attachPosition(new HReturn(value), node));
     }
   }
 
   visitThrow(Throw node) {
-    if (node.expression == null) {
-      HInstruction exception = rethrowableException;
-      if (exception == null) {
-        exception = graph.addConstantNull(constantSystem);
-        compiler.internalError(
-            'rethrowableException should not be null', node: node);
-      }
+    visit(node.expression);
+    if (isReachable) {
       handleInTryStatement();
-      closeAndGotoExit(new HThrow(exception, isRethrow: true));
-    } else {
-      visit(node.expression);
-      handleInTryStatement();
-      if (inliningStack.isEmpty) {
-        closeAndGotoExit(new HThrow(pop()));
-      } else if (isReachable) {
-        // We don't close the block when we are inlining, because we could be
-        // inside an expression, and it is rather complicated to close the
-        // block at an arbitrary place in an expression.
-        add(new HThrowExpression(pop()));
-        isReachable = false;
-      }
+      push(new HThrowExpression(pop()));
+      isReachable = false;
     }
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     compiler.internalError('visiting type annotation in SSA builder',
                            node: node);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     assert(isReachable);
@@ skipping 955 matching lines @@
     node.visitChildren(this);
   }
 
   visitLoop(Node node) {
     // It's actually not difficult to inline a method with a loop, but
     // our measurements show that it's currently better to not inline a
     // method that contains a loop.
     tooDifficult = true;
   }
 
+  void visitRethrow(Rethrow node) {
+    if (!registerNode()) return;
+    tooDifficult = true;
+  }
+
   void visitReturn(Return node) {
     if (!registerNode()) return;
     if (seenReturn
         || identical(node.getBeginToken().stringValue, 'native')
         || node.isRedirectingFactoryBody) {
       tooDifficult = true;
       return;
     }
     node.visitChildren(this);
     seenReturn = true;
   }
 
   void visitTryStatement(Node node) {
     if (!registerNode()) return;
     tooDifficult = true;
   }
 
   void visitThrow(Throw node) {
     if (!registerNode()) return;
-    // We can't inline rethrows and we don't want to handle throw after a return
-    // even if it is in an "if".
-    if (seenReturn || node.expression == null) tooDifficult = true;
+    // For now, we don't want to handle throw after a return even if
+    // it is in an "if".
+    if (seenReturn) tooDifficult = true;
   }
 }
 
 class InliningState {
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [function] must be an implementation element.
    */
   final PartialFunctionElement function;
@@ skipping 241 matching lines @@
           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;
   }
 }