Fix not throwing error when redefine eval or arguments in strict mode.

src/parsing/parser-base.h

 // 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/base/hashmap.h"
@@ skipping 1943 matching lines @@
   ExpressionT name_expression = ParsePropertyName(
       name, &is_get, &is_set, &is_await, is_computed_name, classifier,
       CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
   if (fni_ != nullptr && !*is_computed_name) {
     this->PushLiteralName(fni_, *name);
   }
 
   if (!in_class && !is_generator) {
     DCHECK(!IsStaticMethod(method_kind));
-
     if (peek() == Token::COLON) {
       // PropertyDefinition
       //    PropertyName ':' AssignmentExpression
       if (!*is_computed_name) {
         checker->CheckProperty(name_token, kValueProperty, MethodKind::Normal,
                                CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
       }
       Consume(Token::COLON);
       int beg_pos = peek_position();
       ExpressionT value = this->ParseAssignmentExpression(
@@ skipping 12 matching lines @@
       // PropertyDefinition
       //    IdentifierReference
       //    CoverInitializedName
       //
       // CoverInitializedName
       //    IdentifierReference Initializer?
       if (classifier->duplicate_finder() != nullptr &&
           scanner()->FindSymbol(classifier->duplicate_finder(), 1) != 0) {
         classifier->RecordDuplicateFormalParameterError(scanner()->location());
       }
+
+      if (this->IsEvalOrArguments(*name)) {
+        classifier->RecordStrictModeFormalParameterError(

[adamk, 2016/08/17 19:32:51]

Can you explain why this is needed? In particular, which tests fail without it?
I don't see any added sloppy-mode error cases.

[lpy, 2016/08/19 17:00:40]

My mistakes. My understanding is when we enter PropertyDefinition, it means we
are not using formal parameter error, instead we are using non-simple parameter
list. So the RecordStrictModeFormalParameterError is not necessary here.

+            scanner()->location(), MessageTemplate::kStrictEvalArguments);
+        if (is_strict(language_mode())) {
+          classifier->RecordBindingPatternError(
+              scanner()->location(), MessageTemplate::kStrictEvalArguments);
+        }
+      }
+
       if (name_token == Token::LET) {
         classifier->RecordLetPatternError(
             scanner()->location(), MessageTemplate::kLetInLexicalBinding);
       }
       if (is_await) {
         if (is_async_function()) {
           classifier->RecordPatternError(
               Scanner::Location(next_beg_pos, next_end_pos),
               MessageTemplate::kAwaitBindingIdentifier);
         } else {
@@ skipping 1727 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H