runtime-forin.cc 5.1 KB
Newer Older
1 2 3 4 5
// 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"
6 7

#include "src/arguments.h"
8
#include "src/elements.h"
9 10
#include "src/factory.h"
#include "src/isolate-inl.h"
11
#include "src/keys.h"
12
#include "src/objects-inl.h"
13 14 15 16

namespace v8 {
namespace internal {

17 18 19 20 21 22 23 24
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();
25
  JSObject::MakePrototypesFast(receiver, kStartAtReceiver, isolate);
26 27
  FastKeyAccumulator accumulator(isolate, receiver,
                                 KeyCollectionMode::kIncludePrototypes,
28
                                 ENUMERABLE_STRINGS);
29
  accumulator.set_is_for_in(true);
30
  // Test if we have an enum cache for {receiver}.
31
  if (!accumulator.is_receiver_simple_enum()) {
32
    Handle<FixedArray> keys;
33
    ASSIGN_RETURN_ON_EXCEPTION(
34
        isolate, keys, accumulator.GetKeys(GetKeysConversion::kConvertToString),
35
        HeapObject);
36
    // Test again, since cache may have been built by GetKeys() calls above.
37
    if (!accumulator.is_receiver_simple_enum()) return keys;
38
  }
39
  DCHECK(!receiver->IsJSModuleNamespace());
40 41 42
  return handle(receiver->map(), isolate);
}

43
// This is a slight modifcation of JSReceiver::HasProperty, dealing with
44
// the oddities of JSProxy and JSModuleNamespace in for-in filter.
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
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);
68 69 70
          if (prototype->IsNull(isolate)) {
            return isolate->factory()->undefined_value();
          }
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
          // 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();
96 97 98 99 100 101 102 103
      case LookupIterator::ACCESSOR: {
        if (it.GetHolder<Object>()->IsJSModuleNamespace()) {
          result = JSModuleNamespace::GetPropertyAttributes(&it);
          if (result.IsNothing()) return MaybeHandle<Object>();
          DCHECK_EQ(0, result.FromJust() & DONT_ENUM);
        }
        return it.GetName();
      }
104 105
      case LookupIterator::DATA:
        return it.GetName();
106 107
    }
  }
108 109 110 111 112 113 114
  return isolate->factory()->undefined_value();
}

}  // namespace


RUNTIME_FUNCTION(Runtime_ForInEnumerate) {
115 116
  HandleScope scope(isolate);
  DCHECK_EQ(1, args.length());
117
  CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
118
  RETURN_RESULT_OR_FAILURE(isolate, Enumerate(receiver));
119
}
120 121


122 123 124 125 126 127 128 129 130 131
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));
}
132 133 134

}  // namespace internal
}  // namespace v8