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 132 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 v8::internal::Statement* Statement;
   typedef ZoneList<v8::internal::Statement*>* StatementList;
   typedef v8::internal::Block* Block;
 
   // For constructing objects returned by the traversing functions.
   typedef AstNodeFactory Factory;
 
@@ skipping 543 matching lines @@
   // is also compared with it and the result is true only if they are equal.
   V8_INLINE bool IsStringLiteral(Statement* statement,
                                  const AstRawString* arg = nullptr) const {
     ExpressionStatement* e_stat = statement->AsExpressionStatement();
     if (e_stat == nullptr) return false;
     Literal* literal = e_stat->expression()->AsLiteral();
     if (literal == nullptr || !literal->raw_value()->IsString()) return false;
     return arg == nullptr || literal->raw_value()->AsString() == arg;
   }
 
-  V8_INLINE static Expression* GetPropertyValue(
-      ObjectLiteral::Property* property) {
+  V8_INLINE static Expression* GetPropertyValue(LiteralProperty* property) {
     return property->value();
   }
 
   // Functions for encapsulating the differences between parsing and preparsing;
   // operations interleaved with the recursive descent.
   V8_INLINE void PushLiteralName(const AstRawString* id) {
     DCHECK_NOT_NULL(fni_);
     fni_->PushLiteralName(id);
   }
 
@@ skipping 112 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 65 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 25 matching lines @@
 
 #ifdef DEBUG
   void Print(AstNode* node);
 #endif  // DEBUG
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_