dart2dart: Implementation of simple try/catch.

pkg/compiler/lib/src/dart_backend/backend_ast_emitter.dart

 // Copyright (c) 2014, 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 backend_ast_emitter;
 
 import '../tree_ir/tree_ir_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
@@ skipping 20 matching lines @@
   /// Maps variables to their name.
   final Map<tree.Variable, String> variableNames;
 
   /// Maps local constants to their name.
   final Map<VariableElement, String> constantNames =
       <VariableElement, String>{};
 
   /// Variables that have had their declaration created.
   final Set<tree.Variable> declaredVariables = new Set<tree.Variable>();
 
+  /// Variables that are used as catch handler parameters.
+  final Set<tree.Variable> handlerVariables = new Set<tree.Variable>();
+
   /// Variable names that have already been used. Used to avoid name clashes.
   final Set<String> usedVariableNames;
 
   /// Statements emitted by the most recent call to [visitStatement].
   List<T> _statementBuffer = <T>[];
 
   /// The element currently being emitted.
   ExecutableElement currentElement;
 
   /// Bookkeeping object needed to synthesize a variable declaration.
@@ skipping 25 matching lines @@
         variableNames = <tree.Variable, String>{};
 
   BuilderContext.initializer(BuilderContext<T> parent)
       : this._parent = parent,
         usedVariableNames = parent.usedVariableNames,
         inInitializer = true,
         variableNames =
             new Map<tree.Variable, String>.from(parent.variableNames);
 
   // TODO(johnniwinther): Fully encapsulate handling of parameter, variable
-  // and local funciton declarations.
+  // and local function declarations.
   void addDeclaration(tree.Variable variable, [Expression initializer]) {
     assert(!declaredVariables.contains(variable));
     String name = getVariableName(variable);
     VariableDeclaration decl = new VariableDeclaration(name, initializer);
     decl.element = variable.element;
     declaredVariables.add(variable);
     variables.add(decl);
   }
 
   /// Generates a name for the given variable and synthesizes an element for it,
@@ skipping 256 matching lines @@
       body = new EmptyStatement();
     } else {
       context.firstStatement = definition.body;
       visitStatement(definition.body, context);
       context.removeTrailingReturn(_recognizeTrailingReturn);
 
       // Some of the variable declarations have already been added
       // if their first assignment could be pulled into the initializer.
       // Add the remaining variable declarations now.
       for (tree.Variable variable in context.variableNames.keys) {
-        if (!context.declaredVariables.contains(variable)) {
+        if (!context.declaredVariables.contains(variable) &&
+            !context.handlerVariables.contains(variable)) {
           context.addDeclaration(variable);
         }
       }
 
       // Add constant declarations.
       List<VariableDeclaration> constants = <VariableDeclaration>[];
       for (ConstDeclaration constDecl in definition.localConstants) {
         if (!context.constantNames.containsKey(constDecl.element)) {
           continue; // Discard unused constants declarations.
         }
@@ skipping 248 matching lines @@
                            BuilderContext<Statement> context) {
     Expression condition = visitExpression(stmt.condition, context);
     Block body = visitInSubContext(stmt.body, context, fallthrough: stmt);
     Statement statement = new While(condition, body);
     addLabeledStatement(stmt.label, statement, context);
 
     visitStatement(stmt.next, context);
   }
 
   @override
+  void visitTryStatement(tree.TryStatement stmt,
+                         BuilderContext<Statement> context) {
+    Block tryBody = visitInSubContext(stmt.tryBody, context);
+    Block catchBody = visitInSubContext(stmt.catchBody, context);
+    CatchBlock catchBlock;
+    tree.Variable exceptionVariable = stmt.catchParameters[0];
+    context.handlerVariables.add(exceptionVariable);
+    VariableDeclaration exceptionParameter =
+        new VariableDeclaration(context.getVariableName(exceptionVariable));
+    exceptionParameter.element = exceptionVariable.element;
+    if (stmt.catchParameters.length == 2) {
+      tree.Variable stackTraceVariable = stmt.catchParameters[1];
+      context.handlerVariables.add(stackTraceVariable);
+      VariableDeclaration stackTraceParameter =
+          new VariableDeclaration(context.getVariableName(stackTraceVariable));
+      stackTraceParameter.element = stackTraceVariable.element;
+      catchBlock = new CatchBlock(catchBody,
+          exceptionVar: exceptionParameter,
+          stackVar: stackTraceParameter);
+    } else {
+      assert(stmt.catchParameters.length == 1);
+      catchBlock = new CatchBlock(catchBody,
+          exceptionVar: exceptionParameter);
+    }
+    context.addStatement(new Try(tryBody, <CatchBlock>[catchBlock], null));
+  }
+
+  @override
   Expression visitConstant(tree.Constant exp,
                            BuilderContext<Statement> context) {
     return ConstantEmitter.createExpression(exp.expression, context);
   }
 
   @override
   Expression visitThis(tree.This exp,
                        BuilderContext<Statement> context) {
     return new This();
   }
@@ skipping 616 matching lines @@
       : super(name, ElementKind.VARIABLE, enclosingElement, variables, null);
 
   ExecutableElement get executableContext => enclosingElement;
 
   ExecutableElement get memberContext => executableContext.memberContext;
 
   bool get isLocal => true;
 
   LibraryElement get implementationLibrary => enclosingElement.library;
 }