Remove some of the state-dependent behavior from the code generator....

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 122 matching lines @@
 
 class Statement: public Node {
  public:
   virtual Statement* AsStatement()  { return this; }
   virtual ReturnStatement* AsReturnStatement() { return NULL; }
 
   bool IsEmpty() { return AsEmptyStatement() != NULL; }
 };
 
 
+class Reference;
+
 class Expression: public Node {
  public:
   virtual Expression* AsExpression()  { return this; }
 
   virtual bool IsValidLeftHandSide() { return false; }
 
   // 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 */ }
+
+  // Generate code to store into an expression evaluated as the left-hand
+  // side of an assignment.  The code will expect the stored value on top of
+  // the expression stack, and a reference containing the expression
+  // immediately below that.  This function is overridden for expression
+  // types that can be stored into.
+  virtual void GenerateStoreCode(MacroAssembler* masm,
+                                 Scope* scope,
+                                 Reference* ref,
+                                 bool is_const_init) {

[iposva, 2008/09/10 18:01:44]

Can you please use an enum for the is_const_init to improve the readability at
the caller sites?

[Kevin Millikin (Chromium), 2008/09/11 07:15:55]

Done.  InitState with values CONST_INIT and NOT_CONST_INIT defined in ast.h for
now, but will move to a more logical place as the codegen state evolves.

+    UNREACHABLE();
+  }
 };
 
 
 /**
  * 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:
@@ skipping 583 matching lines @@
   Handle<String> name() const  { return name_; }
   Variable* var() const  { return var_; }
   UseCount* var_uses()  { return &var_uses_; }
   UseCount* obj_uses()  { return &obj_uses_; }
   bool is_this() const  { return is_this_; }
   bool inside_with() const  { return inside_with_; }
 
   // Bind this proxy to the variable var.
   void BindTo(Variable* var);
 
+  // Generate code to store into an expression evaluated as the left-hand
+  // side of an assignment.  The code will expect the stored value on top of
+  // the expression stack, and a reference containing the expression
+  // immediately below that.
+  virtual void GenerateStoreCode(MacroAssembler* masm,
+                                 Scope* scope,
+                                 Reference* ref,
+                                 bool is_const_init);
  protected:
   Handle<String> name_;
   Variable* var_;  // resolved variable, or NULL
   bool is_this_;
   bool inside_with_;
 
   // VariableProxy usage info.
   UseCount var_uses_;  // uses of the variable value
   UseCount obj_uses_;  // uses of the object the variable points to
 
@@ skipping 55 matching lines @@
   virtual void Accept(Visitor* v);
 
   // Type testing & conversion
   virtual Slot* AsSlot()  { return this; }
 
   // Accessors
   Variable* var() const  { return var_; }
   Type type() const  { return type_; }
   int index() const  { return index_; }
 
+  // Generate code to store into an expression evaluated as the left-hand
+  // side of an assignment.  The code will expect the stored value on top of
+  // the expression stack, and a reference containing the expression
+  // immediately below that.
+  virtual void GenerateStoreCode(MacroAssembler* masm,
+                                 Scope* scope,
+                                 Reference* ref,
+                                 bool is_const_init);
  private:
   Variable* var_;
   Type type_;
   int index_;
 };
 
 
 class Property: public Expression {
  public:
   Property(Expression* obj, Expression* key, int pos)
       : obj_(obj), key_(key), pos_(pos) { }
 
   virtual void Accept(Visitor* v);
 
   // Type testing & conversion
   virtual Property* AsProperty() { return this; }
 
   virtual bool IsValidLeftHandSide() { return true; }
 
   Expression* obj() const { return obj_; }
   Expression* key() const { return key_; }
   int position() const { return pos_; }
 
   // Returns a property singleton property access on 'this'.  Used
   // during preparsing.
   static Property* this_property() { return &this_property_; }
 
+  // Generate code to store into an expression evaluated as the left-hand
+  // side of an assignment.  The code will expect the stored value on top of
+  // the expression stack, and a reference containing the expression
+  // immediately below that.
+  virtual void GenerateStoreCode(MacroAssembler* masm,
+                                 Scope* scope,
+                                 Reference* ref,
+                                 bool is_const_init);
  private:
   Expression* obj_;
   Expression* key_;
   int pos_;
 
   // Dummy property used during preparsing
   static Property this_property_;
 };
 
 
@@ skipping 359 matching lines @@
 #undef DEF_VISIT
 
  private:
   bool stack_overflow_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_