[parser] parenthesized Literals are not valid AssignmentPatterns

src/parsing/preparser.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_PARSING_PREPARSER_H
 #define V8_PARSING_PREPARSER_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/hashmap.h"
@@ skipping 261 matching lines @@
   // and PreParser.
   PreParserExpression* operator->() { return this; }
 
   // More dummy implementations of things PreParser doesn't need to track:
   void set_index(int index) {}  // For YieldExpressions
   void set_should_eager_compile() {}
 
   int position() const { return RelocInfo::kNoPosition; }
   void set_function_token_position(int position) {}
 
+  // Parenthesized expressions in the form `( Expression )`.
+  void set_is_parenthesized() { code_ |= ParenthesizedField::encode(true); }
+  bool is_parenthesized() const { return ParenthesizedField::decode(code_); }
+
  private:
   enum Type {
     kExpression,
     kIdentifierExpression,
     kStringLiteralExpression,
     kBinaryOperationExpression,
     kSpreadExpression,
     kObjectLiteralExpression,
     kArrayLiteralExpression
   };
 
   enum ExpressionType {
     kThisExpression,
     kThisPropertyExpression,
     kPropertyExpression,
     kCallExpression,
     kSuperCallReference,
     kNoTemplateTagExpression,
     kAssignment
   };
 
   explicit PreParserExpression(uint32_t expression_code)
       : code_(expression_code) {}
 
   // The first three bits are for the Type.
   typedef BitField<Type, 0, 3> TypeField;
 
   // The rest of the bits are interpreted depending on the value
   // of the Type field, so they can share the storage.

[adamk, 2016/01/08 16:24:23]

This comment is weird and out of date (some of the things below share storage,
and some do not. I'm guessing that's why you chose 31? Given that we appear to
have 32 bits available, could we just use the space we have available and wait
till later to do such micro-optimizations?

[caitp (gmail), 2016/01/08 16:36:01]

Are you saying "We don't need to have both ExpressionType and Type? I think the
idea was to be able to classify expressions vs statements, without having a
"is_expression" bit somewhere. In any case, rearranging this seems outside of
the scope of this CL, so I assume this is just a general comment on how this
should change during parser cleanup

[adamk, 2016/01/08 16:52:53]

No, it's not a general comment, since you've seeming-randomly chosen the last
bit of the bitfield to store ParenthesizedField (which is independent of the
TypeField, and thus makes this comment untrue, since that line _is_ below the
comment).

I guess you could move the new line up above the comment, with a TODO to fix up
the mess in a followup.

[caitp (gmail), 2016/01/08 16:58:37]

Alright, done

   typedef BitField<ExpressionType, TypeField::kNext, 3> ExpressionTypeField;
   typedef BitField<bool, TypeField::kNext, 1> IsUseStrictField;
   typedef BitField<bool, IsUseStrictField::kNext, 1> IsUseStrongField;
   typedef BitField<PreParserIdentifier::Type, TypeField::kNext, 10>
       IdentifierTypeField;
   typedef BitField<bool, TypeField::kNext, 1> HasCoverInitializedNameField;
+  typedef BitField<bool, 31, 1> ParenthesizedField;
 
   uint32_t code_;
 };
 
 
 // The pre-parser doesn't need to build lists of expressions, identifiers, or
 // the like.
 template <typename T>
 class PreParserList {
  public:
@@ skipping 799 matching lines @@
     const PreParserFormalParameters& parameters, FunctionKind kind,
     FunctionLiteral::FunctionType function_type, bool* ok) {
   return pre_parser_->ParseEagerFunctionBody(function_name, pos, parameters,
                                              kind, function_type, ok);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H