Class syntax parsing

src/ast.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_AST_H_
 #define V8_AST_H_
 
 #include "src/v8.h"
 
 #include "src/assembler.h"
@@ skipping 22 matching lines @@
 
 // Nodes are allocated in a separate zone, which allows faster
 // allocation and constant-time deallocation of the entire syntax
 // tree.
 
 
 // ----------------------------------------------------------------------------
 // Nodes of the abstract syntax tree. Only concrete classes are
 // enumerated here.
 
-#define DECLARATION_NODE_LIST(V)                \
-  V(VariableDeclaration)                        \
-  V(FunctionDeclaration)                        \
-  V(ModuleDeclaration)                          \
-  V(ImportDeclaration)                          \
-  V(ExportDeclaration)                          \
+#define DECLARATION_NODE_LIST(V) \
+  V(VariableDeclaration)         \
+  V(FunctionDeclaration)         \
+  V(ClassDeclaration)            \
+  V(ModuleDeclaration)           \
+  V(ImportDeclaration)           \
+  V(ExportDeclaration)
 
 #define MODULE_NODE_LIST(V)                     \
   V(ModuleLiteral)                              \
   V(ModuleVariable)                             \
   V(ModulePath)                                 \
   V(ModuleUrl)
 
 #define STATEMENT_NODE_LIST(V)                  \
   V(Block)                                      \
   V(ModuleStatement)                            \
   V(ExpressionStatement)                        \
   V(EmptyStatement)                             \
   V(IfStatement)                                \
   V(ContinueStatement)                          \
   V(BreakStatement)                             \
   V(ReturnStatement)                            \
   V(WithStatement)                              \
   V(SwitchStatement)                            \
   V(DoWhileStatement)                           \
   V(WhileStatement)                             \
   V(ForStatement)                               \
   V(ForInStatement)                             \
   V(ForOfStatement)                             \
   V(TryCatchStatement)                          \
   V(TryFinallyStatement)                        \
   V(DebuggerStatement)
 
-#define EXPRESSION_NODE_LIST(V)                 \
-  V(FunctionLiteral)                            \
-  V(NativeFunctionLiteral)                      \
-  V(Conditional)                                \
-  V(VariableProxy)                              \
-  V(Literal)                                    \
-  V(RegExpLiteral)                              \
-  V(ObjectLiteral)                              \
-  V(ArrayLiteral)                               \
-  V(Assignment)                                 \
-  V(Yield)                                      \
-  V(Throw)                                      \
-  V(Property)                                   \
-  V(Call)                                       \
-  V(CallNew)                                    \
-  V(CallRuntime)                                \
-  V(UnaryOperation)                             \
-  V(CountOperation)                             \
-  V(BinaryOperation)                            \
-  V(CompareOperation)                           \
-  V(ThisFunction)                               \
-  V(SuperReference)                             \
+#define EXPRESSION_NODE_LIST(V) \
+  V(FunctionLiteral)            \
+  V(ClassLiteral)               \
+  V(NativeFunctionLiteral)      \
+  V(Conditional)                \
+  V(VariableProxy)              \
+  V(Literal)                    \
+  V(RegExpLiteral)              \
+  V(ObjectLiteral)              \
+  V(ArrayLiteral)               \
+  V(Assignment)                 \
+  V(Yield)                      \
+  V(Throw)                      \
+  V(Property)                   \
+  V(Call)                       \
+  V(CallNew)                    \
+  V(CallRuntime)                \
+  V(UnaryOperation)             \
+  V(CountOperation)             \
+  V(BinaryOperation)            \
+  V(CompareOperation)           \
+  V(ThisFunction)               \
+  V(SuperReference)             \
   V(CaseClause)
 
 #define AST_NODE_LIST(V)                        \
   DECLARATION_NODE_LIST(V)                      \
   MODULE_NODE_LIST(V)                           \
   STATEMENT_NODE_LIST(V)                        \
   EXPRESSION_NODE_LIST(V)
 
 // Forward declarations
 class AstConstructionVisitor;
@@ skipping 445 matching lines @@
     // At the moment there are no "const functions" in JavaScript...
     DCHECK(mode == VAR || mode == LET);
     DCHECK(fun != NULL);
   }
 
  private:
   FunctionLiteral* fun_;
 };
 
 
