Ensure that generated code for object literals will call Runtime_DefineOrRedefineAccessorProperty o…

src/full-codegen.h

Index: src/full-codegen.h
diff --git a/src/full-codegen.h b/src/full-codegen.h
index 25e3dba124dfc2f954b5b4dffa90f2e67784443f..58d59862a5dc1703d91d0baf43e4fffde9ed4af4 100644
--- a/src/full-codegen.h
+++ b/src/full-codegen.h
@@ -470,6 +470,8 @@ class FullCodeGenerator: public AstVisitor {
                                  Label* done);
   void EmitVariableLoad(VariableProxy* proxy);
 
+  void EmitAccessor(Expression* expression);
+
   // Expects the arguments and the function already pushed.
   void EmitResolvePossiblyDirectEval(int arg_count);
 
@@ -804,6 +806,28 @@ class FullCodeGenerator: public AstVisitor {
 };
 
 
+// A map from property names to getter/setter pairs allocated in the zone.
+class AccessorTable: public TemplateHashMap<Literal,
+                                            ObjectLiteral::Accessors,
+                                            ZoneListAllocationPolicy> {
+ public:
+  explicit AccessorTable(Zone* zone) :
+      TemplateHashMap<Literal,
+                      ObjectLiteral::Accessors,
+                      ZoneListAllocationPolicy>(Literal::Match),
+      zone_(zone) { }
+
+  Iterator lookup(Literal* literal) {

[rossberg, 2012/03/14 16:29:03]

Nit: Shouldn't this be called 'find' and have the same interface?

On second thought, this wrapper class wouldn't even be necessary if the HashMap
itself was properly templatized and could work on arbitrary types, not just
pointers, like a real STL thingy. Then the accessor struct could be flattened
into the entry struct and needn't be allocated separately.

Such a change might or might not blow up code size -- would be worth a try (but
not in this CL :) ).

[Sven Panne, 2012/03/15 07:12:57]

In a language with lazy evaluation, yes. In C++ we would need a mechanism to
delay the creation of an Accessors instance somehow. Introducing a new abstract
class just for this or waiting for lambdas to be available everywhere seems to
be too much. :-)

In general, I think that mixing lookup and insertion is a bad idea from a
design/API point of view. STL has find and insert for this... *sigh*

Regarding proper templatization: We discussed this offline, and it was *you* who
proposed to do this in a stepwise manner and for pointers only initially. :-)
But I fully agree that this class is only a hint that its base class is poorly
designed, and we can change this in later CLs.

+    Iterator it = find(literal, true);
+    if (it->second == NULL) it->second = new(zone_) ObjectLiteral::Accessors();
+    return it;
+  }
+
+ private:
+  Zone* zone_;
+};
+
+
 } }  // namespace v8::internal
 
 #endif  // V8_FULL_CODEGEN_H_