Allow eval and arguments as property names

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"
@@ skipping 922 matching lines @@
   if (is_lazily_parsed) {
     ParseLazyFunctionLiteralBody(CHECK_OK);
   } else {
     ParseSourceElements(Token::RBRACE, ok);
   }
   Expect(Token::RBRACE, CHECK_OK);
 
   // Validate strict mode. We can do this only after parsing the function,
   // since the function can declare itself strict.
   // Concise methods use StrictFormalParameters.
-  if (is_strict(language_mode()) || IsConciseMethod(kind) || is_rest) {
-    if (function_name.IsEvalOrArguments()) {
-      ReportMessageAt(function_name_location, "strict_eval_arguments");
-      *ok = false;
-      return Expression::Default();
+  bool check_params =
+      is_strict(language_mode()) || IsConciseMethod(kind) || is_rest;
+  if (check_params) {
+    bool check_name = is_strict(language_mode()) && !IsConciseMethod(kind) &&
+                      !IsAccessorFunction(kind);
+    if (!check_name) {
+      CheckStrictFunctionParameters(eval_args_error_loc, dupe_error_loc,

[arv (Not doing code reviews), 2015/02/06 00:03:55]

Another option might be to pass in language_mode(), kind, is_rest to
CheckStrictFunctionNameAndParameters.

[adamk, 2015/02/06 00:23:58]

Yeah, I think that's a better move than having to duplicate both the
check_params and check_name logic in the parser and preparser.

+                                    reserved_error_loc, CHECK_OK);
+    } else {
+      CheckStrictFunctionNameAndParameters(
+          function_name, name_is_strict_reserved, function_name_location,
+          eval_args_error_loc, dupe_error_loc, reserved_error_loc, CHECK_OK);
     }
-    if (name_is_strict_reserved) {
-      ReportMessageAt(function_name_location, "unexpected_strict_reserved");
-      *ok = false;
-      return Expression::Default();
-    }
-    if (eval_args_error_loc.IsValid()) {
-      ReportMessageAt(eval_args_error_loc, "strict_eval_arguments");
-      *ok = false;
-      return Expression::Default();
-    }
-    if (dupe_error_loc.IsValid()) {
-      ReportMessageAt(dupe_error_loc, "strict_param_dupe");
-      *ok = false;
-      return Expression::Default();
-    }
-    if (reserved_error_loc.IsValid()) {
-      ReportMessageAt(reserved_error_loc, "unexpected_strict_reserved");
-      *ok = false;
-      return Expression::Default();
-    }
+  }
 
+  if (is_strict(language_mode())) {
     int end_position = scanner()->location().end_pos;
     CheckStrictOctalLiteral(start_position, end_position, CHECK_OK);
   }
 
   return Expression::Default();
 }
 
 
 void PreParser::ParseLazyFunctionLiteralBody(bool* ok) {
   int body_start = position();
@@ skipping 67 matching lines @@
   ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   ParseArguments(ok);
 
   return Expression::Default();
 }
 
 #undef CHECK_OK
 
 
 } }  // v8::internal