Implement try/catch in the JS backend.

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

 // Copyright (c) 2013, 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 dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 472 matching lines @@
   //
   // Return without a subexpression is translated as if it were return null.
   ir.Primitive visitReturn(ast.Return node) {
     assert(irBuilder.isOpen);
     assert(invariant(node, node.beginToken.value != 'native'));
     irBuilder.buildReturn(build(node.expression));
     return null;
   }
 
   visitTryStatement(ast.TryStatement node) {
-    // Try/catch is not yet implemented in the JS backend.
-    if (tryStatements == null) {
-      return giveup(node, 'try/catch in the JS backend');
-    }
     // Multiple catch blocks are not yet implemented.
     if (node.catchBlocks.isEmpty ||
         node.catchBlocks.nodes.tail == null) {
       return giveup(node, 'not exactly one catch block');
     }
     // 'on T' catch blocks are not yet implemented.
     if ((node.catchBlocks.nodes.head as ast.CatchBlock).onKeyword != null) {
       return giveup(node, '"on T" catch block');
     }
     // Finally blocks are not yet implemented.
@@ skipping 2073 matching lines @@
     body.functionSignature.orderedForEachParameter((ParameterElement param) {
       if (scope != null && scope.capturedVariables.containsKey(param)) {
         // Do not pass this parameter; the box will carry its value.
       } else {
         parameters.add(param);
       }
     });
     return parameters;
   }
 
+  DartCapturedVariables _analyzeCapturedVariables(ast.Node node) {
+    DartCapturedVariables variables = new DartCapturedVariables(elements);
+    try {
+      variables.analyze(node);
+    } catch (e) {
+      bailoutMessage = variables.bailoutMessage;
+      rethrow;
+    }
+    return variables;
+  }
+
   /// Builds the IR for the body of a constructor.
   ///
   /// This function is invoked from one or more "factory" constructors built by
   /// [buildConstructor].
   ir.FunctionDefinition buildConstructorBody(ConstructorBodyElement body) {
     ConstructorElement constructor = body.constructor;
     ast.FunctionExpression node = constructor.node;
     closureMap = compiler.closureToClassMapper.computeClosureToClassMapping(
         constructor,
         node,
         elements);
 
+    // We compute variables boxed in mutable variables on entry to each try
+    // block, not including variables captured by a closure (which are boxed
+    // in the heap).  This duplicates some of the work of closure conversion
+    // without directly using the results.  This duplication is wasteful and
+    // error-prone.
+    // TODO(kmillikin): We should combine closure conversion and try/catch
+    // variable analysis in some way.
+    DartCapturedVariables variables = _analyzeCapturedVariables(node);
+    tryStatements = variables.tryStatements;
     JsIrBuilder builder = getBuilderFor(body);
 
     return withBuilder(builder, () {
       irBuilder.buildConstructorBodyHeader(getConstructorBodyParameters(body),
                                            getClosureScopeForNode(node));
       visit(node.body);
       return irBuilder.makeFunctionDefinition([]);
     });
   }
 
   ir.FunctionDefinition buildFunction(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
     ast.FunctionExpression node = element.node;
 
     assert(!element.isSynthesized);
     assert(node != null);
     assert(elements[node] != null);
 
     closureMap = compiler.closureToClassMapper.computeClosureToClassMapping(
         element,
         node,
         elements);
+    DartCapturedVariables variables = _analyzeCapturedVariables(node);
+    tryStatements = variables.tryStatements;
     IrBuilder builder = getBuilderFor(element);
     return withBuilder(builder, () => _makeFunctionBody(element, node));
   }
 
   /// Creates a primitive for the default value of [parameter].
   ir.Primitive translateDefaultValue(ParameterElement parameter) {
     if (parameter.initializer == null) {
       return irBuilder.buildNullLiteral();
     } else {
       return inlineConstant(parameter.executableContext, parameter.initializer);
@@ skipping 130 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }