Add support for sync* and yield

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/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 3042 matching lines @@
     ASSERT(current_class().raw() == func.Owner());
     params.AddReceiver(ReceiverType(current_class()), func.token_pos());
   } else if (func.IsFactory()) {
     // The first parameter of a factory is the TypeArguments vector of
     // the type of the instance to be allocated.
     params.AddFinalParameter(
         TokenPos(),
         &Symbols::TypeArgumentsParameter(),
         &Type::ZoneHandle(Z, Type::DynamicType()));
   }
+  // Expect the parameter list unless this is a getter function, or the
+  // body closure of an async or generator getter function.
   ASSERT((CurrentToken() == Token::kLPAREN) ||
          func.IsGetterFunction() ||
-         func.is_async_closure());
+         (func.is_generated_body() &&
+             Function::Handle(func.parent_function()).IsGetterFunction()));
   const bool allow_explicit_default_values = true;
   if (func.IsGetterFunction()) {
     // Populate function scope with the formal parameters. Since in this case
     // we are compiling a getter this will at most populate the receiver.
     AddFormalParamsToScope(&params, current_block_->scope);
-  } else if (func.is_async_closure()) {
-    // Async closures have two optional parameters:
-    // * A continuation result.
-    // * A continuation error.
-    //
-    // If the error!=null we rethrow the error at the next await.
-    const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
-    ParamDesc result_param;
-    result_param.name = &Symbols::AsyncOperationParam();
-    result_param.default_value = &Object::null_instance();
-    result_param.type = &dynamic_type;
-    ParamDesc error_param;
-    error_param.name = &Symbols::AsyncOperationErrorParam();
-    error_param.default_value = &Object::null_instance();
-    error_param.type = &dynamic_type;
-    params.parameters->Add(result_param);
-    params.parameters->Add(error_param);
-    params.num_optional_parameters += 2;
-    params.has_optional_positional_parameters = true;
+  } else if (func.IsAsyncClosure()) {
+    AddAsyncClosureParameters(&params);
     SetupDefaultsForOptionalParams(&params, default_parameter_values);
     AddFormalParamsToScope(&params, current_block_->scope);
     ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
     ASSERT(func.NumParameters() == params.parameters->length());
     if (!Function::Handle(func.parent_function()).IsGetterFunction()) {
       // Parse and discard any formal parameters. They are accessed as
       // context variables.
-      ParamList parse_away;
+      ParamList discarded_params;
       ParseFormalParameterList(allow_explicit_default_values,
                                false,
-                               &parse_away);
+                               &discarded_params);
+    }
+  } else if (func.IsSyncGenClosure()) {
+    AddSyncGenClosureParameters(&params);
+    SetupDefaultsForOptionalParams(&params, default_parameter_values);
+    AddFormalParamsToScope(&params, current_block_->scope);
+    ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
+    if (!Function::Handle(func.parent_function()).IsGetterFunction()) {
+      // Parse and discard any formal parameters. They are accessed as
+      // context variables.
+      ParamList discarded_params;
+      ParseFormalParameterList(allow_explicit_default_values,
+                               false,
+                               &discarded_params);
     }
   } else {
     ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
     // The number of parameters and their type are not yet set in local
     // functions, since they are not 'top-level' parsed.
     if (func.IsLocalFunction()) {
       AddFormalParamsToFunction(&params, func);
     }
     SetupDefaultsForOptionalParams(&params, default_parameter_values);
@@ skipping 21 matching lines @@
       if (IsInstantiatorRequired()) {
         // Make sure that the receiver of the enclosing instance function
         // (or implicit first parameter of an enclosing factory) is marked as
         // captured if type checks are enabled, because they may access it to
         // instantiate types.
         CaptureInstantiator();
       }
     }
   }
 
+  const intptr_t modifier_pos = TokenPos();
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
-  func.set_modifier(func_modifier);
+  if (!func.is_generated_body()) {
+    // Don't add a modifier to the closure representing the body of
+    // the asynchronous function or generator.
+    func.set_modifier(func_modifier);
+  }
 
   OpenBlock();  // Open a nested scope for the outermost function block.
 
