Add a predicate IsPrimitive to AST Expression nodes.

src/ast.h

 // Copyright 2010 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 202 matching lines @@
 
   // True if the expression does not have (evaluated) subexpressions.
   // Function literals are leaves because their subexpressions are not
   // evaluated.
   virtual bool IsLeaf() { return false; }
 
   // True if the expression has no side effects and is safe to
   // evaluate out of order.
   virtual bool IsTrivial() { return false; }
 
+  // True if the expression always has one of the non-Object JS types
+  // (Undefined, Null, Boolean, String, or Number).
+  virtual bool IsPrimitive() = 0;
+
   // Mark the expression as being compiled as an expression
   // statement. This is used to transform postfix increments to
   // (faster) prefix increments.
   virtual void MarkAsStatement() { /* do nothing */ }
 
   // Static type information for this expression.
   StaticType* type() { return &type_; }
 
   // Data flow information.
   DefinitionInfo* var_def() { return def_; }
@@ skipping 40 matching lines @@
 /**
  * A sentinel used during pre parsing that represents some expression
  * that is a valid left hand side without having to actually build
  * the expression.
  */
 class ValidLeftHandSideSentinel: public Expression {
  public:
   virtual bool IsValidLeftHandSide() { return true; }
   virtual void Accept(AstVisitor* v) { UNREACHABLE(); }
   static ValidLeftHandSideSentinel* instance() { return &instance_; }
+
+  virtual bool IsPrimitive() { UNREACHABLE(); return false; }
+
  private:
   static ValidLeftHandSideSentinel instance_;
 };
 
 
 class BreakableStatement: public Statement {
  public:
   enum Type {
     TARGET_FOR_ANONYMOUS,
     TARGET_FOR_NAMED_ONLY
@@ skipping 498 matching lines @@
   virtual bool IsPropertyName() {
     if (handle_->IsSymbol()) {
       uint32_t ignored;
       return !String::cast(*handle_)->AsArrayIndex(&ignored);
     }
     return false;
   }
 
   virtual bool IsLeaf() { return true; }
   virtual bool IsTrivial() { return true; }
+  virtual bool IsPrimitive();
 
   // Identity testers.
   bool IsNull() const { return handle_.is_identical_to(Factory::null_value()); }
   bool IsTrue() const { return handle_.is_identical_to(Factory::true_value()); }
   bool IsFalse() const {
     return handle_.is_identical_to(Factory::false_value());
   }
 
   Handle<Object> handle() const { return handle_; }
 
@@ skipping 67 matching lines @@
       : MaterializedLiteral(literal_index, is_simple, depth),
         constant_properties_(constant_properties),
         properties_(properties),
         fast_elements_(fast_elements) {}
 
   virtual ObjectLiteral* AsObjectLiteral() { return this; }
   virtual void Accept(AstVisitor* v);
 
   virtual bool IsLeaf() { return properties()->is_empty(); }
 
+  virtual bool IsPrimitive();
+
   Handle<FixedArray> constant_properties() const {
     return constant_properties_;
   }
   ZoneList<Property*>* properties() const { return properties_; }
 
   bool fast_elements() const { return fast_elements_; }
 
  private:
   Handle<FixedArray> constant_properties_;
   ZoneList<Property*>* properties_;
   bool fast_elements_;
 };
 
 
 // Node for capturing a regexp literal.
 class RegExpLiteral: public MaterializedLiteral {
  public:
   RegExpLiteral(Handle<String> pattern,
                 Handle<String> flags,
                 int literal_index)
       : MaterializedLiteral(literal_index, false, 1),
         pattern_(pattern),
         flags_(flags) {}
 
   virtual void Accept(AstVisitor* v);
 
   virtual bool IsLeaf() { return true; }
 
+  virtual bool IsPrimitive();
+
   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 MaterializedLiteral {
  public:
   ArrayLiteral(Handle<FixedArray> constant_elements,
                ZoneList<Expression*>* values,
                int literal_index,
                bool is_simple,
                int depth)
       : MaterializedLiteral(literal_index, is_simple, depth),
         constant_elements_(constant_elements),
         values_(values) {}
 
   virtual void Accept(AstVisitor* v);
   virtual ArrayLiteral* AsArrayLiteral() { return this; }
 
   virtual bool IsLeaf() { return values()->is_empty(); }
 
+  virtual bool IsPrimitive();
+
   Handle<FixedArray> constant_elements() const { return constant_elements_; }
   ZoneList<Expression*>* values() const { return values_; }
 
  private:
   Handle<FixedArray> constant_elements_;
   ZoneList<Expression*>* values_;
 };
 
 
 // Node for constructing a context extension object for a catch block.
 // The catch context extension object has one property, the catch
 // variable, which should be DontDelete.
 class CatchExtensionObject: public Expression {
  public:
   CatchExtensionObject(Literal* key, VariableProxy* value)
       : key_(key), value_(value) {
   }
 
   virtual void Accept(AstVisitor* v);
 
+  virtual bool IsPrimitive();
+
   Literal* key() const { return key_; }
   VariableProxy* value() const { return value_; }
 
  private:
   Literal* key_;
   VariableProxy* value_;
 };
 
 
 class VariableProxy: public Expression {
@@ skipping 16 matching lines @@
 
   virtual bool IsLeaf() {
     ASSERT(var_ != NULL);  // Variable must be resolved.
     return var()->is_global() || var()->rewrite()->IsLeaf();
   }
 
   // Reading from a mutable variable is a side effect, but 'this' is
   // immutable.
   virtual bool IsTrivial() { return is_trivial_; }
 
+  virtual bool IsPrimitive();
+
   bool IsVariable(Handle<String> n) {
     return !is_this() && name().is_identical_to(n);
   }
 
   bool IsArguments() {
     Variable* variable = AsVariable();
     return (variable == NULL) ? false : variable->is_arguments();
   }
 
   Handle<String> name() const  { return name_; }
@@ skipping 21 matching lines @@
 
 
 class VariableProxySentinel: public VariableProxy {
  public:
   virtual bool IsValidLeftHandSide() { return !is_this(); }
   static VariableProxySentinel* this_proxy() { return &this_proxy_; }
   static VariableProxySentinel* identifier_proxy() {
     return &identifier_proxy_;
   }
 
+  virtual bool IsPrimitive() { UNREACHABLE(); return false; }
+
  private:
   explicit VariableProxySentinel(bool is_this) : VariableProxy(is_this) { }
   static VariableProxySentinel this_proxy_;
   static VariableProxySentinel identifier_proxy_;
 };
 
 
 class Slot: public Expression {
  public:
   enum Type {
@@ skipping 23 matching lines @@
     ASSERT(var != NULL);
   }
 
   virtual void Accept(AstVisitor* v);
 
   // Type testing & conversion
   virtual Slot* AsSlot() { return this; }
 
   virtual bool IsLeaf() { return true; }
 
+  virtual bool IsPrimitive() { UNREACHABLE(); return false; }
+
   bool IsStackAllocated() { return type_ == PARAMETER || type_ == LOCAL; }
 
   // Accessors
   Variable* var() const { return var_; }
   Type type() const { return type_; }
   int index() const { return index_; }
   bool is_arguments() const { return var_->is_arguments(); }
 
  private:
   Variable* var_;
@@ skipping 12 matching lines @@
   Property(Expression* obj, Expression* key, int pos, Type type = NORMAL)
       : obj_(obj), key_(key), pos_(pos), type_(type) { }
 
   virtual void Accept(AstVisitor* v);
 
   // Type testing & conversion
   virtual Property* AsProperty() { return this; }
 
   virtual bool IsValidLeftHandSide() { return true; }
 
+  virtual bool IsPrimitive();
+
   Expression* obj() const { return obj_; }
   Expression* key() const { return key_; }
   int position() const { return pos_; }
   bool is_synthetic() const { return type_ == SYNTHETIC; }
 
   // Returns a property singleton property access on 'this'.  Used
   // during preparsing.
   static Property* this_property() { return &this_property_; }
 
  private:
@@ skipping 10 matching lines @@
 class Call: public Expression {
  public:
   Call(Expression* expression, ZoneList<Expression*>* arguments, int pos)
       : expression_(expression), arguments_(arguments), pos_(pos) { }
 
   virtual void Accept(AstVisitor* v);
 
   // Type testing and conversion.
   virtual Call* AsCall() { return this; }
 
+  virtual bool IsPrimitive();
+
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
   int position() { return pos_; }
 
   static Call* sentinel() { return &sentinel_; }
 
  private:
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
   int pos_;
 
   static Call sentinel_;
 };
 
 
 class CallNew: public Expression {
  public:
   CallNew(Expression* expression, ZoneList<Expression*>* arguments, int pos)
       : expression_(expression), arguments_(arguments), pos_(pos) { }
 
   virtual void Accept(AstVisitor* v);
 
+  virtual bool IsPrimitive();
+
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
   int position() { return pos_; }
 
  private:
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
   int pos_;
 };
 
 
 // The CallRuntime class does not represent any official JavaScript
 // language construct. Instead it is used to call a C or JS function
 // with a set of arguments. This is used from the builtins that are
 // implemented in JavaScript (see "v8natives.js").
 class CallRuntime: public Expression {
  public:
   CallRuntime(Handle<String> name,
               Runtime::Function* function,
               ZoneList<Expression*>* arguments)
       : name_(name), function_(function), arguments_(arguments) { }
 
   virtual void Accept(AstVisitor* v);
 
+  virtual bool IsPrimitive();
+
   Handle<String> name() const { return name_; }
   Runtime::Function* function() const { return function_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
   bool is_jsruntime() const { return function_ == NULL; }
 
  private:
   Handle<String> name_;
   Runtime::Function* function_;
   ZoneList<Expression*>* arguments_;
 };
 
 
 class UnaryOperation: public Expression {
  public:
   UnaryOperation(Token::Value op, Expression* expression)
       : op_(op), expression_(expression) {
     ASSERT(Token::IsUnaryOp(op));
   }
 
   virtual void Accept(AstVisitor* v);
 
   // Type testing & conversion
   virtual UnaryOperation* AsUnaryOperation() { return this; }
 
+  virtual bool IsPrimitive();
+
   Token::Value op() const { return op_; }
   Expression* expression() const { return expression_; }
 
  private:
   Token::Value op_;
   Expression* expression_;
 };
 
 
 class BinaryOperation: public Expression {
  public:
   BinaryOperation(Token::Value op, Expression* left, Expression* right)
       : op_(op), left_(left), right_(right) {
     ASSERT(Token::IsBinaryOp(op));
   }
 
   virtual void Accept(AstVisitor* v);
 
   // Type testing & conversion
   virtual BinaryOperation* AsBinaryOperation() { return this; }
 
+  virtual bool IsPrimitive();
+
   // True iff the result can be safely overwritten (to avoid allocation).
   // False for operations that can return one of their operands.
   bool ResultOverwriteAllowed() {
     switch (op_) {
       case Token::COMMA:
       case Token::OR:
       case Token::AND:
         return false;
       case Token::BIT_OR:
       case Token::BIT_XOR:
@@ skipping 32 matching lines @@
   }
 
   virtual void Accept(AstVisitor* v);
 
   virtual CountOperation* AsCountOperation() { return this; }
 
   virtual Variable* AssignedVar() {
     return expression()->AsVariableProxy()->AsVariable();
   }
 
+  virtual bool IsPrimitive();
+
   bool is_prefix() const { return is_prefix_; }
   bool is_postfix() const { return !is_prefix_; }
   Token::Value op() const { return op_; }
   Token::Value binary_op() {
     return op_ == Token::INC ? Token::ADD : Token::SUB;
   }
   Expression* expression() const { return expression_; }
 
   virtual void MarkAsStatement() { is_prefix_ = true; }
 
  private:
   bool is_prefix_;
   Token::Value op_;
   Expression* expression_;
 };
 
 
 class CompareOperation: public Expression {
  public:
   CompareOperation(Token::Value op, Expression* left, Expression* right)
       : op_(op), left_(left), right_(right), is_for_loop_condition_(false) {
     ASSERT(Token::IsCompareOp(op));
   }
 
   virtual void Accept(AstVisitor* v);
 
+  virtual bool IsPrimitive();
+
   Token::Value op() const { return op_; }
   Expression* left() const { return left_; }
   Expression* right() const { return right_; }
 
   // Accessors for flag whether this compare operation is hanging of a for loop.
   bool is_for_loop_condition() const { return is_for_loop_condition_; }
   void set_is_for_loop_condition() { is_for_loop_condition_ = true; }
 
   // Type testing & conversion
   virtual CompareOperation* AsCompareOperation() { return this; }
@@ skipping 10 matching lines @@
  public:
   Conditional(Expression* condition,
               Expression* then_expression,
               Expression* else_expression)
       : condition_(condition),
         then_expression_(then_expression),
         else_expression_(else_expression) { }
 
   virtual void Accept(AstVisitor* v);
 
+  virtual bool IsPrimitive();
+
   Expression* condition() const { return condition_; }
   Expression* then_expression() const { return then_expression_; }
   Expression* else_expression() const { return else_expression_; }
 
  private:
   Expression* condition_;
   Expression* then_expression_;
   Expression* else_expression_;
 };
 
 
 class Assignment: public Expression {
  public:
   Assignment(Token::Value op, Expression* target, Expression* value, int pos)
       : op_(op), target_(target), value_(value), pos_(pos),
         block_start_(false), block_end_(false) {
     ASSERT(Token::IsAssignmentOp(op));
   }
 
   virtual void Accept(AstVisitor* v);
   virtual Assignment* AsAssignment() { return this; }
 
+  virtual bool IsPrimitive();
+
   Assignment* AsSimpleAssignment() { return !is_compound() ? this : NULL; }
 
   virtual Variable* AssignedVar() {
     return target()->AsVariableProxy()->AsVariable();
   }
 
   Token::Value binary_op() const;
 
   Token::Value op() const { return op_; }
   Expression* target() const { return target_; }
@@ skipping 20 matching lines @@
   bool block_end_;
 };
 
 
 class Throw: public Expression {
  public:
   Throw(Expression* exception, int pos)
       : exception_(exception), pos_(pos) {}
 
   virtual void Accept(AstVisitor* v);
+
+  virtual bool IsPrimitive();
+
   Expression* exception() const { return exception_; }
   int position() const { return pos_; }
 
  private:
   Expression* exception_;
   int pos_;
 };
 
 
 class FunctionLiteral: public Expression {
@@ skipping 29 matching lines @@
 #endif
   }
 
   virtual void Accept(AstVisitor* v);
 
   // Type testing & conversion
   virtual FunctionLiteral* AsFunctionLiteral()  { return this; }
 
   virtual bool IsLeaf() { return true; }
 
+  virtual bool IsPrimitive();
+
   Handle<String> name() const  { return name_; }
   Scope* scope() const  { return scope_; }
   ZoneList<Statement*>* body() const  { return body_; }
   void set_function_token_position(int pos) { function_token_position_ = pos; }
   int function_token_position() const { return function_token_position_; }
   int start_position() const { return start_position_; }
   int end_position() const { return end_position_; }
   bool is_expression() const { return is_expression_; }
 
   int materialized_literal_count() { return materialized_literal_count_; }
@@ skipping 50 matching lines @@
       : boilerplate_(boilerplate) {
     ASSERT(boilerplate->IsBoilerplate());
   }
 
   Handle<JSFunction> boilerplate() const { return boilerplate_; }
 
   virtual bool IsLeaf() { return true; }
 
   virtual void Accept(AstVisitor* v);
 
+  virtual bool IsPrimitive();
+
  private:
   Handle<JSFunction> boilerplate_;
 };
 
 
 class ThisFunction: public Expression {
  public:
   virtual void Accept(AstVisitor* v);
   virtual bool IsLeaf() { return true; }
+  virtual bool IsPrimitive();
 };
 
 
 // ----------------------------------------------------------------------------
 // Regular expressions
 
 
 class RegExpVisitor BASE_EMBEDDED {
  public:
   virtual ~RegExpVisitor() { }
@@ skipping 377 matching lines @@
 #undef DEF_VISIT
 
  private:
   bool stack_overflow_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_