Fix several bugs in closure conversion.

pkg/kernel/lib/transformations/closure/converter.dart

 // Copyright (c) 2016, 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 kernel.transformations.closure.converter;
 
 import '../../ast.dart'
     show
+        AsyncMarker,
         Arguments,
         Block,
         Catch,
         Class,
         ClosureCreation,
         Constructor,
         DartType,
+        DoStatement,
         EmptyStatement,
         Expression,
         ExpressionStatement,
         Field,
         ForInStatement,
         ForStatement,
         FunctionDeclaration,
         FunctionExpression,
         FunctionNode,
         FunctionType,
@@ skipping 19 matching lines @@
         ThisExpression,
         Transformer,
         TreeNode,
         TypeParameter,
         TypeParameterType,
         VariableDeclaration,
         VariableGet,
         VariableSet,
         VectorCreation,
         VectorType,
+        WhileStatement,
         transformList;
 
 import '../../frontend/accessors.dart' show VariableAccessor;
 
 import '../../clone.dart' show CloneVisitor;
 
 import '../../core_types.dart' show CoreTypes;
 
 import '../../type_algebra.dart' show substitute;
 
 import 'clone_without_body.dart' show CloneWithoutBody;
 
 import 'context.dart' show Context, NoContext, LocalContext;
 
 import 'info.dart' show ClosureInfo;
 
 import 'rewriter.dart' show AstRewriter, BlockRewriter, InitializerListRewriter;
 
+bool isLoop(TreeNode node) {
+  return node is WhileStatement ||
+      node is DoStatement ||
+      node is ForStatement ||
+      node is ForInStatement;
+}
+
 class ClosureConverter extends Transformer {
   final CoreTypes coreTypes;
 
   final Set<VariableDeclaration> capturedVariables;
 
   // This map pairs variables that are captured with flags indicating whether
   // they are used inside or outside an initializer. See
   // [ClosureInfo.parameterUses].
   final Map<VariableDeclaration, int> parameterUses;
 
@@ skipping 257 matching lines @@
   TreeNode visitField(Field node) {
     currentMember = node;
     context = new NoContext(this);
     node = super.visitField(node);
     context = null;
     currentMember = null;
     return node;
   }
 
   Expression handleLocalFunction(FunctionNode function) {
+    if (function.asyncMarker == AsyncMarker.SyncYielding) {
+      function.transformChildren(this);
+      return new FunctionExpression(function);
+    }
     FunctionNode enclosingFunction = currentFunction;
     Map<TypeParameter, DartType> enclosingTypeSubstitution = typeSubstitution;
     currentFunction = function;
     Statement body = function.body;
     assert(body != null);
 
     rewriter = makeRewriterForBody(function);
 
     VariableDeclaration contextVariable =
         new VariableDeclaration("#contextParameter", type: const VectorType());
@@ skipping 187 matching lines @@
         .forEach(extendContextConditionally(inInitializer: false));
     assert(node.body != null);
     node.body = node.body.accept(this);
     node.body.parent = node;
     return node;
   }
 
   TreeNode visitBlock(Block node) {
     return saveContext(() {
       BlockRewriter blockRewriter = rewriter = rewriter.forNestedBlock(node);
+      if (node.parent is Statement &&
+          isLoop(node.parent) &&
+          context is! NoContext) {
+        context = context.toNestedContext();
+      }
       blockRewriter.transformStatements(this);
       return node;
     });
   }
 
   TreeNode visitVariableDeclaration(VariableDeclaration node) {
     node.transformChildren(this);
 
     if (!capturedVariables.contains(node)) return node;
     if (node.initializer == null && node.parent is FunctionNode) {
@@ skipping 253 matching lines @@
     copy.function.body.parent = copy.function;
     return copy;
   }
 
   void addGetterForwarder(Name name, Procedure getter) {
     assert(getter.isGetter);
     newClassMembers
         .add(copyWithBody(getter, forwardToThisProperty(getter))..name = name);
   }
 }