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 1068 matching lines @@
     StaticCallNode* init_call =
         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 ReturnNode(ident_pos, new LoadStaticFieldNode(ident_pos, field));
     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 125 matching lines @@
   LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
   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);
+  ReturnNode* return_node = new ReturnNode(Scanner::kNoSourcePos, load_field);
   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 1862 matching lines @@
   ComparisonNode* check_arg =
       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);
+  SequenceNode* arg_is_null = new SequenceNode(Scanner::kNoSourcePos,
+                                               current_block_->scope);
   arg_is_null->Add(new ReturnNode(Scanner::kNoSourcePos, result));
   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) {
@@ skipping 2520 matching lines @@
           new (I) LoadLocalNode(
               Scanner::kNoSourcePos,
               async_completer),
           Symbols::CompleterFuture()));
   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)));
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope, bool test_only) {
@@ skipping 5511 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart