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 922 matching lines @@
     if (name == const SourceString('==')) {
       if (!backend.operatorEqHandlesNullArgument(functionElement)) {
         handleIf(
             function,
             () {
               HParameterValue parameter = parameters.values.first;
               push(new HIdentity(
                   parameter, graph.addConstantNull(constantSystem)));
             },
             () {
-              HReturn ret = new HReturn(
-                  graph.addConstantBool(false, constantSystem));
-              close(ret).addSuccessor(graph.exit);
+              closeAndGotoExit(new HReturn(
+                  graph.addConstantBool(false, constantSystem)));
             },
             null);
       }
     }
     function.body.accept(this);
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(VariableElement variable) {
     SendSet node = variable.parseNode(compiler);
     openFunction(variable, node);
     Link<Node> link = node.arguments;
     assert(!link.isEmpty && link.tail.isEmpty);
     visit(link.head);
     HInstruction value = pop();
     value = potentiallyCheckType(value, variable.computeType(compiler));
-    close(new HReturn(value)).addSuccessor(graph.exit);
+    closeAndGotoExit(new HReturn(value));
     return closeFunction();
   }
 
   /**
    * Returns the constructor body associated with the given constructor or
    * creates a new constructor body, if none can be found.
    *
    * Returns [:null:] if the constructor does not have a body.
    */
   ConstructorBodyElement getConstructorBody(FunctionElement constructor) {
@@ skipping 556 matching lines @@
       // these selectors. Maybe the resolver can do more of the work
       // for us here?
       LibraryElement library = body.getLibrary();
       Selector selector = new Selector.call(
           name, library, bodyCallInputs.length - 1);
       HInvokeDynamic invoke =
           new HInvokeDynamicMethod(selector, bodyCallInputs);
       invoke.element = body;
       add(invoke);
     }
-    close(new HReturn(newObject)).addSuccessor(graph.exit);
+    closeAndGotoExit(new HReturn(newObject));
     return closeFunction();
   }
 
   void addParameterCheckInstruction(Element element) {
     HInstruction check;
     Element checkResultElement =
         localsHandler.closureData.parametersWithSentinel[element];
     if (currentElement.isGenerativeConstructorBody()) {
       // A generative constructor body receives extra parameters that
       // indicate if a parameter was passed to the factory.
@@ skipping 107 matching lines @@
       HInstruction original, DartType type,
       { int kind: HTypeConversion.CHECKED_MODE_CHECK }) {
     if (!compiler.enableTypeAssertions) return original;
     HInstruction other = original.convertType(compiler, type, kind);
     if (other != original) add(other);
     return other;
   }
 
   HGraph closeFunction() {
     // TODO(kasperl): Make this goto an implicit return.
-    if (!isAborted()) close(new HGoto()).addSuccessor(graph.exit);
+    if (!isAborted()) closeAndGotoExit(new HGoto());
     graph.finalize();
     return graph;
   }
 
   HBasicBlock addNewBlock() {
     HBasicBlock block = graph.addNewBlock();
     // If adding a new block during building of an expression, it is due to
     // conditional expressions or short-circuit logical operators.
     return block;
   }
 
   void open(HBasicBlock block) {
     block.open();
     current = block;
     lastOpenedBlock = block;
   }
 
   HBasicBlock close(HControlFlow end) {
     HBasicBlock result = current;
     current.close(end);
     current = null;
     return result;
   }
 
+  HBasicBlock closeAndGotoExit(HControlFlow end) {
+    HBasicBlock result = current;
+    current.close(end);
+    current = null;
+    result.addSuccessor(graph.exit);
+    return result;
+  }
+
   void goto(HBasicBlock from, HBasicBlock to) {
     from.close(new HGoto());
     from.addSuccessor(to);
   }
 
   bool isAborted() {
     return _current == null;
   }
 
   /**
@@ skipping 2218 matching lines @@
       visit(node.expression);
       value = pop();
       value = potentiallyCheckType(value, returnType);
     }
 
     handleInTryStatement();
 
     if (!inliningStack.isEmpty) {
       localsHandler.updateLocal(returnElement, value);
     } else {
-      close(attachPosition(new HReturn(value), node)).addSuccessor(graph.exit);
+      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);
       }
-      close(new HThrow(exception, isRethrow: true));
+      handleInTryStatement();
+      closeAndGotoExit(new HThrow(exception, isRethrow: true));
     } else {
+      visit(node.expression);
+      handleInTryStatement();
       if (inliningStack.isEmpty) {
-        visit(node.expression);
-        close(new HThrow(pop()));
+        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.
-        visit(node.expression);
         add(new HThrowExpression(pop()));
         isReachable = false;
       }
     }
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     compiler.internalError('visiting type annotation in SSA builder',
                            node: node);
   }
@@ skipping 395 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));
+        closeAndGotoExit(new HThrow(error));
       }
       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));
+        closeAndGotoExit(new HThrow(error));
       }
     }
 
     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));
+          closeAndGotoExit(new HThrow(exception, isRethrow: true));
         } 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 459 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;
   }
 }