Make invalid LHSs a parse-time (reference) error

src/preparser.h

 // Copyright 2012 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 324 matching lines @@
   }
 
   typename Traits::Type::Factory* factory() {
     return function_state_->factory();
   }
 
   StrictMode strict_mode() { return scope_->strict_mode(); }
   bool is_generator() const { return function_state_->is_generator(); }
 
   // Report syntax errors.
-  void ReportMessage(const char* message, Vector<const char*> args) {
+  void ReportMessage(const char* message, Vector<const char*> args,
+                     bool is_reference_error = false) {
     Scanner::Location source_location = scanner()->location();
-    Traits::ReportMessageAt(source_location, message, args);
+    Traits::ReportMessageAt(source_location, message, args, is_reference_error);
   }
 
-  void ReportMessageAt(Scanner::Location location, const char* message) {
-    Traits::ReportMessageAt(location, message, Vector<const char*>::empty());
+  void ReportMessageAt(Scanner::Location location, const char* message,
+                       bool is_reference_error = false) {
+    Traits::ReportMessageAt(location, message, Vector<const char*>::empty(),
+                            is_reference_error);
   }
 
   void ReportUnexpectedToken(Token::Value token);
 
   // Recursive descent functions:
 
   // Parses an identifier that is valid for the current scope, in particular it
   // fails on strict mode future reserved keywords in a strict scope. If
   // allow_eval_or_arguments is kAllowEvalOrArguments, we allow "eval" or
   // "arguments" as identifier even in strict mode (this is needed in cases like
@@ skipping 420 matching lines @@
     // PreParser should not use FuncNameInferrer.
     ASSERT(false);
   }
 
   static void CheckFunctionLiteralInsideTopLevelObjectLiteral(
       PreParserScope* scope, PreParserExpression value, bool* has_function) {}
 
   static void CheckAssigningFunctionLiteralToProperty(
       PreParserExpression left, PreParserExpression right) {}
 
-
-  static PreParserExpression ValidateAssignmentLeftHandSide(
-      PreParserExpression expression) {
-    // Parser generates a runtime error here if the left hand side is not valid.
-    // PreParser doesn't have to.
-    return expression;
+  // Determine whether the expression is a valid assignment left-hand side.
+  static bool IsValidLeftHandSide(PreParserExpression expression) {
+    // TODO(marja): check properly; for now, leave it to parser.
+    return true;
   }
 
   static PreParserExpression MarkExpressionAsLValue(
       PreParserExpression expression) {
     // TODO(marja): To be able to produce the same errors, the preparser needs
     // to start tracking which expressions are variables and which are lvalues.
     return expression;
   }
 
   // Checks LHS expression for assignment and prefix/postfix increment/decrement
   // in strict mode.
   void CheckStrictModeLValue(PreParserExpression expression, bool* ok);
 
 
   // Reporting errors.
   void ReportMessageAt(Scanner::Location location,
                        const char* message,
-                       Vector<const char*> args);
+                       Vector<const char*> args,
+                       bool is_reference_error = false);
   void ReportMessageAt(Scanner::Location location,
                        const char* type,
-                       const char* name_opt);
+                       const char* name_opt,
+                       bool is_reference_error = false);
   void ReportMessageAt(int start_pos,
                        int end_pos,
                        const char* type,
-                       const char* name_opt);
+                       const char* name_opt,
+                       bool is_reference_error = false);
 
   // "null" return type creators.
   static PreParserIdentifier EmptyIdentifier() {
     return PreParserIdentifier::Default();
   }
   static PreParserExpression EmptyExpression() {
     return PreParserExpression::Default();
   }
   static PreParserExpression EmptyLiteral() {
     return PreParserExpression::Default();
@@ skipping 766 matching lines @@
 
 // Precedence = 2
 template <class Traits>
 typename Traits::Type::Expression ParserBase<Traits>::ParseAssignmentExpression(
     bool accept_IN, bool* ok) {
   // AssignmentExpression ::
   //   ConditionalExpression
   //   YieldExpression
   //   LeftHandSideExpression AssignmentOperator AssignmentExpression
 
+  Scanner::Location lhs_location = scanner()->peek_location();
+
   if (peek() == Token::YIELD && is_generator()) {
     return this->ParseYieldExpression(ok);
   }
 
   if (fni_ != NULL) fni_->Enter();
   typename Traits::Type::Expression expression =
       this->ParseConditionalExpression(accept_IN, CHECK_OK);
 
   if (!Token::IsAssignmentOp(peek())) {
     if (fni_ != NULL) fni_->Leave();
     // Parsed conditional expression only (no assignment).
     return expression;
   }
 
-  // Signal a reference error if the expression is an invalid left-hand
-  // side expression.  We could report this as a syntax error here but
-  // for compatibility with JSC we choose to report the error at
-  // runtime.
-  // TODO(ES5): Should change parsing for spec conformance.
-  expression = this->ValidateAssignmentLeftHandSide(expression);
+  if (!IsValidLeftHandSide(expression)) {
+    this->ReportMessageAt(lhs_location, "invalid_lhs_in_assignment", true);
+    *ok = false;
+    return this->EmptyExpression();
+  }
 
   if (strict_mode() == STRICT) {
     // Assignment to eval or arguments is disallowed in strict mode.
     this->CheckStrictModeLValue(expression, CHECK_OK);
   }
   expression = this->MarkExpressionAsLValue(expression);
 
   Token::Value op = Next();  // Get assignment operator.
   int pos = position();
   typename Traits::Type::Expression right =
@@ skipping 83 matching lines @@
                                "accessor_get_set");
     }
     *ok = false;
   }
 }
 
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H