Short curcuit the inlining when code in the middle of an expression is aborting.

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 1299 matching lines @@
           && (selector.mask == null || selector.mask.isNullable)) {
         addWithPosition(
             new HFieldGet(null, providedArguments[0], backend.dynamicType,
                           isAssignable: false),
             currentNode);
       }
       List<HInstruction> compiledArguments = completeSendArgumentsList(
           function, selector, providedArguments, currentNode);
       enterInlinedMethod(function, currentNode, compiledArguments);
       inlinedFrom(function, () {
-        doInline(function);
+        if (!isReachable) {
+          emitReturn(graph.addConstantNull(compiler), null);
+        } else {
+          doInline(function);
+        }
       });
       leaveInlinedMethod();
     }
 
     if (meetsHardConstraints() && heuristicSayGoodToGo()) {
       doInlining();
       return true;
     }
 
     return false;
   }
 
+  void emitReturn(HInstruction value, N node);
+
   void doInline(FunctionElement function);
 
   inlinedFrom(Element element, f()) {
     assert(element is FunctionElement || element is VariableElement);
     return compiler.withCurrentElement(element, () {
       // The [sourceElementStack] contains declaration elements.
       sourceElementStack.add(element.declaration);
       var result = f();
       sourceElementStack.removeLast();
       return result;
@@ skipping 2639 matching lines @@
     HInstruction typeInfo = buildLiteralList(rtiInputs);
     add(typeInfo);
 
     // Set the runtime type information on the object.
     Element typeInfoSetterElement = backend.getSetRuntimeTypeInfo();
     pushInvokeStatic(
         null,
         typeInfoSetterElement,
         <HInstruction>[newObject, typeInfo],
         backend.dynamicType);
+
+    // The new object will now be referenced through the
+    // `setRuntimeTypeInfo` call. We therefore set the type of that
+    // instruction to be of the object's type.
+    assert(stack.last is HInvokeStatic || stack.last == newObject);
     stack.last.instructionType = newObject.instructionType;
     return pop();
   }
 
   handleNewSend(NewExpression node) {
     Send send = node.send;
     bool isFixedList = false;
     bool isFixedListConstructorCall =
         Elements.isFixedListConstructorCall(elements[send], send, compiler);
     bool isGrowableListConstructorCall =
@@ skipping 855 matching lines @@
     } else {
       visit(node.expression);
       value = pop();
       value = potentiallyCheckType(value, returnType);
     }
 
     handleInTryStatement();
     emitReturn(value, node);
   }
 
-  void emitReturn(HInstruction value, Node node);
-
   visitThrow(Throw node) {
     visitThrowExpression(node.expression);
     if (isReachable) {
       handleInTryStatement();
       push(new HThrowExpression(pop()));
       isReachable = false;
     }
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
@@ skipping 1503 matching lines @@
     DartType unaliased = type.unalias(builder.compiler);
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaFromAstMixin builder) {
     ClassElement cls = builder.compiler.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }