Support local variables in dart2dart.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_tree.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 dart_tree;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../util/util.dart';
 import '../elements/elements.dart'
@@ skipping 198 matching lines @@
 
   // Uses of IR definitions are replaced with Tree variables.  This is the
   // mapping from definitions to variables.
   final Map<ir.Definition, Variable> variables = {};
 
   FunctionDefinition function;
   ir.Continuation returnContinuation;
 
   Builder(this.compiler);
 
+  static final String _bailout = 'Bailout Tree Builder';
+
+  bailout() => throw _bailout;
+
   FunctionDefinition build(ir.FunctionDefinition node) {
-    visit(node);
-    return function;
+    try {
+      visit(node);
+      return function;
+    } catch (e) {
+      if (e == _bailout) return null;
+      rethrow;
+    }
   }
 
   List<Expression> translateArguments(List<ir.Reference> args) {
     return new List.generate(args.length,
          (int index) => variables[args[index].definition]);
   }
 
   Expression visitFunctionDefinition(ir.FunctionDefinition node) {
     returnContinuation = node.returnContinuation;
     List<Variable> parameters = <Variable>[];
@@ skipping 50 matching lines @@
       } else {
         return new Sequence([invoke, visit(cont.body)]);
       }
     }
   }
 
   Expression visitInvokeContinuation(ir.InvokeContinuation node) {
     // TODO(kmillikin): Support non-return continuations.  These could arise
     // due to local control flow or due to inlining or other optimization.
     assert(node.continuation.definition == returnContinuation);
-    return new Return(variables[node.argument.definition]);
+    assert(node.arguments.length == 1);
+    return new Return(variables[node.arguments[0].definition]);
+  }
+
+  Expression visitBranch(ir.Branch node) {
+    return bailout();
   }
 
   Expression visitConstant(ir.Constant node) {
     return new Constant(node.value);
   }
 
   Expression visitParameter(ir.Parameter node) {
     // Continuation parameters are not visited (continuations themselves are
     // not visited yet).
     compiler.internalError(compiler.currentElement, 'Unexpected IR node.');
@@ skipping 459 matching lines @@
   }
 
   ast.Expression visitInterceptor(dart2js.InterceptorConstant constant) {
     return unimplemented();
   }
 
   ast.Expression visitDummy(dart2js.DummyConstant constant) {
     return unimplemented();
   }
 }