Split the AST representation of class properties from object properties

src/parsing/parser.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_PARSER_H_
 #define V8_PARSING_PARSER_H_
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/parsing/parser-base.h"
@@ skipping 131 matching lines @@
   typedef ParserBase<Parser> Base;
   typedef Parser Impl;
 
   typedef Variable GeneratorVariable;
 
   // Return types for traversing functions.
   typedef const AstRawString* Identifier;
   typedef v8::internal::Expression* Expression;
   typedef v8::internal::FunctionLiteral* FunctionLiteral;
   typedef ObjectLiteral::Property* ObjectLiteralProperty;
+  typedef ClassLiteral::Property* ClassLiteralProperty;
   typedef ZoneList<v8::internal::Expression*>* ExpressionList;
   typedef ZoneList<ObjectLiteral::Property*>* PropertyList;
   typedef ParserFormalParameters FormalParameters;
   typedef ZoneList<v8::internal::Statement*>* StatementList;
   typedef v8::internal::Block* Block;
 
   // For constructing objects returned by the traversing functions.
   typedef AstNodeFactory Factory;
 };
 
@@ skipping 538 matching lines @@
   V8_INLINE static bool IsArrayIndex(const AstRawString* string,
                                      uint32_t* index) {
     return string->AsArrayIndex(index);
   }
 
   V8_INLINE static Expression* GetPropertyValue(
       ObjectLiteral::Property* property) {
     return property->value();
   }
 
+  V8_INLINE static Expression* GetPropertyValue(

[adamk, 2016/09/01 21:18:23]

Can't you just take a LiteralProperty* instead?

[bakkot, 2016/09/01 23:24:31]

Whoops. Done.

+      ClassLiteral::Property* property) {
+    return property->value();
+  }
+
   // Functions for encapsulating the differences between parsing and preparsing;
   // operations interleaved with the recursive descent.
   V8_INLINE static void PushLiteralName(FuncNameInferrer* fni,
                                         const AstRawString* id) {
     fni->PushLiteralName(id);
   }
 
   V8_INLINE static void PushVariableName(FuncNameInferrer* fni,
                                          const AstRawString* id) {
     fni->PushVariableName(id);
@@ skipping 110 matching lines @@
                                            arg, error_type);
   }
 
   // "null" return type creators.
   V8_INLINE static const AstRawString* EmptyIdentifier() { return nullptr; }
   V8_INLINE static Expression* EmptyExpression() { return nullptr; }
   V8_INLINE static Literal* EmptyLiteral() { return nullptr; }
   V8_INLINE static ObjectLiteralProperty* EmptyObjectLiteralProperty() {
     return nullptr;
   }
+  V8_INLINE static ClassLiteralProperty* EmptyClassLiteralProperty() {
+    return nullptr;
+  }
   V8_INLINE static FunctionLiteral* EmptyFunctionLiteral() { return nullptr; }
   V8_INLINE static Block* NullBlock() { return nullptr; }
 
   V8_INLINE static bool IsEmptyExpression(Expression* expr) {
     return expr == nullptr;
   }
 
   // Used in error return values.
   V8_INLINE static ZoneList<Expression*>* NullExpressionList() {
     return nullptr;
@@ skipping 55 matching lines @@
     return factory()->NewStringLiteral(symbol, pos);
   }
 
   V8_INLINE ZoneList<Expression*>* NewExpressionList(int size) const {
     return new (zone()) ZoneList<Expression*>(size, zone());
   }
   V8_INLINE ZoneList<ObjectLiteral::Property*>* NewPropertyList(
       int size) const {
     return new (zone()) ZoneList<ObjectLiteral::Property*>(size, zone());
   }
+  V8_INLINE ZoneList<ClassLiteral::Property*>* NewClassPropertyList(
+      int size) const {
+    return new (zone()) ZoneList<ClassLiteral::Property*>(size, zone());
+  }
   V8_INLINE ZoneList<Statement*>* NewStatementList(int size) const {
     return new (zone()) ZoneList<Statement*>(size, zone());
   }
 
   V8_INLINE Block* NewBlock(ZoneList<const AstRawString*>* labels, int capacity,
                             bool ignore_completion_value, int pos) {
     return factory()->NewBlock(labels, capacity, ignore_completion_value, pos);
   }
 
   V8_INLINE void AddParameterInitializationBlock(
@@ skipping 60 matching lines @@
   V8_INLINE static bool IsTaggedTemplate(const Expression* tag) {
     return tag != NULL;
   }
 
   V8_INLINE void MaterializeUnspreadArgumentsLiterals(int count) {}
 
   Expression* ExpressionListToExpression(ZoneList<Expression*>* args);
 
   void SetFunctionNameFromPropertyName(ObjectLiteralProperty* property,
                                        const AstRawString* name);
+  void SetFunctionNameFromPropertyName(ClassLiteralProperty* property,
+                                       const AstRawString* name);
 
   void SetFunctionNameFromIdentifierRef(Expression* value,
                                         Expression* identifier);
 
   V8_INLINE ZoneList<typename ExpressionClassifier::Error>*
   GetReportedErrorList() const {
     return function_state_->GetReportedErrorList();
   }
 
   V8_INLINE ZoneList<Expression*>* GetNonPatternList() const {
@@ skipping 50 matching lines @@
   static const int kLiteralTypeSlot = 0;
   static const int kElementsSlot = 1;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompileTimeValue);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_