Fix first part on liveness analysis of bug https://code.google.com/p/dart/issues/detail?id=9687: a …

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 3881 matching lines @@
   }
 
   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);
       }
-      close(new HThrow(exception, isRethrow: true));
+      handleInTryStatement();
+      close(new HThrow(exception, isRethrow: true)).addSuccessor(graph.exit);

[kasperl, 2013/04/11 12:28:53]

I'd prefer a new version of close that adds the exit block as a successor.

[ngeoffray, 2013/04/11 12:52:28]

Done.

     } else {
       visit(node.expression);
-      close(new HThrow(pop()));
+      handleInTryStatement();
+      close(new HThrow(pop())).addSuccessor(graph.exit);
     }
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     compiler.internalError('visiting type annotation in SSA builder',
                            node: node);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     for (Link<Node> link = node.definitions.nodes;
@@ skipping 391 matching lines @@
         // default case.
         expressionBlock.addSuccessor(block);
         hasDefault = true;
       }
       open(block);
       localsHandler = new LocalsHandler.from(savedLocals);
       visit(switchCase.statements);
       if (!isAborted() && caseIterator.hasNext) {
         pushInvokeHelper0(getFallThroughErrorElement, HType.UNKNOWN);
         HInstruction error = pop();
-        close(new HThrow(error));
+        close(new HThrow(error)).addSuccessor(graph.exit);
       }
       statements.add(
           new HSubGraphBlockInformation(new SubGraph(block, lastOpenedBlock)));
     }
 
     // Add a join-block if necessary.
     // We create [joinBlock] early, and then go through the cases that might
     // want to jump to it. In each case, if we add [joinBlock] as a successor
     // of another block, we also add an element to [caseHandlers] that is used
     // to create the phis in [joinBlock].
@@ skipping 96 matching lines @@
     // Called for the statements on all but the last case block.
     // Ensures that a user expecting a fallthrough gets an error.
     void visitStatementsAndAbort() {
       visit(node.statements);
       if (!isAborted()) {
         compiler.reportWarning(node, 'Missing break at end of switch case');
         Element element =
             compiler.findHelper(const SourceString("getFallThroughError"));
         pushInvokeHelper0(element, HType.UNKNOWN);
         HInstruction error = pop();
-        close(new HThrow(error));
+        close(new HThrow(error)).addSuccessor(graph.exit);
       }
     }
 
     Link<Node> skipLabels(Link<Node> labelsAndCases) {
       while (!labelsAndCases.isEmpty && labelsAndCases.head is Label) {
         labelsAndCases = labelsAndCases.tail;
       }
       return labelsAndCases;
     }
 
@@ skipping 195 matching lines @@
           pushInvokeHelper1(
               backend.getTraceFromException(), exception, HType.UNKNOWN);
           HInstruction traceInstruction = pop();
           localsHandler.updateLocal(elements[trace], traceInstruction);
         }
         visit(catchBlock);
       }
 
       void visitElse() {
         if (link.isEmpty) {
-          close(new HThrow(exception, isRethrow: true));
+          HBasicBlock block = close(new HThrow(exception, isRethrow: true));
+          block.addSuccessor(graph.exit);
         } else {
           CatchBlock newBlock = link.head;
           handleIf(node,
                    () { pushCondition(newBlock); },
                    visitThen, visitElse);
         }
       }
 
       CatchBlock firstBlock = link.head;
       handleIf(node, () { pushCondition(firstBlock); }, visitThen, visitElse);
@@ skipping 21 matching lines @@
     addExitTrySuccessor(successor) {
       if (successor == null) return;
       // Iterate over all blocks created inside this try/catch, and
       // attach successor information to blocks that end with
       // [HExitTry].
       for (int i = startTryBlock.id; i < successor.id; i++) {
         HBasicBlock block = graph.blocks[i];
         var last = block.last;
         if (last is HExitTry) {
           block.addSuccessor(successor);
-        } else if (last is HTry) {
-          // Skip all blocks inside this nested try/catch.
-          i = last.joinBlock.id;
         }
       }
     }
 
     // Setup all successors. The entry block that contains the [HTry]
     // has 1) the body, 2) the catch, 3) the finally, and 4) the exit
     // blocks as successors.
     enterBlock.addSuccessor(startTryBlock);
     addOptionalSuccessor(enterBlock, startCatchBlock);
     addOptionalSuccessor(enterBlock, startFinallyBlock);
@@ skipping 457 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;
   }
 }