OLD | NEW |
1 // Copyright 2015 the V8 project authors. All rights reserved. | 1 // Copyright 2015 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/runtime/runtime-utils.h" | 5 #include "src/runtime/runtime-utils.h" |
6 | 6 |
7 #include "src/arguments.h" | 7 #include "src/arguments.h" |
8 #include "src/elements.h" | 8 #include "src/elements.h" |
9 #include "src/factory.h" | 9 #include "src/factory.h" |
10 #include "src/isolate-inl.h" | 10 #include "src/isolate-inl.h" |
11 #include "src/keys.h" | 11 #include "src/keys.h" |
12 #include "src/objects-inl.h" | 12 #include "src/objects-inl.h" |
13 | 13 |
14 namespace v8 { | 14 namespace v8 { |
15 namespace internal { | 15 namespace internal { |
16 | 16 |
17 namespace { | 17 namespace { |
18 | 18 |
19 // Returns either a FixedArray or, if the given {receiver} has an enum cache | 19 // Returns either a FixedArray or, if the given {receiver} has an enum cache |
20 // that contains all enumerable properties of the {receiver} and its prototypes | 20 // that contains all enumerable properties of the {receiver} and its prototypes |
21 // have none, the map of the {receiver}. This is used to speed up the check for | 21 // have none, the map of the {receiver}. This is used to speed up the check for |
22 // deletions during a for-in. | 22 // deletions during a for-in. |
23 MaybeHandle<HeapObject> Enumerate(Handle<JSReceiver> receiver) { | 23 MaybeHandle<HeapObject> Enumerate(Handle<JSReceiver> receiver) { |
24 Isolate* const isolate = receiver->GetIsolate(); | 24 Isolate* const isolate = receiver->GetIsolate(); |
25 FastKeyAccumulator accumulator(isolate, receiver, INCLUDE_PROTOS, | 25 FastKeyAccumulator accumulator(isolate, receiver, INCLUDE_PROTOS, |
26 ENUMERABLE_STRINGS); | 26 ENUMERABLE_STRINGS); |
| 27 accumulator.set_filter_proxy_keys(false); |
27 // Test if we have an enum cache for {receiver}. | 28 // Test if we have an enum cache for {receiver}. |
28 if (!accumulator.is_receiver_simple_enum()) { | 29 if (!accumulator.is_receiver_simple_enum()) { |
29 Handle<FixedArray> keys; | 30 Handle<FixedArray> keys; |
30 ASSIGN_RETURN_ON_EXCEPTION(isolate, keys, accumulator.GetKeys(KEEP_NUMBERS), | 31 ASSIGN_RETURN_ON_EXCEPTION(isolate, keys, accumulator.GetKeys(KEEP_NUMBERS), |
31 HeapObject); | 32 HeapObject); |
32 // Test again, since cache may have been built by GetKeys() calls above. | 33 // Test again, since cache may have been built by GetKeys() calls above. |
33 if (!accumulator.is_receiver_simple_enum()) return keys; | 34 if (!accumulator.is_receiver_simple_enum()) return keys; |
34 } | 35 } |
35 return handle(receiver->map(), isolate); | 36 return handle(receiver->map(), isolate); |
36 } | 37 } |
37 | 38 |
| 39 // This is a slight modifcation of JSReceiver::HasProperty, dealing with |
| 40 // the oddities of JSProxy in for-in filter. |
| 41 MaybeHandle<Object> HasEnumerableProperty(Isolate* isolate, |
| 42 Handle<JSReceiver> receiver, |
| 43 Handle<Object> key) { |
| 44 bool success = false; |
| 45 Maybe<PropertyAttributes> result = Just(ABSENT); |
| 46 LookupIterator it = |
| 47 LookupIterator::PropertyOrElement(isolate, receiver, key, &success); |
| 48 if (!success) return isolate->factory()->undefined_value(); |
| 49 for (; it.IsFound(); it.Next()) { |
| 50 switch (it.state()) { |
| 51 case LookupIterator::NOT_FOUND: |
| 52 case LookupIterator::TRANSITION: |
| 53 UNREACHABLE(); |
| 54 case LookupIterator::JSPROXY: { |
| 55 // For proxies we have to invoke the [[GetOwnProperty]] trap. |
| 56 result = JSProxy::GetPropertyAttributes(&it); |
| 57 if (result.IsNothing()) return MaybeHandle<Object>(); |
| 58 if (result.FromJust() == ABSENT) { |
| 59 // Continue lookup on the proxy's prototype. |
| 60 Handle<JSProxy> proxy = it.GetHolder<JSProxy>(); |
| 61 Handle<Object> prototype; |
| 62 ASSIGN_RETURN_ON_EXCEPTION(isolate, prototype, |
| 63 JSProxy::GetPrototype(proxy), Object); |
| 64 if (prototype->IsNull()) break; |
| 65 // We already have a stack-check in JSProxy::GetPrototype. |
| 66 return HasEnumerableProperty( |
| 67 isolate, Handle<JSReceiver>::cast(prototype), key); |
| 68 } else if (result.FromJust() & DONT_ENUM) { |
| 69 return isolate->factory()->undefined_value(); |
| 70 } else { |
| 71 return it.GetName(); |
| 72 } |
| 73 } |
| 74 case LookupIterator::INTERCEPTOR: { |
| 75 result = JSObject::GetPropertyAttributesWithInterceptor(&it); |
| 76 if (result.IsNothing()) return MaybeHandle<Object>(); |
| 77 if (result.FromJust() != ABSENT) return it.GetName(); |
| 78 continue; |
| 79 } |
| 80 case LookupIterator::ACCESS_CHECK: { |
| 81 if (it.HasAccess()) continue; |
| 82 result = JSObject::GetPropertyAttributesWithFailedAccessCheck(&it); |
| 83 if (result.IsNothing()) return MaybeHandle<Object>(); |
| 84 if (result.FromJust() != ABSENT) return it.GetName(); |
| 85 return isolate->factory()->undefined_value(); |
| 86 } |
| 87 case LookupIterator::INTEGER_INDEXED_EXOTIC: |
| 88 // TypedArray out-of-bounds access. |
| 89 return isolate->factory()->undefined_value(); |
| 90 case LookupIterator::ACCESSOR: |
| 91 case LookupIterator::DATA: |
| 92 return it.GetName(); |
| 93 } |
| 94 } |
| 95 return isolate->factory()->undefined_value(); |
| 96 } |
38 | 97 |
39 MaybeHandle<Object> Filter(Handle<JSReceiver> receiver, Handle<Object> key) { | 98 MaybeHandle<Object> Filter(Handle<JSReceiver> receiver, Handle<Object> key) { |
40 Isolate* const isolate = receiver->GetIsolate(); | 99 Isolate* const isolate = receiver->GetIsolate(); |
41 Handle<Name> name; | 100 return HasEnumerableProperty(isolate, receiver, key); |
42 ASSIGN_RETURN_ON_EXCEPTION(isolate, name, Object::ToName(isolate, key), | |
43 Object); | |
44 // Directly check for elements if the key is a smi and avoid a conversion | |
45 // roundtrip (Number -> Name -> Number). | |
46 if (key->IsNumber() && receiver->map()->OnlyHasSimpleProperties()) { | |
47 Handle<JSObject> object = Handle<JSObject>::cast(receiver); | |
48 ElementsAccessor* accessor = object->GetElementsAccessor(); | |
49 DCHECK_LT(key->Number(), kMaxUInt32); | |
50 if (accessor->HasElement(object, key->Number(), ONLY_ENUMERABLE)) { | |
51 return name; | |
52 } | |
53 } | |
54 Maybe<bool> result = JSReceiver::HasProperty(receiver, name); | |
55 MAYBE_RETURN_NULL(result); | |
56 if (result.FromJust()) return name; | |
57 return isolate->factory()->undefined_value(); | |
58 } | 101 } |
59 | 102 |
60 } // namespace | 103 } // namespace |
61 | 104 |
62 | 105 |
63 RUNTIME_FUNCTION(Runtime_ForInEnumerate) { | 106 RUNTIME_FUNCTION(Runtime_ForInEnumerate) { |
64 HandleScope scope(isolate); | 107 HandleScope scope(isolate); |
65 DCHECK_EQ(1, args.length()); | 108 DCHECK_EQ(1, args.length()); |
66 CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0); | 109 CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0); |
67 Handle<HeapObject> result; | 110 Handle<HeapObject> result; |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
144 SealHandleScope scope(isolate); | 187 SealHandleScope scope(isolate); |
145 DCHECK_EQ(1, args.length()); | 188 DCHECK_EQ(1, args.length()); |
146 CONVERT_SMI_ARG_CHECKED(index, 0); | 189 CONVERT_SMI_ARG_CHECKED(index, 0); |
147 DCHECK_LE(0, index); | 190 DCHECK_LE(0, index); |
148 DCHECK_LT(index, Smi::kMaxValue); | 191 DCHECK_LT(index, Smi::kMaxValue); |
149 return Smi::FromInt(index + 1); | 192 return Smi::FromInt(index + 1); |
150 } | 193 } |
151 | 194 |
152 } // namespace internal | 195 } // namespace internal |
153 } // namespace v8 | 196 } // namespace v8 |
OLD | NEW |