Fix keyed access of primitive objects in the runtime.

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/v8.h"
 
 #include "src/bootstrapper.h"
 #include "src/deoptimizer.h"
 #include "src/lookup.h"
 #include "src/lookup-inl.h"
@@ skipping 41 matching lines @@
   interceptor_state_ = InterceptorState::kProcessNonMasking;
   state_ = NOT_FOUND;
   property_details_ = PropertyDetails::Empty();
   number_ = DescriptorArray::kNotFound;
   holder_ = initial_holder_;
   holder_map_ = handle(holder_->map(), isolate_);
   Next();
 }
 
 
-Handle<JSReceiver> LookupIterator::GetRoot(Handle<Object> receiver,
-                                           Isolate* isolate) {
-  if (receiver->IsJSReceiver()) return Handle<JSReceiver>::cast(receiver);
-  auto root = handle(receiver->GetRootMap(isolate)->prototype(), isolate);
+Handle<JSReceiver> LookupIterator::GetRoot() {

[Igor Sheludko, 2015/07/10 10:02:42]

I think it is better to keep GetRoot() static given that you call it during
object construction. You just need an additional parameter "bool is_element".

+  if (receiver_->IsJSReceiver()) return Handle<JSReceiver>::cast(receiver_);
+  // Strings are the only objects with properties (only elements) directly on
+  // the wrapper. Hence we can skip generating the wrapper for all other cases.
+  if (IsElement() && receiver_->IsString() &&
+      index_ < static_cast<uint32_t>(String::cast(*receiver_)->length())) {
+    // TODO(verwaest): Speed this up. Perhaps use a cached wrapper on the native
+    // context, ensuring that we don't leak it into JS?
+    Handle<JSFunction> constructor = isolate_->string_function();
+    Handle<JSObject> result = factory()->NewJSObject(constructor);
+    Handle<JSValue>::cast(result)->set_value(*receiver_);
+    return result;
+  }
+  auto root = handle(receiver_->GetRootMap(isolate_)->prototype(), isolate_);
   if (root->IsNull()) {
     unsigned int magic = 0xbbbbbbbb;
-    isolate->PushStackTraceAndDie(magic, *receiver, NULL, magic);
+    isolate_->PushStackTraceAndDie(magic, *receiver_, NULL, magic);
   }
   return Handle<JSReceiver>::cast(root);
 }
 
 
 Handle<Map> LookupIterator::GetReceiverMap() const {
   if (receiver_->IsNumber()) return isolate_->factory()->heap_number_map();
   return handle(Handle<HeapObject>::cast(receiver_)->map(), isolate_);
 }
 
@@ skipping 413 matching lines @@
       case InterceptorState::kSkipNonMasking:
         return true;
       case InterceptorState::kProcessNonMasking:
         return false;
     }
   }
   return interceptor_state_ == InterceptorState::kProcessNonMasking;
 }
 }  // namespace internal
 }  // namespace v8