Add LookupIterator constructor for arbitrary Object keys

src/lookup.cc

Index: src/lookup.cc
diff --git a/src/lookup.cc b/src/lookup.cc
index 809c35e4a5339354bc9dd1bc7cb3e2e9530cbbfc..e545063172d498312a2d77c646599d68b20d29c8 100644
--- a/src/lookup.cc
+++ b/src/lookup.cc
@@ -13,6 +13,43 @@ 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_);