Split AST Declaration class, in preparation for new module declaration forms.

src/ast.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 41 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)                        \
+
 #define STATEMENT_NODE_LIST(V)                  \
   V(Block)                                      \
   V(ExpressionStatement)                        \
   V(EmptyStatement)                             \
   V(IfStatement)                                \
   V(ContinueStatement)                          \
   V(BreakStatement)                             \
   V(ReturnStatement)                            \
   V(WithStatement)                              \
   V(SwitchStatement)                            \
@@ skipping 20 matching lines @@
   V(Call)                                       \
   V(CallNew)                                    \
   V(CallRuntime)                                \
   V(UnaryOperation)                             \
   V(CountOperation)                             \
   V(BinaryOperation)                            \
   V(CompareOperation)                           \
   V(ThisFunction)
 
 #define AST_NODE_LIST(V)                        \
-  V(Declaration)                                \
+  DECLARATION_NODE_LIST(V)                      \
   STATEMENT_NODE_LIST(V)                        \
   EXPRESSION_NODE_LIST(V)
 
 // Forward declarations
 class AstConstructionVisitor;
 template<class> class AstNodeFactory;
 class AstVisitor;
+class Declaration;
 class BreakableStatement;
 class Expression;
 class IterationStatement;
 class MaterializedLiteral;
 class Statement;
 class TargetCollector;
 class TypeFeedbackOracle;
 
 class RegExpAlternative;
 class RegExpAssertion;
@@ skipping 75 matching lines @@
   virtual void Accept(AstVisitor* v) = 0;
   virtual Type node_type() const { return kInvalid; }
 
   // Type testing & conversion functions overridden by concrete subclasses.
 #define DECLARE_NODE_FUNCTIONS(type)                  \
   bool Is##type() { return node_type() == AstNode::k##type; }          \
   type* As##type() { return Is##type() ? reinterpret_cast<type*>(this) : NULL; }
   AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
+  virtual Declaration* AsDeclaration() { return NULL; }
   virtual Statement* AsStatement() { return NULL; }
   virtual Expression* AsExpression() { return NULL; }
   virtual TargetCollector* AsTargetCollector() { return NULL; }
   virtual BreakableStatement* AsBreakableStatement() { return NULL; }
   virtual IterationStatement* AsIterationStatement() { return NULL; }
   virtual MaterializedLiteral* AsMaterializedLiteral() { return NULL; }
 
   static void ResetIds() { Isolate::Current()->set_ast_node_id(0); }
 
  protected:
@@ skipping 211 matching lines @@
 
  private:
   ZoneList<Statement*> statements_;
   bool is_initializer_block_;
   Scope* block_scope_;
 };
 
 
 class Declaration: public AstNode {
  public:
-  DECLARE_NODE_TYPE(Declaration)
-
   VariableProxy* proxy() const { return proxy_; }
   VariableMode mode() const { return mode_; }
-  FunctionLiteral* fun() const { return fun_; }  // may be NULL
-  bool IsInlineable() const;
   Scope* scope() const { return scope_; }
+  virtual bool IsInlineable() const;

[Kevin Millikin (Chromium), 2012/02/08 15:23:04]

I think this method is obsolete (and the check in hydrogen.cc is unnecessary),
because the declaration's inline-ability is already recorded in the function
containing it.  Talk to jkummerow.

[Jakob Kummerow, 2012/02/08 15:40:28]

This is true for all AstNodes *except* Declarations, because inline-ability of
declarations is not known yet when the AstNodeFactory creates them.

[rossberg, 2012/02/08 15:46:43]

I can't tell, but according to Jakob, the info is available for all AstNodes,
except Declarations, because they are kind of special, e.g. because they live in
the scope.

+
+  virtual Declaration* AsDeclaration() { return this; }
+  virtual VariableDeclaration* AsVariableDeclaration() { return NULL; }
 
  protected:
   template<class> friend class AstNodeFactory;

[Jakob Kummerow, 2012/02/08 15:40:28]

I think you don't need this any more.

[rossberg, 2012/02/08 15:52:21]

Done.

 
   Declaration(VariableProxy* proxy,
               VariableMode mode,
-              FunctionLiteral* fun,
               Scope* scope)
       : proxy_(proxy),
         mode_(mode),
-        fun_(fun),
         scope_(scope) {
     ASSERT(mode == VAR ||
            mode == CONST ||
            mode == CONST_HARMONY ||
            mode == LET);
-    // At the moment there are no "const functions"'s in JavaScript...
-    ASSERT(fun == NULL || mode == VAR || mode == LET);
   }
 
  private:
   VariableProxy* proxy_;
   VariableMode mode_;
-  FunctionLiteral* fun_;
 
   // Nested scope from which the declaration originated.
   Scope* scope_;
 };
 
 
+class VariableDeclaration: public Declaration {

[Kevin Millikin (Chromium), 2012/02/08 15:23:04]

It's a little weird that VariableDeclaration includes 'function' and 'const' as
well as 'var' and 'let'.  Does the (proposed) ES grammar have a name for those
things?

[rossberg, 2012/02/08 15:46:43]

Not yet, it currently still just calls them "declarations" collectively, because
modules haven't made it into the draft yet. The grammar in the modules proposal
uses VariableDeclaration to include 'const' (it seems), but not 'function'.

Would LocalDeclaration be better? (Those are the ones that are allowed locally,
although they may also appear in global or module scope.)

+ public:
+  VariableDeclaration(VariableProxy* proxy,

[Jakob Kummerow, 2012/02/08 15:40:28]

Suggestion: Move the constructor to a "protected:" section and add a
"template<class> friend class AstNodeFactory;" in that section too, then the
compiler will enforce for you that nobody accidentally calls the c'tor directly.

[rossberg, 2012/02/08 15:52:21]

Done.

+                      VariableMode mode,
+                      FunctionLiteral* fun,
+                      Scope* scope)
+      : Declaration(proxy, mode, scope),
+        fun_(fun) {
+    // At the moment there are no "const functions"'s in JavaScript...
+    ASSERT(fun == NULL || mode == VAR || mode == LET);
+  }
+
+  DECLARE_NODE_TYPE(VariableDeclaration)
+
+  virtual VariableDeclaration* AsVariableDeclaration() { return this; }
+
+  FunctionLiteral* fun() const { return fun_; }  // may be NULL
+  virtual bool IsInlineable() const;
+
+ private:
+  FunctionLiteral* fun_;
+};
+
+
 class IterationStatement: public BreakableStatement {
  public:
   // Type testing & conversion.
   virtual IterationStatement* AsIterationStatement() { return this; }
 
   Statement* body() const { return body_; }
 
   // Bailout support.
   int OsrEntryId() const { return osr_entry_id_; }
   virtual int ContinueId() const = 0;
@@ skipping 1878 matching lines @@
   explicit AstNodeFactory(Isolate* isolate)
       : isolate_(isolate),
         zone_(isolate_->zone()) { }
 
   Visitor* visitor() { return &visitor_; }
 
 #define VISIT_AND_RETURN(NodeType, node) \
   visitor_.Visit##NodeType((node)); \
   return node;
 
+  VariableDeclaration* NewVariableDeclaration(VariableProxy* proxy,
+                                              VariableMode mode,
+                                              FunctionLiteral* fun,
+                                              Scope* scope) {
+    VariableDeclaration* decl =
+        new(zone_) VariableDeclaration(proxy, mode, fun, scope);
+    VISIT_AND_RETURN(VariableDeclaration, decl)
+  }
+
   Block* NewBlock(ZoneStringList* labels,
                   int capacity,
                   bool is_initializer_block) {
     Block* block = new(zone_) Block(
         isolate_, labels, capacity, is_initializer_block);
     VISIT_AND_RETURN(Block, block)
   }
 
-  Declaration* NewDeclaration(VariableProxy* proxy,
-                              VariableMode mode,
-                              FunctionLiteral* fun,
-                              Scope* scope) {
-    Declaration* decl = new(zone_) Declaration(proxy, mode, fun, scope);
-    VISIT_AND_RETURN(Declaration, decl)
-  }
-
 #define STATEMENT_WITH_LABELS(NodeType) \
   NodeType* New##NodeType(ZoneStringList* labels) { \
     NodeType* stmt = new(zone_) NodeType(isolate_, labels); \
     VISIT_AND_RETURN(NodeType, stmt); \
   }
   STATEMENT_WITH_LABELS(DoWhileStatement)
   STATEMENT_WITH_LABELS(WhileStatement)
   STATEMENT_WITH_LABELS(ForStatement)
   STATEMENT_WITH_LABELS(ForInStatement)
   STATEMENT_WITH_LABELS(SwitchStatement)
@@ skipping 251 matching lines @@
  private:
   Isolate* isolate_;
   Zone* zone_;
   Visitor visitor_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_