Optimizing generation of nested literals for both object and array literals.

src/ast.h

 // Copyright 2006-2008 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 77 matching lines @@
   V(CallRuntime)                                \
   V(UnaryOperation)                             \
   V(CountOperation)                             \
   V(BinaryOperation)                            \
   V(CompareOperation)                           \
   V(ThisFunction)
 
 
 // Forward declarations
 class TargetCollector;
+class MaterializedLiteral;
 
 #define DEF_FORWARD_DECLARATION(type) class type;
 NODE_LIST(DEF_FORWARD_DECLARATION)
 #undef DEF_FORWARD_DECLARATION
 
 
 // Typedef only introduced to avoid unreadable code.
 // Please do appreciate the required space in "> >".
 typedef ZoneList<Handle<String> > ZoneStringList;
 
@@ skipping 14 matching lines @@
   virtual VariableProxy* AsVariableProxy() { return NULL; }
   virtual Property* AsProperty() { return NULL; }
   virtual Call* AsCall() { return NULL; }
   virtual TargetCollector* AsTargetCollector() { return NULL; }
   virtual BreakableStatement* AsBreakableStatement() { return NULL; }
   virtual IterationStatement* AsIterationStatement() { return NULL; }
   virtual UnaryOperation* AsUnaryOperation() { return NULL; }
   virtual BinaryOperation* AsBinaryOperation() { return NULL; }
   virtual Assignment* AsAssignment() { return NULL; }
   virtual FunctionLiteral* AsFunctionLiteral() { return NULL; }
+  virtual MaterializedLiteral* AsMaterializedLiteral() { return NULL; }
   virtual ObjectLiteral* AsObjectLiteral() { return NULL; }
+  virtual ArrayLiteral* AsArrayLiteral() { return NULL; }
 
   void set_statement_pos(int statement_pos) { statement_pos_ = statement_pos; }
   int statement_pos() const { return statement_pos_; }
 
  private:
   int statement_pos_;
 };
 
 
 class Statement: public Node {
@@ skipping 483 matching lines @@
   Handle<Object> handle() const { return handle_; }
 
  private:
   Handle<Object> handle_;
 };
 
 
 // Base class for literals that needs space in the corresponding JSFunction.
 class MaterializedLiteral: public Expression {
  public:
-  explicit MaterializedLiteral(int literal_index)
-      : literal_index_(literal_index) {}
+  explicit MaterializedLiteral(int literal_index, bool is_simple)
+      : literal_index_(literal_index), is_simple_(is_simple) {}
+
+  virtual MaterializedLiteral* AsMaterializedLiteral() { return this; }
+
   int literal_index() { return literal_index_; }
+
+  // A materialized literal is simple if the values consist of only
+  // constants and simple object and array literals.
+  bool is_simple() const { return is_simple_; }
+
  private:
   int literal_index_;
+  bool is_simple_;
 };
 
 
 // An object literal has a boilerplate object that is used
 // for minimizing the work when constructing it at runtime.
 class ObjectLiteral: public MaterializedLiteral {
  public:
   // Property is used for passing information
   // about an object literal's properties from the parser
   // to the code generator.
   class Property: public ZoneObject {
    public:
 
     enum Kind {
-      CONSTANT,        // Property with constant value (at compile time).
-      COMPUTED,        // Property with computed value (at execution time).
-      OBJECT_LITERAL,  // Property value is an object literal.
-      GETTER, SETTER,  // Property is an accessor function.
-      PROTOTYPE        // Property is __proto__.
+      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__.
     };
 
     Property(Literal* key, Expression* value);
     Property(bool is_getter, FunctionLiteral* value);
 
     Literal* key() { return key_; }
     Expression* value() { return value_; }
     Kind kind() { return kind_; }
 
    private:
     Literal* key_;
     Expression* value_;
     Kind kind_;
   };
 
   ObjectLiteral(Handle<FixedArray> constant_properties,
                 ZoneList<Property*>* properties,
                 int literal_index,
                 bool is_simple)
-      : MaterializedLiteral(literal_index),
+      : MaterializedLiteral(literal_index, is_simple),
         constant_properties_(constant_properties),
-        properties_(properties),
-        is_simple_(is_simple) {
-  }
+        properties_(properties) {}
 
   virtual ObjectLiteral* AsObjectLiteral() { return this; }
   virtual void Accept(AstVisitor* v);
 
   Handle<FixedArray> constant_properties() const {
     return constant_properties_;
   }
   ZoneList<Property*>* properties() const { return properties_; }
 
-  // An object literal is simple if the values consist of only
-  // constants and simple object literals.
-  bool is_simple() const { return is_simple_; }
-
  private:
   Handle<FixedArray> constant_properties_;
   ZoneList<Property*>* properties_;
-  bool is_simple_;
 };
 
 
 // Node for capturing a regexp literal.
 class RegExpLiteral: public MaterializedLiteral {
  public:
   RegExpLiteral(Handle<String> pattern,
                 Handle<String> flags,
                 int literal_index)
-      : MaterializedLiteral(literal_index),
+      : MaterializedLiteral(literal_index, false),
         pattern_(pattern),
         flags_(flags) {}
 
   virtual void Accept(AstVisitor* v);
 
   Handle<String> pattern() const { return pattern_; }
   Handle<String> flags() const { return flags_; }
 
  private:
   Handle<String> pattern_;
   Handle<String> flags_;
 };
 
 // An array literal has a literals object that is used
 // for minimizing the work when constructing it at runtime.
-class ArrayLiteral: public Expression {
+class ArrayLiteral: public MaterializedLiteral {
  public:
   ArrayLiteral(Handle<FixedArray> literals,
-               ZoneList<Expression*>* values)
-      : literals_(literals), values_(values) {
-  }
+               ZoneList<Expression*>* values,
+               int literal_index,
+               bool is_simple)
+      : MaterializedLiteral(literal_index, is_simple),
+        literals_(literals),
+        values_(values) {}
 
   virtual void Accept(AstVisitor* v);
+  virtual ArrayLiteral* AsArrayLiteral() { return this; }
 
   Handle<FixedArray> literals() const { return literals_; }
   ZoneList<Expression*>* values() const { return values_; }
 
  private:
   Handle<FixedArray> literals_;
   ZoneList<Expression*>* values_;
 };
 
 
@@ skipping 923 matching lines @@
 #undef DEF_VISIT
 
  private:
   bool stack_overflow_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_