Fix problems with async* and await for in dart2js.

pkg/compiler/lib/src/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;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 6015 matching lines @@
   ///
   /// Note that to get the right locals behavior, the code visited by [buildTry]
   /// and [buildFinally] must have been analyzed as if inside a try-statement by
   /// [ClosureTranslator].
   void buildProtectedByFinally(void buildTry(), void buildFinally()) {
     // Save the current locals. The finally block must not reuse the existing
     // locals handler. None of the variables that have been defined in the
     // body-block will be used, but for loops we will add (unnecessary) phis
     // that will reference the body variables. This makes it look as if the
     // variables were used in a non-dominated block.
+    LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     HBasicBlock enterBlock = openNewBlock();
     HTry tryInstruction = new HTry();
     close(tryInstruction);
     bool oldInTryStatement = inTryStatement;
     inTryStatement = true;
 
     HBasicBlock startTryBlock;
     HBasicBlock endTryBlock;
     HBasicBlock startFinallyBlock;
     HBasicBlock endFinallyBlock;
 
     startTryBlock = graph.addNewBlock();
     open(startTryBlock);
     buildTry();
     // We use a [HExitTry] instead of a [HGoto] for the try block
     // because it will have two successors: the join block, and
     // the finally block.
     if (!isAborted()) endTryBlock = close(new HExitTry());
     SubGraph bodyGraph = new SubGraph(startTryBlock, lastOpenedBlock);
 
     SubGraph finallyGraph = null;
 
+    localsHandler = new LocalsHandler.from(savedLocals);
     startFinallyBlock = graph.addNewBlock();
     open(startFinallyBlock);
     buildFinally();
     if (!isAborted()) endFinallyBlock = close(new HGoto());
     tryInstruction.finallyBlock = startFinallyBlock;
     finallyGraph = new SubGraph(startFinallyBlock, lastOpenedBlock);
 
     HBasicBlock exitBlock = graph.addNewBlock();
 
     void addExitTrySuccessor(HBasicBlock successor) {
@@ skipping 23 matching lines @@
     }
 
     // The finally block has the exit block as successor.
     endFinallyBlock.addSuccessor(exitBlock);
 
     // If a block inside try/catch aborts (eg with a return statement),
     // we explicitely mark this block a predecessor of the catch
     // block and the finally block.
     addExitTrySuccessor(startFinallyBlock);
 
+    // Use the locals handler not altered by the catch and finally
+    // blocks.
+    // TODO(sigurdm): We can probably do this, because try-variables are boxed.
+    // Need to verify.
+    localsHandler = savedLocals;
     open(exitBlock);
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
           wrapStatementGraph(bodyGraph),
           null, // No catch-variable.
           null, // No catchGraph.
           wrapStatementGraph(finallyGraph)),
         exitBlock);
     inTryStatement = oldInTryStatement;
   }
@@ skipping 826 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }