dart2js: Allow 'throw' when inlining

sdk/lib/_internal/compiler/implementation/ssa/nodes.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;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 46 matching lines @@
   R visitReturn(HReturn node);
   R visitShiftLeft(HShiftLeft node);
   R visitStatic(HStatic node);
   R visitStaticStore(HStaticStore node);
   R visitStringConcat(HStringConcat node);
   R visitStringify(HStringify node);
   R visitSubtract(HSubtract node);
   R visitSwitch(HSwitch node);
   R visitThis(HThis node);
   R visitThrow(HThrow node);
+  R visitThrowExpression(HThrowExpression node);
   R visitTry(HTry node);
   R visitTypeGuard(HTypeGuard node);
   R visitTypeConversion(HTypeConversion node);
 }
 
 abstract class HGraphVisitor {
   visitDominatorTree(HGraph graph) {
     void visitBasicBlockAndSuccessors(HBasicBlock block) {
       visitBasicBlock(block);
       List dominated = block.dominatedBlocks;
@@ skipping 255 matching lines @@
   visitReturn(HReturn node) => visitControlFlow(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);
   visitStringConcat(HStringConcat node) => visitInstruction(node);
   visitStringify(HStringify node) => visitInstruction(node);
   visitThis(HThis node) => visitParameterValue(node);
   visitThrow(HThrow node) => visitControlFlow(node);
+  visitThrowExpression(HThrowExpression node) => visitInstruction(node);
   visitTry(HTry node) => visitControlFlow(node);
   visitTypeGuard(HTypeGuard node) => visitCheck(node);
   visitIs(HIs node) => visitInstruction(node);
   visitTypeConversion(HTypeConversion node) => visitCheck(node);
 }
 
 class SubGraph {
   // The first and last block of the sub-graph.
   final HBasicBlock start;
   final HBasicBlock end;
@@ skipping 1659 matching lines @@
   bool typeEquals(other) => other is HLessEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HReturn extends HControlFlow {
   HReturn(value) : super(<HInstruction>[value]);
   toString() => 'return';
   accept(HVisitor visitor) => visitor.visitReturn(this);
 }
 
+class HThrowExpression extends HInstruction {

[karlklose, 2013/04/09 11:58:46]

Shouldn't this extends HControlFlow?

[ngeoffray, 2013/04/10 12:06:39]

Wouldn't it be simpler to have HTrow be treated as an expression in our SSA
nodes?

[erikcorry, 2013/04/10 12:52:32]

I don't think so.

[erikcorry, 2013/04/10 12:52:32]

No, we can't do control flow (closing the block with a throw) inside an
expression because the code generator can't cope.  So we just throw and keep
going (rather like a call to a method that always throws).  But we stop
generating code at the next statement boundary.

If it turns out to be common and cause bloat, we can do the work to handle throw
properly in mid-statement.  I had a patch that worked for 99% of cases, but I
kept finding more corner cases.  It is possible that it would work now that I
fixed https://codereview.chromium.org/13723002/ but I sort of lost patience with
it after being at (what I thought was) 99% for a week or two.

+  HThrowExpression(value) : super(<HInstruction>[value]);
+  toString() => 'throwexpression';
+  accept(HVisitor visitor) => visitor.visitThrowExpression(this);
+  bool canThrow() => true;
+}
+
 class HThrow extends HControlFlow {
   final bool isRethrow;
   HThrow(value, {this.isRethrow: false}) : super(<HInstruction>[value]);
   toString() => 'throw';
   accept(HVisitor visitor) => visitor.visitThrow(this);
 }
 
 class HStatic extends HInstruction {
   final Element element;
   HStatic(this.element) : super(<HInstruction>[]) {
@@ skipping 607 matching lines @@
   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);
 }