Merge libv1.

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;
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
@@ skipping 314 matching lines @@
   void enterScope(Node node, Element element) {
     // See if any variable in the top-scope of the function is captured. If yes
     // we need to create a box-object.
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData != null) {
       HInstruction box;
       // The scope has captured variables.
       if (element != null && element.isGenerativeConstructorBody()) {
         // The box is passed as a parameter to a generative
         // constructor body.
-        box = new HParameterValue(scopeData.boxElement);
-        builder.add(box);
+        box = builder.addParameter(scopeData.boxElement);
       } else {
         box = createBox();
       }
       // Add the box to the known locals.
       directLocals[scopeData.boxElement] = box;
       // Make sure that accesses to the boxed locals go into the box. We also
       // need to make sure that parameters are copied into the box if necessary.
       scopeData.capturedVariableMapping.forEach((Element from, Element to) {
         // The [from] can only be a parameter for function-scopes and not
         // loop scopes.
@@ skipping 40 matching lines @@
   void startFunction(Element element, Expression node) {
     assert(invariant(node, element.isImplementation));
     Compiler compiler = builder.compiler;
     closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
             element, node, builder.elements);
 
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       FunctionSignature params = functionElement.computeSignature(compiler);
       params.orderedForEachParameter((Element parameterElement) {
-        HInstruction parameter = new HParameterValue(parameterElement);
-        builder.add(parameter);
+        HInstruction parameter = builder.addParameter(parameterElement);
         builder.parameters[parameterElement] = parameter;
         directLocals[parameterElement] = parameter;
         parameter.guaranteedType =
             builder.mapInferredType(
                 typesTask.getGuaranteedTypeOfElement(parameterElement));
       });
     }
 
     enterScope(node, element);
 
@@ skipping 249 matching lines @@
     // In all other cases a new box will be created when entering the body of
     // the next iteration.
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     if (scopeData.hasBoxedLoopVariables()) {
       updateCaptureBox(scopeData.boxElement, scopeData.boxedLoopVariables);
     }
   }
 
   void endLoop(HBasicBlock loopEntry) {
+    // If the loop has an aborting body, we don't update the loop
+    // phis.
+    if (loopEntry.predecessors.length == 1) return;
     loopEntry.forEachPhi((HPhi phi) {
       Element element = phi.sourceElement;
       HInstruction postLoopDefinition = directLocals[element];
       phi.addInput(postLoopDefinition);
     });
   }
 
   /**
    * Merge [otherLocals] into this locals handler, creating phi-nodes when
    * there is a conflict.
@@ skipping 82 matching lines @@
 
 abstract class JumpHandler {
   factory JumpHandler(SsaBuilder builder, TargetElement target) {
     return new TargetJumpHandler(builder, target);
   }
   void generateBreak([LabelElement label]);
   void generateContinue([LabelElement label]);
   void forEachBreak(void action(HBreak instruction, LocalsHandler locals));
   void forEachContinue(void action(HContinue instruction,
                                    LocalsHandler locals));
+  bool hasAnyContinue();
+  bool hasAnyBreak();
   void close();
   final TargetElement target;
   List<LabelElement> labels();
 }
 
 // Insert break handler used to avoid null checks when a target isn't
 // used as the target of a break, and therefore doesn't need a break
 // handler associated with it.
 class NullJumpHandler implements JumpHandler {
   final Compiler compiler;
 
   NullJumpHandler(this.compiler);
 
   void generateBreak([LabelElement label]) {
     compiler.internalError('generateBreak should not be called');
   }
 
   void generateContinue([LabelElement label]) {
     compiler.internalError('generateContinue should not be called');
   }
 
   void forEachBreak(Function ignored) { }
   void forEachContinue(Function ignored) { }
   void close() { }
+  bool hasAnyContinue() => false;
+  bool hasAnyBreak() => false;
 
   List<LabelElement> labels() => const <LabelElement>[];
   TargetElement get target => null;
 }
 
 // Records breaks until a target block is available.
 // Breaks are always forward jumps.
 // Continues in loops are implemented as breaks of the body.
 // Continues in switches is currently not handled.
 class TargetJumpHandler implements JumpHandler {
@@ skipping 37 matching lines @@
       if (entry.isBreak()) action(entry.jumpInstruction, entry.locals);
     }
   }
 
   void forEachContinue(Function action) {
     for (JumpHandlerEntry entry in jumps) {
       if (entry.isContinue()) action(entry.jumpInstruction, entry.locals);
     }
   }
 
+  bool hasAnyContinue() {
+    for (JumpHandlerEntry entry in jumps) {
+      if (entry.isContinue()) return true;
+    }
+    return false;
+  }
+
+  bool hasAnyBreak() {
+    for (JumpHandlerEntry entry in jumps) {
+      if (entry.isBreak()) return true;
+    }
+    return false;
+  }
+
   void close() {
     // The mapping from TargetElement to JumpHandler is no longer needed.
     builder.jumpTargets.remove(target);
   }
 
   List<LabelElement> labels() {
     List<LabelElement> result = null;
     for (LabelElement element in target.labels) {
       if (result == null) result = <LabelElement>[];
       result.add(element);
     }
     return (result == null) ? const <LabelElement>[] : result;
   }
 }
 
 class SsaBuilder extends ResolvedVisitor implements Visitor {
   final SsaBuilderTask builder;
   final JavaScriptBackend backend;
   final Interceptors interceptors;
   final WorkItem work;
   final ConstantSystem constantSystem;
   bool methodInterceptionEnabled;
   HGraph graph;
   LocalsHandler localsHandler;
   HInstruction rethrowableException;
   Map<Element, HInstruction> parameters;
   final RuntimeTypeInformation rti;
+  HParameterValue lastAddedParameter;
 
   Map<TargetElement, JumpHandler> jumpTargets;
 
   /**
    * Variables stored in the current activation. These variables are
    * being updated in try/catch blocks, and should be
    * accessed indirectly through [HLocalGet] and [HLocalSet].
    */
   Map<Element, HLocalValue> activationVariables;
 
@@ skipping 31 matching lines @@
       rti = builder.compiler.codegenWorld.rti,
       super(work.resolutionTree) {
     localsHandler = new LocalsHandler(this);
   }
 
   static const MAX_INLINING_DEPTH = 3;
   static const MAX_INLINING_SOURCE_SIZE = 128;
   List<InliningState> inliningStack;
   Element returnElement;
   DartType returnType;
+  bool inTryStatement = false;
 
   void disableMethodInterception() {
     assert(methodInterceptionEnabled);
     methodInterceptionEnabled = false;
   }
 
   void enableMethodInterception() {
     assert(!methodInterceptionEnabled);
     methodInterceptionEnabled = true;
   }
@@ skipping 71 matching lines @@
         classElement.origin.backendMembers =
             classElement.origin.backendMembers.prepend(bodyElement.origin);
       }
       compiler.enqueuer.codegen.addToWorkList(bodyElement.declaration,
                                               treeElements);
     }
     assert(bodyElement.isGenerativeConstructorBody());
     return bodyElement;
   }
 