+class ClassDeclaration FINAL : public Declaration {
+ public:
+  DECLARE_NODE_TYPE(ClassDeclaration)
+
+  ClassLiteral* classLiteral() const { return classLiteral_; }
+  virtual InitializationFlag initialization() const OVERRIDE {
+    return kCreatedInitialized;
+  }
+
+ protected:
+  ClassDeclaration(Zone* zone, VariableProxy* proxy, ClassLiteral* classLiteral,
+                   Scope* scope, int pos)
+      : Declaration(zone, proxy, LET, scope, pos), classLiteral_(classLiteral) {
+    DCHECK(classLiteral != NULL);
+  }
+
+ private:
+  ClassLiteral* classLiteral_;
+};
+
+
 class ModuleDeclaration FINAL : public Declaration {
  public:
   DECLARE_NODE_TYPE(ModuleDeclaration)
 
   Module* module() const { return module_; }
   virtual InitializationFlag initialization() const OVERRIDE {
     return kCreatedInitialized;
   }
 
  protected:
@@ skipping 879 matching lines @@
  public:
   enum Kind {
     CONSTANT,              // Property with constant value (compile time).
     COMPUTED,              // Property with computed value (execution time).
     MATERIALIZED_LITERAL,  // Property value is a materialized literal.
     GETTER, SETTER,        // Property is an accessor function.
     PROTOTYPE              // Property is __proto__.
   };
 
   ObjectLiteralProperty(Zone* zone, AstValueFactory* ast_value_factory,
-                        Literal* key, Expression* value);
+                        Literal* key, Expression* value,
+                        bool is_static = false);
 
   Literal* key() { return key_; }
   Expression* value() { return value_; }
   Kind kind() { return kind_; }
 
   // Type feedback information.
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   bool IsMonomorphic() { return !receiver_type_.is_null(); }
   Handle<Map> GetReceiverType() { return receiver_type_; }
 
   bool IsCompileTimeValue();
 
   void set_emit_store(bool emit_store);
   bool emit_store();
 
  protected:
   template<class> friend class AstNodeFactory;
 
-  ObjectLiteralProperty(Zone* zone, bool is_getter, FunctionLiteral* value);
+  ObjectLiteralProperty(Zone* zone, bool is_getter, FunctionLiteral* value,
+                        bool is_static = false);
   void set_key(Literal* key) { key_ = key; }
 
  private:
   Literal* key_;
   Expression* value_;
   Kind kind_;
   bool emit_store_;
   Handle<Map> receiver_type_;
+  bool is_static_;
 };
 
 
 // An object literal has a boilerplate object that is used
 // for minimizing the work when constructing it at runtime.
 class ObjectLiteral FINAL : public MaterializedLiteral {
  public:
   typedef ObjectLiteralProperty Property;
 
   DECLARE_NODE_TYPE(ObjectLiteral)
@@ skipping 991 matching lines @@
   class IsExpression : public BitField<bool, 0, 1> {};
   class IsAnonymous : public BitField<bool, 1, 1> {};
   class Pretenure : public BitField<bool, 2, 1> {};
   class HasDuplicateParameters : public BitField<ParameterFlag, 3, 1> {};
   class IsFunction : public BitField<IsFunctionFlag, 4, 1> {};
   class IsParenthesized : public BitField<IsParenthesizedFlag, 5, 1> {};
   class FunctionKindBits : public BitField<FunctionKind, 6, 3> {};
 };
 
 
