Follow-up to r19112.

src/preparser.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1040 matching lines @@
     Identifier identifier = Identifier::Default();
     if (peek_any_identifier()) {
       identifier = ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
     }
     result = ParseFunctionLiteral(is_generator, CHECK_OK);
     // If we're in strict mode, ParseIdentifier will catch using eval, arguments
     // or a strict reserved word as function name. However, if only the function
     // is strict, we need to do an extra check.
     if (result.IsStrictFunction() && !identifier.IsValidStrictVariable()) {
       StrictModeIdentifierViolation(scanner()->location(),
-                                    "strict_eval_arguments",
                                     identifier,
                                     ok);
       return Expression::Default();
     }
   } else {
     result = ParsePrimaryExpression(CHECK_OK);
   }
 
   while (true) {
     switch (peek()) {
@@ skipping 417 matching lines @@
 // "arguments" as identifier even in strict mode (this is needed in cases like
 // "var foo = eval;").
 PreParser::Identifier PreParser::ParseIdentifier(
     AllowEvalOrArgumentsAsIdentifier allow_eval_or_arguments,
     bool* ok) {
   Token::Value next = Next();
   if (next == Token::IDENTIFIER) {
     PreParser::Identifier name = GetIdentifierSymbol();
     if (allow_eval_or_arguments == kDontAllowEvalOrArguments &&
         !is_classic_mode() && name.IsEvalOrArguments()) {
-      StrictModeIdentifierViolation(
-          scanner()->location(), "strict_eval_arguments", name, ok);
+      StrictModeIdentifierViolation(scanner()->location(), name, ok);
     }
     return name;
   } else if (is_classic_mode() &&
              (next == Token::FUTURE_STRICT_RESERVED_WORD ||
               (next == Token::YIELD && !scope_->is_generator()))) {
     return GetIdentifierSymbol();
   } else {
     ReportUnexpectedToken(next);
     *ok = false;
     return Identifier::Default();
@@ skipping 28 matching lines @@
   Scanner::Location location = strict_mode_violation_location_;
   if (location.IsValid() &&
       location.beg_pos > beg_pos && location.end_pos < end_pos) {
     ReportMessageAt(location, strict_mode_violation_type_, NULL);
     *ok = false;
   }
 }
 
 
 void PreParser::StrictModeIdentifierViolation(Scanner::Location location,
-                                              const char* eval_args_type,
                                               Identifier identifier,
                                               bool* ok) {
-  const char* type = eval_args_type;
+  const char* type = "strict_eval_arguments";
   if (identifier.IsFutureReserved()) {
     type = "unexpected_reserved";
   } else if (identifier.IsFutureStrictReserved() || identifier.IsYield()) {
     type = "unexpected_strict_reserved";
   }
   if (!is_classic_mode()) {
     ReportMessageAt(location, type, NULL);
     *ok = false;
     return;
   }
@@ skipping 65 matching lines @@
       ASSERT(IsAccessorAccessorConflict(old_type, type));
       // Both accessors of the same type.
       parser()->ReportMessageAt(scanner()->location(),
                                "accessor_get_set");
     }
     *ok = false;
   }
 }
 
 } }  // v8::internal