+  HParameterValue addParameter(Element element) {
+    HParameterValue result = new HParameterValue(element);
+    if (lastAddedParameter == null) {
+      graph.entry.addBefore(graph.entry.first, result);
+    } else {
+      graph.entry.addAfter(lastAddedParameter, result);
+    }
+    lastAddedParameter = result;
+    return result;
+  }
+
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [function] must be an implementation element.
    */
   InliningState enterInlinedMethod(PartialFunctionElement function,
                                    Selector selector,
                                    Link<Node> arguments) {
     assert(invariant(function, function.isImplementation));
 
@@ skipping 398 matching lines @@
     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.
-      check = new HParameterValue(checkResultElement);
-      add(check);
+      check = addParameter(checkResultElement);
     } else {
       // This is the code we emit for a parameter that is being checked
       // on whether it was given at value at the call site:
       //
       // foo([a = 42) {
       //   if (?a) print('parameter passed $a');
       // }
       //
       // foo([a = 42]) {
       //   var t1 = a === sentinel;
@@ skipping 71 matching lines @@
     } else {
       // Otherwise it is a lazy initializer which does not have parameters.
       assert(element is VariableElement);
     }
 
     // Add the type parameters of the class as parameters of this
     // method.
     var enclosing = element.enclosingElement;
     if (element.isConstructor() && compiler.world.needsRti(enclosing)) {
       enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
-        HParameterValue param = new HParameterValue(typeVariable.element);
-        add(param);
+        HParameterValue param = addParameter(typeVariable.element);
         localsHandler.directLocals[typeVariable.element] = param;
       });
     }
   }
 
   HInstruction potentiallyCheckType(
       HInstruction original, DartType type,
       { int kind: HTypeConversion.CHECKED_MODE_CHECK }) {
     if (!compiler.enableTypeAssertions) return original;
     HInstruction other = original.convertType(compiler, type, kind);
@@ skipping 165 matching lines @@
   /**
    * Ends the loop:
    * - creates a new block and adds it as successor to the [branchBlock].
    * - opens the new block (setting as [current]).
    * - notifies the locals handler that we're exiting a loop.
    */
   void endLoop(HBasicBlock loopEntry,
                HBasicBlock branchBlock,
                JumpHandler jumpHandler,
                LocalsHandler savedLocals) {
+    if (branchBlock == null && !jumpHandler.hasAnyBreak()) return;
+
     HBasicBlock loopExitBlock = addNewBlock();
-    assert(branchBlock.successors.length == 1);
+    assert(branchBlock == null || branchBlock.successors.length == 1);
     List<LocalsHandler> breakLocals = <LocalsHandler>[];
     jumpHandler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
       breakInstruction.block.addSuccessor(loopExitBlock);
       breakLocals.add(locals);
     });
-    branchBlock.addSuccessor(loopExitBlock);
+    if (branchBlock != null) {
+      branchBlock.addSuccessor(loopExitBlock);
+    }
     open(loopExitBlock);
     localsHandler.endLoop(loopEntry);
     if (!breakLocals.isEmpty) {
       breakLocals.add(savedLocals);
       localsHandler = savedLocals.mergeMultiple(breakLocals, loopExitBlock);
     } else {
       localsHandler = savedLocals;
     }
   }
 
@@ skipping 50 matching lines @@
         new SubExpression(conditionBlock, conditionExitBlock);
 
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
 
     // The body.
     HBasicBlock beginBodyBlock = addNewBlock();
     conditionExitBlock.addSuccessor(beginBodyBlock);
     open(beginBodyBlock);
 
     localsHandler.enterLoopBody(loop);
-    hackAroundPossiblyAbortingBody(loop, body);
+    body();
 
-    SubGraph bodyGraph = new SubGraph(beginBodyBlock, current);
-    HBasicBlock bodyBlock = close(new HGoto());
+    SubGraph bodyGraph = new SubGraph(beginBodyBlock, lastOpenedBlock);
+    HBasicBlock bodyBlock = current;
+    if (current != null) close(new HGoto());
 
-    // Update.
-    // We create an update block, even when we are in a while loop. There the
-    // update block is the jump-target for continue statements. We could avoid
-    // the creation if there is no continue, but for now we always create it.
-    HBasicBlock updateBlock = addNewBlock();
+    SubExpression updateGraph;
 
