Await always waits

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 2907 matching lines @@
     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()));
   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()) {
-    ReportError("async modifier requires dart:async to be imported without "
-                "prefix");
-  }
-  return cls.raw();
-}
-
-
 // Parser is at the opening parenthesis of the formal parameter
 // declaration of the function or constructor.
 // Parse the formal parameters and code.
 SequenceNode* Parser::ParseFunc(const Function& func,
                                 Array* default_parameter_values) {
   TRACE_PARSER("ParseFunc");
   Function& saved_innermost_function =
       Function::Handle(I, innermost_function().raw());
   innermost_function_ = func.raw();
 
@@ skipping 130 matching lines @@
   OpenBlock();  // Open a nested scope for the outermost function block.
 
   Function& async_closure = Function::ZoneHandle(I);
   if (func.IsAsyncFunction() && !func.is_async_closure()) {
     async_closure = OpenAsyncFunction(formal_params_pos);
   } else if (func.is_async_closure()) {
     OpenAsyncClosure();
   }
 
   bool saved_await_is_keyword = await_is_keyword_;
-  if (func.IsAsyncFunction() || func.is_async_closure()) {
-    await_is_keyword_ = true;
-  }
+  await_is_keyword_ = func.IsAsyncFunction() || func.is_async_closure();
 
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     if (String::Handle(I, func.name()).Equals(
         Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(I, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
@@ skipping 957 matching lines @@
     ConsumeToken();
   }
   ExpectToken(Token::kCLASS);
   const intptr_t classname_pos = TokenPos();
   String& class_name = *ExpectUserDefinedTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
   }
   Class& cls = Class::Handle(I);
   TypeArguments& orig_type_parameters = TypeArguments::Handle(I);
-  Object& obj = Object::Handle(I,
-                               library_.LookupLocalObject(class_name));
+  Object& obj = Object::Handle(I, library_.LookupLocalObject(class_name));
   if (obj.IsNull()) {
     if (is_patch) {
       ReportError(classname_pos, "missing class '%s' cannot be patched",
                   class_name.ToCString());
     }
     cls = Class::New(class_name, script_, classname_pos);
     library_.AddClass(cls);
   } else {
     if (!obj.IsClass()) {
       ReportError(classname_pos, "'%s' is already defined",
@@ skipping 186 matching lines @@
   cls.SetFunctions(array);
 
   // Add an implicit constructor if no explicit constructor is present.
   // No implicit constructors are needed for patch classes.
   if (need_implicit_constructor) {
     AddImplicitConstructor(cls);
   }
 
   if (cls.is_patch()) {
     // Apply the changes to the patched class looked up above.
-    Object& obj = Object::Handle(I,
-                                 library_.LookupLocalObject(class_name));
+    Object& obj = Object::Handle(I, library_.LookupLocalObject(class_name));
     // The patched class must not be finalized yet.
     const Class& orig_class = Class::Cast(obj);
     ASSERT(!orig_class.is_finalized());
     Error& error = Error::Handle(I);
     if (!orig_class.ApplyPatch(cls, &error)) {
       Report::LongJumpF(error, script_, class_pos, "applying patch failed");
     }
   }
 }
 
@@ skipping 74 matching lines @@
     const GrowableObjectArray& pending_classes,
     const Class& toplevel_class,
     intptr_t metadata_pos) {
   TRACE_PARSER("ParseMixinAppAlias");
   const intptr_t classname_pos = TokenPos();
   String& class_name = *ExpectUserDefinedTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("toplevel parsing mixin application alias class '%s'\n",
               class_name.ToCString());
   }
-  const Object& obj = Object::Handle(I,
-                                     library_.LookupLocalObject(class_name));
+  const Object& obj = Object::Handle(I, library_.LookupLocalObject(class_name));
   if (!obj.IsNull()) {
     ReportError(classname_pos, "'%s' is already defined",
                 class_name.ToCString());
   }
   const Class& mixin_application =
       Class::Handle(I, Class::New(class_name, script_, classname_pos));
   mixin_application.set_is_mixin_app_alias();
   library_.AddClass(mixin_application);
   set_current_class(mixin_application);
   ParseTypeParameters(mixin_application);
@@ skipping 100 matching lines @@
     // Wait until we have an owner class before resolving the result type.
     result_type = ParseType(ClassFinalizer::kDoNotResolve);
   }
 
   const intptr_t alias_name_pos = TokenPos();
   const String* alias_name =
       ExpectUserDefinedTypeIdentifier("function alias name expected");
 
   // Lookup alias name and report an error if it is already defined in
   // the library scope.
-  const Object& obj = Object::Handle(I,
-                                     library_.LookupLocalObject(*alias_name));
+  const Object& obj =
+      Object::Handle(I, library_.LookupLocalObject(*alias_name));
   if (!obj.IsNull()) {
     ReportError(alias_name_pos,
                 "'%s' is already defined", alias_name->ToCString());
   }
 
   // Create the function type alias signature class. It will be linked to its
   // signature function after it has been parsed. The type parameters, in order
   // to be properly finalized, need to be associated to this signature class as
   // they are parsed.
   const Class& function_type_alias = Class::Handle(I,
@@ skipping 44 matching lines @@
 
   const String& signature = String::Handle(I,
                                            signature_function.Signature());
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing function type alias '%s'\n",
               signature.ToCString());
   }
   // Lookup the signature class, i.e. the class whose name is the signature.
   // We only lookup in the current library, but not in its imports, and only
   // create a new canonical signature class if it does not exist yet.
-  Class& signature_class = Class::ZoneHandle(I,
-      library_.LookupLocalClass(signature));
+  Class& signature_class =
+      Class::ZoneHandle(I, library_.LookupLocalClass(signature));
   if (signature_class.IsNull()) {
     signature_class = Class::NewSignatureClass(signature,
                                                signature_function,
                                                script_,
                                                alias_name_pos);
     // Record the function signature class in the current library.
     library_.AddClass(signature_class);
   } else {
     // Forget the just created signature function and use the existing one.
     signature_function = signature_class.signature_function();
@@ skipping 324 matching lines @@
       ConsumeToken();
       break;
     } else {
       ExpectSemicolon();  // Reports error.
     }
   }
 }
 
 
 RawFunction::AsyncModifier Parser::ParseFunctionModifier() {
-  if (FLAG_enable_async) {
-    if (CurrentLiteral()->raw() == Symbols::Async().raw()) {
-      ConsumeToken();
-      return RawFunction::kAsync;
+  if (CurrentLiteral()->raw() == Symbols::Async().raw()) {
+    if (!FLAG_enable_async) {
+      ReportError("use flag --enable-async to enable async/await features");
     }
+    ConsumeToken();
+    return RawFunction::kAsync;
   }
   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(I, Type::DynamicType());
@@ skipping 933 matching lines @@
 
   closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
   closure_body->scope()->CaptureVariable(Symbols::AsyncCompleter());
 
   // Create and return a new future that executes a closure with the current
   // body.
 
   // No need to capture parameters or other variables, since they have already
   // been captured in the corresponding scope as the body has been parsed within
   // a nested block (contained in the async funtion's block).
-  const Class& future = Class::ZoneHandle(I,
-      GetClassForAsync(Symbols::Future()));
+  const Class& future =
+      Class::ZoneHandle(I, I->object_store()->future_class());
   ASSERT(!future.IsNull());
   const Function& constructor = Function::ZoneHandle(I,
       future.LookupFunction(Symbols::FutureConstructor()));
   ASSERT(!constructor.IsNull());
-  const Class& completer = Class::ZoneHandle(I,
-      GetClassForAsync(Symbols::Completer()));
+  const Class& completer =
+      Class::ZoneHandle(I, I->object_store()->completer_class());
   ASSERT(!completer.IsNull());
   const Function& completer_constructor = Function::ZoneHandle(I,
       completer.LookupFunction(Symbols::CompleterConstructor()));
   ASSERT(!completer_constructor.IsNull());
 
   LocalVariable* async_completer = current_block_->scope->LookupVariable(
       Symbols::AsyncCompleter(), false);
 
   // Add to AST:
   //   :async_completer = new Completer();
@@ skipping 701 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()) && !IsAwaitAsKeyword();
+  return Token::IsIdentifier(CurrentToken()) && !IsAwaitKeyword();
 }
 
 
 // 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 ||
-        (FLAG_enable_async &&
-            CurrentLiteral()->raw() == Symbols::Async().raw())) {
+        (CurrentLiteral()->raw() == Symbols::Async().raw())) {
       SetPosition(saved_pos);
       return true;
     }
   }
   SetPosition(saved_pos);
   return false;
 }
 
 
 bool Parser::IsTopLevelAccessor() {
@@ skipping 1524 matching lines @@
   ConsumeToken();
   return ident;
 }
 
 
 bool Parser::IsLiteral(const char* literal) {
   return IsIdentifier() && CurrentLiteral()->Equals(literal);
 }
 
 
