Save the entry context for a function that has captured loop variables.

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 "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 149 matching lines @@
     // Parameter i will be at fp[kFirstLocalSlotFromFp - i] and local variable
     // j will be at fp[kFirstLocalSlotFromFp - num_params - j].
     first_parameter_index_ = kFirstLocalSlotFromFp;
     first_stack_local_index_ = first_parameter_index_ - num_params;
     num_copied_params_ = num_params;
   }
 
   // Allocate parameters and local variables, either in the local frame or
   // in the context(s).
   LocalScope* context_owner = NULL;  // No context needed yet.
+  bool found_captured_variables = false;
   int next_free_frame_index =
       scope->AllocateVariables(first_parameter_index_,
                                num_params,
                                first_stack_local_index_,
                                scope,
-                               &context_owner);
+                               &context_owner,
+                               &found_captured_variables);
 
-  // If this function allocates context variables, but none of its enclosing
-  // functions do, the context on entry is not linked as parent of the allocated
-  // context but saved on entry and restored on exit as to prevent memory leaks.
-  // Add and allocate a local variable to this purpose.
-  if (context_owner != NULL) {
+  // We save the entry context for a function when...
+  //
+  //   - some variable in the function is captured by nested functions, and
+  //   - the function does not capture any variables from parent functions.
+  //
+  // We used to link to the parent context in these cases, but this
+  // had the effect of unintentionally retaining parent contexts which
+  // would never be accessed.  By breaking the context chain at this
+  // point, we allow these outer contexts to be collected.
+  if (found_captured_variables) {
     const ContextScope& context_scope =
         ContextScope::Handle(function().context_scope());
     if (context_scope.IsNull() || (context_scope.num_variables() == 0)) {
+      // Allocate a local variable for saving the entry context.
       LocalVariable* context_var =
           new LocalVariable(function().token_pos(),
                             Symbols::SavedEntryContextVar(),
                             Type::ZoneHandle(Type::DynamicType()));
       context_var->set_index(next_free_frame_index--);
       scope->AddVariable(context_var);
       set_saved_entry_context_var(context_var);
     }
   }
 
@@ skipping 10752 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart