Unify paren handling in (Pre)Parser::ParseExpressionOrLabelledStatement.

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.IsParenthesized()) {
-        if (expression.IsUseStrictLiteral()) {
-          return Statement(kUseStrictExpressionStatement);
-        }
-        if (expression.IsStringLiteral()) {
-          return Statement(kStringLiteralExpressionStatement);
-        }
+      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