[modules] Improve error messages.

src/parsing/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/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 1076 matching lines @@
   Token::Value name_tok;
   while ((name_tok = peek()) != Token::RBRACE) {
     // Keep track of the first reserved word encountered in case our
     // caller needs to report an error.
     if (!reserved_loc->IsValid() &&
         !Token::IsIdentifier(name_tok, STRICT, false, parsing_module_)) {
       *reserved_loc = scanner()->location();
     }
     const AstRawString* local_name = ParseIdentifierName(CHECK_OK_VOID);
     const AstRawString* export_name = NULL;
+    Scanner::Location location = scanner()->location();
     if (CheckContextualKeyword(CStrVector("as"))) {
       export_name = ParseIdentifierName(CHECK_OK_VOID);
+      // Set the location to the whole "a as b" string, so that it makes sense
+      // both for errors due to "a" and for errors due to "b".
+      location.end_pos = scanner()->location().end_pos;
     }
     if (export_name == NULL) {
       export_name = local_name;
     }
     export_names->Add(export_name, zone());
     local_names->Add(local_name, zone());
-    export_locations->Add(scanner()->location(), zone());
+    export_locations->Add(location, zone());
     if (peek() == Token::RBRACE) break;
     Expect(Token::COMMA, CHECK_OK_VOID);
   }
 
   Expect(Token::RBRACE, CHECK_OK_VOID);
 }
 
 
 ZoneList<const Parser::NamedImport*>* Parser::ParseNamedImports(
     int pos, bool* ok) {
   // NamedImports :
   //   '{' '}'
   //   '{' ImportsList '}'
   //   '{' ImportsList ',' '}'
   //
   // ImportsList :
   //   ImportSpecifier
   //   ImportsList ',' ImportSpecifier
   //
   // ImportSpecifier :
   //   BindingIdentifier
   //   IdentifierName 'as' BindingIdentifier
 
   Expect(Token::LBRACE, CHECK_OK);
 
   auto result = new (zone()) ZoneList<const NamedImport*>(1, zone());
   while (peek() != Token::RBRACE) {
     const AstRawString* import_name = ParseIdentifierName(CHECK_OK);
     const AstRawString* local_name = import_name;
+    Scanner::Location location = scanner()->location();
     // In the presence of 'as', the left-side of the 'as' can
     // be any IdentifierName. But without 'as', it must be a valid
     // BindingIdentifier.
     if (CheckContextualKeyword(CStrVector("as"))) {
       local_name = ParseIdentifierName(CHECK_OK);
     }
     if (!Token::IsIdentifier(scanner()->current_token(), STRICT, false,
                              parsing_module_)) {
       *ok = false;
       ReportMessage(MessageTemplate::kUnexpectedReserved);
       return nullptr;
     } else if (IsEvalOrArguments(local_name)) {
       *ok = false;
       ReportMessage(MessageTemplate::kStrictEvalArguments);
       return nullptr;
     }
 
     DeclareModuleImport(local_name, position(), CHECK_OK);
 
-    NamedImport* import = new (zone()) NamedImport(
-        import_name, local_name, scanner()->location());
+    NamedImport* import =
+        new (zone()) NamedImport(import_name, local_name, location);
     result->Add(import, zone());
 
     if (peek() == Token::RBRACE) break;
     Expect(Token::COMMA, CHECK_OK);
   }
 
   Expect(Token::RBRACE, CHECK_OK);
   return result;
 }
 
@@ skipping 166 matching lines @@
 }
 
 Statement* Parser::ParseExportDeclaration(bool* ok) {
   // ExportDeclaration:
   //    'export' '*' 'from' ModuleSpecifier ';'
   //    'export' ExportClause ('from' ModuleSpecifier)? ';'
   //    'export' VariableStatement
   //    'export' Declaration
   //    'export' 'default' ... (handled in ParseExportDefault)
 
-  int pos = peek_position();
   Expect(Token::EXPORT, CHECK_OK);
+  int pos = position();
 
   Statement* result = nullptr;
   ZoneList<const AstRawString*> names(1, zone());
+  Scanner::Location loc = scanner()->peek_location();
   switch (peek()) {
     case Token::DEFAULT:
       return ParseExportDefault(ok);
 
     case Token::MUL: {
       Consume(Token::MUL);
+      loc = scanner()->location();
       ExpectContextualKeyword(CStrVector("from"), CHECK_OK);
       const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK);
       ExpectSemicolon(CHECK_OK);
-      module()->AddStarExport(module_specifier, scanner()->location(), zone());
+      module()->AddStarExport(module_specifier, loc, zone());
       return factory()->NewEmptyStatement(pos);
     }
 
     case Token::LBRACE: {
       // There are two cases here:
       //
       // 'export' ExportClause ';'
       // and
       // 'export' ExportClause FromClause ';'
       //
@@ skipping 60 matching lines @@
         result = ParseAsyncFunctionDeclaration(&names, false, CHECK_OK);
         break;
       }
     /* falls through */
 
     default:
       *ok = false;
       ReportUnexpectedToken(scanner()->current_token());
       return nullptr;
   }
+  loc.end_pos = scanner()->location().end_pos;
 
   ModuleDescriptor* descriptor = module();
   for (int i = 0; i < names.length(); ++i) {
-    // TODO(neis): Provide better location.
-    descriptor->AddExport(names[i], names[i], scanner()->location(), zone());
+    descriptor->AddExport(names[i], names[i], loc, zone());
   }
 
   DCHECK_NOT_NULL(result);
   return result;
 }
 
 VariableProxy* Parser::NewUnresolved(const AstRawString* name, int begin_pos,
                                      VariableKind kind) {
   return scope()->NewUnresolved(factory(), name, begin_pos, kind);
 }
@@ skipping 3951 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8