-bool Parser::IsAwaitAsKeyword() {
+bool Parser::IsAwaitKeyword() {
   return await_is_keyword_ &&
          (CurrentLiteral()->raw() == Symbols::Await().raw());
 }
 
 
 static bool IsIncrementOperator(Token::Kind token) {
   return token == Token::kINCR || token == Token::kDECR;
 }
 
 
@@ skipping 544 matching lines @@
   TRACE_PARSER("ParseAwaitableExpr");
   parsed_function()->reset_have_seen_await();
   AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
   if (parsed_function()->have_seen_await()) {
     // Make sure we do not reuse the scope to avoid creating contexts that we
     // are unaware of, i.e, creating contexts that have already been covered.
     // See FlowGraphBuilder::VisitSequenceNode() for details on when contexts
     // are created.
     OpenBlock();
     AwaitTransformer at(current_block_->statements,
-                        library_,
                         parsed_function(),
                         async_temp_scope_);
     AstNode* result = at.Transform(expr);
     SequenceNode* preamble = CloseBlock();
     if (await_preamble == NULL) {
       current_block_->statements->Add(preamble);
     } else {
       *await_preamble = preamble;
     }
     parsed_function()->reset_have_seen_await();
@@ skipping 90 matching lines @@
     expr = new(I) ConditionalExprNode(expr_pos, expr, expr1, expr2);
   }
   return expr;
 }
 
 
 AstNode* Parser::ParseUnaryExpr() {
   TRACE_PARSER("ParseUnaryExpr");
   AstNode* expr = NULL;
   const intptr_t op_pos = TokenPos();
-  if (IsAwaitAsKeyword()) {
+  if (IsAwaitKeyword()) {
     TRACE_PARSER("ParseAwaitExpr");
     ConsumeToken();
     parsed_function()->record_await();
     expr = new (I) AwaitNode(TokenPos(), ParseUnaryExpr());
   } else if (IsPrefixOperator(CurrentToken())) {
     Token::Kind unary_op = CurrentToken();
     if (unary_op == Token::kSUB) {
       unary_op = Token::kNEGATE;
     }
     ConsumeToken();
@@ skipping 2809 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart