1 files changed, 144 insertions, 0 deletions
diff --git a/deps/v8/src/lookup-inl.h b/deps/v8/src/lookup-inl.h
new file mode 100644
index 0000000000..6e95d06b0f
--- /dev/null
+++ b/deps/v8/src/lookup-inl.h
@@ -0,0 +1,144 @@
+// Copyright 2014 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.
+
+#ifndef V8_LOOKUP_INL_H_
+#define V8_LOOKUP_INL_H_
+
+#include "src/lookup.h"
+
+#include "src/handles-inl.h"
+#include "src/heap/factory-inl.h"
+#include "src/objects-inl.h"
+#include "src/objects/api-callbacks.h"
+#include "src/objects/name-inl.h"
+#include "src/objects/map-inl.h"
+
+namespace v8 {
+namespace internal {
+
+LookupIterator::LookupIterator(Handle<Object> receiver, Handle<Name> name,
+                               Handle<JSReceiver> holder,
+                               Configuration configuration)
+    : LookupIterator(holder->GetIsolate(), receiver, name, holder,
+                     configuration) {}
+
+LookupIterator::LookupIterator(Isolate* isolate, Handle<Object> receiver,
+                               Handle<Name> name, Handle<JSReceiver> holder,
+                               Configuration configuration)
+    : configuration_(ComputeConfiguration(configuration, name)),
+      interceptor_state_(InterceptorState::kUninitialized),
+      property_details_(PropertyDetails::Empty()),
+      isolate_(isolate),
+      name_(isolate_->factory()->InternalizeName(name)),
+      receiver_(receiver),
+      initial_holder_(holder),
+      // kMaxUInt32 isn't a valid index.
+      index_(kMaxUInt32),
+      number_(static_cast<uint32_t>(DescriptorArray::kNotFound)) {
+#ifdef DEBUG
+  uint32_t index;  // Assert that the name is not an array index.
+  DCHECK(!name->AsArrayIndex(&index));
+#endif  // DEBUG
+  Start<false>();
+}
+
+LookupIterator LookupIterator::PropertyOrElement(
+    Isolate* isolate, Handle<Object> receiver, Handle<Name> name,
+    Handle<JSReceiver> holder, Configuration configuration) {
+  uint32_t index;
+  if (name->AsArrayIndex(&index)) {
+    LookupIterator it =
+        LookupIterator(isolate, receiver, index, holder, configuration);
+    it.name_ = name;
+    return it;
+  }
+  return LookupIterator(receiver, name, holder, configuration);
+}
+
+LookupIterator LookupIterator::PropertyOrElement(
+    Isolate* isolate, Handle<Object> receiver, Handle<Name> name,
+    Configuration configuration) {
+  uint32_t index;
+  if (name->AsArrayIndex(&index)) {
+    LookupIterator it = LookupIterator(isolate, receiver, index, configuration);
+    it.name_ = name;
+    return it;
+  }
+  return LookupIterator(isolate, receiver, name, configuration);
+}
+
+Handle<Name> LookupIterator::GetName() {
+  if (name_.is_null()) {
+    DCHECK(IsElement());
+    name_ = factory()->Uint32ToString(index_);
+  }
+  return name_;
+}
+
+bool LookupIterator::is_dictionary_holder() const {
+  return !holder_->HasFastProperties();
+}
+
+bool LookupIterator::ExtendingNonExtensible(Handle<JSReceiver> receiver) {
+  DCHECK(receiver.is_identical_to(GetStoreTarget<JSReceiver>()));
+  return !receiver->map()->is_extensible() &&
+         (IsElement() || !name_->IsPrivate());
+}
+
+bool LookupIterator::IsCacheableTransition() {
+  DCHECK_EQ(TRANSITION, state_);
+  return transition_->IsPropertyCell() ||
+         (transition_map()->is_dictionary_map() &&
+          !GetStoreTarget<JSReceiver>()->HasFastProperties()) ||
+         transition_map()->GetBackPointer()->IsMap();
+}
+
+void LookupIterator::UpdateProtector() {
+  if (IsElement()) return;
+  // This list must be kept in sync with
+  // CodeStubAssembler::CheckForAssociatedProtector!
+  ReadOnlyRoots roots(heap());
+  if (*name_ == roots.is_concat_spreadable_symbol() ||
+      *name_ == roots.constructor_string() || *name_ == roots.next_string() ||
+      *name_ == roots.species_symbol() || *name_ == roots.iterator_symbol() ||
+      *name_ == roots.resolve_string() || *name_ == roots.then_string()) {
+    InternalUpdateProtector();
+  }
+}
+
+LookupIterator::Configuration LookupIterator::ComputeConfiguration(
+    Configuration configuration, Handle<Name> name) {
+  return name->IsPrivate() ? OWN_SKIP_INTERCEPTOR : configuration;
+}
+
+Handle<JSReceiver> LookupIterator::GetRoot(Isolate* isolate,
+                                           Handle<Object> receiver,
+                                           uint32_t index) {
+  if (receiver->IsJSReceiver()) return Handle<JSReceiver>::cast(receiver);
+  return GetRootForNonJSReceiver(isolate, receiver, index);
+}
+
+template <class T>
+Handle<T> LookupIterator::GetStoreTarget() const {
+  DCHECK(receiver_->IsJSReceiver());
+  if (receiver_->IsJSGlobalProxy()) {
+    Map* map = JSGlobalProxy::cast(*receiver_)->map();
+    if (map->has_hidden_prototype()) {
+      return handle(JSGlobalObject::cast(map->prototype()), isolate_);
+    }
+  }
+  return Handle<T>::cast(receiver_);
+}
+inline Handle<InterceptorInfo> LookupIterator::GetInterceptor() const {
+  DCHECK_EQ(INTERCEPTOR, state_);
+  InterceptorInfo* result =
+      IsElement() ? GetInterceptor<true>(JSObject::cast(*holder_))
+                  : GetInterceptor<false>(JSObject::cast(*holder_));
+  return handle(result, isolate_);
+}
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_LOOKUP_INL_H_