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 1952 matching lines @@
           classifier->RecordAsyncArrowFormalParametersError(
               Scanner::Location(next_beg_pos, next_end_pos),
               MessageTemplate::kAwaitBindingIdentifier);
         }
       }
       ExpressionT lhs = this->ExpressionFromIdentifier(
           *name, next_beg_pos, next_end_pos, scope(), factory());
       CheckDestructuringElement(lhs, classifier, next_beg_pos, next_end_pos);
 
       ExpressionT value;
-      if (peek() == Token::ASSIGN) {
+      if (IsValidReferenceExpression(lhs) && peek() == Token::ASSIGN) {

[Dan Ehrenberg, 2016/07/28 00:13:38]

Does the insertion of IsValidReferenceExpression(lhs) here have any other
effects observable in tests?

         Consume(Token::ASSIGN);
         ExpressionClassifier rhs_classifier(this);
         ExpressionT rhs = this->ParseAssignmentExpression(
             true, &rhs_classifier, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
         Traits::RewriteNonPattern(&rhs_classifier,
                                   CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
         classifier->Accumulate(&rhs_classifier,
                                ExpressionClassifier::ExpressionProductions);
         value = factory()->NewAssignment(Token::ASSIGN, lhs, rhs,
                                          kNoSourcePosition);
         classifier->RecordCoverInitializedNameError(
             Scanner::Location(next_beg_pos, scanner()->location().end_pos),
             MessageTemplate::kInvalidCoverInitializedName);
 
         Traits::SetFunctionNameFromIdentifierRef(rhs, lhs);
       } else {
+        if (this->IsIdentifier(lhs) && is_strict(language_mode()) &&
+            this->IsEvalOrArguments(this->AsIdentifier(lhs))) {
+          ReportMessageAt(Scanner::Location(next_beg_pos, next_end_pos),

[adamk, 2016/07/28 18:46:55]

I think you should be able to detect this when parsing the identifier. See
ParseAndClassifyIdentifier (and in particular its callers).

ExpressionClassifier is the right way to handle this error; it's the thing we
use to record "speculative" errors, before we know exactly what we're trying to
parse.

Anyway, in pointing to the destructuring assignment tests, I also meant to
suggest looking at how the destructuring assignment case manages to get the
right error (I'd use gdb or printf debugging for that :)

[lpy, 2016/08/05 22:15:41]

Done.

+                          MessageTemplate::kStrictEvalArguments, kSyntaxError);
+        }
         value = lhs;
       }
 
       return factory()->NewObjectLiteralProperty(
           name_expression, value, ObjectLiteralProperty::COMPUTED, is_static,
           false);
     }
   }
 
   // Method definitions are never valid in patterns.
@@ skipping 1657 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H