Fix await/async/yield keyword recognition

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 1812 matching lines @@
     }
   } else {
     ConsumeToken();
   }
   ExpectToken(Token::kRPAREN);
 }
 
 
 String& Parser::ParseNativeDeclaration() {
   TRACE_PARSER("ParseNativeDeclaration");
-  ASSERT(IsLiteral("native"));
+  ASSERT(IsSymbol(Symbols::Native()));
   ConsumeToken();
   CheckToken(Token::kSTRING, "string literal expected");
   String& native_name = *CurrentLiteral();
   ConsumeToken();
   return native_name;
 }
 
 
 // Resolve and return the dynamic function of the given name in the superclass.
 // If it is not found, and resolve_getter is true, try to resolve a getter of
@@ skipping 1129 matching lines @@
 
   if (CurrentToken() == Token::kLBRACE) {
     // We checked in the top-level parse phase that a redirecting
     // constructor does not have a body.
     ASSERT(!is_redirecting_constructor);
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ReportError("constructors may not return a value");
-  } else if (IsLiteral("native")) {
+  } else if (IsSymbol(Symbols::Native())) {
     ReportError("native constructors not supported");
   } else if (CurrentToken() == Token::kSEMICOLON) {
     // Some constructors have no function body.
     ConsumeToken();
     if (func.is_external()) {
       // Body of an external method contains a single throw.
       const String& function_name = String::ZoneHandle(func.name());
       current_block_->statements->Add(
           ThrowNoSuchMethodError(TokenPos(),
                                  cls,
@@ skipping 238 matching lines @@
       const Class& owner = Class::Handle(Z, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     const intptr_t expr_pos = TokenPos();
     AstNode* expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
     end_token_pos = TokenPos();
-  } else if (IsLiteral("native")) {
+  } else if (IsSymbol(Symbols::Native())) {
     if (String::Handle(Z, func.name()).Equals(
         Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(Z, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     ParseNativeFunctionBlock(&params, func);
     end_token_pos = TokenPos();
     ExpectSemicolon();
@@ skipping 394 matching lines @@
                     "=> 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")) {
+  } else if (IsSymbol(Symbols::Native())) {
     if (method->has_abstract) {
       ReportError(method->name_pos,
                   "abstract method '%s' may not have a function body",
                   method->name->ToCString());
     } else if (method->IsConstructor() && method->has_const) {
       ReportError(method->name_pos,
                   "const constructor '%s' may not be native",
                   method->name->ToCString());
     }
     if (method->redirect_name != NULL) {
@@ skipping 1613 matching lines @@
       ConsumeToken();
       break;
     } else {
       ExpectSemicolon();  // Reports error.
     }
   }
 }
 
 
 RawFunction::AsyncModifier Parser::ParseFunctionModifier() {
-  if (CurrentLiteral()->raw() == Symbols::Async().raw()) {
+  if (IsSymbol(Symbols::Async())) {
     ConsumeToken();
     if (CurrentToken() == Token::kMUL) {
       const bool enableAsyncStar = true;
       if (!enableAsyncStar) {
         ReportError("async* generator functions are not yet supported");
       }
       ConsumeToken();
       return RawFunction::kAsyncGen;
     } else {
       return RawFunction::kAsync;
     }
-  } else if ((CurrentLiteral()->raw() == Symbols::Sync().raw()) &&
+  } else if (IsSymbol(Symbols::Sync()) &&
       (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;
@@ skipping 69 matching lines @@
     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")) {
+  } else if (IsSymbol(Symbols::Native())) {
     ParseNativeDeclaration();
     function_end_pos = TokenPos();
     ExpectSemicolon();
     is_native = true;
   } else {
     ReportError("function block expected");
   }
   Function& func = Function::Handle(Z,
       Function::New(func_name,
                     RawFunction::kRegularFunction,
@@ skipping 129 matching lines @@
     if (is_getter && ((func_modifier & RawFunction::kGeneratorBit) != 0)) {
       ReportError(modifier_pos,
                   "=> style getter may not be sync* or async* generator");
     }
     ConsumeToken();
     BoolScope allow_await(&this->await_is_keyword_,
                           func_modifier != RawFunction::kNoModifier);
     SkipExpr();
     accessor_end_pos = TokenPos();
     ExpectSemicolon();
-  } else if (IsLiteral("native")) {
+  } else if (IsSymbol(Symbols::Native())) {
     ParseNativeDeclaration();
     accessor_end_pos = TokenPos();
     ExpectSemicolon();
     is_native = true;
   } else {
     ReportError("function block expected");
   }
   Function& func = Function::Handle(Z,
       Function::New(accessor_name,
                     is_getter ? RawFunction::kGetterFunction :
@@ skipping 105 matching lines @@
   ConsumeToken();
   CheckToken(Token::kSTRING, "library url expected");
   AstNode* url_literal = ParseStringLiteral(false);
   ASSERT(url_literal->IsLiteralNode());
   ASSERT(url_literal->AsLiteralNode()->literal().IsString());
   const String& url = String::Cast(url_literal->AsLiteralNode()->literal());
   if (url.Length() == 0) {
     ReportError("library url expected");
   }
   bool is_deferred_import = false;
-  if (is_import && (IsLiteral("deferred"))) {
+  if (is_import && (IsSymbol(Symbols::Deferred()))) {
     is_deferred_import = true;
     ConsumeToken();
     CheckToken(Token::kAS, "'as' expected");
   }
   String& prefix = String::Handle(Z);
   intptr_t prefix_pos = 0;
   if (is_import && (CurrentToken() == Token::kAS)) {
     ConsumeToken();
     prefix_pos = TokenPos();
     prefix = ExpectIdentifier("prefix identifier expected")->raw();
   }
 
   Array& show_names = Array::Handle(Z);
   Array& hide_names = Array::Handle(Z);
-  if (is_deferred_import || IsLiteral("show") || IsLiteral("hide")) {
+  if (is_deferred_import ||
+      IsSymbol(Symbols::Show()) ||
+      IsSymbol(Symbols::Hide())) {
     GrowableObjectArray& show_list =
         GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
     GrowableObjectArray& hide_list =
         GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
     // Libraries imported through deferred import automatically hide
     // the name 'loadLibrary'.
     if (is_deferred_import) {
       hide_list.Add(Symbols::LoadLibrary());
     }
     for (;;) {
-      if (IsLiteral("show")) {
+      if (IsSymbol(Symbols::Show())) {
         ConsumeToken();
         ParseIdentList(&show_list);
-      } else if (IsLiteral("hide")) {
+      } else if (IsSymbol(Symbols::Hide())) {
         ConsumeToken();
         ParseIdentList(&hide_list);
       } else {
         break;
       }
     }
     if (show_list.Length() > 0) {
       show_names = Array::MakeArray(show_list);
     }
     if (hide_list.Length() > 0) {
@@ skipping 130 matching lines @@
     metadata_pos = SkipMetadata();
   }
   SetPosition(rewind_pos);
 }
 
 
 void Parser::ParsePartHeader() {
   SkipMetadata();
   CheckToken(Token::kPART, "'part of' expected");
   ConsumeToken();
-  if (!IsLiteral("of")) {
+  if (!IsSymbol(Symbols::Of())) {
     ReportError("'part of' expected");
   }
   ConsumeToken();
   // The VM is not required to check that the library name matches the
   // name of the current library, so we ignore it.
   ExpectIdentifier("library name expected");
   while (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ExpectIdentifier("malformed library name");
   }
@@ skipping 31 matching lines @@
       ParseClassDeclaration(pending_classes, toplevel_class, metadata_pos);
     } else if (CurrentToken() == Token::kENUM) {
       ParseEnumDeclaration(pending_classes, toplevel_class, metadata_pos);
     } else if ((CurrentToken() == Token::kTYPEDEF) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       set_current_class(toplevel_class);
       ParseTypedef(pending_classes, toplevel_class, metadata_pos);
     } else if ((CurrentToken() == Token::kABSTRACT) &&
         (LookaheadToken(1) == Token::kCLASS)) {
       ParseClassDeclaration(pending_classes, toplevel_class, metadata_pos);
-    } else if (is_patch_source() && IsLiteral("patch") &&
+    } else if (is_patch_source() && IsSymbol(Symbols::Patch()) &&
                (LookaheadToken(1) == Token::kCLASS)) {
       ParseClassDeclaration(pending_classes, toplevel_class, metadata_pos);
     } else {
       set_current_class(toplevel_class);
       if (IsVariableDeclaration()) {
         ParseTopLevelVariable(&top_level, metadata_pos);
       } else if (IsFunctionDeclaration()) {
         ParseTopLevelFunction(&top_level, metadata_pos);
       } else if (IsTopLevelAccessor()) {
         ParseTopLevelAccessor(&top_level, metadata_pos);
@@ skipping 1624 matching lines @@
 // Returns true if the current token is kIDENT or a pseudo-keyword.
 bool Parser::IsIdentifier() {
   return Token::IsIdentifier(CurrentToken()) &&
       !(await_is_keyword_ &&
        ((CurrentLiteral()->raw() == Symbols::Await().raw()) ||
        (CurrentLiteral()->raw() == Symbols::Async().raw()) ||
        (CurrentLiteral()->raw() == Symbols::YieldKw().raw())));
 }
 
 
+bool Parser::IsSymbol(const String& symbol) {
+  return (CurrentLiteral()->raw() == symbol.raw()) &&
+      (CurrentToken() == Token::kIDENT);
+}
+
+
 // 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;
   }
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
@@ skipping 123 matching lines @@
     ConsumeToken();  // Consume function identifier.
   } else {
     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_top_level_ && IsSymbol(Symbols::Native())) ||
         is_external ||
-        (CurrentLiteral()->raw() == Symbols::Async().raw()) ||
-        (CurrentLiteral()->raw() == Symbols::Sync().raw())) {
+        IsSymbol(Symbols::Async()) ||
+        IsSymbol(Symbols::Sync())) {
       SetPosition(saved_pos);
       return true;
     }
   }
   SetPosition(saved_pos);
   return false;
 }
 
 
 bool Parser::IsTopLevelAccessor() {
   const intptr_t saved_pos = TokenPos();
-  if (is_patch_source() &&
-      (CurrentToken() == Token::kIDENT) &&
-      (CurrentLiteral()->Equals("patch"))) {
+  if (is_patch_source() && IsSymbol(Symbols::Patch())) {
     ConsumeToken();
   } else if (CurrentToken() == Token::kEXTERNAL) {
     ConsumeToken();
   }
   if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
     SetPosition(saved_pos);
     return true;
   }
   if (TryParseReturnType()) {
     if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
@@ skipping 1102 matching lines @@
     const GrowableObjectArray& handler_types,
     bool* needs_stack_trace) {
   // All catch blocks are merged into an if-then-else sequence of the
   // different types specified using the 'is' operator.  While parsing
   // record the type tests (either a ComparisonNode or else the LiteralNode
   // true for a generic catch) and the catch bodies in a pair of parallel
   // lists.  Afterward, construct the nested if-then-else.
   bool generic_catch_seen = false;
   GrowableArray<AstNode*> type_tests;
   GrowableArray<SequenceNode*> catch_blocks;
-  while ((CurrentToken() == Token::kCATCH) || IsLiteral("on")) {
+  while ((CurrentToken() == Token::kCATCH) || IsSymbol(Symbols::On())) {
     // Open a block that contains the if or an unconditional body.  It's
     // closed in the loop that builds the if-then-else nest.
     OpenBlock();
     const intptr_t catch_pos = TokenPos();
     CatchParamDesc exception_param;
     CatchParamDesc stack_trace_param;
-    if (IsLiteral("on")) {
+    if (IsSymbol(Symbols::On())) {
       ConsumeToken();
       exception_param.type = &AbstractType::ZoneHandle(Z,
           ParseType(ClassFinalizer::kCanonicalize));
     } else {
       exception_param.type = &AbstractType::ZoneHandle(Z, Type::DynamicType());
     }
     if (CurrentToken() == Token::kCATCH) {
       ConsumeToken();  // Consume the 'catch'.
       ExpectToken(Token::kLPAREN);
       exception_param.token_pos = TokenPos();
@@ skipping 302 matching lines @@
   ExpectToken(Token::kLBRACE);
 
   if (is_async) {
     SetupSavedTryContext(context_var);
   }
 
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* try_block = CloseBlock();
 
-  if ((CurrentToken() != Token::kCATCH) && !IsLiteral("on") &&
+  if ((CurrentToken() != Token::kCATCH) && !IsSymbol(Symbols::On()) &&
       (CurrentToken() != Token::kFINALLY)) {
     ReportError("catch or finally clause expected");
   }
 
   // Now parse the 'catch' blocks if any.
   try_stack_->enter_catch();
   const intptr_t handler_pos = TokenPos();
   const GrowableObjectArray& handler_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   bool needs_stack_trace = false;
@@ skipping 521 matching lines @@
 String* Parser::ExpectIdentifier(const char* msg) {
   if (!IsIdentifier()) {
     ReportError("%s", msg);
   }
   String* ident = CurrentLiteral();
   ConsumeToken();
   return ident;
 }
 
 
-bool Parser::IsLiteral(const char* literal) {
-  return IsIdentifier() && CurrentLiteral()->Equals(literal);
-}
-
-
 bool Parser::IsAwaitKeyword() {
-  return await_is_keyword_ &&
-         (CurrentLiteral()->raw() == Symbols::Await().raw());
+  return await_is_keyword_ && IsSymbol(Symbols::Await());
 }
 
 
 bool Parser::IsYieldKeyword() {
-  return await_is_keyword_ &&
-         (CurrentLiteral()->raw() == Symbols::YieldKw().raw());
+  return await_is_keyword_ && IsSymbol(Symbols::YieldKw());
 }
 
 
 static bool IsIncrementOperator(Token::Kind token) {
   return token == Token::kINCR || token == Token::kDECR;
 }
 
 
 static bool IsPrefixOperator(Token::Kind token) {
   return (token == Token::kSUB) ||
@@ skipping 3499 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart