Convert primitive receivers for API property callbacks

src/accessors.cc

 // Copyright 2012 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/accessors.h"
 
 #include "src/api.h"
 #include "src/contexts.h"
 #include "src/deoptimizer.h"
 #include "src/execution.h"
@@ skipping 14 matching lines @@
     Handle<Name> name,
     AccessorNameGetterCallback getter,
     AccessorNameSetterCallback setter,
     PropertyAttributes attributes) {
   Factory* factory = isolate->factory();
   Handle<AccessorInfo> info = factory->NewAccessorInfo();
   info->set_property_attributes(attributes);
   info->set_all_can_read(false);
   info->set_all_can_write(false);
   info->set_is_special_data_property(true);
+  info->set_is_sloppy(false);
   name = factory->InternalizeName(name);
   info->set_name(*name);
   Handle<Object> get = v8::FromCData(isolate, getter);
   if (setter == nullptr) setter = &ReconfigureToDataProperty;
   Handle<Object> set = v8::FromCData(isolate, setter);
   info->set_getter(*get);
   info->set_setter(*set);
   Address redirected = info->redirected_getter();
   if (redirected != nullptr) {
     Handle<Object> js_get = v8::FromCData(isolate, redirected);
@@ skipping 208 matching lines @@
 // Accessors::StringLength
 //
 
 void Accessors::StringLengthGetter(
     v8::Local<v8::Name> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(info.GetIsolate());
   DisallowHeapAllocation no_allocation;
   HandleScope scope(isolate);
 
   // We have a slight impedance mismatch between the external API and the way we

[jochen (gone - plz use gerrit), 2016/05/06 13:56:39]

slight? in the sense of how sloppy and strict are slightly different? :-/

   // use callbacks internally: Externally, callbacks can only be used with
   // v8::Object, but internally we have callbacks on entities which are higher
   // in the hierarchy, in this case for String values.
 
   Object* value = *Utils::OpenHandle(*v8::Local<v8::Value>(info.This()));
   if (!value->IsString()) {
     // Not a string value. That means that we either got a String wrapper or
     // a Value with a String wrapper in its prototype chain.
     value = JSValue::cast(*Utils::OpenHandle(*info.Holder()))->value();
   }
@@ skipping 930 matching lines @@
   Isolate* isolate = name->GetIsolate();
   Handle<AccessorInfo> info = MakeAccessor(isolate, name, &ModuleGetExport,
                                            &ModuleSetExport, attributes);
   info->set_data(Smi::FromInt(index));
   return info;
 }
 
 
 }  // namespace internal
 }  // namespace v8