Runtime version of declarative native accessors.

include/v8.h

Index: include/v8.h
diff --git a/include/v8.h b/include/v8.h
index 56e176ab14834bc87e99054e6920cde99345d0fa..78857aa764a03f38bab6ebc339ef629d7a7f52b6 100644
--- a/include/v8.h
+++ b/include/v8.h
@@ -1530,6 +1530,55 @@ typedef void (*AccessorSetter)(Local<String> property,
                                const AccessorInfo& info);
 
 
+enum AccessorDescriptorType {
+  kDescriptorPointerCompare,
+  kDescriptorBitmaskCompare,
+  kDescriptorPrimitiveValue,
+  kDescriptorPointerDereference,
+  kDescriptorInternalFieldDereference
+};
+
+
+enum AccessorDescriptorDataType {
+    kDescriptorBoolType,
+    kDescriptorInt8Type, kDescriptorUint8Type,
+    kDescriptorInt16Type, kDescriptorUint16Type,
+    kDescriptorInt32Type, kDescriptorUint32Type,
+    kDescriptorFloatType, kDescriptorDoubleType
+};
+
+
+struct BitmaskCompareDescriptor {
+  uint32_t bitmask;
+  uint32_t compare_value;
+  uint8_t size;  // Must be in {1,2,4}.
+};
+
+
+struct PointerCompareDescriptor {
+  void* compare_value;
+};
+
+
+struct PrimitiveValueDescriptor {
+  AccessorDescriptorDataType data_type;
+  uint8_t bool_offset;  // Must be in [0,7], used for kDescriptorBoolType.
+};
+
+
+struct AccessorDescriptor {

[Sven Panne, 2013/02/19 08:41:16]

I'm not totally happy with the way this algebraic data type is encoded. Let's
discuss this offline, there are *many* ways of doing it...

Regardless how this finally looks, we need some serious documentation via
comments here!

+  uint8_t internal_field;  // Ignored for kDescriptorPointerDereference.
+  int16_t byte_offset;
+  AccessorDescriptorType type;
+  union {
+    AccessorDescriptor* derefence_descriptor;
+    struct BitmaskCompareDescriptor bitmask_compare_descriptor;
+    struct PointerCompareDescriptor pointer_compare_descriptor;
+    struct PrimitiveValueDescriptor primitive_value_descriptor;
+  };
+};
+
+
 /**
  * Access control specifications.
  *
@@ -1606,6 +1655,11 @@ class V8EXPORT Object : public Value {
                    AccessControl settings = DEFAULT,
                    PropertyAttribute attribute = None);
 
+  bool SetAccessor(Handle<String> name,
+                   const AccessorDescriptor* descriptor,
+                   AccessControl settings = DEFAULT,
+                   PropertyAttribute attribute = None);
+
   /**
    * Returns an array containing the names of the enumerable properties
    * of this object, including properties from prototype objects.  The
@@ -2377,13 +2431,6 @@ class V8EXPORT FunctionTemplate : public Template {
 
  private:
   FunctionTemplate();
-  void AddInstancePropertyAccessor(Handle<String> name,
-                                   AccessorGetter getter,
-                                   AccessorSetter setter,
-                                   Handle<Value> data,
-                                   AccessControl settings,
-                                   PropertyAttribute attributes,
-                                   Handle<AccessorSignature> signature);
   void SetNamedInstancePropertyHandler(NamedPropertyGetter getter,
                                        NamedPropertySetter setter,
                                        NamedPropertyQuery query,
@@ -2456,6 +2503,13 @@ class V8EXPORT ObjectTemplate : public Template {
                    Handle<AccessorSignature> signature =
                        Handle<AccessorSignature>());
 
+  bool SetAccessor(Handle<String> name,
+                   const AccessorDescriptor* descriptor,
+                   AccessControl settings = DEFAULT,
+                   PropertyAttribute attribute = None,
+                   Handle<AccessorSignature> signature =
+                       Handle<AccessorSignature>());
+
   /**
    * Sets a named property handler on the object template.
    *
@@ -4589,6 +4643,81 @@ void Template::Set(const char* name, v8::Handle<Data> value) {
 }
 
 
+struct DescriptorVisitorHelper {

[Sven Panne, 2013/02/19 08:41:16]

Why do we need all this stuff here in the external header? (Basically 2
questions: Why at all? Why here?)

+  template<typename Descriptor, typename Visitor>
+  static inline void VisitDescriptor(Descriptor* descriptor, Visitor* visitor) {
+    if (!visitor->ShouldVisit(descriptor)) return;
+    VisitFields(descriptor, visitor);
+  }
+  template<typename Visitor>
+  static inline void VisitFields(BitmaskCompareDescriptor* descriptor,
+                                 Visitor* visitor);
+  template<typename Visitor>
+  static inline void VisitFields(PointerCompareDescriptor* descriptor,
+                                 Visitor* visitor);
+  template<typename Visitor>
+  static inline void VisitFields(PrimitiveValueDescriptor* descriptor,
+                                 Visitor* visitor);
+  template<typename Visitor>
+  static inline void VisitFields(AccessorDescriptor* descriptor,
+                                 Visitor* visitor);
+};
+
+
+template<typename Visitor>
+inline void DescriptorVisitorHelper::VisitFields(
+    BitmaskCompareDescriptor* descriptor,
+    Visitor* visitor) {
+  visitor->Visit(&descriptor->size);
+  visitor->Visit(&descriptor->bitmask);
+  visitor->Visit(&descriptor->compare_value);
+}
+
+
+template<typename Visitor>
+inline void DescriptorVisitorHelper::VisitFields(
+    PointerCompareDescriptor* descriptor,
+    Visitor* visitor) {
+  visitor->Visit(&descriptor->compare_value);
+}
+
+
+template<typename Visitor>
+inline void DescriptorVisitorHelper::VisitFields(
+    PrimitiveValueDescriptor* descriptor,
+    Visitor* visitor) {
+  visitor->Visit(&descriptor->data_type);
+}
+
+
+template<typename Visitor>
+inline void DescriptorVisitorHelper::VisitFields(
+    AccessorDescriptor* descriptor,
+    Visitor* visitor) {
+  visitor->Visit(&descriptor->internal_field);
+  visitor->Visit(&descriptor->byte_offset);
+  visitor->Visit(&descriptor->type);
+  switch (static_cast<AccessorDescriptorType>(descriptor->type)) {
+    case kDescriptorBitmaskCompare:
+      VisitDescriptor(&descriptor->bitmask_compare_descriptor, visitor);
+      break;
+    case kDescriptorPointerCompare:
+      VisitDescriptor(&descriptor->pointer_compare_descriptor, visitor);
+      break;
+    case kDescriptorPrimitiveValue:
+      VisitDescriptor(&descriptor->primitive_value_descriptor, visitor);
+      break;
+    case kDescriptorPointerDereference:
+    case kDescriptorInternalFieldDereference:
+      VisitDescriptor(descriptor->derefence_descriptor, visitor);
+      break;
+    default:
+      visitor->VisitError();
+      break;
+  }
+}
+
+
 Local<Value> Object::GetInternalField(int index) {
 #ifndef V8_ENABLE_CHECKS
   typedef internal::Object O;