Revision: 10847
Author: [email protected]
Date: Mon Feb 27 23:16:50 2012
Log: Handle CALLBACKS correctly in IsProperty functions.
With transitions in AccessorPairs, it is not enough to look at the
PropertyType
alone to decide whether we look at a property or not: For objects with
JavaScript accessors, we have to look into the AccessorPair itself and see
if
one of its 2 parts is actually a JavaScript accessor. Therefore, a predicate
with a PropertyType argument alone doesn't make sense anymore, we might
need the
associated value, too.
Things are complicated by the fact that the holder in a LookupResult can be
NULL, so we must be careful to retrieve its value only when it is really
needed. To achieve the needed call-by-name semantics, a new Entry is
introduced,
which is basically a closure over a DescriptorArray and an index into this
array
(C++0x to the rescue!). GCC is clever enough to inline this class, so we
pay no
runtime penalty for this abstraction.
It's all a bit ugly, but this is caused by the current structure of
Descriptor,
DescriptorArray and LookupResult: Things would be much easier if
DescriptorArray
were, well, an array of Descriptors, and LookupResult were a 'Maybe
Descriptor'
(in Haskell-terms).
Review URL: https://chromiumcodereview.appspot.com/9466047
http://code.google.com/p/v8/source/detail?r=10847
Modified:
/branches/bleeding_edge/src/objects-inl.h
/branches/bleeding_edge/src/objects.h
/branches/bleeding_edge/src/property-details.h
/branches/bleeding_edge/src/property.h
=======================================
--- /branches/bleeding_edge/src/objects-inl.h Sun Feb 26 23:49:14 2012
+++ /branches/bleeding_edge/src/objects-inl.h Mon Feb 27 23:16:50 2012
@@ -1988,7 +1988,8 @@
bool DescriptorArray::IsProperty(int descriptor_number) {
- return IsRealProperty(GetType(descriptor_number));
+ Entry entry(this, descriptor_number);
+ return IsPropertyDescriptor(&entry);
}
=======================================
--- /branches/bleeding_edge/src/objects.h Sun Feb 26 23:49:14 2012
+++ /branches/bleeding_edge/src/objects.h Mon Feb 27 23:16:50 2012
@@ -2589,6 +2589,20 @@
static const int kMaxNumberOfDescriptors = 1024 + 512;
private:
+ // An entry in a DescriptorArray, represented as an (array, index) pair.
+ class Entry {
+ public:
+ inline explicit Entry(DescriptorArray* descs, int index) :
+ descs_(descs), index_(index) { }
+
+ inline PropertyType type() { return descs_->GetType(index_); }
+ inline Object* GetCallbackObject() { return descs_->GetValue(index_); }
+
+ private:
+ DescriptorArray* descs_;
+ int index_;
+ };
+
// Conversion from descriptor number to array indices.
static int ToKeyIndex(int descriptor_number) {
return descriptor_number+kFirstIndex;
@@ -7918,6 +7932,10 @@
set_setter(value);
}
}
+
+ bool ContainsAccessor() {
+ return IsJSAccessor(getter()) || IsJSAccessor(setter());
+ }
#ifdef OBJECT_PRINT
void AccessorPairPrint(FILE* out = stdout);
@@ -7931,6 +7949,15 @@
static const int kSize = kSetterOffset + kPointerSize;
private:
+ // Strangely enough, in addition to functions and harmony proxies, the
spec
+ // requires us to consider undefined as a kind of accessor, too:
+ // var obj = {};
+ // Object.defineProperty(obj, "foo", {get: undefined});
+ // assertTrue("foo" in obj);
+ bool IsJSAccessor(Object* obj) {
+ return obj->IsSpecFunction() || obj->IsUndefined();
+ }
+
DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorPair);
};
=======================================
--- /branches/bleeding_edge/src/property-details.h Mon Feb 6 04:11:40 2012
+++ /branches/bleeding_edge/src/property-details.h Mon Feb 27 23:16:50 2012
@@ -73,26 +73,6 @@
};
-inline bool IsRealProperty(PropertyType type) {
- switch (type) {
- case NORMAL:
- case FIELD:
- case CONSTANT_FUNCTION:
- case CALLBACKS:
- case HANDLER:
- case INTERCEPTOR:
- return true;
- case MAP_TRANSITION:
- case ELEMENTS_TRANSITION:
- case CONSTANT_TRANSITION:
- case NULL_DESCRIPTOR:
- return false;
- }
- UNREACHABLE(); // keep the compiler happy
- return false;
-}
-
-
// PropertyDetails captures type and attributes for a property.
// They are used both in property dictionaries and instance descriptors.
class PropertyDetails BASE_EMBEDDED {
=======================================
--- /branches/bleeding_edge/src/property.h Mon Feb 6 04:11:40 2012
+++ /branches/bleeding_edge/src/property.h Mon Feb 27 23:16:50 2012
@@ -162,6 +162,35 @@
int index = 0)
: Descriptor(key, foreign, attributes, CALLBACKS, index) {}
};
+
+
+template <class T>
+bool IsPropertyDescriptor(T* desc) {
+ switch (desc->type()) {
+ case NORMAL:
+ case FIELD:
+ case CONSTANT_FUNCTION:
+ case HANDLER:
+ case INTERCEPTOR:
+ return true;
+ case CALLBACKS: {
+ Object* callback_object = desc->GetCallbackObject();
+ // Non-JavaScript (i.e. native) accessors are always a property,
otherwise
+ // either the getter or the setter must be an accessor. Put another
way:
+ // If we only see map transitions and holes in a pair, this is not a
+ // property.
+ return (!callback_object->IsAccessorPair() ||
+ AccessorPair::cast(callback_object)->ContainsAccessor());
+ }
+ case MAP_TRANSITION:
+ case ELEMENTS_TRANSITION:
+ case CONSTANT_TRANSITION:
+ case NULL_DESCRIPTOR:
+ return false;
+ }
+ UNREACHABLE(); // keep the compiler happy
+ return false;
+}
class LookupResult BASE_EMBEDDED {
@@ -261,10 +290,9 @@
bool IsFound() { return lookup_type_ != NOT_FOUND; }
bool IsHandler() { return lookup_type_ == HANDLER_TYPE; }
- // Is the result is a property excluding transitions and the null
- // descriptor?
+ // Is the result is a property excluding transitions and the null
descriptor?
bool IsProperty() {
- return IsFound() && IsRealProperty(GetPropertyDetails().type());
+ return IsFound() && IsPropertyDescriptor(this);
}
bool IsCacheable() { return cacheable_; }
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
