Make PreParser track valid left hand sides.

src/preparser.cc

 // Copyright 2011 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 856 matching lines @@
 
   while (true) {
     switch (peek()) {
       case Token::LBRACK: {
         Consume(Token::LBRACK);
         ParseExpression(true, CHECK_OK);
         Expect(Token::RBRACK, CHECK_OK);
         if (result.IsThis()) {
           result = Expression::ThisProperty();
         } else {
-          result = Expression::Default();
+          result = Expression::Property();
         }
         break;
       }
 
       case Token::LPAREN: {
         ParseArguments(CHECK_OK);
         result = Expression::Default();
         break;
       }
 
       case Token::PERIOD: {
         Consume(Token::PERIOD);
         ParseIdentifierName(CHECK_OK);
         if (result.IsThis()) {
           result = Expression::ThisProperty();
         } else {
-          result = Expression::Default();
+          result = Expression::Property();
         }
         break;
       }
 
       default:
         return result;
     }
   }
 }
 
 
 PreParser::Expression PreParser::ParseMemberWithNewPrefixesExpression(
     bool* ok) {
   // NewExpression ::
   //   ('new')+ MemberExpression
 
   // See Parser::ParseNewExpression.
 
   if (peek() == Token::NEW) {
     Consume(Token::NEW);
     ParseMemberWithNewPrefixesExpression(CHECK_OK);
+    Expression expression = Expression::Default();
     if (peek() == Token::LPAREN) {
       // NewExpression with arguments.
       ParseArguments(CHECK_OK);
-      // The expression can still continue with . or [ after the arguments.
-      ParseMemberExpressionContinuation(Expression::Default(), CHECK_OK);
+      // The expression can still continue with . or [ after the arguments. Here
+      // we need to transmit the "is valid left hand side" property of the
+      // expression.
+      expression =
+          ParseMemberExpressionContinuation(Expression::Default(), CHECK_OK);
     }
-    return Expression::Default();
+    return expression;
   }
   // No 'new' keyword.
   return ParseMemberExpression(ok);
 }
 
 
 PreParser::Expression PreParser::ParseMemberExpression(bool* ok) {
   // MemberExpression ::
   //   (PrimaryExpression | FunctionLiteral)
   //     ('[' Expression ']' | '.' Identifier | Arguments)*
@@ skipping 40 matching lines @@
   // ('[' Expression ']' | '.' Identifier)*
   while (true) {
     switch (peek()) {
       case Token::LBRACK: {
         Consume(Token::LBRACK);
         ParseExpression(true, CHECK_OK);
         Expect(Token::RBRACK, CHECK_OK);
         if (expression.IsThis()) {
           expression = Expression::ThisProperty();
         } else {
-          expression = Expression::Default();
+          expression = Expression::Property();
         }
         break;
       }
       case Token::PERIOD: {
         Consume(Token::PERIOD);
         ParseIdentifierName(CHECK_OK);
         if (expression.IsThis()) {
           expression = Expression::ThisProperty();
         } else {
-          expression = Expression::Default();
+          expression = Expression::Property();
         }
         break;
       }
       default:
         return expression;
     }
   }
   ASSERT(false);
   return PreParserExpression::Default();
 }
@@ skipping 91 matching lines @@
       return Expression::Default();
     }
     if (reserved_error_loc.IsValid()) {
       ReportMessageAt(reserved_error_loc, "unexpected_strict_reserved");
       *ok = false;
       return Expression::Default();
     }
 
     int end_position = scanner()->location().end_pos;
     CheckOctalLiteral(start_position, end_position, CHECK_OK);
-    return Expression::StrictFunction();
   }
 
   return Expression::Default();
 }
 
 
 void PreParser::ParseLazyFunctionLiteralBody(bool* ok) {
   int body_start = position();
   bool is_logging = log_->ShouldLogSymbols();
   if (is_logging) log_->PauseRecording();
@@ skipping 30 matching lines @@
 
 
 void PreParser::LogSymbol() {
   if (log_->ShouldLogSymbols()) {
     scanner()->LogSymbol(log_, position());
   }
 }
 
 
 } }  // v8::internal