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)

[hausner, 2015/09/02 22:07:55]

Rename function_top_ to async_temp_scope_ so the naming is consistent
throughout?

[regis, 2015/09/03 01:28:04]

Done.

     : preamble_(preamble),
       temp_cnt_(0),
       function_top_(function_top),
       thread_(Thread::Current()) {
   ASSERT(function_top_ != NULL);
 }
 
 
 AstNode* AwaitTransformer::Transform(AstNode* expr) {
   expr->Visit(this);
   return result_;
 }
 
 
 LocalVariable* AwaitTransformer::EnsureCurrentTempVar() {
-  const char* await_temp_prefix = ":await_temp_var_";
+  const char* await_temp_prefix = Symbols::AwaitTempVarPrefix().ToCString();

[hausner, 2015/09/02 22:07:55]

Does it make sense to define this string constant as a symbol, yet the only way
we use it is to convert it to a C string to make another symbol?

You could do this instead:

symbol = String::ZoneHandle(String::NewFormatted("%d", temp_cnt_));
symbol = Symbol::FromConcat(Symbols::AwaitTempVarPrefix(), symbol);

[regis, 2015/09/03 01:28:03]

Done.

[srdjan, 2015/09/03 01:50:47]

This is problematic as it allocates a String in the new space.

[regis, 2015/09/03 16:48:38]

The previous version also allocates a new string, but does not hold onto it
either. Shouldn't the methods of Symbols copy the input from new space to old
space before returning a new Symbol?
Or maybe I do not understand the problem you are mentioning. 

   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));
   ASSERT(!symbol.IsNull());
   // Look up the variable in the scope used for async temp variables.
   LocalVariable* await_tmp = function_top_->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()));
@@ skipping 53 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(function_top_, 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 427 matching lines @@
 
 
 void AwaitTransformer::VisitThrowNode(ThrowNode* node) {
   AstNode* new_exception = Transform(node->exception());
   result_ = new(Z) ThrowNode(node->token_pos(),
                              new_exception,
                              node->stacktrace());
 }
 
 }  // namespace dart