Simplify error message logic in ParseImportNames

src/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 1320 matching lines @@
     if (peek() == Token::RBRACE) break;
     Expect(Token::COMMA, CHECK_OK);
   }
 
   Expect(Token::RBRACE, CHECK_OK);
 
   return 0;
 }
 
 
-void* Parser::ParseNamedImports(ZoneList<const AstRawString*>* names,
+void* Parser::ParseNamedImports(ZoneList<const AstRawString*>* import_names,
+                                ZoneList<const AstRawString*>* local_names,
                                 bool* ok) {
   // NamedImports :
   //   '{' '}'
   //   '{' ImportsList '}'
   //   '{' ImportsList ',' '}'
   //
   // ImportsList :
   //   ImportSpecifier
   //   ImportsList ',' ImportSpecifier
   //
   // ImportSpecifier :
   //   BindingIdentifier
   //   IdentifierName 'as' BindingIdentifier
 
   Expect(Token::LBRACE, CHECK_OK);
 
-  Token::Value name_tok;
-  while ((name_tok = peek()) != Token::RBRACE) {
-    const AstRawString* name = ParseIdentifierName(CHECK_OK);
-    const AstRawString* import_name = NULL;
+  while (peek() != Token::RBRACE) {
+    const AstRawString* import_name = ParseIdentifierName(CHECK_OK);
+    const AstRawString* local_name = import_name;
     // In the presence of 'as', the left-side of the 'as' can
     // be any IdentifierName. But without 'as', it must be a valid
-    // BindingIdentiifer.
+    // BindingIdentifier.
     if (CheckContextualKeyword(CStrVector("as"))) {
-      import_name = ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
-    } else if (!Token::IsIdentifier(name_tok, STRICT, false)) {
+      local_name = ParseIdentifierName(CHECK_OK);
+    }
+    if (!Token::IsIdentifier(scanner()->current_token(), STRICT, false)) {
       *ok = false;
-      ReportMessageAt(scanner()->location(), "unexpected_reserved");
+      ReportMessage("unexpected_reserved");
       return NULL;
-    } else if (IsEvalOrArguments(name)) {
+    } else if (IsEvalOrArguments(local_name)) {
       *ok = false;
-      ReportMessageAt(scanner()->location(), "strict_eval_arguments");
+      ReportMessage("strict_eval_arguments");
       return NULL;
     }
-    // TODO(ES6): Return the import_name as well as the name.
-    names->Add(name, zone());
-    USE(import_name);
+    import_names->Add(import_name, zone());
+    local_names->Add(local_name, zone());
     if (peek() == Token::RBRACE) break;
     Expect(Token::COMMA, CHECK_OK);
   }
 
   Expect(Token::RBRACE, CHECK_OK);
 
   return NULL;
 }
 
 
@@ skipping 12 matching lines @@
   // NameSpaceImport :
   //   '*' 'as' ImportedBinding
 
   int pos = peek_position();
   Expect(Token::IMPORT, CHECK_OK);
 
   Token::Value tok = peek();
 
   // 'import' ModuleSpecifier ';'
   if (tok == Token::STRING) {
-    ParseModuleSpecifier(CHECK_OK);
+    Literal* module_specifier = ParseModuleSpecifier(CHECK_OK);
     ExpectSemicolon(CHECK_OK);
+    // TODO(ES6): Add module to the requested modules of scope_->module().
+    USE(module_specifier);
     return factory()->NewEmptyStatement(pos);
   }
 
   // Parse ImportedDefaultBinding if present.
   const AstRawString* imported_default_binding = NULL;
   if (tok != Token::MUL && tok != Token::LBRACE) {
     imported_default_binding =
         ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
   }
 
   const AstRawString* module_instance_binding = NULL;
-  ZoneList<const AstRawString*> names(1, zone());
+  ZoneList<const AstRawString*> local_names(1, zone());
+  ZoneList<const AstRawString*> import_names(1, zone());
   if (imported_default_binding == NULL || Check(Token::COMMA)) {
     switch (peek()) {
       case Token::MUL: {
         Consume(Token::MUL);
         ExpectContextualKeyword(CStrVector("as"), CHECK_OK);
         module_instance_binding =
             ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
         break;
       }
 
       case Token::LBRACE:
-        ParseNamedImports(&names, CHECK_OK);
+        ParseNamedImports(&import_names, &local_names, CHECK_OK);
         break;
 
       default:
         *ok = false;
         ReportUnexpectedToken(scanner()->current_token());
         return NULL;
     }
   }
 
   ExpectContextualKeyword(CStrVector("from"), CHECK_OK);
   Literal* module = ParseModuleSpecifier(CHECK_OK);
   USE(module);
 
   ExpectSemicolon(CHECK_OK);
 
   if (module_instance_binding != NULL) {
     // TODO(ES6): Bind name to the Module Instance Object of module.
   }
 
   if (imported_default_binding != NULL) {
     // TODO(ES6): Add an appropriate declaration.
   }
 
-  for (int i = 0; i < names.length(); ++i) {
+  const int length = import_names.length();
+  DCHECK_EQ(length, local_names.length());
+  for (int i = 0; i < length; ++i) {
     // TODO(ES6): Add an appropriate declaration for each name
   }
 
   return factory()->NewEmptyStatement(pos);
 }
 
 
 Statement* Parser::ParseExportDefault(bool* ok) {
   //  Supports the following productions, starting after the 'default' token:
   //    'export' 'default' FunctionDeclaration
@@ skipping 3943 matching lines @@
     } else {
       const uc16* data = reinterpret_cast<const uc16*>(raw_string->raw_data());
       running_hash = StringHasher::ComputeRunningHash(running_hash, data,
                                                       raw_string->length());
     }
   }
 
   return running_hash;
 }
 } }  // namespace v8::internal