Fix scoping async functions.

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/parser.h"
 
 namespace dart {
 
@@ skipping 24 matching lines @@
   V(While)
 
 #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,
+                                   const Library& library,
+                                   ParsedFunction* const parsed_function,
+                                   LocalScope* function_top)
+    : preamble_(preamble),
+      temp_cnt_(0),
+      library_(library),
+      parsed_function_(parsed_function),
+      function_top_(function_top),
+      isolate_(Isolate::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 String& cnt_str = String::ZoneHandle(
       I, String::NewFormatted("%s%d", await_temp_prefix, temp_cnt_));
   const String& symbol = String::ZoneHandle(I, Symbols::New(cnt_str));
   ASSERT(!symbol.IsNull());
-  LocalVariable* await_tmp =
-      parsed_function_->await_temps_scope()->LookupVariable(symbol, false);
+  // Look up the variable through the preamble scope.
+  LocalVariable* await_tmp = preamble_->scope()->LookupVariable(symbol, false);
   if (await_tmp == NULL) {
-    await_tmp = new(I) LocalVariable(
-        Scanner::kNoSourcePos,
-        symbol,
-        Type::ZoneHandle(I, Type::DynamicType()));
-    parsed_function_->await_temps_scope()->AddVariable(await_tmp);
+    // If we need a new temp variable, we add it to the function's top scope.
+    await_tmp = new (I) LocalVariable(
+        Scanner::kNoSourcePos, symbol, Type::ZoneHandle(Type::DynamicType()));
+    function_top_->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) {
+  LocalVariable* var = scope->LookupVariable(symbol, false);
+  ASSERT(var != NULL);
+  return var;
+}
+
+
 LocalVariable* AwaitTransformer::AddToPreambleNewTempVar(AstNode* node) {
   LocalVariable* tmp_var = EnsureCurrentTempVar();
   preamble_->Add(new(I) StoreLocalNode(Scanner::kNoSourcePos, tmp_var, node));
   NextTempVar();
   return tmp_var;
 }
 
 
 void AwaitTransformer::VisitLiteralNode(LiteralNode* node) {
   result_ = node;
@@ skipping 12 matching lines @@
   //   :result_param = :await_temp_var_X;
   //   if (:result_param is Future) {
   //     AwaitMarker(kNewContinuationState);
   //     :result_param.then(:async_op);
   //     return;  // (return_type() == kContinuation)
   //   }
   //   AwaitMarker(kTargetForContinuation);  // Join happens here.
   //   :saved_try_ctx_var = :await_saved_try_ctx_var_y;
   //   :await_temp_var_(X+1) = :result_param;
 
-  LocalVariable* async_op = preamble_->scope()->LookupVariable(
-      Symbols::AsyncOperation(), false);
-  ASSERT(async_op != NULL);
-  LocalVariable* result_param = preamble_->scope()->LookupVariable(
-      Symbols::AsyncOperationParam(), false);
-  ASSERT(result_param != NULL);
+  LocalVariable* async_op = GetVariableInScope(
+      preamble_->scope(), Symbols::AsyncOperation());
+  LocalVariable* result_param = GetVariableInScope(
+      preamble_->scope(), Symbols::AsyncOperationParam());
 
   node->expr()->Visit(this);
   preamble_->Add(new(I) StoreLocalNode(
       Scanner::kNoSourcePos, result_param, result_));
   LoadLocalNode* load_result_param = new(I) LoadLocalNode(
       Scanner::kNoSourcePos, result_param);
-  SequenceNode* is_future_branch = new(I) SequenceNode(
-      Scanner::kNoSourcePos, preamble_->scope());
-  AwaitMarkerNode* await_marker =
-      new(I) AwaitMarkerNode(AwaitMarkerNode::kNewContinuationState);
-  await_marker->set_scope(preamble_->scope());
+  LocalScope* is_future_scope = ChainNewScope(preamble_->scope());
+  SequenceNode* is_future_branch = new (I) SequenceNode(
+      Scanner::kNoSourcePos, is_future_scope);
+  AwaitMarkerNode* await_marker = new (I) AwaitMarkerNode(
+      AwaitMarkerNode::kNewContinuationState);
+  await_marker->set_scope(is_future_scope);
+  GetVariableInScope(is_future_scope, Symbols::AwaitJumpVar());
+  GetVariableInScope(is_future_scope, Symbols::AwaitContextVar());
   is_future_branch->Add(await_marker);
   ArgumentListNode* args = new(I) ArgumentListNode(Scanner::kNoSourcePos);
   args->Add(new(I) LoadLocalNode(Scanner::kNoSourcePos, async_op));
   is_future_branch->Add(new(I) InstanceCallNode(
       Scanner::kNoSourcePos, load_result_param, Symbols::FutureThen(), args));
   ReturnNode* continuation_return = new(I) ReturnNode(Scanner::kNoSourcePos);
   continuation_return->set_return_type(ReturnNode::kContinuation);
   is_future_branch->Add(continuation_return);
 
   const Class& cls = Class::ZoneHandle(
       I, library_.LookupClass(Symbols::Future()));
   const AbstractType& future_type = AbstractType::ZoneHandle(I, cls.RareType());
   ASSERT(!future_type.IsNull());
   preamble_->Add(new(I) IfNode(
       Scanner::kNoSourcePos,
       new (I) ComparisonNode(
           Scanner::kNoSourcePos,
           Token::kIS,
           load_result_param,
           new (I) TypeNode(Scanner::kNoSourcePos, future_type)),
       is_future_branch,
       NULL));
   preamble_->Add(new (I) AwaitMarkerNode(
       AwaitMarkerNode::kTargetForContinuation));
+
   // If this expression is part of a try block, also append the code for
   // restoring the saved try context that lives on the stack.
-  if (parsed_function_->saved_try_ctx() != NULL) {
+  const String& async_saved_try_ctx_name =
+      String::Handle(I, parsed_function_->async_saved_try_ctx_name());
+  if (!async_saved_try_ctx_name.IsNull()) {
+    LocalVariable* async_saved_try_ctx =
+        GetVariableInScope(preamble_->scope(), async_saved_try_ctx_name);
     preamble_->Add(new (I) StoreLocalNode(
         Scanner::kNoSourcePos,
         parsed_function_->saved_try_ctx(),
-        new (I) LoadLocalNode(
-            Scanner::kNoSourcePos, parsed_function_->async_saved_try_ctx())));
+        new (I) LoadLocalNode(Scanner::kNoSourcePos, async_saved_try_ctx)));
   }
 
   LocalVariable* result = AddToPreambleNewTempVar(new(I) LoadLocalNode(
       Scanner::kNoSourcePos, result_param));
   result_ = new(I) LoadLocalNode(Scanner::kNoSourcePos, result);
 }
 
 
 // Transforms boolean expressions into a sequence of evaluatons that only lazily
 // evaluate subexpressions.
@@ skipping 10 matching lines @@
 //   }
 //   t_3 = t_1 || t_2;  // Compiler takes care that lazy evaluation takes place
 //                         on this level.
 AstNode* AwaitTransformer::LazyTransform(const Token::Kind logical_op,
                                          AstNode* new_left,
                                          AstNode* right) {
   ASSERT(logical_op == Token::kAND || logical_op == Token::kOR);
   AstNode* result = NULL;
   const Token::Kind compare_logical_op = (logical_op == Token::kAND) ?
       Token::kEQ : Token::kNE;
-  SequenceNode* eval = new(I) SequenceNode(
-      Scanner::kNoSourcePos, preamble_->scope());
+  SequenceNode* eval = new (I) SequenceNode(
+      Scanner::kNoSourcePos, ChainNewScope(preamble_->scope()));
   SequenceNode* saved_preamble = preamble_;
   preamble_ = eval;
   result = Transform(right);
   preamble_ = saved_preamble;
   IfNode* right_body = new(I) IfNode(
       Scanner::kNoSourcePos,
       new(I) ComparisonNode(
           Scanner::kNoSourcePos,
           compare_logical_op,
           new_left,
           new(I) LiteralNode(Scanner::kNoSourcePos, Bool::True())),
       eval,
       NULL);
   preamble_->Add(right_body);
   return result;
 }
 
 
+LocalScope* AwaitTransformer::ChainNewScope(LocalScope* parent) {
+  return new (I) LocalScope(
+      parent, parent->function_level(), parent->loop_level());
+}
+
+
 void AwaitTransformer::VisitBinaryOpNode(BinaryOpNode* node) {
   node->left()->Visit(this);
   AstNode* new_left = result_;
   AstNode* new_right = NULL;
   // Preserve lazy evaluaton.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     new_right = LazyTransform(node->kind(), new_left, node->right());
   } else {
     new_right = Transform(node->right());
   }
@@ skipping 44 matching lines @@
   LocalVariable* result = AddToPreambleNewTempVar(
       new(I) UnaryOpNode(node->token_pos(), node->kind(), new_operand));
   result_ = new(I) LoadLocalNode(Scanner::kNoSourcePos, result);
 }
 
 
 // ::= (<condition>) ? <true-branch> : <false-branch>
 //
 void AwaitTransformer::VisitConditionalExprNode(ConditionalExprNode* node) {
   AstNode* new_condition = Transform(node->condition());
-  SequenceNode* new_true = new(I) SequenceNode(
-      Scanner::kNoSourcePos, preamble_->scope());
+  SequenceNode* new_true = new (I) SequenceNode(
+      Scanner::kNoSourcePos, ChainNewScope(preamble_->scope()));
   SequenceNode* saved_preamble = preamble_;
   preamble_ = new_true;
   AstNode* new_true_result = Transform(node->true_expr());
-  SequenceNode* new_false = new(I) SequenceNode(
-      Scanner::kNoSourcePos, preamble_->scope());
+  SequenceNode* new_false = new (I) SequenceNode(
+      Scanner::kNoSourcePos, ChainNewScope(preamble_->scope()));
   preamble_ = new_false;
   AstNode* new_false_result = Transform(node->false_expr());
   preamble_ = saved_preamble;
   IfNode* new_if = new(I) IfNode(Scanner::kNoSourcePos,
                                  new_condition,
                                  new_true,
                                  new_false);
   preamble_->Add(new_if);
   LocalVariable* result = AddToPreambleNewTempVar(
       new(I) ConditionalExprNode(Scanner::kNoSourcePos,
@@ skipping 222 matching lines @@
 void AwaitTransformer::VisitThrowNode(ThrowNode* node) {
   // TODO(mlippautz): Check if relevant.
   AstNode* new_exception = Transform(node->exception());
   AstNode* new_stacktrace = Transform(node->stacktrace());
   result_ = new(I) ThrowNode(node->token_pos(),
                              new_exception,
                              new_stacktrace);
 }
 
 }  // namespace dart