Implement implicit instance checks for API 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 8068 matching lines @@
 // If the accessor in the prototype has the READ_ONLY property attribute, then
 // a new value is added to the local object when the property is set.
 // This shadows the accessor in the prototype.
 class AccessorInfo: public Struct {
  public:
   DECL_ACCESSORS(getter, Object)
   DECL_ACCESSORS(setter, Object)
   DECL_ACCESSORS(data, Object)
   DECL_ACCESSORS(name, Object)
   DECL_ACCESSORS(flag, Smi)
+  DECL_ACCESSORS(compatible, Object)

[Sven Panne, 2012/06/04 07:50:32]

The name "compatible" is a bit unclear, something like "expected_receiver_type"
might be better (although our 80-column rule might hurt then >:-).

[Michael Starzinger, 2012/06/04 09:11:15]

Done. I agree, the name bothered me as well, "expected_receiver_type" is much
better.

 
   inline bool all_can_read();
   inline void set_all_can_read(bool value);
 
   inline bool all_can_write();
   inline void set_all_can_write(bool value);
 
   inline bool prohibits_overwriting();
   inline void set_prohibits_overwriting(bool value);
 
   inline PropertyAttributes property_attributes();
   inline void set_property_attributes(PropertyAttributes attributes);
 
+  // Checks whether the given receiver is compatible with this accessor.
+  inline bool IsCompatibleReceiver(Object* receiver);
+
   static inline AccessorInfo* cast(Object* obj);
 
 #ifdef OBJECT_PRINT
   inline void AccessorInfoPrint() {
     AccessorInfoPrint(stdout);
   }
   void AccessorInfoPrint(FILE* out);
 #endif
 #ifdef DEBUG
   void AccessorInfoVerify();
 #endif
 
   static const int kGetterOffset = HeapObject::kHeaderSize;
   static const int kSetterOffset = kGetterOffset + kPointerSize;
   static const int kDataOffset = kSetterOffset + kPointerSize;
   static const int kNameOffset = kDataOffset + kPointerSize;
   static const int kFlagOffset = kNameOffset + kPointerSize;
-  static const int kSize = kFlagOffset + kPointerSize;
+  static const int kCompatibleOffset = kFlagOffset + kPointerSize;
+  static const int kSize = kCompatibleOffset + kPointerSize;
 
  private:
   // 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);
 };
@@ skipping 554 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_