1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/runtime/runtime-utils.h"
#include "src/arguments.h"
#include "src/elements.h"
#include "src/factory.h"
#include "src/isolate-inl.h"
#include "src/keys.h"
#include "src/objects-inl.h"
namespace v8 {
namespace internal {
namespace {
// Returns either a FixedArray or, if the given {receiver} has an enum cache
// that contains all enumerable properties of the {receiver} and its prototypes
// have none, the map of the {receiver}. This is used to speed up the check for
// deletions during a for-in.
MaybeHandle<HeapObject> Enumerate(Handle<JSReceiver> receiver) {
Isolate* const isolate = receiver->GetIsolate();
JSObject::MakePrototypesFast(receiver, kStartAtReceiver, isolate);
FastKeyAccumulator accumulator(isolate, receiver,
KeyCollectionMode::kIncludePrototypes,
ENUMERABLE_STRINGS);
accumulator.set_is_for_in(true);
// Test if we have an enum cache for {receiver}.
if (!accumulator.is_receiver_simple_enum()) {
Handle<FixedArray> keys;
ASSIGN_RETURN_ON_EXCEPTION(
isolate, keys, accumulator.GetKeys(GetKeysConversion::kConvertToString),
HeapObject);
// Test again, since cache may have been built by GetKeys() calls above.
if (!accumulator.is_receiver_simple_enum()) return keys;
}
return handle(receiver->map(), isolate);
}
// This is a slight modifcation of JSReceiver::HasProperty, dealing with
// the oddities of JSProxy in for-in filter.
MaybeHandle<Object> HasEnumerableProperty(Isolate* isolate,
Handle<JSReceiver> receiver,
Handle<Object> key) {
bool success = false;
Maybe<PropertyAttributes> result = Just(ABSENT);
LookupIterator it =
LookupIterator::PropertyOrElement(isolate, receiver, key, &success);
if (!success) return isolate->factory()->undefined_value();
for (; it.IsFound(); it.Next()) {
switch (it.state()) {
case LookupIterator::NOT_FOUND:
case LookupIterator::TRANSITION:
UNREACHABLE();
case LookupIterator::JSPROXY: {
// For proxies we have to invoke the [[GetOwnProperty]] trap.
result = JSProxy::GetPropertyAttributes(&it);
if (result.IsNothing()) return MaybeHandle<Object>();
if (result.FromJust() == ABSENT) {
// Continue lookup on the proxy's prototype.
Handle<JSProxy> proxy = it.GetHolder<JSProxy>();
Handle<Object> prototype;
ASSIGN_RETURN_ON_EXCEPTION(isolate, prototype,
JSProxy::GetPrototype(proxy), Object);
if (prototype->IsNull(isolate)) {
return isolate->factory()->undefined_value();
}
// We already have a stack-check in JSProxy::GetPrototype.
return HasEnumerableProperty(
isolate, Handle<JSReceiver>::cast(prototype), key);
} else if (result.FromJust() & DONT_ENUM) {
return isolate->factory()->undefined_value();
} else {
return it.GetName();
}
}
case LookupIterator::INTERCEPTOR: {
result = JSObject::GetPropertyAttributesWithInterceptor(&it);
if (result.IsNothing()) return MaybeHandle<Object>();
if (result.FromJust() != ABSENT) return it.GetName();
continue;
}
case LookupIterator::ACCESS_CHECK: {
if (it.HasAccess()) continue;
result = JSObject::GetPropertyAttributesWithFailedAccessCheck(&it);
if (result.IsNothing()) return MaybeHandle<Object>();
if (result.FromJust() != ABSENT) return it.GetName();
return isolate->factory()->undefined_value();
}
case LookupIterator::INTEGER_INDEXED_EXOTIC:
// TypedArray out-of-bounds access.
return isolate->factory()->undefined_value();
case LookupIterator::ACCESSOR:
case LookupIterator::DATA:
return it.GetName();
}
}
return isolate->factory()->undefined_value();
}
} // namespace
RUNTIME_FUNCTION(Runtime_ForInEnumerate) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
RETURN_RESULT_OR_FAILURE(isolate, Enumerate(receiver));
}
RUNTIME_FUNCTION(Runtime_ForInHasProperty) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
Handle<Object> result;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, result, HasEnumerableProperty(isolate, receiver, key));
return isolate->heap()->ToBoolean(!result->IsUndefined(isolate));
}
} // namespace internal
} // namespace v8
|
