Fix returning from async functions.

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 816 matching lines @@
     case RawFunction::kInvokeFieldDispatcher:
       node_sequence =
           parser.ParseInvokeFieldDispatcher(func, &default_parameter_values);
       break;
     default:
       UNREACHABLE();
   }
 
   if (!HasReturnNode(node_sequence)) {
     // Add implicit return node.
-    node_sequence->Add(new ReturnNode(func.end_token_pos()));
+    ReturnNode* implicit_return =
+        new(Isolate::Current()) ReturnNode(func.end_token_pos(),
+                                           node_sequence->scope());
+    node_sequence->Add(implicit_return);
   }
   if (parsed_function->has_expression_temp_var()) {
     node_sequence->scope()->AddVariable(parsed_function->expression_temp_var());
   }
   if (parsed_function->has_saved_current_context_var()) {
     node_sequence->scope()->AddVariable(
         parsed_function->saved_current_context_var());
   }
   parsed_function->SetNodeSequence(node_sequence);
 
@@ skipping 161 matching lines @@
     // We don't want to use ParseConstExpr() here because we don't want
     // the constant folding code to create, compile and execute a code
     // fragment to evaluate the expression. Instead, we just make sure
     // the static const field initializer is a constant expression and
     // leave the evaluation to the getter function.
     AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
     // This getter will only be called once at compile time.
     if (expr->EvalConstExpr() == NULL) {
       ReportError(expr_pos, "initializer is not a valid compile-time constant");
     }
-    ReturnNode* return_node = new ReturnNode(ident_pos, expr);
+    ReturnNode* return_node =
+        new ReturnNode(ident_pos, expr, current_block_->scope);
     current_block_->statements->Add(return_node);
   } else {
     // This getter may be called each time the static field is accessed.
     // The following generated code lazily initializes the field:
     // if (field.value === transition_sentinel) {
     //   field.value = null;
     //   throw("circular dependency in field initialization");
     // }
     // if (field.value === sentinel) {
     //   field.value = transition_sentinel;
@@ skipping 50 matching lines @@
         new StaticCallNode(expr_pos, init_function, arguments);
     initialize_field->Add(init_call);
 
     AstNode* uninitialized_check =
         new IfNode(ident_pos, compare_uninitialized, initialize_field, NULL);
     current_block_->statements->Add(uninitialized_check);
 
     // Generate code returning the field value.
     ReturnNode* return_node =
         new ReturnNode(ident_pos,
-                       new LoadStaticFieldNode(ident_pos, field));
+                       new LoadStaticFieldNode(ident_pos, field),
+                       current_block_->scope);
     current_block_->statements->Add(return_node);
   }
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseStaticInitializer(const Function& func) {
   TRACE_PARSER("ParseStaticInitializer");
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
@@ skipping 126 matching lines @@
   ASSERT(IsIdentifier());
   const String& field_name = *CurrentLiteral();
   const Class& field_class = Class::Handle(I, func.Owner());
   const Field& field =
       Field::ZoneHandle(I, field_class.LookupInstanceField(field_name));
 
   LoadInstanceFieldNode* load_field =
       new LoadInstanceFieldNode(ident_pos, load_receiver, field);
 
   ReturnNode* return_node =
-      new ReturnNode(Scanner::kNoSourcePos, load_field);
+      new ReturnNode(Scanner::kNoSourcePos, load_field, current_block_->scope);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 // Create AstNodes for an implicit instance setter method:
 //   LoadLocalNode 0 ('this')
 //   LoadLocalNode 1 ('value')
 //   SetInstanceField (field_name);
 //   ReturnNode (void);
@@ skipping 23 matching lines @@
 
   LoadLocalNode* receiver =
       new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(0));
   LoadLocalNode* value =
       new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(1));
 
   EnsureExpressionTemp();
   StoreInstanceFieldNode* store_field =
       new StoreInstanceFieldNode(ident_pos, receiver, field, value);
   current_block_->statements->Add(store_field);
-  current_block_->statements->Add(new ReturnNode(Scanner::kNoSourcePos));
+  current_block_->statements->Add(new ReturnNode(Scanner::kNoSourcePos, NULL));
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseMethodExtractor(const Function& func) {
   TRACE_PARSER("ParseMethodExtractor");
   ParamList params;
 
   const intptr_t ident_pos = func.token_pos();
   ASSERT(func.token_pos() == 0);
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // Receiver.
   ASSERT(!func.HasOptionalParameters());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
 
   ClosureNode* closure = new ClosureNode(
       ident_pos,
       Function::ZoneHandle(I, func.extracted_method_closure()),
       load_receiver,
       NULL);
 
-  ReturnNode* return_node = new ReturnNode(Scanner::kNoSourcePos, closure);
+  ReturnNode* return_node =
+      new ReturnNode(Scanner::kNoSourcePos, closure, current_block_->scope);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::BuildDispatcherScope(const Function& func,
                                   const ArgumentsDescriptor& desc,
                                   Array* default_values) {
   ParamList params;
   // Receiver first.
@@ skipping 76 matching lines @@
   if (no_such_method.IsNull()) {
     // If noSuchMethod(i) is not found, call Object:noSuchMethod.
     no_such_method ^= Resolver::ResolveDynamicForReceiverClass(
         Class::Handle(I, I->object_store()->object_class()),
         Symbols::NoSuchMethod(),
         args_desc);
   }
   StaticCallNode* call =
       new StaticCallNode(token_pos, no_such_method, arguments);
 
-  ReturnNode* return_node = new ReturnNode(token_pos, call);
+  ReturnNode* return_node = new ReturnNode(token_pos, call, NULL);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseInvokeFieldDispatcher(const Function& func,
                                                  Array* default_values) {
   TRACE_PARSER("ParseInvokeFieldDispatcher");
 
   ASSERT(func.IsInvokeFieldDispatcher());
@@ skipping 39 matching lines @@
   const Class& owner = Class::Handle(I, func.Owner());
   ASSERT(!owner.IsNull());
   AstNode* result = NULL;
   if (owner.IsSignatureClass() && name.Equals(Symbols::Call())) {
     EnsureSavedCurrentContext();
     result = new ClosureCallNode(token_pos, getter_call, args);
   } else {
     result = BuildClosureCall(token_pos, getter_call, args);
   }
 
-  ReturnNode* return_node = new ReturnNode(token_pos, result);
+  ReturnNode* return_node = new ReturnNode(token_pos, result, NULL);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 AstNode* Parser::BuildClosureCall(intptr_t token_pos,
                                   AstNode* closure,
                                   ArgumentListNode* arguments) {
   return new InstanceCallNode(token_pos,
                               closure,
@@ skipping 1090 matching lines @@
     }
   }
 
   GenerateSuperConstructorCall(current_class(),
                                Scanner::kNoSourcePos,
                                receiver,
                                forwarding_args);
   CheckFieldsInitialized(current_class());
 
   // Empty constructor body.
-  current_block_->statements->Add(new ReturnNode(Scanner::kNoSourcePos));
+  current_block_->statements->Add(new ReturnNode(Scanner::kNoSourcePos, NULL));
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 void Parser::CheckRecursiveInvocation() {
   const GrowableObjectArray& pending_functions =
       GrowableObjectArray::Handle(I,
           I->object_store()->pending_functions());
   for (int i = 0; i < pending_functions.Length(); i++) {
@@ skipping 298 matching lines @@
     AstNode* comparison =
         new ComparisonNode(Scanner::kNoSourcePos,
                            Token::kNE_STRICT,
                            phase_check,
                            new LiteralNode(body_pos,
                                            Smi::ZoneHandle(Smi::New(0))));
     AstNode* guarded_block_statements =
         new IfNode(Scanner::kNoSourcePos, comparison, ctor_block, NULL);
     current_block_->statements->Add(guarded_block_statements);
   }
-  current_block_->statements->Add(new ReturnNode(func.end_token_pos()));
+  current_block_->statements->Add(new ReturnNode(func.end_token_pos(), NULL));
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 // TODO(mlippautz): Once we know where these classes should come from, adjust
 // how we get their definition.
 RawClass* Parser::GetClassForAsync(const String& class_name) {
   const Class& cls = Class::Handle(library_.LookupClass(class_name));
   if (cls.IsNull()) {
@@ skipping 138 matching lines @@
     if (String::Handle(I, func.name()).Equals(
         Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(I, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     const intptr_t expr_pos = TokenPos();
     AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
     ASSERT(expr != NULL);
-    current_block_->statements->Add(new ReturnNode(expr_pos, expr));
+    current_block_->statements->Add(
+        new ReturnNode(expr_pos, expr, current_block_->scope));
     end_token_pos = TokenPos();
   } else if (IsLiteral("native")) {
     if (String::Handle(I, func.name()).Equals(
         Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(I, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     ParseNativeFunctionBlock(&params, func);
@@ skipping 43 matching lines @@
       new ComparisonNode(Scanner::kNoSourcePos,
                          Token::kEQ_STRICT,
                          argument,
                          null_operand);
   ComparisonNode* result =
       new ComparisonNode(Scanner::kNoSourcePos,
                          Token::kEQ_STRICT,
                          LoadReceiver(Scanner::kNoSourcePos),
                          null_operand);
   SequenceNode* arg_is_null = new SequenceNode(Scanner::kNoSourcePos, NULL);
-  arg_is_null->Add(new ReturnNode(Scanner::kNoSourcePos, result));
+  arg_is_null->Add(
+      new ReturnNode(Scanner::kNoSourcePos, result, current_block_->scope));
   IfNode* if_arg_null = new IfNode(Scanner::kNoSourcePos,
                                    check_arg,
                                    arg_is_null,
                                    NULL);
   current_block_->statements->Add(if_arg_null);
 }
 
 
 void Parser::SkipIf(Token::Kind token) {
   if (CurrentToken() == token) {
@@ skipping 2512 matching lines @@
 
   // Add to AST:
   //   return :async_completer.future;
   ReturnNode* return_node = new (I) ReturnNode(
       Scanner::kNoSourcePos,
       new (I) InstanceGetterNode(
           Scanner::kNoSourcePos,
           new (I) LoadLocalNode(
               Scanner::kNoSourcePos,
               async_completer),
-          Symbols::CompleterFuture()));
+          Symbols::CompleterFuture()),
+      current_block_->scope);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::CloseAsyncClosure(SequenceNode* body) {
-  ASSERT(body != NULL);
-  // Replace an optional ReturnNode with the appropriate completer calls.
-  intptr_t last_index = body->length() - 1;
-  AstNode* last = NULL;
-  if (last_index >= 0) {
-    // Non-empty async closure.
-    last = body->NodeAt(last_index);
-  }
-  ArgumentListNode* args = new (I) ArgumentListNode(Scanner::kNoSourcePos);
-  LocalVariable* completer = body->scope()->LookupVariable(
-      Symbols::AsyncCompleter(), false);
-  ASSERT(completer != NULL);
-  if (last != NULL && last->IsReturnNode()) {
-    // Replace
-    //   return <expr>;
-    // with
-    //   completer.complete(<expr>);
-    args->Add(body->NodeAt(last_index)->AsReturnNode()->value());
-    body->ReplaceNodeAt(last_index,
-        new (I) InstanceCallNode(
-          Scanner::kNoSourcePos,
-          new (I) LoadLocalNode(Scanner::kNoSourcePos, completer),
-          Symbols::CompleterComplete(),
-          args));
-  } else {
-    // Add to AST:
-    //   completer.complete();
-    body->Add(
-        new (I) InstanceCallNode(
-          Scanner::kNoSourcePos,
-          new (I) LoadLocalNode(Scanner::kNoSourcePos, completer),
-          Symbols::CompleterComplete(),
-          args));
-  }
+  // We need a temporary expression to store intermediate return values.
+  parsed_function()->EnsureExpressionTemp();
 }
 
 
 // Set up default values for all optional parameters to the function.
 void Parser::SetupDefaultsForOptionalParams(const ParamList* params,
                                             Array* default_values) {
   if (params->num_optional_parameters > 0) {
     // Build array of default parameter values.
     ParamDesc* param =
       params->parameters->data() + params->num_fixed_parameters;
@@ skipping 88 matching lines @@
     ReportError(native_pos,
                 "native function '%s' (%" Pd " arguments) cannot be found",
                 native_name.ToCString(), func.NumParameters());
   }
   func.SetIsNativeAutoSetupScope(auto_setup_scope);
 
   // Now add the NativeBodyNode and return statement.
   Dart_NativeEntryResolver resolver = library.native_entry_resolver();
   bool is_bootstrap_native = Bootstrap::IsBootstapResolver(resolver);
   current_block_->statements->Add(new(I) ReturnNode(
-      TokenPos(), new(I) NativeBodyNode(
+      TokenPos(),
+      new(I) NativeBodyNode(
           TokenPos(),
           Function::ZoneHandle(I, func.raw()),
           native_name,
           native_function,
           current_block_->scope,
-          is_bootstrap_native)));
+          is_bootstrap_native),
+      NULL));
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope, bool test_only) {
   ASSERT(!current_function().is_static());
   return from_scope->LookupVariable(Symbols::This(), test_only);
 }
 
 
 LocalVariable* Parser::LookupTypeArgumentsParameter(LocalScope* from_scope,
@@ skipping 1877 matching lines @@
   } else if (token == Token::kRETURN) {
     const intptr_t return_pos = TokenPos();
     ConsumeToken();
     if (CurrentToken() != Token::kSEMICOLON) {
       if (current_function().IsConstructor() &&
           (current_block_->scope->function_level() == 0)) {
         ReportError(return_pos,
                     "return of a value not allowed in constructors");
       }
       AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
-      statement = new(I) ReturnNode(statement_pos, expr);
+      statement = new(I) ReturnNode(statement_pos, expr, current_block_->scope);
     } else {
-      statement = new(I) ReturnNode(statement_pos);
+      statement = new(I) ReturnNode(statement_pos, current_block_->scope);
     }
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
   } else if (token == Token::kIF) {
     statement = ParseIfStatement(label_name);
   } else if (token == Token::kASSERT) {
     statement = ParseAssertStatement();
     ExpectSemicolon();
   } else if (IsVariableDeclaration()) {
     statement = ParseVariableDeclarationList();
@@ skipping 3247 matching lines @@
   } else if (expr->IsLoadStaticFieldNode()) {
     const Field& field = expr->AsLoadStaticFieldNode()->field();
     // We already checked that this field is const and has been
     // initialized.
     ASSERT(field.is_const());
     ASSERT(field.value() != Object::sentinel().raw());
     ASSERT(field.value() != Object::transition_sentinel().raw());
     return Instance::ZoneHandle(I, field.value());
   } else {
     ASSERT(expr->EvalConstExpr() != NULL);
-    ReturnNode* ret = new(I) ReturnNode(expr->token_pos(), expr);
+    ReturnNode* ret = new(I) ReturnNode(expr->token_pos(), expr, NULL);
     // Compile time constant expressions cannot reference anything from a
     // local scope.
     LocalScope* empty_scope = new(I) LocalScope(NULL, 0, 0);
     SequenceNode* seq = new(I) SequenceNode(expr->token_pos(),
                                                     empty_scope);
     seq->Add(ret);
 
     Object& result = Object::Handle(I, Compiler::ExecuteOnce(seq));
     if (result.IsError()) {
       ReportErrors(Error::Cast(result),
@@ skipping 337 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart