Migrate error messages, part 12.

src/preparser.cc

 // Copyright 2011 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 <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
 #include "src/globals.h"
 #include "src/hashmap.h"
 #include "src/list.h"
 #include "src/preparse-data.h"
 #include "src/preparse-data-format.h"
 #include "src/preparser.h"
 #include "src/unicode.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 void PreParserTraits::ReportMessageAt(Scanner::Location location,
-                                      const char* message, const char* arg,
+                                      MessageTemplate::Template message,
+                                      const char* arg,
                                       ParseErrorType error_type) {
   ReportMessageAt(location.beg_pos, location.end_pos, message, arg, error_type);
 }
 
 
 void PreParserTraits::ReportMessageAt(int start_pos, int end_pos,
-                                      const char* message, const char* arg,
+                                      MessageTemplate::Template message,
+                                      const char* arg,
                                       ParseErrorType error_type) {
   pre_parser_->log_->LogMessage(start_pos, end_pos, message, arg, error_type);
 }
 
 
 PreParserIdentifier PreParserTraits::GetSymbol(Scanner* scanner) {
   if (scanner->current_token() == Token::FUTURE_RESERVED_WORD) {
     return PreParserIdentifier::FutureReserved();
   } else if (scanner->current_token() ==
              Token::FUTURE_STRICT_RESERVED_WORD) {
@@ skipping 83 matching lines @@
   } else {
     DCHECK_EQ(Token::RBRACE, scanner()->peek());
     if (is_strict(scope_->language_mode())) {
       int end_pos = scanner()->location().end_pos;
       CheckStrictOctalLiteral(start_position, end_pos, &ok);
       if (!ok) return kPreParseSuccess;
 
       if (is_strong(scope_->language_mode()) && IsSubclassConstructor(kind)) {
         if (!function_state.super_location().IsValid()) {
           ReportMessageAt(Scanner::Location(start_position, start_position + 1),
-                          "strong_super_call_missing", kReferenceError);
+                          MessageTemplate::kStrongSuperCallMissing,
+                          kReferenceError);
           return kPreParseSuccess;
         }
       }
     }
   }
   return kPreParseSuccess;
 }
 
 
 PreParserExpression PreParserTraits::ParseClassLiteral(
@@ skipping 76 matching lines @@
     Statement statement = ParseStatementListItem(ok);
     if (!*ok) return;
 
     if (is_strong(language_mode()) &&
         scope_->is_function_scope() &&
         i::IsConstructor(function_state_->kind())) {
       Scanner::Location this_loc = function_state_->this_location();
       Scanner::Location super_loc = function_state_->super_location();
       if (this_loc.beg_pos != old_this_loc.beg_pos &&
           this_loc.beg_pos != token_loc.beg_pos) {
-        ReportMessageAt(this_loc, "strong_constructor_this");
+        ReportMessageAt(this_loc, MessageTemplate::kStrongConstructorThis);
         *ok = false;
         return;
       }
       if (super_loc.beg_pos != old_super_loc.beg_pos &&
           super_loc.beg_pos != token_loc.beg_pos) {
-        ReportMessageAt(super_loc, "strong_constructor_super");
+        ReportMessageAt(super_loc, MessageTemplate::kStrongConstructorSuper);
         *ok = false;
         return;
       }
     }
 
     if (directive_prologue) {
       if (statement.IsUseStrictLiteral()) {
         scope_->SetLanguageMode(
             static_cast<LanguageMode>(scope_->language_mode() | STRICT_BIT));
       } else if (statement.IsUseStrongLiteral() && allow_strong_mode()) {
@@ skipping 67 matching lines @@
   // parsed into an empty statement.
 
   // Keep the source position of the statement
   switch (peek()) {
     case Token::LBRACE:
       return ParseBlock(ok);
 
     case Token::SEMICOLON:
       if (is_strong(language_mode())) {
         PreParserTraits::ReportMessageAt(scanner()->peek_location(),
-                                         "strong_empty");
+                                         MessageTemplate::kStrongEmpty);
         *ok = false;
         return Statement::Default();
       }
       Next();
       return Statement::Default();
 
     case Token::IF:
       return ParseIfStatement(ok);
 
     case Token::DO:
@@ skipping 26 matching lines @@
     case Token::TRY:
       return ParseTryStatement(ok);
 
     case Token::FUNCTION: {
       Scanner::Location start_location = scanner()->peek_location();
       Statement statement = ParseFunctionDeclaration(CHECK_OK);
       Scanner::Location end_location = scanner()->location();
       if (is_strict(language_mode())) {
         PreParserTraits::ReportMessageAt(start_location.beg_pos,
                                          end_location.end_pos,
-                                         "strict_function");
+                                         MessageTemplate::kStrictFunction);
         *ok = false;
         return Statement::Default();
       } else {
         return statement;
       }
     }
 
     case Token::DEBUGGER:
       return ParseDebuggerStatement(ok);
 
@@ skipping 32 matching lines @@
                                     : FunctionKind::kNormalFunction,
                        pos, FunctionLiteral::DECLARATION,
                        FunctionLiteral::NORMAL_ARITY, CHECK_OK);
   return Statement::FunctionDeclaration();
 }
 
 
 PreParser::Statement PreParser::ParseClassDeclaration(bool* ok) {
   Expect(Token::CLASS, CHECK_OK);
   if (!allow_harmony_sloppy() && is_sloppy(language_mode())) {
-    ReportMessage("sloppy_lexical");
+    ReportMessage(MessageTemplate::kSloppyLexical);
     *ok = false;
     return Statement::Default();
   }
 
   int pos = position();
   bool is_strict_reserved = false;
   Identifier name =
       ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
   ParseClassLiteral(name, scanner()->location(), is_strict_reserved, pos,
                     CHECK_OK);
@@ skipping 55 matching lines @@
   //   Identifier '=' AssignmentExpression
   //
   // TODO(ES6):
   // ConstBinding ::
   //   BindingPattern '=' AssignmentExpression
   bool require_initializer = false;
   bool is_strict_const = false;
   if (peek() == Token::VAR) {
     if (is_strong(language_mode())) {
       Scanner::Location location = scanner()->peek_location();
-      ReportMessageAt(location, "strong_var");
+      ReportMessageAt(location, MessageTemplate::kStrongVar);
       *ok = false;
       return Statement::Default();
     }
     Consume(Token::VAR);
   } else if (peek() == Token::CONST) {
     // TODO(ES6): The ES6 Draft Rev4 section 12.2.2 reads:
     //
     // ConstDeclaration : const ConstBinding (',' ConstBinding)* ';'
     //
     // * It is a Syntax Error if the code that matches this production is not
@@ skipping 97 matching lines @@
         switch (peek()) {
           case Token::SEMICOLON:
             Consume(Token::SEMICOLON);
             break;
           case Token::RBRACE:
           case Token::EOS:
             break;
           default:
             if (!scanner()->HasAnyLineTerminatorBeforeNext()) {
               ReportMessageAt(function_state_->this_location(),
-                              is_this ? "strong_constructor_this"
-                                      : "strong_constructor_super");
+                              is_this
+                                  ? MessageTemplate::kStrongConstructorThis
+                                  : MessageTemplate::kStrongConstructorSuper);
               *ok = false;
               return Statement::Default();
             }
         }
         return Statement::ExpressionStatement(expr);
       }
       break;
 
     // TODO(arv): Handle `let [`
     // https://code.google.com/p/v8/issues/detail?id=3847