-    List<LocalsHandler> continueLocals = <LocalsHandler>[];
-    jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {
-      instruction.block.addSuccessor(updateBlock);
-      continueLocals.add(locals);
-    });
-    bodyBlock.addSuccessor(updateBlock);
-    continueLocals.add(localsHandler);
+    // Check that the loop has at least one back-edge.
+    if (jumpHandler.hasAnyContinue() || bodyBlock != null) {
+      // Update.
+      // We create an update block, even when we are in a while loop. There the
+      // update block is the jump-target for continue statements. We could avoid
+      // the creation if there is no continue, but for now we always create it.
+      HBasicBlock updateBlock = addNewBlock();
 
-    open(updateBlock);
+      List<LocalsHandler> continueLocals = <LocalsHandler>[];
+      jumpHandler.forEachContinue((HContinue instruction,
+                                   LocalsHandler locals) {
+        instruction.block.addSuccessor(updateBlock);
+        continueLocals.add(locals);
+      });
 
-    localsHandler = localsHandler.mergeMultiple(continueLocals, updateBlock);
 
-    HLabeledBlockInformation labelInfo;
-    List<LabelElement> labels = jumpHandler.labels();
-    TargetElement target = elements[loop];
-    if (!labels.isEmpty) {
-      beginBodyBlock.setBlockFlow(
-          new HLabeledBlockInformation(
-              new HSubGraphBlockInformation(bodyGraph),
-              jumpHandler.labels(),
-              isContinue: true),
-          updateBlock);
-    } else if (target != null && target.isContinueTarget) {
-      beginBodyBlock.setBlockFlow(
-          new HLabeledBlockInformation.implicit(
-              new HSubGraphBlockInformation(bodyGraph),
-              target,
-              isContinue: true),
-          updateBlock);
+      if (bodyBlock != null) {
+        continueLocals.add(localsHandler);
+        bodyBlock.addSuccessor(updateBlock);
+      }
+
+      open(updateBlock);
+      localsHandler =
+          continueLocals[0].mergeMultiple(continueLocals, updateBlock);
+
+      HLabeledBlockInformation labelInfo;
+      List<LabelElement> labels = jumpHandler.labels();
+      TargetElement target = elements[loop];
+      if (!labels.isEmpty) {
+        beginBodyBlock.setBlockFlow(
+            new HLabeledBlockInformation(
+                new HSubGraphBlockInformation(bodyGraph),
+                jumpHandler.labels(),
+                isContinue: true),
+            updateBlock);
+      } else if (target != null && target.isContinueTarget) {
+        beginBodyBlock.setBlockFlow(
+            new HLabeledBlockInformation.implicit(
+                new HSubGraphBlockInformation(bodyGraph),
+                target,
+                isContinue: true),
+            updateBlock);
+      }
+
+      localsHandler.enterLoopUpdates(loop);
+
+      update();
+
+      HBasicBlock updateEndBlock = close(new HGoto());
+      // The back-edge completing the cycle.
+      updateEndBlock.addSuccessor(conditionBlock);
+      updateGraph = new SubExpression(updateBlock, updateEndBlock);
     }
 
-    localsHandler.enterLoopUpdates(loop);
-
-    update();
-
-    HBasicBlock updateEndBlock = close(new HGoto());
-    // The back-edge completing the cycle.
-    updateEndBlock.addSuccessor(conditionBlock);
     conditionBlock.postProcessLoopHeader();
-    SubExpression updateGraph = new SubExpression(updateBlock, updateEndBlock);
 
     endLoop(conditionBlock, conditionExitBlock, jumpHandler, savedLocals);
     HLoopBlockInformation info =
         new HLoopBlockInformation(
             HLoopBlockInformation.loopType(loop),
             wrapExpressionGraph(initializerGraph),
             wrapExpressionGraph(conditionExpression),
             wrapStatementGraph(bodyGraph),
             wrapExpressionGraph(updateGraph),
             conditionBlock.loopInformation.target,
@@ skipping 64 matching lines @@
       // Add extra block to hang labels on.
       // It doesn't currently work if they are on the same block as the
       // HLoopInfo. The handling of HLabeledBlockInformation will visit a
       // SubGraph that starts at the same block again, so the HLoopInfo is
       // either handled twice, or it's handled after the labeled block info,
       // both of which generate the wrong code.
       // Using a separate block is just a simple workaround.
       bodyEntryBlock = openNewBlock();
     }
     localsHandler.enterLoopBody(node);
-    hackAroundPossiblyAbortingBody(node, () { visit(node.body); });
+    visit(node.body);
 
     // If there are no continues we could avoid the creation of the condition
     // block. This could also lead to a block having multiple entries and exits.
-    HBasicBlock bodyExitBlock = close(new HGoto());
-    HBasicBlock conditionBlock = addNewBlock();
+    HBasicBlock bodyExitBlock;
+    bool isAbortingBody = false;
+    if (current != null) {
+      bodyExitBlock = close(new HGoto());
+    } else {
+      isAbortingBody = true;
+      bodyExitBlock = lastOpenedBlock;
+    }
 
-    List<LocalsHandler> continueLocals = <LocalsHandler>[];
-    jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {
-      instruction.block.addSuccessor(conditionBlock);
-      continueLocals.add(locals);
-    });
-    bodyExitBlock.addSuccessor(conditionBlock);
-    if (!continueLocals.isEmpty) {
-      continueLocals.add(localsHandler);
-      localsHandler = savedLocals.mergeMultiple(continueLocals, conditionBlock);
-      SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
-      List<LabelElement> labels = jumpHandler.labels();
-      HSubGraphBlockInformation bodyInfo =
-          new HSubGraphBlockInformation(bodyGraph);
-      HLabeledBlockInformation info;
-      if (!labels.isEmpty) {
-        info = new HLabeledBlockInformation(bodyInfo, labels, isContinue: true);
-      } else {
-        info = new HLabeledBlockInformation.implicit(bodyInfo, target,
-                                                     isContinue: true);
+    SubExpression conditionExpression;
+    HBasicBlock conditionEndBlock;
+    if (!isAbortingBody || hasContinues) {
+      HBasicBlock conditionBlock = addNewBlock();
+
+      List<LocalsHandler> continueLocals = <LocalsHandler>[];
+      jumpHandler.forEachContinue((HContinue instruction,
+                                   LocalsHandler locals) {
+        instruction.block.addSuccessor(conditionBlock);
+        continueLocals.add(locals);
+      });
+
+      if (!isAbortingBody) {
+        bodyExitBlock.addSuccessor(conditionBlock);
       }
-      bodyEntryBlock.setBlockFlow(info, conditionBlock);
+
+      if (!continueLocals.isEmpty) {
+        if (!isAbortingBody) continueLocals.add(localsHandler);
+        localsHandler =
+            savedLocals.mergeMultiple(continueLocals, conditionBlock);
+        SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
+        List<LabelElement> labels = jumpHandler.labels();
+        HSubGraphBlockInformation bodyInfo =
+            new HSubGraphBlockInformation(bodyGraph);
+        HLabeledBlockInformation info;
+        if (!labels.isEmpty) {
+          info = new HLabeledBlockInformation(bodyInfo, labels,
+                                              isContinue: true);
+        } else {
+          info = new HLabeledBlockInformation.implicit(bodyInfo, target,
+                                                       isContinue: true);
+        }
+        bodyEntryBlock.setBlockFlow(info, conditionBlock);
+      }
+      open(conditionBlock);
+
+      visit(node.condition);
+      assert(!isAborted());
+      HInstruction conditionInstruction = popBoolified();
+      conditionEndBlock = close(
+          new HLoopBranch(conditionInstruction, HLoopBranch.DO_WHILE_LOOP));
+
+      conditionEndBlock.addSuccessor(loopEntryBlock);  // The back-edge.
+      conditionExpression =
+          new SubExpression(conditionBlock, conditionEndBlock);
     }
-    open(conditionBlock);
 
-    visit(node.condition);
-    assert(!isAborted());
-    HInstruction conditionInstruction = popBoolified();
-    HBasicBlock conditionEndBlock =
-        close(new HLoopBranch(conditionInstruction, HLoopBranch.DO_WHILE_LOOP));
-
-    conditionEndBlock.addSuccessor(loopEntryBlock);  // The back-edge.
     loopEntryBlock.postProcessLoopHeader();
 
     endLoop(loopEntryBlock, conditionEndBlock, jumpHandler, localsHandler);
     jumpHandler.close();
 
-    SubExpression conditionExpression =
-        new SubExpression(conditionBlock, conditionEndBlock);
     SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
 
     HLoopBlockInformation loopBlockInfo =
         new HLoopBlockInformation(
             HLoopBlockInformation.DO_WHILE_LOOP,
             null,
             wrapExpressionGraph(conditionExpression),
             wrapStatementGraph(bodyGraph),
             null,
             loopEntryBlock.loopInformation.target,
@@ skipping 205 matching lines @@
   HInstruction generateInstanceSendReceiver(Send send) {
     assert(Elements.isInstanceSend(send, elements));
     if (send.receiver == null) {
       return localsHandler.readThis();
     }
     visit(send.receiver);
     return pop();
   }
 
   String getTargetName(ErroneousElement error, [String prefix]) {
-    String result = error.targetName.slowToString();
+    String result = error.name.slowToString();
     if (?prefix) {
       result = '$prefix $result';
     }
     return result;
   }
 
   void generateInstanceGetterWithCompiledReceiver(Send send,
                                                   HInstruction receiver) {
     assert(Elements.isInstanceSend(send, elements));
     // TODO(kasperl): This is a convoluted way of checking if we're
@@ skipping 788 matching lines @@
         return HType.UNKNOWN;
       }
     }
 
     Element constructor = elements[node];
     Selector selector = elements.getSelector(node);
     if (compiler.enqueuer.resolution.getCachedElements(constructor) == null) {
       compiler.internalError("Unresolved element: $constructor", node: node);
     }
     FunctionElement functionElement = constructor;
-    constructor = functionElement.defaultImplementation;
+    constructor = functionElement.redirectionTarget;
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
     HInstruction target = new HStatic(constructor.declaration);
     add(target);
     var inputs = <HInstruction>[];
     inputs.add(target);
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [addStaticSendArgumentsToList].
     bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                   constructor.implementation,
@@ skipping 213 matching lines @@
       existingArguments.add(parameter.name.slowToString());
     });
     generateThrowNoSuchMethod(diagnosticNode,
                               function.name.slowToString(),
                               argumentNodes: argumentNodes,
                               existingArguments: existingArguments);
   }
 
   visitNewExpression(NewExpression node) {
     Element element = elements[node.send];
+    if (!Elements.isErroneousElement(element)) {
+      element = element.redirectionTarget;
+    }
     if (Elements.isErroneousElement(element)) {
       ErroneousElement error = element;
       if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
         generateThrowNoSuchMethod(node.send,
                                   getTargetName(error, 'constructor'),
                                   argumentNodes: node.send.arguments);
       } else if (error.messageKind == MessageKind.CANNOT_RESOLVE) {
         Message message = error.messageKind.message(error.messageArguments);
         generateRuntimeError(node.send, message.toString());
       } else {
@@ skipping 183 matching lines @@
     visit(node.expression);
     // Remove the result and reveal the duplicated receiver on the stack.
     pop();
   }
 
   visitCascadeReceiver(CascadeReceiver node) {
     visit(node.expression);
     dup();
   }
 
+  void handleInTryStatement() {
+    if (!inTryStatement) return;
+    HBasicBlock block = close(new HExitTry());
+    HBasicBlock newBlock = graph.addNewBlock();
+    block.addSuccessor(newBlock);
+    open(newBlock);
+  }
+
   visitReturn(Return node) {
     if (identical(node.getBeginToken().stringValue, 'native')) {
       native.handleSsaNative(this, node.expression);
       return;
     }
-    if (node.isRedirectingFactoryBody) {
-      compiler.internalError("Unimplemented: Redirecting factory constructor",
-                             node: node);
-    }
+    assert(invariant(node, !node.isRedirectingFactoryBody));
     HInstruction value;
     if (node.expression == null) {
       value = graph.addConstantNull(constantSystem);
     } else {
       visit(node.expression);
       value = pop();
       if (value is HForeign) {
         // TODO(6530, 6534): remove this check.
       } else {
         value = potentiallyCheckType(value, returnType);
       }
     }
+
+    handleInTryStatement();
+
     if (!inliningStack.isEmpty) {
       localsHandler.updateLocal(returnElement, value);
     } else {
       close(attachPosition(new HReturn(value), node)).addSuccessor(graph.exit);
     }
   }
 
   visitThrow(Throw node) {
     if (node.expression == null) {
       HInstruction exception = rethrowableException;
@@ skipping 70 matching lines @@
   visitEmptyStatement(EmptyStatement node) {
     // Do nothing, empty statement.
   }
 
   visitModifiers(Modifiers node) {
     compiler.unimplemented('SsaBuilder.visitModifiers', node: node);
   }
 
   visitBreakStatement(BreakStatement node) {
     assert(!isAborted());
+    handleInTryStatement();
     TargetElement target = elements[node];
     assert(target != null);
     JumpHandler handler = jumpTargets[target];
     assert(handler != null);
     if (node.target == null) {
       handler.generateBreak();
     } else {
       LabelElement label = elements[node.target];
       handler.generateBreak(label);
     }
   }
 
   visitContinueStatement(ContinueStatement node) {
+    handleInTryStatement();
     TargetElement target = elements[node];
     assert(target != null);
     JumpHandler handler = jumpTargets[target];
     assert(handler != null);
     if (node.target == null) {
       handler.generateContinue();
     } else {
       LabelElement label = elements[node.target];
       assert(label != null);
       handler.generateContinue(label);
@@ skipping 90 matching lines @@
       // a break or continue for a different target. In that case, this
       // label is also always unused.
       visit(body);
       return;
     }
     LocalsHandler beforeLocals = new LocalsHandler.from(localsHandler);
     assert(targetElement.isBreakTarget);
     JumpHandler handler = new JumpHandler(this, targetElement);
     // Introduce a new basic block.
     HBasicBlock entryBlock = openNewBlock();
-    hackAroundPossiblyAbortingBody(node, () { visit(body); });
+    visit(body);
     SubGraph bodyGraph = new SubGraph(entryBlock, lastOpenedBlock);
 
     HBasicBlock joinBlock = graph.addNewBlock();
     List<LocalsHandler> breakLocals = <LocalsHandler>[];
     handler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
       breakInstruction.block.addSuccessor(joinBlock);
       breakLocals.add(locals);
     });
     bool hasBreak = breakLocals.length > 0;
     if (!isAborted()) {
@@ skipping 408 matching lines @@
     // Save the current locals. The catch block and the finally block
     // must not reuse the existing locals handler. None of the variables
     // that have been defined in the body-block will be used, but for
     // loops we will add (unnecessary) phis that will reference the body
     // variables. This makes it look as if the variables were used
     // in a non-dominated block.
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     HBasicBlock enterBlock = openNewBlock();
     HTry tryInstruction = new HTry();
     close(tryInstruction);
+    bool oldInTryStatement = inTryStatement;
+    inTryStatement = true;
 
     HBasicBlock startTryBlock;
     HBasicBlock endTryBlock;
     HBasicBlock startCatchBlock;
     HBasicBlock endCatchBlock;
     HBasicBlock startFinallyBlock;
     HBasicBlock endFinallyBlock;
 
     startTryBlock = graph.addNewBlock();
     open(startTryBlock);
@@ skipping 94 matching lines @@
       open(startFinallyBlock);
       visit(node.finallyBlock);
       if (!isAborted()) endFinallyBlock = close(new HGoto());
       tryInstruction.finallyBlock = startFinallyBlock;
       finallyGraph = new SubGraph(startFinallyBlock, lastOpenedBlock);
     }
 
     HBasicBlock exitBlock = graph.addNewBlock();
 
     addOptionalSuccessor(b1, b2) { if (b2 != null) b1.addSuccessor(b2); }
+    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);
     enterBlock.addSuccessor(exitBlock);
 
     // The body has either the catch or the finally block as successor.
     if (endTryBlock != null) {
       assert(startCatchBlock != null || startFinallyBlock != null);
       endTryBlock.addSuccessor(
           startCatchBlock != null ? startCatchBlock : startFinallyBlock);
     }
 
     // The catch block has either the finally or the exit block as
     // successor.
     if (endCatchBlock != null) {
       endCatchBlock.addSuccessor(
           startFinallyBlock != null ? startFinallyBlock : exitBlock);
     }
 
     // The finally block has the exit block as successor.
     if (endFinallyBlock != null) {
       endFinallyBlock.addSuccessor(exitBlock);
     }
 
+    // If a block inside try/catch aborts (eg with a return statement),
+    // we explicitely mark this block a predecessor of the catch
+    // block and the finally block.
+    addExitTrySuccessor(startCatchBlock);
+    addExitTrySuccessor(startFinallyBlock);
+
     // Use the locals handler not altered by the catch and finally
     // blocks.
     localsHandler = savedLocals;
     open(exitBlock);
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
           wrapStatementGraph(bodyGraph),
           exception,
           wrapStatementGraph(catchGraph),
           wrapStatementGraph(finallyGraph)),
         exitBlock);
+    inTryStatement = oldInTryStatement;
   }
 
   visitScriptTag(ScriptTag node) {
     compiler.unimplemented('SsaBuilder.visitScriptTag', node: node);
   }
 
   visitCatchBlock(CatchBlock node) {
     visit(node.block);
   }
 
@@ skipping 10 matching lines @@
     ClassElement element = concreteType.getUniqueType();
     if (element == null) return HType.UNKNOWN;
     if (element == builder.compiler.boolClass) return HType.BOOLEAN;
     if (element == builder.compiler.doubleClass) return HType.DOUBLE;
     if (element == builder.compiler.intClass) return HType.INTEGER;
     if (element == builder.compiler.listClass) return HType.READABLE_ARRAY;
     if (element == builder.compiler.nullClass) return HType.NULL;
     if (element == builder.compiler.stringClass) return HType.STRING;
     return HType.UNKNOWN;
   }
-
-  /** HACK HACK HACK */
-  void hackAroundPossiblyAbortingBody(Node statement, void body()) {
-    visitCondition() {
-      stack.add(graph.addConstantBool(true, constantSystem));
-    }
-    buildBody() {
-      // TODO(lrn): Make sure to take continue into account.
-      body();
-    }
-    handleIf(statement, visitCondition, buildBody, null);
-  }
 }
 
 /**
  * Visitor that handles generation of string literals (LiteralString,
  * StringInterpolation), and otherwise delegates to the given visitor for
  * non-literal subexpressions.
  * TODO(lrn): Consider whether to handle compile time constant int/boolean
  * expressions as well.
  */
 class StringBuilderVisitor extends Visitor {
@@ skipping 364 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;
   }
 }