Add LookupIterator constructor for arbitrary Object keys

src/lookup.cc

 // 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.
 
 #include "src/lookup.h"
 
 #include "src/bootstrapper.h"
 #include "src/deoptimizer.h"
 #include "src/isolate-inl.h"
 #include "src/lookup-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
+// static
+LookupIterator LookupIterator::PropertyOrElement(Isolate* isolate,
+                                                 Handle<Object> receiver,
+                                                 Handle<Object> name,

[Toon Verwaest, 2015/09/30 13:02:33]

What about calling this key?

[Jakob Kummerow, 2015/09/30 14:27:32]

Done.

+                                                 bool* success,
+                                                 Configuration configuration) {
+  uint32_t index = 0;
+  bool is_index = false;
+  if (name->IsNumber()) {

[Toon Verwaest, 2015/09/30 13:02:34]

What about a slightly less branchy version:

uint32_t index = 0;

if (key->ToArrayIndex(&index)) {
  *success = true;
  return LookupIterator(isolate, receiver, index, configuration);
}

Handle<Name> name;
*success = Object::ToName(isolate, key).ToHandle(&name);
if (!*success) {
  DCHECK(isolate->has_pending_exception());
  // Return an unusable dummy.
  return LookupIterator(receiver, isolate->factory()->empty_string());
}

if (name->AsArrayIndex(&index)) {
  LookupIterator it(isolate, receiver, index, configuration);
  // Here we try to avoid having to rebuild the string later
  // by storing it on the indexed LookupIterator.
  it.name_ = name;
  return it;
}

return LookupIterator(receiver, name, configuration);

[Jakob Kummerow, 2015/09/30 14:27:31]

Nice simplification. Done.

+    if (name->ToArrayIndex(&index)) {
+      is_index = true;
+    } else {
+      name = isolate->factory()->NumberToString(name);
+    }
+  } else {
+    if (!Object::ToName(isolate, name).ToHandle(&name)) {
+      DCHECK(isolate->has_pending_exception());
+      *success = false;
+      // Return an unusable dummy.
+      return LookupIterator(receiver, isolate->factory()->empty_string());
+    }
+    DCHECK(name->IsName());
+    name = Name::Flatten(Handle<Name>::cast(name));
+    is_index = Handle<Name>::cast(name)->AsArrayIndex(&index);
+  }
+  *success = true;
+  if (is_index) {
+    return LookupIterator(isolate, receiver, index, configuration);
+  } else {
+    DCHECK(name->IsName());
+    LookupIterator it(receiver, Handle<Name>::cast(name), configuration);
+    it.name_ = Handle<Name>::cast(name);

[Toon Verwaest, 2015/09/30 13:02:33]

You don't need to set the .name_ if you know it's not an index (and you used
this particular constructor). The only reason the other static constructors do
it is to not have to convert index back to a name when needed for code that
needs the "original string version" of the property name.

[Jakob Kummerow, 2015/09/30 14:27:32]

Done.
(Not sure why that was there... probably an artifact from an earlier version of
the code.)

+    return it;
+  }
+}
+
+
 void LookupIterator::Next() {
   DCHECK_NE(JSPROXY, state_);
   DCHECK_NE(TRANSITION, state_);
   DisallowHeapAllocation no_gc;
   has_property_ = false;
 
   JSReceiver* holder = *holder_;
   Map* map = *holder_map_;
 
   // Perform lookup on current holder.
@@ skipping 530 matching lines @@
       case InterceptorState::kSkipNonMasking:
         return true;
       case InterceptorState::kProcessNonMasking:
         return false;
     }
   }
   return interceptor_state_ == InterceptorState::kProcessNonMasking;
 }
 }  // namespace internal
 }  // namespace v8