Runtime version of declarative native accessors.

src/objects.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 8361 matching lines @@
   // Bit positions in flag.
   static const int kAllCanReadBit = 0;
   static const int kAllCanWriteBit = 1;
   static const int kProhibitsOverwritingBit = 2;
   class AttributesField: public BitField<PropertyAttributes, 3, 3> {};
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorInfo);
 };
 
 
+class AccessorDescriptorSerializerBase {
+ public:
+  void VisitError() { CHECK(false); }

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

Hmmm, unless I misunderstood things, this seems to be an indicator that this
class should actually be abstract.

+  bool Complete() { return length_ == offset_; }
+
+ protected:
+  AccessorDescriptorSerializerBase(uint16_t length, uint8_t* storage) :
+      offset_(0), length_(length), storage_(storage) {
+  }
+
+  uint16_t offset_;
+  const uint16_t length_;
+  uint8_t* const storage_;
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorDescriptorSerializerBase);
+};
+
+
+class AccessorDescriptorDeserializer
+    : public AccessorDescriptorSerializerBase {
+ public:
+  inline AccessorDescriptorDeserializer(uint16_t length, uint8_t* storage);
+
+  template<typename T>
+  inline bool ShouldVisit(T* descriptor);
+  inline bool ShouldVisit(v8::AccessorDescriptor* descriptor);
+
+  template<typename T>
+  inline void Visit(T* member);
+
+  inline void Next(v8::AccessorDescriptor* descriptor);
+
+ private:
+  bool visited_;
+  DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorDescriptorDeserializer);
+};
+
+
 class DeclaredAccessorDescriptor: public Struct {
  public:
-  // TODO(dcarney): Fill out this class.
-  DECL_ACCESSORS(internal_field, Smi)
+  DECL_ACCESSORS(serialized_descriptor, ByteArray)

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

Why do we need it? It's unclear to me, which is an indicator that at least a
comment might be appropriate.

 
   static inline DeclaredAccessorDescriptor* cast(Object* obj);
 
+  static int SerializedLength(
+      const v8::AccessorDescriptor* descriptor);
+  static Handle<DeclaredAccessorDescriptor> Create(
+      const v8::AccessorDescriptor* descriptor,
+      Isolate* isolate);
+
   // Dispatched behavior.
   DECLARE_PRINTER(DeclaredAccessorDescriptor)
   DECLARE_VERIFIER(DeclaredAccessorDescriptor)
 
-  static const int kInternalFieldOffset = HeapObject::kHeaderSize;
-  static const int kSize = kInternalFieldOffset + kPointerSize;
+  static const int kSerializedDescriptorOffset = HeapObject::kHeaderSize;
+  static const int kSize = kSerializedDescriptorOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(DeclaredAccessorDescriptor);
 };
 
 
 class DeclaredAccessorInfo: public AccessorInfo {
  public:
   DECL_ACCESSORS(descriptor, DeclaredAccessorDescriptor)
 
@@ skipping 545 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_