+class ClassLiteral FINAL : public Expression {
+ public:
+  typedef ObjectLiteralProperty Property;
+
+  DECLARE_NODE_TYPE(ClassLiteral)
+
+  Handle<String> name() const { return raw_name_->string(); }
+  const AstRawString* raw_name() const { return raw_name_; }
+  Expression* extends() const { return extends_; }
+  ZoneList<Property*>* properties() const { return properties_; }
+
+ protected:
+  ClassLiteral(Zone* zone, const AstRawString* name, Expression* extends,
+               ZoneList<Property*>* properties,
+               AstValueFactory* ast_value_factory, int position, IdGen* id_gen)
+      : Expression(zone, position, id_gen),
+        raw_name_(name),
+        raw_inferred_name_(ast_value_factory->empty_string()),
+        extends_(extends),
+        properties_(properties) {}
+
+ private:
+  const AstRawString* raw_name_;
+  Handle<String> name_;
+  const AstString* raw_inferred_name_;
+  Handle<String> inferred_name_;
+  Expression* extends_;
+  ZoneList<Property*>* properties_;
+};
+
+
 class NativeFunctionLiteral FINAL : public Expression {
  public:
   DECLARE_NODE_TYPE(NativeFunctionLiteral)
 
   Handle<String> name() const { return name_->string(); }
   v8::Extension* extension() const { return extension_; }
 
  protected:
   NativeFunctionLiteral(Zone* zone, const AstRawString* name,
                         v8::Extension* extension, int pos, IdGen* id_gen)
@@ skipping 534 matching lines @@
   FunctionDeclaration* NewFunctionDeclaration(VariableProxy* proxy,
                                               VariableMode mode,
                                               FunctionLiteral* fun,
                                               Scope* scope,
                                               int pos) {
     FunctionDeclaration* decl =
         new(zone_) FunctionDeclaration(zone_, proxy, mode, fun, scope, pos);
     VISIT_AND_RETURN(FunctionDeclaration, decl)
   }
 
+  ClassDeclaration* NewClassDeclaration(VariableProxy* proxy, ClassLiteral* lit,
+                                        Scope* scope, int pos) {
+    ClassDeclaration* decl =
+        new (zone_) ClassDeclaration(zone_, proxy, lit, scope, pos);
+    VISIT_AND_RETURN(ClassDeclaration, decl)
+  }
+
   ModuleDeclaration* NewModuleDeclaration(VariableProxy* proxy,
                                           Module* module,
                                           Scope* scope,
                                           int pos) {
     ModuleDeclaration* decl =
         new(zone_) ModuleDeclaration(zone_, proxy, module, scope, pos);
     VISIT_AND_RETURN(ModuleDeclaration, decl)
   }
 
   ImportDeclaration* NewImportDeclaration(VariableProxy* proxy,
@@ skipping 217 matching lines @@
       int boilerplate_properties,
       bool has_function,
       int pos) {
     ObjectLiteral* lit = new (zone_)
         ObjectLiteral(zone_, properties, literal_index, boilerplate_properties,
                       has_function, pos, id_gen_);
     VISIT_AND_RETURN(ObjectLiteral, lit)
   }
 
   ObjectLiteral::Property* NewObjectLiteralProperty(Literal* key,
-                                                    Expression* value) {
-    return new (zone_)
-        ObjectLiteral::Property(zone_, ast_value_factory_, key, value);
+                                                    Expression* value,
+                                                    bool is_static) {
+    return new (zone_) ObjectLiteral::Property(zone_, ast_value_factory_, key,
+                                               value, is_static);
   }
 
   ObjectLiteral::Property* NewObjectLiteralProperty(bool is_getter,
                                                     FunctionLiteral* value,
-                                                    int pos) {
+                                                    int pos, bool is_static) {
     ObjectLiteral::Property* prop =
-        new(zone_) ObjectLiteral::Property(zone_, is_getter, value);
+        new (zone_) ObjectLiteral::Property(zone_, is_getter, value, is_static);
     prop->set_key(NewStringLiteral(value->raw_name(), pos));
     return prop;  // Not an AST node, will not be visited.
   }
 
   RegExpLiteral* NewRegExpLiteral(const AstRawString* pattern,
                                   const AstRawString* flags,
                                   int literal_index,
                                   int pos) {
     RegExpLiteral* lit = new (zone_)
         RegExpLiteral(zone_, pattern, flags, literal_index, pos, id_gen_);
@@ skipping 135 matching lines @@
         expected_property_count, handler_count, parameter_count, function_type,
         has_duplicate_parameters, is_function, is_parenthesized, kind, position,
         id_gen_);
     // Top-level literal doesn't count for the AST's properties.
     if (is_function == FunctionLiteral::kIsFunction) {
       visitor_.VisitFunctionLiteral(lit);
     }
     return lit;
   }
 
+  ClassLiteral* NewClassLiteral(const AstRawString* name, Expression* extends,
+                                ZoneList<ObjectLiteral::Property*>* properties,
+                                AstValueFactory* ast_value_factory,
+                                int position) {
+    ClassLiteral* lit = new (zone_) ClassLiteral(
+        zone_, name, extends, properties, ast_value_factory, position, id_gen_);
+    VISIT_AND_RETURN(ClassLiteral, lit)
+  }
+
   NativeFunctionLiteral* NewNativeFunctionLiteral(const AstRawString* name,
                                                   v8::Extension* extension,
                                                   int pos) {
     NativeFunctionLiteral* lit =
         new (zone_) NativeFunctionLiteral(zone_, name, extension, pos, id_gen_);
     VISIT_AND_RETURN(NativeFunctionLiteral, lit)
   }
 
   ThisFunction* NewThisFunction(int pos) {
     ThisFunction* fun = new (zone_) ThisFunction(zone_, pos, id_gen_);
@@ skipping 12 matching lines @@
   Zone* zone_;
   Visitor visitor_;
   AstValueFactory* ast_value_factory_;
   AstNode::IdGen* id_gen_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_