Don't inline in a throw 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 895 matching lines @@
 
   /**
    * Indicates whether the current block is dead (because it has a throw or a
    * return further up).  If this is false, then [_current] may be null.  If the
    * block is dead then it may also be aborted, but for simplicity we only
    * abort on statement boundaries, not in the middle of expressions.  See
    * isAborted.
    */
   bool isReachable = true;
 
+  /**
+   * True if we are visiting the expression of a throw expression.
+   */
+  bool inThrowExpression = false;
+
   final List<Element> sourceElementStack;
 
   Element get currentElement => sourceElementStack.last.declaration;
   Element get currentNonClosureClass {
     ClassElement cls = currentElement.getEnclosingClass();
     if (cls != null && cls.isClosure()) {
       var closureClass = cls;
       return closureClass.methodElement.getEnclosingClass();
     } else {
       return cls;
@@ skipping 380 matching lines @@
     bool heuristicSayGoodToGo(FunctionExpression functionExpression) {
       // Don't inline recursivly
       if (inliningStack.any((entry) => entry.function == function)) {
         return false;
       }
 
       if (element.isSynthesized) return true;
 
       if (cachedCanBeInlined == true) return cachedCanBeInlined;
 
+      if (inThrowExpression) return false;
+
       int numParameters = function.functionSignature.parameterCount;
       int maxInliningNodes;
       if (insideLoop) {
         maxInliningNodes = InlineWeeder.INLINING_NODES_INSIDE_LOOP +
             InlineWeeder.INLINING_NODES_INSIDE_LOOP_ARG_FACTOR * numParameters;
       } else {
         maxInliningNodes = InlineWeeder.INLINING_NODES_OUTSIDE_LOOP +
             InlineWeeder.INLINING_NODES_OUTSIDE_LOOP_ARG_FACTOR * numParameters;
       }
       bool canBeInlined = InlineWeeder.canBeInlined(
@@ skipping 727 matching lines @@
       }
     }
     assert(!current.isClosed());
     if (!stack.isEmpty) compiler.cancel('non-empty instruction stack');
   }
 
   visitClassNode(ClassNode node) {
     compiler.internalError('visitClassNode should not be called', node: node);
   }
 
+  visitThrowExpression(Expression expression) {
+    bool old = inThrowExpression;
+    try {
+      inThrowExpression = true;
+      visit(expression);
+    } finally {
+      inThrowExpression = old;
+    }
+  }
+
   visitExpressionStatement(ExpressionStatement node) {
     if (!isReachable) return;
     Throw throwExpression = node.expression.asThrow();
     if (throwExpression != null && inliningStack.isEmpty) {
-      visit(throwExpression.expression);
+      visitThrowExpression(throwExpression.expression);
       handleInTryStatement();
       closeAndGotoExit(new HThrow(pop()));
     } else {
       visit(node.expression);
       pop();
     }
   }
 
   /**
    * Creates a new loop-header block. The previous [current] block
@@ skipping 2234 matching lines @@
     handleInTryStatement();
 
     if (!inliningStack.isEmpty) {
       localsHandler.updateLocal(returnElement, value);
     } else {
       closeAndGotoExit(attachPosition(new HReturn(value), node));
     }
   }
 
   visitThrow(Throw node) {
-    visit(node.expression);
+    visitThrowExpression(node.expression);
     if (isReachable) {
       handleInTryStatement();
       push(new HThrowExpression(pop()));
       isReachable = false;
     }
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     compiler.internalError('visiting type annotation in SSA builder',
                            node: node);
@@ skipping 1241 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;
   }
 }