Revert "Unify paren handling in Parser and PreParser."

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 329 matching lines @@
     Type type_;
 
     friend class Expression;
   };
 
   // Bits 0 and 1 are used to identify the type of expression:
   // If bit 0 is set, it's an identifier.
   // if bit 1 is set, it's a string literal.
   // If neither is set, it's no particular type, and both set isn't
   // use yet.
+  // Bit 2 is used to mark the expression as being parenthesized,
+  // so "(foo)" isn't recognized as a pure identifier (and possible label).
   class Expression {
    public:
     static Expression Default() {
       return Expression(kUnknownExpression);
     }
 
     static Expression FromIdentifier(Identifier id) {
       return Expression(kIdentifierFlag | (id.type_ << kIdentifierShift));
     }
 
@@ skipping 20 matching lines @@
     bool IsIdentifier() {
       return (code_ & kIdentifierFlag) != 0;
     }
 
     // Only works corretly if it is actually an identifier expression.
     PreParser::Identifier AsIdentifier() {
       return PreParser::Identifier(
           static_cast<PreParser::Identifier::Type>(code_ >> kIdentifierShift));
     }
 
+    bool IsParenthesized() {
+      // If bit 0 or 1 is set, we interpret bit 2 as meaning parenthesized.
+      return (code_ & 7) > 4;
+    }
+
+    bool IsRawIdentifier() {
+      return !IsParenthesized() && IsIdentifier();
+    }
+
     bool IsStringLiteral() { return (code_ & kStringLiteralFlag) != 0; }
 
+    bool IsRawStringLiteral() {
+      return !IsParenthesized() && IsStringLiteral();
+    }
+
     bool IsUseStrictLiteral() {
       return (code_ & kStringLiteralMask) == kUseStrictString;
     }
 
     bool IsThis() {
       return code_ == kThisExpression;
     }
 
     bool IsThisProperty() {
       return code_ == kThisPropertyExpression;
     }
 
     bool IsStrictFunction() {
       return code_ == kStrictFunctionExpression;
     }
 
+    Expression Parenthesize() {
+      int type = code_ & 3;
+      if (type != 0) {
+        // Identifiers and string literals can be parenthesized.
+        // They no longer work as labels or directive prologues,
+        // but are still recognized in other contexts.
+        return Expression(code_ | kParenthesizedExpressionFlag);
+      }
+      // For other types of expressions, it's not important to remember
+      // the parentheses.
+      return *this;
+    }
+
    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.
+    // If bit 0 or 1 are set, bit 2 marks that the expression has
+    // been wrapped in parentheses (a string literal can no longer
+    // be a directive prologue, and an identifier can no longer be
+    // a label.
     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,
 
+      // Only if identifier or string literal.
+      kParenthesizedExpressionFlag = 4,
+
       // Below here applies if neither identifier nor string literal.
       kThisExpression = 4,
       kThisPropertyExpression = 8,
       kStrictFunctionExpression = 12
     };
 
     explicit Expression(int expression_code) : code_(expression_code) { }
 
     int code_;
   };
 
   class Statement {
    public:
     static Statement Default() {
       return Statement(kUnknownStatement);
     }
 
     static Statement FunctionDeclaration() {
       return Statement(kFunctionDeclaration);
     }
 
     // Creates expression statement from expression.
     // Preserves being an unparenthesized string literal, possibly
     // "use strict".
     static Statement ExpressionStatement(Expression expression) {
-      if (expression.IsUseStrictLiteral()) {
-        return Statement(kUseStrictExpressionStatement);
-      }
-      if (expression.IsStringLiteral()) {
-        return Statement(kStringLiteralExpressionStatement);
+      if (!expression.IsParenthesized()) {
+        if (expression.IsUseStrictLiteral()) {
+          return Statement(kUseStrictExpressionStatement);
+        }
+        if (expression.IsStringLiteral()) {
+          return Statement(kStringLiteralExpressionStatement);
+        }
       }
       return Default();
     }
 
     bool IsStringLiteral() {
       return code_ == kStringLiteralExpressionStatement;
     }
 
     bool IsUseStrictLiteral() {
       return code_ == kUseStrictExpressionStatement;
@@ skipping 187 matching lines @@
   ParserRecorder* log_;
   Scope* scope_;
   Scanner::Location strict_mode_violation_location_;
   const char* strict_mode_violation_type_;
   bool parenthesized_function_;
 };
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H