dart2js: Do not inline when try is seen.

pkg/compiler/lib/src/cps_ir/inline.dart

 // Copyright (c) 2015, 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.
 
 library cps_ir.optimization.inline;
 
 import 'cps_fragment.dart';
 import 'cps_ir_builder.dart' show ThisParameterLocal;
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
@@ skipping 148 matching lines @@
   final List<StackEntry> stack = <StackEntry>[];
 
   Inliner(this.functionCompiler);
 
   bool isCalledOnce(Element element) {
     return functionCompiler.compiler.typesTask.typesInferrer.isCalledOnce(
         element);
   }
 
   void rewrite(FunctionDefinition node, [CallStructure callStructure]) {
-    Element function = node.element;
+    ExecutableElement function = node.element;
 
     // Inlining in asynchronous or generator functions is disabled.  Inlining
     // triggers a bug in the async rewriter.
     // TODO(kmillikin): Fix the bug and eliminate this restriction if it makes
     // sense.
     if (function is FunctionElement &&
         function.asyncMarker != AsyncMarker.SYNC) {
       return;
     }
 
+    // Do not inline in functions containing try statements.  V8 does not
+    // optimize code in such functions, so inlining will move optimizable code
+    // into a context where it cannot be optimized.
+    if (function.resolvedAst.elements.containsTryStatement) {
+      return;
+    }
+
     stack.add(new StackEntry(function, callStructure));
     new InliningVisitor(this).visit(node);
     assert(stack.last.match(function, callStructure));
     stack.removeLast();
     new ShrinkingReducer().rewrite(node);
   }
 }
 
 /// Compute an abstract size of an IR function definition.
 ///
@@ skipping 156 matching lines @@
   //
   // An optional call structure indicates a dynamic call.  Calls that are
   // already resolved statically have a null call structure.
   //
   // The [Primitive] representing the result of the inlined call is returned
   // if the call was inlined, and the inlined function body is available in
   // [_fragment].  If the call was not inlined, null is returned.
   Primitive tryInlining(InvocationPrimitive invoke, FunctionElement target,
                         CallStructure callStructure) {
     // Quick checks: do not inline or even cache calls to targets without an
-    // AST node or targets that are asynchronous or generator functions.
+    // AST node, targets that are asynchronous or generator functions, or
+    // targets containing a try statement.
     if (!target.hasNode) return null;
     if (target.asyncMarker != AsyncMarker.SYNC) return null;
+    // V8 does not optimize functions containing a try statement.  Inlining
+    // code containing a try statement will make the optimizable calling code
+    // become unoptimizable.
+    if (target.resolvedAst.elements.containsTryStatement) {
+      return null;
+    }
 
     Reference<Primitive> dartReceiver = invoke.dartReceiverReference;
     TypeMask abstractReceiver =
         dartReceiver == null ? null : abstractType(dartReceiver);
     List<TypeMask> abstractArguments =
         invoke.arguments.map(abstractType).toList();
     var cachedResult = _inliner.cache.get(target, callStructure,
         abstractReceiver,
         abstractArguments);
 
@@ skipping 140 matching lines @@
       // We cannot inline a constructor invocation containing type arguments
       // because CreateInstance in the body does not know the type arguments.
       // We would incorrectly instantiate a class like A instead of A<B>.
       // TODO(kmillikin): try to fix this.
       GenericType generic = node.dartType;
       if (generic.typeArguments.any((DartType t) => !t.isDynamic)) return null;
     }
     return tryInlining(node, node.target, null);
   }
 }