Fix for loop variable capturing

runtime/vm/parser.cc

 // 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.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 5913 matching lines @@
 
 AstNode* Parser::ParseForStatement(String* label_name) {
   TRACE_PARSER("ParseForStatement");
   const intptr_t for_pos = TokenPos();
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   SourceLabel* label = SourceLabel::New(for_pos, label_name, SourceLabel::kFor);
   if (IsForInStatement()) {
     return ParseForInStatement(for_pos, label);
   }
-  OpenBlock();
-  // The label is added to the implicit scope that also contains
-  // the loop variable declarations.
-  current_block_->scope->AddLabel(label);
+  // Open a block that contains the loop variable. Make it a loop block so
+  // that we allocate a new context if the loop variable is captured.
+  OpenLoopBlock();
   AstNode* initializer = NULL;
   const intptr_t init_pos = TokenPos();
   LocalScope* init_scope = current_block_->scope;
   if (CurrentToken() != Token::kSEMICOLON) {
     if (IsVariableDeclaration()) {
       initializer = ParseVariableDeclarationList();
     } else {
       initializer = ParseExpr(kAllowConst, kConsumeCascades);
     }
   }
   ExpectSemicolon();
   AstNode* condition = NULL;
   if (CurrentToken() != Token::kSEMICOLON) {
     condition = ParseExpr(kAllowConst, kConsumeCascades);
   }
   ExpectSemicolon();
   AstNode* increment = NULL;
   const intptr_t incr_pos = TokenPos();
-  LocalScope* incr_scope = current_block_->scope;
   if (CurrentToken() != Token::kRPAREN) {
     increment = ParseExprList();
   }
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
-  SequenceNode* body = ParseNestedStatement(parsing_loop_body, NULL);
+  SequenceNode* body = ParseNestedStatement(parsing_loop_body, label);
 
   // Check whether any of the variables in the initializer part of
   // the for statement are captured by a closure. If so, we insert a
   // node that creates a new Context for the loop variable before
   // the increment expression is evaluated.
   for (int i = 0; i < init_scope->num_variables(); i++) {
     if (init_scope->VariableAt(i)->is_captured() &&
         (init_scope->VariableAt(i)->owner() == init_scope)) {
-      SequenceNode* incr_sequence = new SequenceNode(incr_pos, incr_scope);
+      SequenceNode* incr_sequence = new SequenceNode(incr_pos, NULL);
       incr_sequence->Add(new CloneContextNode(for_pos));
       if (increment != NULL) {
         incr_sequence->Add(increment);
       }
       increment = incr_sequence;
       break;
     }
   }
-  CloseBlock();
-  return new ForNode(for_pos,
-                     label,
-                     NodeAsSequenceNode(init_pos, initializer, init_scope),
-                     condition,
-                     NodeAsSequenceNode(incr_pos, increment, incr_scope),
-                     body);
+  AstNode* for_node =
+      new ForNode(for_pos,
+                  label,
+                  NodeAsSequenceNode(init_pos, initializer, NULL),
+                  condition,
+                  NodeAsSequenceNode(incr_pos, increment, NULL),
+                  body);
+  current_block_->statements->Add(for_node);
+  return CloseBlock();
 }
 
 
 // Calling VM-internal helpers, uses implementation core library.
 AstNode* Parser::MakeStaticCall(const String& cls_name,
                                 const String& func_name,
                                 ArgumentListNode* arguments) {
   const Class& cls = Class::Handle(LookupCoreClass(cls_name));
   ASSERT(!cls.IsNull());
   const Function& func = Function::ZoneHandle(
@@ skipping 4067 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart