MaterializedLiteral expressions need to cache expression depth.

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 1391 matching lines @@
 };
 
 
 // Base class for literals that needs space in the corresponding JSFunction.
 class MaterializedLiteral : public Expression {
  public:
   virtual MaterializedLiteral* AsMaterializedLiteral() { return this; }
 
   int literal_index() { return literal_index_; }
 
+  int depth() const {
+    // only callable after initialization.
+    ASSERT(depth_ >= 1);
+    return depth_;
+  }
+
  protected:
   MaterializedLiteral(Isolate* isolate,
                       int literal_index,
                       int pos)
       : Expression(isolate, pos),
         literal_index_(literal_index),
-        is_simple_(false) {}
+        is_simple_(false),
+        depth_(0) {}
 
   // 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_; }
   void set_is_simple(bool is_simple) { is_simple_ = is_simple; }
   friend class CompileTimeValue;
 
+  void set_depth(int depth) {
+    ASSERT(depth >= 1);
+    depth_ = depth;
+  }
+
   // Populate the constant properties/elements fixed array.
-  void BuildConstants(Isolate* isolate, int* depth);
+  void BuildConstants(Isolate* isolate);
   friend class ArrayLiteral;
   friend class ObjectLiteral;
 
   // If the expression is a literal, return the literal value;
   // if the expression is a materialized literal and is simple return a
   // compile time value as encoded by CompileTimeValue::GetValue().
   // Otherwise, return undefined literal as the placeholder
   // in the object literal boilerplate.
   Handle<Object> GetBoilerplateValue(Expression* expression, Isolate* isolate);
 
  private:
   int literal_index_;
   bool is_simple_;
+  int depth_;
 };
 
 
 // Property is used for passing information
 // about an object literal's properties from the parser
 // to the code generator.
 class ObjectLiteralProperty V8_FINAL : public ZoneObject {
  public:
   enum Kind {
     CONSTANT,              // Property with constant value (compile time).
@@ skipping 47 matching lines @@
   }
   ZoneList<Property*>* properties() const { return properties_; }
   bool fast_elements() const { return fast_elements_; }
   bool may_store_doubles() const { return may_store_doubles_; }
   bool has_function() const { return has_function_; }
 
   // Decide if a property should be in the object boilerplate.
   static bool IsBoilerplateProperty(Property* property);
 
   // Populate the constant properties fixed array.
-  void BuildConstantProperties(Isolate* isolate, int* depth = NULL);
+  void BuildConstantProperties(Isolate* isolate);
 
   // Mark all computed expressions that are bound to a key that
   // is shadowed by a later occurrence of the same key. For the
   // marked expressions, no store code is emitted.
   void CalculateEmitStore(Zone* zone);
 
   enum Flags {
     kNoFlags = 0,
     kFastElements = 1,
     kHasFunction = 1 << 1
@@ skipping 38 matching lines @@
   Handle<String> flags() const { return flags_; }
 
  protected:
   RegExpLiteral(Isolate* isolate,
                 Handle<String> pattern,
                 Handle<String> flags,
                 int literal_index,
                 int pos)
       : MaterializedLiteral(isolate, literal_index, pos),
         pattern_(pattern),
-        flags_(flags) {}
+        flags_(flags) {
+    set_depth(1);
+  }
 
  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 V8_FINAL : public MaterializedLiteral {
  public:
   DECLARE_NODE_TYPE(ArrayLiteral)
 
   Handle<FixedArray> constant_elements() const { return constant_elements_; }
   ZoneList<Expression*>* values() const { return values_; }
 
   // Return an AST id for an element that is used in simulate instructions.
   BailoutId GetIdForElement(int i) {
     return BailoutId(first_element_id_.ToInt() + i);
   }
 
   // Populate the constant elements fixed array.
-  void BuildConstantElements(Isolate* isolate, int* depth = NULL);
+  void BuildConstantElements(Isolate* isolate);
 
  protected:
   ArrayLiteral(Isolate* isolate,
                ZoneList<Expression*>* values,
                int literal_index,
                int pos)
       : MaterializedLiteral(isolate, literal_index, pos),
         values_(values),
         first_element_id_(ReserveIdRange(isolate, values->length())) {}
 
@@ skipping 1669 matching lines @@
  private:
   Isolate* isolate_;
   Zone* zone_;
   Visitor visitor_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_