Tests and fixes for (pre)parse errors related to strict reserved words.

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 103 matching lines @@
     return ReportMessageAt(source_location, "unexpected_token_number", NULL);
   case Token::STRING:
     return ReportMessageAt(source_location, "unexpected_token_string", NULL);
   case Token::IDENTIFIER:
     return ReportMessageAt(source_location,
                            "unexpected_token_identifier", NULL);
   case Token::FUTURE_RESERVED_WORD:
     return ReportMessageAt(source_location, "unexpected_reserved", NULL);
   case Token::FUTURE_STRICT_RESERVED_WORD:
     return ReportMessageAt(source_location,
-                           "unexpected_strict_reserved", NULL);
+                           is_classic_mode() ? "unexpected_token_identifier"
+                                             : "unexpected_strict_reserved",
+                           NULL);
   default:
     const char* name = Token::String(token);
     ReportMessageAt(source_location, "unexpected_token", name);
   }
 }
 
 
 #define CHECK_OK  ok);                      \
   if (!*ok) return kUnknownSourceElements;  \
   ((void)0
@@ skipping 162 matching lines @@
   Scanner::Location location = scanner()->location();
 
   Expression function_value = ParseFunctionLiteral(is_generator, CHECK_OK);
 
   if (function_value.IsStrictFunction() &&
       !identifier.IsValidStrictVariable()) {
     // Strict mode violation, using either reserved word or eval/arguments
     // as name of strict function.
     const char* type = "strict_function_name";
     if (identifier.IsFutureStrictReserved() || identifier.IsYield()) {
-      type = "strict_reserved_word";
+      type = "unexpected_strict_reserved";
     }
     ReportMessageAt(location, type, NULL);
     *ok = false;
   }
   return Statement::FunctionDeclaration();
 }
 
 
 PreParser::Statement PreParser::ParseBlock(bool* ok) {
   // Block ::
@@ skipping 1186 matching lines @@
         // 'yield' in a generator is only valid as part of a YieldExpression.
         ReportMessageAt(scanner()->location(), "unexpected_token", "yield");
         *ok = false;
         return Identifier::Yield();
       }
       // FALLTHROUGH
     case Token::FUTURE_STRICT_RESERVED_WORD:
       if (!is_classic_mode()) {
         Scanner::Location location = scanner()->location();
         ReportMessageAt(location.beg_pos, location.end_pos,
-                        "strict_reserved_word", NULL);
+                        "unexpected_strict_reserved", NULL);
         *ok = false;
       }
       // FALLTHROUGH
     case Token::IDENTIFIER:
       return GetIdentifierSymbol();
     default:
       *ok = false;
       return Identifier::Default();
   }
 }
@@ skipping 33 matching lines @@
 
 
 void PreParser::StrictModeIdentifierViolation(Scanner::Location location,
                                               const char* eval_args_type,
                                               Identifier identifier,
                                               bool* ok) {
   const char* type = eval_args_type;
   if (identifier.IsFutureReserved()) {
     type = "reserved_word";
   } else if (identifier.IsFutureStrictReserved() || identifier.IsYield()) {
-    type = "strict_reserved_word";
+    type = "unexpected_strict_reserved";
   }
   if (!is_classic_mode()) {
     ReportMessageAt(location, type, NULL);
     *ok = false;
     return;
   }
   strict_mode_violation_location_ = location;
   strict_mode_violation_type_ = type;
 }
 
@@ skipping 61 matching lines @@
       ASSERT(IsAccessorAccessorConflict(old_type, type));
       // Both accessors of the same type.
       parser()->ReportMessageAt(scanner()->location(),
                                "accessor_get_set");
     }
     *ok = false;
   }
 }
 
 } }  // v8::internal