Make library, import, export, part built-in identifiers

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 4070 matching lines @@
     library_.AddObject(func, accessor_name);
   } else {
     library_.ReplaceObject(func, accessor_name);
   }
 }
 
 
 // TODO(hausner): Remove support for old library definition syntax.
 void Parser::ParseLibraryNameObsoleteSyntax() {
   if ((script_.kind() == RawScript::kLibraryTag) &&
-      (CurrentToken() != Token::kLIBRARY)) {
+      (CurrentToken() != Token::kLEGACY_LIBRARY)) {
     // Handle error case early to get consistent error message.
-    ExpectToken(Token::kLIBRARY);
+    ExpectToken(Token::kLEGACY_LIBRARY);
   }
-  if (CurrentToken() == Token::kLIBRARY) {
+  if (CurrentToken() == Token::kLEGACY_LIBRARY) {
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("library name expected");
     }
     const String& name = *CurrentLiteral();
     ConsumeToken();
     ExpectToken(Token::kRPAREN);
     ExpectToken(Token::kSEMICOLON);
     library_.SetName(name);
@@ skipping 16 matching lines @@
     Error& prev_error = Error::Handle();
     prev_error ^= Api::UnwrapHandle(result);
     AppendErrorMsg(prev_error, token_pos, "library handler failed");
   }
   return result;
 }
 
 
 // TODO(hausner): Remove support for old library definition syntax.
 void Parser::ParseLibraryImportObsoleteSyntax() {
-  while (CurrentToken() == Token::kIMPORT) {
+  while (CurrentToken() == Token::kLEGACY_IMPORT) {
     const intptr_t import_pos = TokenPos();
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("library url expected");
     }
     const String& url = *CurrentLiteral();
     ConsumeToken();
     String& prefix = String::Handle();
     if (CurrentToken() == Token::kCOMMA) {
@@ skipping 46 matching lines @@
         library_prefix = LibraryPrefix::New(prefix, import);
         library_.AddObject(library_prefix, prefix);
       }
     }
   }
 }
 
 
 // TODO(hausner): Remove support for old library definition syntax.
 void Parser::ParseLibraryIncludeObsoleteSyntax() {
-  while (CurrentToken() == Token::kSOURCE) {
+  while (CurrentToken() == Token::kLEGACY_SOURCE) {
     const intptr_t source_pos = TokenPos();
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("source url expected");
     }
     const String& url = *CurrentLiteral();
     ConsumeToken();
     ExpectToken(Token::kRPAREN);
     ExpectToken(Token::kSEMICOLON);
     Dart_Handle handle = CallLibraryTagHandler(kCanonicalizeUrl,
                                                source_pos,
                                                url);
     const String& canon_url = String::CheckedHandle(Api::UnwrapHandle(handle));
     CallLibraryTagHandler(kSourceTag, source_pos, canon_url);
   }
 }
 
 
 void Parser::ParseLibraryName() {
-  ASSERT(IsLiteral("library"));
+  ASSERT(CurrentToken() == Token::kLIBRARY);
   ConsumeToken();
   // TODO(hausner): Exact syntax of library name still unclear: identifier,
   // qualified identifier or even multiple dots allowed? For now we just
   // accept simple identifiers.
   const String& lib_name = *ExpectIdentifier("library name expected");
   library_.SetName(lib_name);
   ExpectSemicolon();
 }
 
 
 void Parser::ParseIdentList(GrowableObjectArray* names) {
   while (IsIdentifier()) {
     names->Add(*CurrentLiteral());
     ConsumeToken();  // Identifier.
     if (CurrentToken() != Token::kCOMMA) {
       return;
     }
     ConsumeToken();  // Comma.
   }
 }
 
 
 void Parser::ParseLibraryImportExport() {
-  bool is_import = IsLiteral("import");
-  bool is_export = IsLiteral("export");
+  bool is_import = (CurrentToken() == Token::kIMPORT);
+  bool is_export = (CurrentToken() == Token::kEXPORT);
   ASSERT(is_import || is_export);
   const intptr_t import_pos = TokenPos();
   ConsumeToken();
   if (CurrentToken() != Token::kSTRING) {
     ErrorMsg("library url expected");
   }
   const String& url = *CurrentLiteral();
   if (url.Length() == 0) {
     ErrorMsg("library url expected");
   }
@@ skipping 89 matching lines @@
 void Parser::ParseLibraryDefinition() {
   TRACE_PARSER("ParseLibraryDefinition");
 
   // Handle the script tag.
   if (CurrentToken() == Token::kSCRIPTTAG) {
     // Nothing to do for script tags except to skip them.
     ConsumeToken();
   }
 
   // TODO(hausner): Remove support for old library definition syntax.
-  if ((CurrentToken() == Token::kLIBRARY) ||
-      (CurrentToken() == Token::kIMPORT) ||
-      (CurrentToken() == Token::kSOURCE)) {
+  if ((CurrentToken() == Token::kLEGACY_LIBRARY) ||
+      (CurrentToken() == Token::kLEGACY_IMPORT) ||
+      (CurrentToken() == Token::kLEGACY_SOURCE)) {
     ParseLibraryNameObsoleteSyntax();
     ParseLibraryImportObsoleteSyntax();
     ParseLibraryIncludeObsoleteSyntax();
     // Core lib has not been explicitly imported, so we implicitly
     // import it here.
     if (!library_.ImportsCorelib()) {
       Library& core_lib = Library::Handle(Library::CoreLibrary());
       ASSERT(!core_lib.IsNull());
       const Namespace& core_ns = Namespace::Handle(
           Namespace::New(core_lib, Array::Handle(), Array::Handle()));
       library_.AddImport(core_ns);
     }
     return;
   }
 
   // We may read metadata tokens that are part of the toplevel
   // declaration that follows the library definitions. Therefore, we
   // need to remember the position of the last token that was
   // successfully consumed.
   intptr_t metadata_pos = TokenPos();
   SkipMetadata();
-  if (IsLiteral("library")) {
+  if (CurrentToken() == Token::kLIBRARY) {
     ParseLibraryName();
     metadata_pos = TokenPos();
     SkipMetadata();
   } else if (script_.kind() == RawScript::kLibraryTag) {
     ErrorMsg("library name definition expected");
   }
-  while (IsLiteral("import") || IsLiteral("export")) {
+  while ((CurrentToken() == Token::kIMPORT) ||
+      (CurrentToken() == Token::kEXPORT)) {
     ParseLibraryImportExport();
     metadata_pos = TokenPos();
     SkipMetadata();
   }
   // Core lib has not been explicitly imported, so we implicitly
   // import it here.
   if (!library_.ImportsCorelib()) {
     Library& core_lib = Library::Handle(Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
     const Namespace& core_ns = Namespace::Handle(
         Namespace::New(core_lib, Array::Handle(), Array::Handle()));
     library_.AddImport(core_ns);
   }
-  while (IsLiteral("part")) {
+  while (CurrentToken() == Token::kPART) {
     ParseLibraryPart();
     metadata_pos = TokenPos();
     SkipMetadata();
   }
-  if (IsLiteral("library") || IsLiteral("import") || IsLiteral("export")) {
-    ErrorMsg("unexpected token '%s'", CurrentLiteral()->ToCString());
-  }
   SetPosition(metadata_pos);
 }
 
 
 void Parser::ParsePartHeader() {
   intptr_t metadata_pos = TokenPos();
   SkipMetadata();
   // TODO(hausner): Once support for old #source directive is removed
   // from the compiler, add an error message here if we don't find
   // a 'part of' directive.
-  if (IsLiteral("part")) {
+  if (CurrentToken() == Token::kPART) {
     ConsumeToken();
     if (!IsLiteral("of")) {
       ErrorMsg("'part of' expected");
     }
     ConsumeToken();
     // TODO(hausner): Exact syntax of library name still unclear: identifier,
     // qualified identifier or even multiple dots allowed? For now we just
     // accept simple identifiers.
     // The VM is not required to check that the library name matches the
     // name of the current library, so we ignore it.
@@ skipping 5439 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart