Fix conditionally parsing await as keyword.

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 268 matching lines @@
 
 // For parsing a compilation unit.
 Parser::Parser(const Script& script, const Library& library, intptr_t token_pos)
     : isolate_(Isolate::Current()),
       script_(Script::Handle(isolate_, script.raw())),
       tokens_iterator_(TokenStream::Handle(isolate_, script.tokens()),
                        token_pos),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
+      await_is_keyword_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(NULL),
       innermost_function_(Function::Handle(isolate_)),
       literal_token_(LiteralToken::Handle(isolate_)),
       current_class_(Class::Handle(isolate_)),
       library_(Library::Handle(isolate_, library.raw())),
       try_blocks_list_(NULL),
       last_used_try_index_(0),
       unregister_pending_function_(false) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!library.IsNull());
 }
 
 
 // For parsing a function.
 Parser::Parser(const Script& script,
                ParsedFunction* parsed_function,
                intptr_t token_position)
     : isolate_(Isolate::Current()),
       script_(Script::Handle(isolate_, script.raw())),
       tokens_iterator_(TokenStream::Handle(isolate_, script.tokens()),
                        token_position),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
+      await_is_keyword_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(parsed_function),
       innermost_function_(Function::Handle(isolate_,
                                            parsed_function->function().raw())),
       literal_token_(LiteralToken::Handle(isolate_)),
       current_class_(Class::Handle(isolate_,
                                    parsed_function->function().Owner())),
       library_(Library::Handle(isolate_, Class::Handle(
           isolate_,
@@ skipping 2721 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;
+  }
+
   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 48 matching lines @@
   func.set_end_token_pos(end_token_pos);
   SequenceNode* body = CloseBlock();
   if (func.IsAsyncFunction() && !func.is_async_closure()) {
     body = CloseAsyncFunction(async_closure, body);
   } else if (func.is_async_closure()) {
     CloseAsyncClosure(body);
   }
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
+  await_is_keyword_ = saved_await_is_keyword;
   return CloseBlock();
 }
 
 
 void Parser::AddEqualityNullCheck() {
   AstNode* argument =
       new LoadLocalNode(Scanner::kNoSourcePos,
                         current_block_->scope->parent()->VariableAt(1));
   LiteralNode* null_operand =
       new LiteralNode(Scanner::kNoSourcePos, Instance::ZoneHandle(I));
@@ skipping 3212 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());
+  return Token::IsIdentifier(CurrentToken()) && !IsAwaitAsKeyword();
 }
 
 
 // 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 1628 matching lines @@
   ConsumeToken();
   return ident;
 }
 
 
 bool Parser::IsLiteral(const char* literal) {
   return IsIdentifier() && CurrentLiteral()->Equals(literal);
 }
 
 
+bool Parser::IsAwaitAsKeyword() {
+  return await_is_keyword_ &&
+         (CurrentLiteral()->raw() == Symbols::Await().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 2917 matching lines @@
   TRACE_PARSER("ParsePrimary");
   ASSERT(!is_top_level_);
   AstNode* primary = NULL;
   const Token::Kind token = CurrentToken();
   if (IsFunctionLiteral()) {
     // The name of a literal function is visible from inside the function, but
     // must not collide with names in the scope declaring the literal.
     OpenBlock();
     primary = ParseFunctionStatement(true);
     CloseBlock();
-  } else if (IsLiteral("await") &&
-             (parsed_function()->function().IsAsyncFunction() ||
-              parsed_function()->function().is_async_closure())) {
+  } else if (IsAwaitAsKeyword()) {
     // The body of an async function is parsed multiple times. The first time
     // when setting up an AsyncFunction() for generating relevant scope
     // information. The second time the body is parsed for actually generating
     // code.
     TRACE_PARSER("ParseAwaitExpr");
     ConsumeToken();
     parsed_function()->record_await();
     primary = new(I) AwaitNode(
         TokenPos(), ParseExpr(kAllowConst, kConsumeCascades));
   } else if (IsIdentifier()) {
@@ skipping 528 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart