[parser] make kInvalidLhsInFor a SyntaxError

src/preparser.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_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/bailout-reason.h"
 #include "src/expression-classifier.h"
 #include "src/func-name-inferrer.h"
@@ skipping 696 matching lines @@
   void CheckArityRestrictions(
       int param_count, FunctionLiteral::ArityRestriction arity_restriction,
       bool has_rest, int formals_start_pos, int formals_end_pos, bool* ok);
 
   // Checks if the expression is a valid reference expression (e.g., on the
   // left-hand side of assignments). Although ruled out by ECMA as early errors,
   // we allow calls for web compatibility and rewrite them to a runtime throw.
   ExpressionT CheckAndRewriteReferenceExpression(
       ExpressionT expression, int beg_pos, int end_pos,
       MessageTemplate::Template message, bool* ok);
+  ExpressionT CheckAndRewriteReferenceExpression(
+      ExpressionT expression, int beg_pos, int end_pos,
+      MessageTemplate::Template message, ParseErrorType type, bool* ok);
 
   // Used to validate property names in object literals and class literals
   enum PropertyKind {
     kAccessorProperty,
     kValueProperty,
     kMethodProperty
   };
 
   class ObjectLiteralCheckerBase {
    public:
@@ skipping 739 matching lines @@
   }
 
   PreParserExpression NewThrowReferenceError(MessageTemplate::Template message,
                                              int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewThrowSyntaxError(MessageTemplate::Template message,
                                           Handle<Object> arg, int pos) {
     return PreParserExpression::Default();
   }
+  PreParserExpression NewThrowSyntaxError(MessageTemplate::Template message,
+                                          int pos) {
+    return PreParserExpression::Default();
+  }
   PreParserExpression NewThrowTypeError(MessageTemplate::Template message,
                                         Handle<Object> arg, int pos) {
     return PreParserExpression::Default();
   }
 
   // Reporting errors.
   void ReportMessageAt(Scanner::Location location,
                        MessageTemplate::Template message,
                        const char* arg = NULL,
                        ParseErrorType error_type = kSyntaxError);
@@ skipping 2444 matching lines @@
   // Once we've reached a TEMPLATE_TAIL, we can close the TemplateLiteral.
   return Traits::CloseTemplateLiteral(&ts, start, tag);
 }
 
 
 template <typename Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::CheckAndRewriteReferenceExpression(
     ExpressionT expression, int beg_pos, int end_pos,
     MessageTemplate::Template message, bool* ok) {
+  return this->CheckAndRewriteReferenceExpression(expression, beg_pos, end_pos,
+                                                  message, kReferenceError, ok);
+}
+
+
+template <typename Traits>
+typename ParserBase<Traits>::ExpressionT
+ParserBase<Traits>::CheckAndRewriteReferenceExpression(
+    ExpressionT expression, int beg_pos, int end_pos,
+    MessageTemplate::Template message, ParseErrorType type, bool* ok) {
   Scanner::Location location(beg_pos, end_pos);
   if (this->IsIdentifier(expression)) {
     if (is_strict(language_mode()) &&
         this->IsEvalOrArguments(this->AsIdentifier(expression))) {
       this->ReportMessageAt(location, MessageTemplate::kStrictEvalArguments,
                             kSyntaxError);
       *ok = false;
       return this->EmptyExpression();
     }
     if (is_strong(language_mode()) &&
         this->IsUndefined(this->AsIdentifier(expression))) {
       this->ReportMessageAt(location, MessageTemplate::kStrongUndefined,
                             kSyntaxError);
       *ok = false;
       return this->EmptyExpression();
     }
   }
   if (expression->IsValidReferenceExpression()) {
     return expression;
   } else if (expression->IsCall()) {
     // If it is a call, make it a runtime error for legacy web compatibility.
     // Rewrite `expr' to `expr[throw ReferenceError]'.
     int pos = location.beg_pos;
-    ExpressionT error = this->NewThrowReferenceError(message, pos);
+    ExpressionT error = type == kReferenceError
+                            ? this->NewThrowReferenceError(message, pos)
+                            : this->NewThrowSyntaxError(message, pos);

[caitp (gmail), 2015/08/14 17:06:17]

I'm not sure if this distinction is necessary or good here --- getting rid of
this does make the patch a lot smaller.

SpiderMonkey does not make the distinction, at any rate.

[adamk, 2015/08/15 01:06:15]

Seems fine to me, and also makes sense tonot throw a SyntaxError at runtime...

     return factory()->NewProperty(expression, error, pos);
   } else {
-    this->ReportMessageAt(location, message, kReferenceError);
+    this->ReportMessageAt(location, message, type);
     *ok = false;
     return this->EmptyExpression();
   }
 }
 
 
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 
 
@@ skipping 46 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H