Make PreParser track valid left hand sides.

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 536 matching lines @@
   }
 
   static PreParserExpression This() {
     return PreParserExpression(kThisExpression);
   }
 
   static PreParserExpression ThisProperty() {
     return PreParserExpression(kThisPropertyExpression);
   }
 
-  static PreParserExpression StrictFunction() {
-    return PreParserExpression(kStrictFunctionExpression);
+  static PreParserExpression Property() {
+    return PreParserExpression(kPropertyExpression);
   }
 
   bool IsIdentifier() { return (code_ & kIdentifierFlag) != 0; }
 
   // Only works corretly if it is actually an identifier expression.
   PreParserIdentifier AsIdentifier() {
     return PreParserIdentifier(
         static_cast<PreParserIdentifier::Type>(code_ >> kIdentifierShift));
   }
 
   bool IsStringLiteral() { return (code_ & kStringLiteralFlag) != 0; }
 
   bool IsUseStrictLiteral() {
     return (code_ & kStringLiteralMask) == kUseStrictString;
   }
 
   bool IsThis() { return code_ == kThisExpression; }
 
   bool IsThisProperty() { return code_ == kThisPropertyExpression; }
 
-  bool IsStrictFunction() { return code_ == kStrictFunctionExpression; }
+  bool IsProperty() {
+    return code_ == kPropertyExpression || code_ == kThisPropertyExpression;
+  }
 
   // Dummy implementation for making expression->AsCall() work (see below).
   PreParserExpression* operator->() { return this; }
 
   // These are only used when doing function name inferring, and PreParser
   // doesn't do function name inferring.
   void* AsCall() const { return NULL; }
   void* AsCallNew() const { return NULL; }
 
   // More dummy implementations of things PreParser doesn't need to track:
   void set_index(int index) {}  // For YieldExpressions
 
  private:
-  // First two/three bits are used as flags.
-  // Bit 0 and 1 represent identifiers or strings literals, and are
-  // mutually exclusive, but can both be absent.
+  // Least significant 2 bits are used as flags. Bits 0 and 1 represent
+  // identifiers or strings literals, and are mutually exclusive, but can both
+  // be absent. If the expression is an identifier or a string literal, the
+  // other bits describe the type (see PreParserIdentifier::Type and string
+  // literal constants below).
   enum {
     kUnknownExpression = 0,
     // Identifiers
     kIdentifierFlag = 1,  // Used to detect labels.
     kIdentifierShift = 3,
 
     kStringLiteralFlag = 2,  // Used to detect directive prologue.
     kUnknownStringLiteral = kStringLiteralFlag,
     kUseStrictString = kStringLiteralFlag | 8,
     kStringLiteralMask = kUseStrictString,
 
-    // Below here applies if neither identifier nor string literal.
-    kThisExpression = 4,
-    kThisPropertyExpression = 8,
-    kStrictFunctionExpression = 12
+    // Below here applies if neither identifier nor string literal. Reserve the
+    // 2 least significant bits for flags.
+    kThisExpression = 1 << 2,
+    kThisPropertyExpression = 2 << 2,
+    kPropertyExpression = 3 << 2
   };
 
   explicit PreParserExpression(int expression_code) : code_(expression_code) {}
 
   int code_;
 };
 
 
 // PreParserExpressionList doesn't actually store the expressions because
 // PreParser doesn't need to.
@@ skipping 202 matching lines @@
   }
 
   static void CheckFunctionLiteralInsideTopLevelObjectLiteral(
       PreParserScope* scope, PreParserExpression value, bool* has_function) {}
 
   static void CheckAssigningFunctionLiteralToProperty(
       PreParserExpression left, PreParserExpression right) {}
 
   // 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;
+    return expression.IsIdentifier() || expression.IsProperty();
   }
 
   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
@@ skipping 1041 matching lines @@
                                "accessor_get_set");
     }
     *ok = false;
   }
 }
 
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H