Improve async code in VM by not unnecessarily capturing parameters of async and

runtime/vm/scopes.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/scopes.h"
 
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
@@ skipping 386 matching lines @@
     }
   }
   return NULL;
 }
 
 
 LocalVariable* LocalScope::LookupVariable(const String& name, bool test_only) {
   LocalScope* current_scope = this;
   while (current_scope != NULL) {
     LocalVariable* var = current_scope->LocalLookupVariable(name);
-    if ((var != NULL) && !var->is_invisible_) {
-      if (!test_only) {
-        if (var->owner()->function_level() != function_level()) {
-          var->set_is_captured();
-        }
-        // Insert aliases of the variable in intermediate scopes.
-        LocalScope* intermediate_scope = this;
-        while (intermediate_scope != current_scope) {
-          intermediate_scope->variables_.Add(var);
-          ASSERT(var->owner() != intermediate_scope);  // Item is an alias.
-          intermediate_scope = intermediate_scope->parent();
-        }
+    // If testing only, return the variable even if invisible.
+    if ((var != NULL) && (!var->is_invisible_ || test_only)) {
+      if (!test_only && (var->owner()->function_level() != function_level())) {
+        CaptureVariable(var);
       }
       return var;
     }
     current_scope = current_scope->parent();
   }
   return NULL;
 }
 
 
-bool LocalScope::CaptureVariable(const String& name) {
-  ASSERT(name.IsSymbol());
-  LocalScope* current_scope = this;
-  while (current_scope != NULL) {
-    LocalVariable* var = current_scope->LocalLookupVariable(name);
-    if (var != NULL) {
-      var->set_is_captured();
-      LocalScope* scope = this;
-      while (var->owner()->function_level() != scope->function_level()) {
-        // Insert an alias of the variable in the top scope of each function
-        // level so that the variable is found in the context.
-        LocalScope* parent_scope = scope->parent();
-        while ((parent_scope != NULL) &&
-               (parent_scope->function_level() == scope->function_level())) {
-          scope = parent_scope;
-          parent_scope = scope->parent();
-        }
-        scope->variables_.Add(var);
-        ASSERT(var->owner() != scope);  // Item is an alias.
-        scope = parent_scope;
-      }
-      return true;
+void LocalScope::CaptureVariable(LocalVariable* variable) {
+  ASSERT(variable != NULL);
+  // The variable must exist in an enclosing scope, not necessarily in this one.
+  variable->set_is_captured();
+  const int variable_function_level = variable->owner()->function_level();
+  LocalScope* scope = this;
+  while (scope->function_level() != variable_function_level) {
+    // Insert an alias of the variable in the top scope of each function
+    // level so that the variable is found in the context.
+    LocalScope* parent_scope = scope->parent();
+    while ((parent_scope != NULL) &&
+           (parent_scope->function_level() == scope->function_level())) {
+      scope = parent_scope;
+      parent_scope = scope->parent();
     }
-    current_scope = current_scope->parent();
+    // An alias may already have been added in this scope, and in that case,
+    // in parent scopes as needed. If so, we are done.
+    if (!scope->AddVariable(variable)) {
+      return;
+    }
+    ASSERT(variable->owner() != scope);  // Item is an alias.
+    scope = parent_scope;
   }
-  return false;
 }
 
 
 SourceLabel* LocalScope::LookupLabel(const String& name) {
   LocalScope* current_scope = this;
   while (current_scope != NULL) {
     SourceLabel* label = current_scope->LocalLookupLabel(name);
     if (label != NULL) {
       return label;
     }
@@ skipping 54 matching lines @@
         outer_switch->AddLabel(label);
       }
     }
   }
   return NULL;
 }
 
 
 int LocalScope::NumCapturedVariables() const {
   // It is not necessary to traverse parent scopes, since we are only interested
-  // in the captured variables referenced in this scope. If this scope
-  // references a captured variable declared in a parent scope, it will contain
-  // an alias for that variable.
+  // in the captured variables referenced in this scope. If this scope is the
+  // top scope at function level 1 and it (or its children scopes) references a
+  // captured variable declared in a parent scope at function level 0, it will
+  // contain an alias for that variable.
 
   // Since code generation for nested functions is postponed until first
   // invocation, the function level of the closure scope can only be 1.
   ASSERT(function_level() == 1);
 
   int num_captured = 0;
   for (int i = 0; i < num_variables(); i++) {
     LocalVariable* variable = VariableAt(i);
     // Count the aliases of captured variables belonging to outer scopes.
     if (variable->owner()->function_level() != 1) {
@@ skipping 80 matching lines @@
     owner_scope->set_context_level(context_scope.ContextLevelAt(i));
     owner_scope->AddVariable(variable);
     outer_scope->AddVariable(variable);  // As alias.
     ASSERT(variable->owner() == owner_scope);
   }
   return outer_scope;
 }
 
 
 void LocalScope::RecursivelyCaptureAllVariables() {
-  bool found = false;
   for (intptr_t i = 0; i < num_variables(); i++) {
     if ((VariableAt(i)->name().raw() == Symbols::StackTraceVar().raw()) ||
         (VariableAt(i)->name().raw() == Symbols::ExceptionVar().raw()) ||
         (VariableAt(i)->name().raw() == Symbols::SavedTryContextVar().raw())) {
       // Don't capture those variables because the VM expects them to be on the
       // stack.
       continue;
     }
-    found = CaptureVariable(VariableAt(i)->name());
-    ASSERT(found);
+    CaptureVariable(VariableAt(i));
   }
   if (sibling() != NULL) { sibling()->RecursivelyCaptureAllVariables(); }
   if (child() != NULL) { child()->RecursivelyCaptureAllVariables(); }
 }
 
 
 RawContextScope* LocalScope::CreateImplicitClosureScope(const Function& func) {
   static const intptr_t kNumCapturedVars = 1;
 
   // Create a ContextScope with space for kNumCapturedVars descriptors.
@@ skipping 39 matching lines @@
     return fixed_parameter_count - (index() - kParamEndSlotFromFp);
   } else {
     // Shift negative indexes so that the lowest one is 0 (they are still
     // non-positive).
     return fixed_parameter_count - (index() - kFirstLocalSlotFromFp);
   }
 }
 
 
 }  // namespace dart