Reduce the number of captured variables in async code, by only capturing local

runtime/vm/ast_transformer.cc

 // Copyright (c) 2014, 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/ast_transformer.h"
 
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/thread.h"
 
@@ skipping 28 matching lines @@
 
 #define DEFINE_UNREACHABLE(BaseName)                                           \
 void AwaitTransformer::Visit##BaseName##Node(BaseName##Node* node) {           \
   UNREACHABLE();                                                               \
 }
 
 FOR_EACH_UNREACHABLE_NODE(DEFINE_UNREACHABLE)
 #undef DEFINE_UNREACHABLE
 
 AwaitTransformer::AwaitTransformer(SequenceNode* preamble,
-                                   LocalScope* function_top)
+                                   LocalScope* async_temp_scope)
     : preamble_(preamble),
       temp_cnt_(0),
-      function_top_(function_top),
+      async_temp_scope_(async_temp_scope),
       thread_(Thread::Current()) {
-  ASSERT(function_top_ != NULL);
+  ASSERT(async_temp_scope_ != NULL);
 }
 
 
 AstNode* AwaitTransformer::Transform(AstNode* expr) {
   expr->Visit(this);
   return result_;
 }
 
 
 LocalVariable* AwaitTransformer::EnsureCurrentTempVar() {
-  const char* await_temp_prefix = ":await_temp_var_";
-  const String& cnt_str = String::ZoneHandle(
-      Z, String::NewFormatted("%s%d", await_temp_prefix, temp_cnt_));
-  const String& symbol = String::ZoneHandle(Z, Symbols::New(cnt_str));
+  String& symbol = String::ZoneHandle(Z, String::NewFormatted("%d", temp_cnt_));
+  symbol = Symbols::FromConcat(Symbols::AwaitTempVarPrefix(), symbol);
   ASSERT(!symbol.IsNull());
   // Look up the variable in the scope used for async temp variables.
-  LocalVariable* await_tmp = function_top_->LocalLookupVariable(symbol);
+  LocalVariable* await_tmp = async_temp_scope_->LocalLookupVariable(symbol);
   if (await_tmp == NULL) {
     // We need a new temp variable; add it to the function's top scope.
     await_tmp = new (Z) LocalVariable(
         Scanner::kNoSourcePos, symbol, Type::ZoneHandle(Type::DynamicType()));
-    function_top_->AddVariable(await_tmp);
+    async_temp_scope_->AddVariable(await_tmp);
     // After adding it to the top scope, we can look it up from the preamble.
     // The following call includes an ASSERT check.
     await_tmp = GetVariableInScope(preamble_->scope(), symbol);
   }
   return await_tmp;
 }
 
 
 LocalVariable* AwaitTransformer::GetVariableInScope(LocalScope* scope,
                                                     const String& symbol) {
@@ skipping 42 matching lines @@
   LocalVariable* result_param = GetVariableInScope(
       preamble_->scope(), Symbols::AsyncOperationParam());
   LocalVariable* error_param = GetVariableInScope(
       preamble_->scope(), Symbols::AsyncOperationErrorParam());
   LocalVariable* stack_trace_param = GetVariableInScope(
       preamble_->scope(), Symbols::AsyncOperationStackTraceParam());
 
   AstNode* transformed_expr = Transform(node->expr());
   LocalVariable* await_temp = AddToPreambleNewTempVar(transformed_expr);
 
-  AwaitMarkerNode* await_marker = new (Z) AwaitMarkerNode();
-  await_marker->set_scope(preamble_->scope());
+  AwaitMarkerNode* await_marker =
+      new (Z) AwaitMarkerNode(async_temp_scope_, node->scope());
   preamble_->Add(await_marker);
 
   // :result_param = _awaitHelper(
   //      :await_temp, :async_then_callback, :async_catch_error_callback)
   const Library& async_lib = Library::Handle(Library::AsyncLibrary());
   const Function& async_await_helper = Function::ZoneHandle(
       Z, async_lib.LookupFunctionAllowPrivate(Symbols::AsyncAwaitHelper()));
   ASSERT(!async_await_helper.IsNull());
   ArgumentListNode* async_await_helper_args = new (Z) ArgumentListNode(
       Scanner::kNoSourcePos);
@@ skipping 404 matching lines @@
 }
 
 
 void AwaitTransformer::VisitLetNode(LetNode* node) {
   // Add all the initializer nodes to the preamble and the
   // temporary variables to the scope for async temporary variables.
   // The temporary variables will be captured as a side effect of being
   // added to a scope, and the subsequent nodes that are added to the
   // preample can access them.
   for (intptr_t i = 0; i < node->num_temps(); i++) {
-    function_top_->AddVariable(node->TempAt(i));
+    async_temp_scope_->AddVariable(node->TempAt(i));
     AstNode* new_init_val = Transform(node->InitializerAt(i));
     preamble_->Add(new(Z) StoreLocalNode(node->token_pos(),
                    node->TempAt(i),
                    new_init_val));
   }
   // The transformed LetNode does not have any temporary variables.
   LetNode* result = new(Z) LetNode(node->token_pos());
   for (intptr_t i = 0; i < node->nodes().length(); i++) {
     result->AddNode(Transform(node->nodes()[i]));
   }
   result_ = result;
 }
 
 
 void AwaitTransformer::VisitThrowNode(ThrowNode* node) {
   AstNode* new_exception = Transform(node->exception());
   result_ = new(Z) ThrowNode(node->token_pos(),
                              new_exception,
                              node->stacktrace());
 }
 
 }  // namespace dart