@@ skipping 20 matching lines @@
     Statement statement = ParseStatement(ok);
     return statement.IsJumpStatement() ? Statement::Default() : statement;
     // Preparsing is disabled for extensions (because the extension details
     // aren't passed to lazily compiled functions), so we don't
     // accept "native function" in the preparser.
   }
   // Parsed expression statement.
   // Detect attempts at 'let' declarations in sloppy mode.
   if (peek() == Token::IDENTIFIER && is_sloppy(language_mode()) &&
       expr.IsIdentifier() && expr.AsIdentifier().IsLet()) {
-    ReportMessage("sloppy_lexical", NULL);
+    ReportMessage(MessageTemplate::kSloppyLexical, NULL);
     *ok = false;
     return Statement::Default();
   }
   ExpectSemicolon(CHECK_OK);
   return Statement::ExpressionStatement(expr);
 }
 
 
 PreParser::Statement PreParser::ParseIfStatement(bool* ok) {
   // IfStatement ::
@@ skipping 69 matching lines @@
 
   Token::Value tok = peek();
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       tok != Token::SEMICOLON &&
       tok != Token::RBRACE &&
       tok != Token::EOS) {
     if (is_strong(language_mode()) &&
         i::IsConstructor(function_state_->kind())) {
       int pos = peek_position();
       ReportMessageAt(Scanner::Location(pos, pos + 1),
-                      "strong_constructor_return_value");
+                      MessageTemplate::kStrongConstructorReturnValue);
       *ok = false;
       return Statement::Default();
     }
     ParseExpression(true, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
   return Statement::Jump();
 }
 
 
 PreParser::Statement PreParser::ParseWithStatement(bool* ok) {
   // WithStatement ::
   //   'with' '(' Expression ')' Statement
   Expect(Token::WITH, CHECK_OK);
   if (is_strict(language_mode())) {
-    ReportMessageAt(scanner()->location(), "strict_mode_with");
+    ReportMessageAt(scanner()->location(), MessageTemplate::kStrictWith);
     *ok = false;
     return Statement::Default();
   }
   Expect(Token::LPAREN, CHECK_OK);
   ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
 
   Scope* with_scope = NewScope(scope_, WITH_SCOPE);
   BlockState block_state(&scope_, with_scope);
   ParseSubStatement(CHECK_OK);
@@ skipping 23 matching lines @@
     token = peek();
     Statement statement = Statement::Jump();
     while (token != Token::CASE &&
            token != Token::DEFAULT &&
            token != Token::RBRACE) {
       statement = ParseStatementListItem(CHECK_OK);
       token = peek();
     }
     if (is_strong(language_mode()) && !statement.IsJumpStatement() &&
         token != Token::RBRACE) {
-      ReportMessageAt(scanner()->location(), "strong_switch_fallthrough");
+      ReportMessageAt(scanner()->location(),
+                      MessageTemplate::kStrongSwitchFallthrough);
       *ok = false;
       return Statement::Default();
     }
   }
   Expect(Token::RBRACE, ok);
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseDoWhileStatement(bool* ok) {
@@ skipping 42 matching lines @@
                                 &first_initializer_loc, &bindings_loc,
                                 CHECK_OK);
       bool accept_IN = decl_count >= 1;
       bool accept_OF = true;
       if (accept_IN && CheckInOrOf(accept_OF, &mode, ok)) {
         if (!*ok) return Statement::Default();
         if (decl_count != 1) {
           const char* loop_type =
               mode == ForEachStatement::ITERATE ? "for-of" : "for-in";
           PreParserTraits::ReportMessageAt(
-              bindings_loc, "for_inof_loop_multi_bindings", loop_type);
+              bindings_loc, MessageTemplate::kForInOfLoopMultiBindings,
+              loop_type);
           *ok = false;
           return Statement::Default();
         }
         if (first_initializer_loc.IsValid() &&
             (is_strict(language_mode()) || mode == ForEachStatement::ITERATE)) {
           if (mode == ForEachStatement::ITERATE) {
-            ReportMessageAt(first_initializer_loc, "for_of_loop_initializer");
+            ReportMessageAt(first_initializer_loc,
+                            MessageTemplate::kForOfLoopInitializer);
           } else {
             // TODO(caitp): This should be an error in sloppy mode, too.
-            ReportMessageAt(first_initializer_loc, "for_in_loop_initializer");
+            ReportMessageAt(first_initializer_loc,
+                            MessageTemplate::kForInLoopInitializer);
           }
           *ok = false;
           return Statement::Default();
         }
         ParseExpression(true, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
         ParseSubStatement(CHECK_OK);
         return Statement::Default();
       }
     } else {
       Expression lhs = ParseExpression(false, CHECK_OK);
       is_let_identifier_expression =
           lhs.IsIdentifier() && lhs.AsIdentifier().IsLet();
       if (CheckInOrOf(lhs.IsIdentifier(), &mode, ok)) {
         if (!*ok) return Statement::Default();
         ParseExpression(true, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
         ParseSubStatement(CHECK_OK);
         return Statement::Default();
       }
     }
   }
 
   // Parsed initializer at this point.
   // Detect attempts at 'let' declarations in sloppy mode.
   if (peek() == Token::IDENTIFIER && is_sloppy(language_mode()) &&
       is_let_identifier_expression) {
-    ReportMessage("sloppy_lexical", NULL);
+    ReportMessage(MessageTemplate::kSloppyLexical, NULL);
     *ok = false;
     return Statement::Default();
   }
   Expect(Token::SEMICOLON, CHECK_OK);
 
   if (peek() != Token::SEMICOLON) {
     ParseExpression(true, CHECK_OK);
   }
   Expect(Token::SEMICOLON, CHECK_OK);
 
   if (peek() != Token::RPAREN) {
     ParseExpression(true, CHECK_OK);
   }
   Expect(Token::RPAREN, CHECK_OK);
 
   ParseSubStatement(ok);
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseThrowStatement(bool* ok) {
   // ThrowStatement ::
   //   'throw' [no line terminator] Expression ';'
 
   Expect(Token::THROW, CHECK_OK);
   if (scanner()->HasAnyLineTerminatorBeforeNext()) {
-    ReportMessageAt(scanner()->location(), "newline_after_throw");
+    ReportMessageAt(scanner()->location(), MessageTemplate::kNewlineAfterThrow);
     *ok = false;
     return Statement::Default();
   }
   ParseExpression(true, CHECK_OK);
   ExpectSemicolon(ok);
   return Statement::Jump();
 }
 
 
 PreParser::Statement PreParser::ParseTryStatement(bool* ok) {
   // TryStatement ::
   //   'try' Block Catch
   //   'try' Block Finally
   //   'try' Block Catch Finally
   //
   // Catch ::
   //   'catch' '(' Identifier ')' Block
   //
   // Finally ::
   //   'finally' Block
 
   Expect(Token::TRY, CHECK_OK);
 
   ParseBlock(CHECK_OK);
 
   Token::Value tok = peek();
   if (tok != Token::CATCH && tok != Token::FINALLY) {
-    ReportMessageAt(scanner()->location(), "no_catch_or_finally");
+    ReportMessageAt(scanner()->location(), MessageTemplate::kNoCatchOrFinally);
     *ok = false;
     return Statement::Default();
   }
   if (tok == Token::CATCH) {
     Consume(Token::CATCH);
     Expect(Token::LPAREN, CHECK_OK);
     ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
     Expect(Token::RPAREN, CHECK_OK);
     {
       Scope* with_scope = NewScope(scope_, WITH_SCOPE);
@@ skipping 87 matching lines @@
   ValidateFormalParameters(&formals_classifier, language_mode(),
                            allow_duplicate_parameters, CHECK_OK);
 
   if (is_strict(language_mode())) {
     int end_position = scanner()->location().end_pos;
     CheckStrictOctalLiteral(start_position, end_position, CHECK_OK);
   }
 
   if (is_strong(language_mode()) && IsSubclassConstructor(kind)) {
     if (!function_state.super_location().IsValid()) {
-      ReportMessageAt(function_name_location, "strong_super_call_missing",
+      ReportMessageAt(function_name_location,
+                      MessageTemplate::kStrongSuperCallMissing,
                       kReferenceError);
       *ok = false;
       return Expression::Default();
     }
   }
 
   return Expression::Default();
 }
 
 
@@ skipping 12 matching lines @@
                     function_state_->expected_property_count(), language_mode(),
                     scope_->uses_super_property());
 }
 
 
 PreParserExpression PreParser::ParseClassLiteral(
     PreParserIdentifier name, Scanner::Location class_name_location,
     bool name_is_strict_reserved, int pos, bool* ok) {
   // All parts of a ClassDeclaration and ClassExpression are strict code.
   if (name_is_strict_reserved) {
-    ReportMessageAt(class_name_location, "unexpected_strict_reserved");
+    ReportMessageAt(class_name_location,
+                    MessageTemplate::kUnexpectedStrictReserved);
     *ok = false;
     return EmptyExpression();
   }
   if (IsEvalOrArguments(name)) {
-    ReportMessageAt(class_name_location, "strict_eval_arguments");
+    ReportMessageAt(class_name_location, MessageTemplate::kStrictEvalArguments);
     *ok = false;
     return EmptyExpression();
   }
   LanguageMode class_language_mode = language_mode();
   if (is_strong(class_language_mode) && IsUndefined(name)) {
-    ReportMessageAt(class_name_location, "strong_undefined");
+    ReportMessageAt(class_name_location, MessageTemplate::kStrongUndefined);
     *ok = false;
     return EmptyExpression();
   }
 
   Scope* scope = NewScope(scope_, BLOCK_SCOPE);
   BlockState block_state(&scope_, scope);
   scope_->SetLanguageMode(
       static_cast<LanguageMode>(class_language_mode | STRICT_BIT));
   // TODO(marja): Make PreParser use scope names too.
   // scope_->SetScopeName(name);
@@ skipping 45 matching lines @@
 
   DCHECK(!spread_pos.IsValid());
 
   return Expression::Default();
 }
 
 #undef CHECK_OK
 
 
 } }  // v8::internal