-  Function& async_closure = Function::ZoneHandle(Z);
-  if (func.IsAsyncFunction() && !func.is_async_closure()) {
+  Function& generated_body_closure = Function::ZoneHandle(Z);
+  if (func.IsAsyncFunction()) {
+    ASSERT(!func.is_generated_body());
     // The code of an async function is synthesized. Disable debugging.
     func.set_is_debuggable(false);
-    async_closure = OpenAsyncFunction(func.token_pos());
-  } else if (func.is_async_closure()) {
+    generated_body_closure = OpenAsyncFunction(func.token_pos());
+  } else if (func.IsAsyncClosure()) {
     // The closure containing the body of an async function is debuggable.
     ASSERT(func.is_debuggable());
     OpenAsyncClosure();
+  } else if (func.IsSyncGenerator()) {
+    // The code of a sync generator is synthesized. Disable debugging.
+    func.set_is_debuggable(false);
+    generated_body_closure = OpenSyncGeneratorFunction(func.token_pos());
+  } else if (func.IsSyncGenClosure()) {
+    // The closure containing the body of a sync generator is debuggable.
+    ASSERT(func.is_debuggable());
+    // Nothing special to do.
   }
 
   BoolScope allow_await(&this->await_is_keyword_,
-                        func.IsAsyncFunction() || func.is_async_closure());
+                        func.IsAsyncOrGenerator() || func.is_generated_body());
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     if (String::Handle(Z, func.name()).Equals(Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(Z, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     ParseStatementSequence();
     end_token_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
+    if (func.IsGenerator()) {
+      ReportError(modifier_pos,
+                  "=> style function may not be sync* or async* generator");
+    }
     ConsumeToken();
     if (String::Handle(Z, func.name()).Equals(
         Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(Z, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     const intptr_t expr_pos = TokenPos();
     AstNode* expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
@@ skipping 26 matching lines @@
                                &func));  // Unpatched external function.
     end_token_pos = TokenPos();
   } else {
     UnexpectedToken();
   }
 
   ASSERT(func.end_token_pos() == func.token_pos() ||
          func.end_token_pos() == end_token_pos);
   func.set_end_token_pos(end_token_pos);
   SequenceNode* body = CloseBlock();
-  if (func.IsAsyncFunction() && !func.is_async_closure()) {
-    body = CloseAsyncFunction(async_closure, body);
-    async_closure.set_end_token_pos(end_token_pos);
-  } else if (func.is_async_closure()) {
+  if (func.IsAsyncFunction()) {
+    body = CloseAsyncFunction(generated_body_closure, body);
+    generated_body_closure.set_end_token_pos(end_token_pos);
+  } else if (func.IsAsyncClosure()) {
     body = CloseAsyncClosure(body);
+  } else if (func.IsSyncGenerator()) {
+    body = CloseSyncGenFunction(generated_body_closure, body);
+    generated_body_closure.set_end_token_pos(end_token_pos);
+  } else if (func.IsSyncGenClosure()) {
+    body->scope()->RecursivelyCaptureAllVariables();
   }
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
   async_temp_scope_ = saved_async_temp_scope;
   parsed_function()->set_saved_try_ctx(saved_saved_try_ctx);
   parsed_function()->set_async_saved_try_ctx_name(
       saved_async_saved_try_ctx_name);
   return CloseBlock();
 }
@@ skipping 298 matching lines @@
   ASSERT((method->redirect_name == NULL) || method->IsConstructor());
 
   if (method->IsConstructor() &&
       method->has_external &&
       method->params.has_field_initializer) {
     ReportError(method->name_pos,
                 "external constructor '%s' may not have field initializers",
                 method->name->ToCString());
   }
 
+  const intptr_t modifier_pos = TokenPos();
   RawFunction::AsyncModifier async_modifier = ParseFunctionModifier();
   if ((method->IsFactoryOrConstructor() || method->IsSetter()) &&
-      async_modifier != RawFunction::kNoModifier) {
-    ReportError(method->name_pos,
-                "%s '%s' may not be async",
+      (async_modifier != RawFunction::kNoModifier)) {
+    ReportError(modifier_pos,
+                "%s '%s' may not be async, async* or sync*",
                 (method->IsSetter()) ? "setter" : "constructor",
                 method->name->ToCString());
   }
 
   intptr_t method_end_pos = TokenPos();
   if ((CurrentToken() == Token::kLBRACE) ||
       (CurrentToken() == Token::kARROW)) {
     if (method->has_abstract) {
       ReportError(TokenPos(),
                   "abstract method '%s' may not have a function body",
@@ skipping 14 matching lines @@
     }
     if (method->redirect_name != NULL) {
       ReportError(method->name_pos,
                   "Constructor with redirection may not have a function body");
     }
     if (CurrentToken() == Token::kLBRACE) {
       SkipBlock();
       method_end_pos = TokenPos();
       ExpectToken(Token::kRBRACE);
     } else {
+      if ((async_modifier & RawFunction::kGeneratorBit) != 0) {
+        ReportError(modifier_pos,
+                    "=> style function may not be sync* or async* generator");
+      }
+
       ConsumeToken();
       BoolScope allow_await(&this->await_is_keyword_,
                             async_modifier != RawFunction::kNoModifier);
       SkipExpr();
       method_end_pos = TokenPos();
       ExpectSemicolon();
     }
   } else if (IsLiteral("native")) {
     if (method->has_abstract) {
       ReportError(method->name_pos,
@@ skipping 43 matching lines @@
       if (must_have_semicolon) {
         ExpectSemicolon();
       } else {
         ReportError(method->name_pos,
                     "function body or semicolon expected for method '%s'",
                     method->name->ToCString());
       }
     }
   }
 
+  if (method->has_abstract && (async_modifier != RawFunction::kNoModifier)) {
+    ReportError(modifier_pos,
+                "abstract function '%s' may not be async, async* or sync*",
+                method->name->ToCString());
+  }
+
   RawFunction::Kind function_kind;
   if (method->IsFactoryOrConstructor()) {
     function_kind = RawFunction::kConstructor;
   } else if (method->IsGetter()) {
     function_kind = RawFunction::kGetterFunction;
   } else if (method->IsSetter()) {
     function_kind = RawFunction::kSetterFunction;
   } else {
     function_kind = RawFunction::kRegularFunction;
   }
@@ skipping 1529 matching lines @@
     } else {
       ExpectSemicolon();  // Reports error.
     }
   }
 }
 
 
 RawFunction::AsyncModifier Parser::ParseFunctionModifier() {
   if (CurrentLiteral()->raw() == Symbols::Async().raw()) {
     ConsumeToken();
-    return RawFunction::kAsync;
+    if (CurrentToken() == Token::kMUL) {
+      ReportError("async* generator functions are not yet supported");
+      ConsumeToken();
+      return RawFunction::kAsyncGen;
+    } else {
+      return RawFunction::kAsync;
+    }
+  } else if ((CurrentLiteral()->raw() == Symbols::Sync().raw()) &&
+      (LookaheadToken(1) == Token::kMUL)) {
+    const bool enableSyncStar = true;
+    if (!enableSyncStar) {
+      ReportError("sync* generator functions are not yet supported");
+    }
+    ConsumeToken();
+    ConsumeToken();
+    return RawFunction::kSyncGen;
   }
   return RawFunction::kNoModifier;
 }
 
 
 void Parser::ParseTopLevelFunction(TopLevel* top_level,
                                    intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelFunction");
   const intptr_t decl_begin_pos = TokenPos();
   AbstractType& result_type = Type::Handle(Z, Type::DynamicType());
@@ skipping 38 matching lines @@
   }
   // A setter named x= may co-exist with a function named x, thus we do
   // not need to check setters.
 
   CheckToken(Token::kLPAREN);
   const intptr_t function_pos = TokenPos();
   ParamList params;
   const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
+  const intptr_t modifier_pos = TokenPos();
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
 
   intptr_t function_end_pos = function_pos;
   bool is_native = false;
   if (is_external) {
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     function_end_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
+    if ((func_modifier & RawFunction::kGeneratorBit) != 0) {
+      ReportError(modifier_pos,
+                  "=> style function may not be sync* or async* generator");
+    }
     ConsumeToken();
     BoolScope allow_await(&this->await_is_keyword_,
                           func_modifier != RawFunction::kNoModifier);
     SkipExpr();
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
     function_end_pos = TokenPos();
     ExpectSemicolon();
@@ skipping 109 matching lines @@
   if (found && !is_patch) {
     ReportError(name_pos, "%s for '%s' is already defined",
                 is_getter ? "getter" : "setter",
                 field_name->ToCString());
   } else if (!found && is_patch) {
     ReportError(name_pos, "missing %s for '%s' cannot be patched",
                 is_getter ? "getter" : "setter",
                 field_name->ToCString());
   }
 
+  const intptr_t modifier_pos = TokenPos();
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
+  if (!is_getter && (func_modifier != RawFunction::kNoModifier)) {
+    ReportError(modifier_pos,
+                "setter function cannot be async, async* or sync*");
+  }
 
   intptr_t accessor_end_pos = accessor_pos;
   bool is_native = false;
   if (is_external) {
     accessor_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     accessor_end_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
@@ skipping 499 matching lines @@
         stack_trace_param.var,
         new(Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_var)));
     current_block_->statements->Add(new(Z) InstanceCallNode(
         Scanner::kNoSourcePos,
         new(Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_param.var),
         Library::PrivateCoreLibName(Symbols::_setupFullStackTrace()),
         no_args));
   }
 
   ASSERT(try_blocks_list_ != NULL);
-  if (innermost_function().is_async_closure() ||
+  if (innermost_function().IsAsyncClosure() ||
       innermost_function().IsAsyncFunction()) {
     if ((try_blocks_list_->outer_try_block() != NULL) &&
         (try_blocks_list_->outer_try_block()->try_block()
             ->scope->function_level() ==
          current_block_->scope->function_level())) {
       // We need to unchain three scope levels: catch clause, catch
       // parameters, and the general try block.
       RestoreSavedTryContext(
           current_block_->scope->parent()->parent()->parent(),
           try_blocks_list_->outer_try_block()->try_index(),
@@ skipping 84 matching lines @@
         TokenPos(),
         Symbols::StackTraceVar(),
         Type::ZoneHandle(Z, Type::DynamicType()));
     current_block_->scope->AddVariable(stack_trace_var);
   }
 
   // Open the try block.
   OpenBlock();
   PushTryBlock(current_block_);
 
-  if (innermost_function().is_async_closure() ||
+  if (innermost_function().IsAsyncClosure() ||
       innermost_function().IsAsyncFunction()) {
     SetupSavedTryContext(context_var);
   }
 }
 
 
+void Parser::AddSyncGenClosureParameters(ParamList* params) {
+  // Create the parameter list for the body closure of a sync generator:
+  // 1) Implicit closure parameter;
+  // 2) Iterator
+  const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
+  // Add implicit closure parameter if not already present.
+  if (params->parameters->length() == 0) {
+    params->AddFinalParameter(0, &Symbols::ClosureParameter(), &dynamic_type);
+  }
+  ParamDesc iterator_param;
+  iterator_param.name = &Symbols::IteratorParameter();
+  iterator_param.type = &dynamic_type;
+  params->parameters->Add(iterator_param);
+  params->num_fixed_parameters++;
+}
+
+
+RawFunction* Parser::OpenSyncGeneratorFunction(intptr_t func_pos) {
+  Function& body = Function::Handle(Z);
+  String& body_closure_name = String::Handle(Z);
+  bool is_new_closure = false;
+
+  AddContinuationVariables();
+
+  // Check whether a function for the body of this generator
+  // function has already been created by a previous
+  // compilation.
+  const Function& found_func = Function::Handle(
+      Z, current_class().LookupClosureFunction(func_pos));
+  if (!found_func.IsNull() &&
+      (found_func.token_pos() == func_pos) &&
+      (found_func.script() == innermost_function().script()) &&
+      (found_func.parent_function() == innermost_function().raw())) {
+    ASSERT(found_func.IsSyncGenClosure());
+    body = found_func.raw();
+    body_closure_name = body.name();
+  } else {
+    // Create the closure containing the body of this generator function.
+    String& generator_name = String::Handle(Z, innermost_function().name());
+    body_closure_name =
+        String::NewFormatted("<%s_sync_body>", generator_name.ToCString());
+    body_closure_name = Symbols::New(body_closure_name);
+    body = Function::NewClosureFunction(body_closure_name,
+                                        innermost_function(),
+                                        func_pos);
+    body.set_is_generated_body(true);
+    body.set_result_type(AbstractType::Handle(Type::DynamicType()));
+    is_new_closure = true;
+  }
+
+  ParamList closure_params;
+  AddSyncGenClosureParameters(&closure_params);
+
+  if (is_new_closure) {
+    // Add the parameters to the newly created closure.
+    AddFormalParamsToFunction(&closure_params, body);
+
+    // Create and set the signature class of the closure.
+    const String& sig = String::Handle(Z, body.Signature());
+    Class& sig_cls = Class::Handle(Z, library_.LookupLocalClass(sig));
+    if (sig_cls.IsNull()) {
+      sig_cls = Class::NewSignatureClass(sig, body, script_, body.token_pos());
+      library_.AddClass(sig_cls);
+    }
+    body.set_signature_class(sig_cls);
+    const Type& sig_type = Type::Handle(Z, sig_cls.SignatureType());
+    if (!sig_type.IsFinalized()) {
+      ClassFinalizer::FinalizeType(
+          sig_cls, sig_type, ClassFinalizer::kCanonicalize);
+    }
+    ASSERT(AbstractType::Handle(Z, body.result_type()).IsResolved());
+    ASSERT(body.NumParameters() == closure_params.parameters->length());
+  }
+
+  OpenFunctionBlock(body);
+  AddFormalParamsToScope(&closure_params, current_block_->scope);
+  OpenBlock();
+
+  /*
+  async_temp_scope_ = current_block_->scope; // Is this needed?
+  */
+  return body.raw();
+}
+
+SequenceNode* Parser::CloseSyncGenFunction(const Function& closure,
+                                           SequenceNode* closure_body) {
+  // The block for the closure body has already been closed. Close the
+  // corresponding function block.
+  CloseBlock();
+
+  closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
+  closure_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
+
+  // :await_jump_var = -1;
+  LocalVariable* jump_var =
+      current_block_->scope->LookupVariable(Symbols::AwaitJumpVar(), false);
+  LiteralNode* init_value =
+      new(Z) LiteralNode(Scanner::kNoSourcePos, Smi::ZoneHandle(Smi::New(-1)));
+  current_block_->statements->Add(
+      new(Z) StoreLocalNode(Scanner::kNoSourcePos, jump_var, init_value));
+
+  // return new SyncIterable(body_closure);
+  const Class& iterable_class =
+      Class::Handle(Z, Library::LookupCoreClass(Symbols::_SyncIterable()));
+  ASSERT(!iterable_class.IsNull());
+  const Function& iterable_constructor = Function::ZoneHandle(Z,
+      iterable_class.LookupConstructorAllowPrivate(
+          Symbols::_SyncIterableConstructor()));
+  ASSERT(!iterable_constructor.IsNull());
+
+  const String& closure_name = String::Handle(Z, closure.name());
+  ASSERT(closure_name.IsSymbol());
+
+  ArgumentListNode* arguments = new(Z) ArgumentListNode(Scanner::kNoSourcePos);
+  ClosureNode* closure_obj = new(Z) ClosureNode(
+      Scanner::kNoSourcePos, closure, NULL, closure_body->scope());
+  arguments->Add(closure_obj);
+  ConstructorCallNode* new_iterable =
+      new(Z) ConstructorCallNode(Scanner::kNoSourcePos,
+          TypeArguments::ZoneHandle(Z),
+          iterable_constructor,
+          arguments);
+  ReturnNode* return_node =
+      new (Z) ReturnNode(Scanner::kNoSourcePos, new_iterable);
+  current_block_->statements->Add(return_node);
+  return CloseBlock();
+}
+
+
+void Parser::AddAsyncClosureParameters(ParamList* params) {
+  // Async closures have two optional parameters:
+  // * A continuation result.
+  // * A continuation error.
+  const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
+  // Add implicit closure parameter if not yet present.
+  if (params->parameters->length() == 0) {
+    params->AddFinalParameter(0, &Symbols::ClosureParameter(), &dynamic_type);
+  }
+  ParamDesc result_param;
+  result_param.name = &Symbols::AsyncOperationParam();
+  result_param.default_value = &Object::null_instance();
+  result_param.type = &dynamic_type;
+  params->parameters->Add(result_param);
+  ParamDesc error_param;
+  error_param.name = &Symbols::AsyncOperationErrorParam();
+  error_param.default_value = &Object::null_instance();
+  error_param.type = &dynamic_type;
+  params->parameters->Add(error_param);
+  params->has_optional_positional_parameters = true;
+  params->num_optional_parameters += 2;
+}
+
+
 RawFunction* Parser::OpenAsyncFunction(intptr_t async_func_pos) {
   TRACE_PARSER("OpenAsyncFunction");
+  AddContinuationVariables();
   AddAsyncClosureVariables();
   Function& closure = Function::Handle(Z);
   bool is_new_closure = false;
 
   // Check whether a function for the asynchronous function body of
   // this async function has already been created by a previous
   // compilation of this function.
   const Function& found_func = Function::Handle(
       Z, current_class().LookupClosureFunction(async_func_pos));
   if (!found_func.IsNull() &&
       (found_func.token_pos() == async_func_pos) &&
       (found_func.script() == innermost_function().script()) &&
       (found_func.parent_function() == innermost_function().raw())) {
-    ASSERT(found_func.is_async_closure());
+    ASSERT(found_func.IsAsyncClosure());
     closure = found_func.raw();
   } else {
     // Create the closure containing the body of this async function.
     const String& async_func_name =
         String::Handle(Z, innermost_function().name());
     String& closure_name = String::Handle(Z,
         String::NewFormatted("<%s_async_body>", async_func_name.ToCString()));
     closure = Function::NewClosureFunction(
         String::Handle(Z, Symbols::New(closure_name)),
         innermost_function(),
         async_func_pos);
-    closure.set_is_async_closure(true);
+    closure.set_is_generated_body(true);
     closure.set_result_type(AbstractType::Handle(Type::DynamicType()));
     is_new_closure = true;
   }
   // Create the parameter list for the async body closure.
   ParamList closure_params;
-  const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
-  closure_params.AddFinalParameter(
-      async_func_pos, &Symbols::ClosureParameter(), &dynamic_type);
-  ParamDesc result_param;
-  result_param.name = &Symbols::AsyncOperationParam();
-  result_param.default_value = &Object::null_instance();
-  result_param.type = &dynamic_type;
-  closure_params.parameters->Add(result_param);
-  ParamDesc error_param;
-  error_param.name = &Symbols::AsyncOperationErrorParam();
-  error_param.default_value = &Object::null_instance();
-  error_param.type = &dynamic_type;
-  closure_params.parameters->Add(error_param);
-  closure_params.has_optional_positional_parameters = true;
-  closure_params.num_optional_parameters += 2;
-
+  AddAsyncClosureParameters(&closure_params);
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
 
     // Create and set the signature class of the closure.
     const String& sig = String::Handle(Z, closure.Signature());
     Class& sig_cls = Class::Handle(Z, library_.LookupLocalClass(sig));
     if (sig_cls.IsNull()) {
       sig_cls =
           Class::NewSignatureClass(sig, closure, script_, closure.token_pos());
       library_.AddClass(sig_cls);
     }
     closure.set_signature_class(sig_cls);
     const Type& sig_type = Type::Handle(Z, sig_cls.SignatureType());
     if (!sig_type.IsFinalized()) {
       ClassFinalizer::FinalizeType(
           sig_cls, sig_type, ClassFinalizer::kCanonicalize);
     }
     ASSERT(AbstractType::Handle(Z, closure.result_type()).IsResolved());
     ASSERT(closure.NumParameters() == closure_params.parameters->length());
   }
   OpenFunctionBlock(closure);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   OpenBlock();
   async_temp_scope_ = current_block_->scope;
   return closure.raw();
 }
 
 
-void Parser::AddAsyncClosureVariables() {
-  // Add to AST:
+void Parser::AddContinuationVariables() {
+  // Add to current block's scope:
   //   var :await_jump_var;
   //   var :await_ctx_var;
-  //   var :async_op;
-  //   var :async_completer;
   const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
   LocalVariable* await_jump_var = new (Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AwaitJumpVar(), dynamic_type);
   current_block_->scope->AddVariable(await_jump_var);
   current_block_->scope->CaptureVariable(Symbols::AwaitJumpVar());
   await_jump_var->set_is_captured();
   LocalVariable* await_ctx_var = new (Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AwaitContextVar(), dynamic_type);
   current_block_->scope->AddVariable(await_ctx_var);
   current_block_->scope->CaptureVariable(Symbols::AwaitContextVar());
   await_ctx_var->set_is_captured();
-  LocalVariable* async_op_var = new (Z) LocalVariable(
+}
+
+
+void Parser::AddAsyncClosureVariables() {
+  // Add to current block's scope:
+  //   var :async_op;
+  //   var :async_completer;
+  const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
+  LocalVariable* async_op_var = new(Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AsyncOperation(), dynamic_type);
   current_block_->scope->AddVariable(async_op_var);
   current_block_->scope->CaptureVariable(Symbols::AsyncOperation());
   async_op_var->set_is_captured();
-  LocalVariable* async_completer = new (Z) LocalVariable(
+  LocalVariable* async_completer = new(Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AsyncCompleter(), dynamic_type);
   current_block_->scope->AddVariable(async_completer);
   current_block_->scope->CaptureVariable(Symbols::AsyncCompleter());
   async_completer->set_is_captured();
 }
 
 
 SequenceNode* Parser::CloseBlock() {
   SequenceNode* statements = current_block_->statements;
   if (current_block_->scope != NULL) {
@@ skipping 61 matching lines @@
       TypeArguments::ZoneHandle(Z),
       completer_constructor,
       empty_args);
   StoreLocalNode* store_completer = new (Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       async_completer,
       completer_constructor_node);
   current_block_->statements->Add(store_completer);
 
   // :await_jump_var = -1;
-  LocalVariable* jump_var = current_block_->scope->LookupVariable(
-        Symbols::AwaitJumpVar(), false);
+  LocalVariable* jump_var =
+      current_block_->scope->LookupVariable(Symbols::AwaitJumpVar(), false);
   LiteralNode* init_value =
-    new(Z) LiteralNode(Scanner::kNoSourcePos, Smi::ZoneHandle(Smi::New(-1)));
+      new(Z) LiteralNode(Scanner::kNoSourcePos, Smi::ZoneHandle(Smi::New(-1)));
   current_block_->statements->Add(
-      new (Z) StoreLocalNode(Scanner::kNoSourcePos, jump_var, init_value));
+      new(Z) StoreLocalNode(Scanner::kNoSourcePos, jump_var, init_value));
 
   // Add to AST:
   //   :async_op = <closure>;  (containing the original body)
   LocalVariable* async_op_var = current_block_->scope->LookupVariable(
       Symbols::AsyncOperation(), false);
   ClosureNode* cn = new(Z) ClosureNode(
       Scanner::kNoSourcePos, closure, NULL, closure_body->scope());
   StoreLocalNode* store_async_op = new (Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       async_op_var,
@@ skipping 236 matching lines @@
         assign_pos, variable, expr);
     if (is_const) {
       ASSERT(expr->IsLiteralNode());
       variable->SetConstValue(expr->AsLiteralNode()->literal());
     }
   } else if (is_final || is_const) {
     ReportError(ident_pos,
                 "missing initialization of 'final' or 'const' variable");
   } else {
     // Initialize variable with null.
-    AstNode* null_expr = new(Z) LiteralNode(
-        ident_pos, Instance::ZoneHandle(Z));
+    AstNode* null_expr = new(Z) LiteralNode(ident_pos, Instance::ZoneHandle(Z));
     initialization = new(Z) StoreLocalNode(
         ident_pos, variable, null_expr);
   }
 
   ASSERT(current_block_ != NULL);
   const intptr_t previous_pos =
   current_block_->scope->PreviousReferencePos(ident);
   if (previous_pos >= 0) {
     ASSERT(!script_.IsNull());
     if (previous_pos > ident_pos) {
@@ skipping 409 matching lines @@
   } else if (CurrentToken() == Token::kFALSE) {
     *value = Bool::False().raw();
     return true;
   }
   return false;
 }
 
 
 // Returns true if the current token is kIDENT or a pseudo-keyword.
 bool Parser::IsIdentifier() {
-  return Token::IsIdentifier(CurrentToken()) && !IsAwaitKeyword();
+  return Token::IsIdentifier(CurrentToken()) &&
+      !(await_is_keyword_ &&
+       ((CurrentLiteral()->raw() == Symbols::Await().raw()) ||
+       (CurrentLiteral()->raw() == Symbols::Async().raw()) ||
+       (CurrentLiteral()->raw() == Symbols::Yield().raw())));
 }
 
 
 // Returns true if the next tokens can be parsed as a an optionally
 // qualified identifier: [ident '.'] ident.
 // Current token position is not restored.
 bool Parser::TryParseQualIdent() {
   if (CurrentToken() != Token::kIDENT) {
     return false;
   }
@@ skipping 128 matching lines @@
     SetPosition(saved_pos);
     return false;
   }
   // Check parameter list and the following token.
   if (CurrentToken() == Token::kLPAREN) {
     SkipToMatchingParenthesis();
     if ((CurrentToken() == Token::kLBRACE) ||
         (CurrentToken() == Token::kARROW) ||
         (is_top_level_ && IsLiteral("native")) ||
         is_external ||
-        (CurrentLiteral()->raw() == Symbols::Async().raw())) {
+        (CurrentLiteral()->raw() == Symbols::Async().raw()) ||
+        (CurrentLiteral()->raw() == Symbols::Sync().raw())) {
       SetPosition(saved_pos);
       return true;
     }
   }
   SetPosition(saved_pos);
   return false;
 }
 
 
 bool Parser::IsTopLevelAccessor() {
@@ skipping 469 matching lines @@
 
 AstNode* Parser::ParseAwaitForStatement(String* label_name) {
   TRACE_PARSER("ParseAwaitForStatement");
   ASSERT(IsAwaitKeyword());
   const intptr_t await_for_pos = TokenPos();
   ConsumeToken();  // await.
   ASSERT(CurrentToken() == Token::kFOR);
   ConsumeToken();  // for.
   ExpectToken(Token::kLPAREN);
 
+  if (!innermost_function().IsAsyncFunction() &&
+      !innermost_function().IsAsyncClosure()) {
+    ReportError(await_for_pos,
+                "await for loop is only allowed in async function");
+  }
+
   // Parse loop variable.
   bool loop_var_is_final = (CurrentToken() == Token::kFINAL);
   if (CurrentToken() == Token::kCONST) {
     ReportError("Loop variable cannot be 'const'");
   }
   bool new_loop_var = false;
   AbstractType& loop_var_type =  AbstractType::ZoneHandle(Z);
   if (LookaheadToken(1) != Token::kIN) {
     // Declaration of a new loop variable.
     // Delay creation of the local variable until we know its actual
@@ skipping 162 matching lines @@
   // It is better to leave the iterator untyped and postpone the type error
   // until the loop variable is assigned to.
   const AbstractType& iterator_type = Type::ZoneHandle(Z, Type::DynamicType());
   LocalVariable* iterator_var = new(Z) LocalVariable(
       collection_pos, Symbols::ForInIter(), iterator_type);
   current_block_->scope->AddVariable(iterator_var);
 
   // Generate initialization of iterator variable.
   ArgumentListNode* no_args = new(Z) ArgumentListNode(collection_pos);
   AstNode* get_iterator = new(Z) InstanceGetterNode(
-      collection_pos, collection_expr, Symbols::GetIterator());
+      collection_pos, collection_expr, Symbols::iterator());
   AstNode* iterator_init =
       new(Z) StoreLocalNode(collection_pos, iterator_var, get_iterator);
   current_block_->statements->Add(iterator_init);
 
   // Generate while loop condition.
   AstNode* iterator_moveNext = new(Z) InstanceCallNode(
       collection_pos,
       new(Z) LoadLocalNode(collection_pos, iterator_var),
       Symbols::MoveNext(),
       no_args);
@@ skipping 230 matching lines @@
 
 
 SequenceNode* Parser::ParseFinallyBlock() {
   TRACE_PARSER("ParseFinallyBlock");
   OpenBlock();
   ExpectToken(Token::kLBRACE);
 
   // In case of async closures we need to restore the saved try index of an
   // outer try block (if it exists).  The current try block has already been
   // removed from the stack of try blocks.
-  if ((innermost_function().is_async_closure() ||
+  if ((innermost_function().IsAsyncClosure() ||
        innermost_function().IsAsyncFunction()) &&
       (try_blocks_list_ != NULL)) {
     // We need two unchain two scopes: finally clause, and the try block level.
     RestoreSavedTryContext(current_block_->scope->parent()->parent(),
                            try_blocks_list_->try_index(),
                            current_block_->statements);
   } else {
     parsed_function()->reset_saved_try_ctx_vars();
   }
 
@@ skipping 139 matching lines @@
           no_args));
     }
 
     // Add nested block with user-defined code.  This blocks allows
     // declarations in the body to shadow the catch parameters.
     CheckToken(Token::kLBRACE);
 
     // In case of async closures we need to restore the saved try index of an
     // outer try block (if it exists).
     ASSERT(try_blocks_list_ != NULL);
-    if (innermost_function().is_async_closure() ||
+    if (innermost_function().IsAsyncClosure() ||
         innermost_function().IsAsyncFunction()) {
       if ((try_blocks_list_->outer_try_block() != NULL) &&
           (try_blocks_list_->outer_try_block()->try_block()
               ->scope->function_level() ==
            current_block_->scope->function_level())) {
         // We need to unchain three scope levels: catch clause, catch
         // parameters, and the general try block.
         RestoreSavedTryContext(
             current_block_->scope->parent()->parent()->parent(),
             try_blocks_list_->outer_try_block()->try_index(),
@@ skipping 87 matching lines @@
   // If the last body was entered conditionally and there is no need to add
   // a rethrow, use an empty else body (current = NULL above).
 
   while (!type_tests.is_empty()) {
     AstNode* type_test = type_tests.RemoveLast();
     SequenceNode* catch_block = catch_blocks.RemoveLast();
 
     // In case of async closures we need to restore the saved try index of an
     // outer try block (if it exists).
     ASSERT(try_blocks_list_ != NULL);
-    if (innermost_function().is_async_closure() ||
+    if (innermost_function().IsAsyncClosure() ||
         innermost_function().IsAsyncFunction()) {
       if ((try_blocks_list_->outer_try_block() != NULL) &&
           (try_blocks_list_->outer_try_block()->try_block()
               ->scope->function_level() ==
            current_block_->scope->function_level())) {
         // We need to unchain three scope levels: catch clause, catch
         // parameters, and the general try block.
         RestoreSavedTryContext(
             current_block_->scope->parent()->parent(),
             try_blocks_list_->outer_try_block()->try_index(),
@@ skipping 17 matching lines @@
   LocalVariable* async_saved_try_ctx = new (Z) LocalVariable(
       Scanner::kNoSourcePos,
       async_saved_try_ctx_name,
       Type::ZoneHandle(Z, Type::DynamicType()));
   async_temp_scope_->AddVariable(async_saved_try_ctx);
   async_saved_try_ctx->set_is_captured();
   async_saved_try_ctx = current_block_->scope->LookupVariable(
       async_saved_try_ctx_name, false);
   ASSERT(async_saved_try_ctx != NULL);
   ASSERT(saved_try_context != NULL);
-  current_block_->statements->Add(new (Z) StoreLocalNode(
-      Scanner::kNoSourcePos, async_saved_try_ctx, new (Z) LoadLocalNode(
-          Scanner::kNoSourcePos, saved_try_context)));
+  current_block_->statements->Add(new(Z) StoreLocalNode(
+      Scanner::kNoSourcePos,
+      async_saved_try_ctx,
+      new(Z) LoadLocalNode(Scanner::kNoSourcePos, saved_try_context)));
   parsed_function()->set_saved_try_ctx(saved_try_context);
   parsed_function()->set_async_saved_try_ctx_name(async_saved_try_ctx_name);
 }
 
 
-// Set up the currently relevant :saved_try_context_var on the stack:
+// Restore the currently relevant :saved_try_context_var on the stack
+// from the captured :async_saved_try_cts_var.
 // * Try blocks: Set the context variable for this try block.
 // * Catch/finally blocks: Set the context variable for any outer try block (if
 //   existent).
 //
 // Also save the captured variable and the stack variable to be able to set
 // it after a function continues execution (await).
 void Parser::RestoreSavedTryContext(LocalScope* saved_try_context_scope,
                                     int16_t try_index,
                                     SequenceNode* target) {
   LocalVariable* saved_try_ctx = saved_try_context_scope->LookupVariable(
@@ skipping 67 matching lines @@
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(try_label);
   }
 
   // Now parse the 'try' block.
   OpenBlock();
   PushTryBlock(current_block_);
   ExpectToken(Token::kLBRACE);
 
-  if (innermost_function().is_async_closure() ||
+  if (innermost_function().IsAsyncClosure() ||
       innermost_function().IsAsyncFunction()) {
     SetupSavedTryContext(context_var);
   }
 
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* try_block = CloseBlock();
 
   if ((CurrentToken() != Token::kCATCH) && !IsLiteral("on") &&
       (CurrentToken() != Token::kFINALLY)) {
@@ skipping 158 matching lines @@
   } else if (token == Token::kDO) {
     statement = ParseDoWhileStatement(label_name);
   } else if (token == Token::kSWITCH) {
     statement = ParseSwitchStatement(label_name);
   } else if (token == Token::kTRY) {
     statement = ParseTryStatement(label_name);
   } else if (token == Token::kRETURN) {
     const intptr_t return_pos = TokenPos();
     ConsumeToken();
     if (CurrentToken() != Token::kSEMICOLON) {
+      const intptr_t expr_pos = TokenPos();
       if (current_function().IsConstructor() &&
           (current_block_->scope->function_level() == 0)) {
-        ReportError(return_pos,
-                    "return of a value not allowed in constructors");
+        ReportError(expr_pos,
+                    "return of a value is not allowed in constructors");
+      } else if (current_function().IsGenerator()) {
+        ReportError(expr_pos, "generator functions may not return a value");
       }
       AstNode* expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
       statement = new(Z) ReturnNode(statement_pos, expr);
     } else {
-      statement = new(Z) ReturnNode(statement_pos);
+      if (current_function().IsSyncGenClosure() &&
+          (current_block_->scope->function_level() == 0)) {
+        // In a synchronous generator, return without an expression
+        // returns false, signaling that the iterator terminates and
+        // did not yield a value.
+        statement = new(Z) ReturnNode(statement_pos,
+            new(Z) LiteralNode(return_pos, Bool::False()));
+      } else {
+        statement = new(Z) ReturnNode(statement_pos);
+      }
     }
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
+  } else if (IsYieldKeyword()) {
+    bool is_yield_each = false;
+    ConsumeToken();
+    ASSERT(innermost_function().IsGenerator() ||
+           innermost_function().IsSyncGenClosure());
+    if (CurrentToken() == Token::kMUL) {
+      is_yield_each = true;
+      ConsumeToken();
+    }
+    AstNode* expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
+    LocalVariable* iterator_param =
+        LookupLocalScope(Symbols::IteratorParameter());
+    ASSERT(iterator_param != NULL);
+    // Generate :iterator.current = expr;
+    AstNode* iterator =
+        new(Z) LoadLocalNode(Scanner::kNoSourcePos, iterator_param);
+    AstNode* store_current =
+        new(Z) InstanceSetterNode(Scanner::kNoSourcePos,
+                                  iterator,
+                                  String::ZoneHandle(Symbols::Current().raw()),
+                                  expr);
+    LetNode* yield = new(Z) LetNode(statement_pos);
+    yield->AddNode(store_current);
+    if (is_yield_each) {
+      // Generate :iterator.isYieldEach = true;
+      AstNode* set_is_yield_each =
+          new(Z) InstanceSetterNode(Scanner::kNoSourcePos,
+              iterator,
+              String::ZoneHandle(Symbols::IsYieldEach().raw()),
+              new(Z) LiteralNode(TokenPos(), Bool::True()));
+      yield->AddNode(set_is_yield_each);
+    }
+    AwaitMarkerNode* await_marker = new(Z) AwaitMarkerNode();
+    await_marker->set_scope(current_block_->scope);
+    yield->AddNode(await_marker);
+    // Return true to indicate that a value has been generated.
+    ReturnNode* return_true = new(Z) ReturnNode(statement_pos,
+        new(Z) LiteralNode(TokenPos(), Bool::True()));
+    return_true->set_return_type(ReturnNode::kContinuationTarget);
+    yield->AddNode(return_true);
+    statement = yield;
+    ExpectSemicolon();
   } else if (token == Token::kIF) {
     statement = ParseIfStatement(label_name);
   } else if (token == Token::kASSERT) {
     statement = ParseAssertStatement();
     ExpectSemicolon();
   } else if (IsVariableDeclaration()) {
     statement = ParseVariableDeclarationList();
     ExpectSemicolon();
   } else if (IsFunctionDeclaration()) {
     statement = ParseFunctionStatement(false);
@@ skipping 165 matching lines @@
   return IsIdentifier() && CurrentLiteral()->Equals(literal);
 }
 
 
 bool Parser::IsAwaitKeyword() {
   return await_is_keyword_ &&
          (CurrentLiteral()->raw() == Symbols::Await().raw());
 }
 
 
+bool Parser::IsYieldKeyword() {
+  return await_is_keyword_ &&
+         (CurrentLiteral()->raw() == Symbols::Yield().raw());
+}
+
+
 static bool IsIncrementOperator(Token::Kind token) {
   return token == Token::kINCR || token == Token::kDECR;
 }
 
 
 static bool IsPrefixOperator(Token::Kind token) {
   return (token == Token::kSUB) ||
          (token == Token::kNOT) ||
          (token == Token::kBIT_NOT);
 }
@@ skipping 637 matching lines @@
   return expr;
 }
 
 
 AstNode* Parser::ParseUnaryExpr() {
   TRACE_PARSER("ParseUnaryExpr");
   AstNode* expr = NULL;
   const intptr_t op_pos = TokenPos();
   if (IsAwaitKeyword()) {
     TRACE_PARSER("ParseAwaitExpr");
+    if (!innermost_function().IsAsyncFunction() &&
+        !innermost_function().IsAsyncClosure()) {
+      ReportError("await operator is only allowed in async function");
+    }
     ConsumeToken();
     parsed_function()->record_await();
     expr = new (Z) AwaitNode(TokenPos(), ParseUnaryExpr());
   } else if (IsPrefixOperator(CurrentToken())) {
     Token::Kind unary_op = CurrentToken();
     if (unary_op == Token::kSUB) {
       unary_op = Token::kNEGATE;
     }
     ConsumeToken();
     expr = ParseUnaryExpr();
@@ skipping 2815 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart