Add a native data property that replaces itself with a real data property

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"
 #include "src/factory.h"
 #include "src/frames-inl.h"
 #include "src/isolate-inl.h"
 #include "src/list-inl.h"
 #include "src/messages.h"
 #include "src/property-details.h"
 #include "src/prototype.h"
 
 namespace v8 {
 namespace internal {
 
 Handle<AccessorInfo> Accessors::MakeAccessor(
     Isolate* isolate, Handle<Name> name, AccessorNameGetterCallback getter,
-    AccessorNameBooleanSetterCallback setter, PropertyAttributes attributes) {
+    AccessorNameBooleanSetterCallback setter, PropertyAttributes attributes,
+    bool replace_on_access) {
   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);
+  info->set_replace_on_access(replace_on_access);
+  DCHECK_IMPLIES(replace_on_access, setter == nullptr);
   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 89 matching lines @@
   HandleScope scope(isolate);
   Object* result = isolate->native_context()->array_values_iterator();
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(result, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::ArgumentsIteratorInfo(
     Isolate* isolate, PropertyAttributes attributes) {
   Handle<Name> name = isolate->factory()->iterator_symbol();
   return MakeAccessor(isolate, name, &ArgumentsIteratorGetter, nullptr,
-                      attributes);
+                      attributes, true);
 }
 
 
 //
 // Accessors::ArrayLength
 //
 
 
 void Accessors::ArrayLengthGetter(
     v8::Local<v8::Name> name,
@@ skipping 40 matching lines @@
       info.GetReturnValue().Set(false);
     }
   } else {
     info.GetReturnValue().Set(true);
   }
 }
 
 
 Handle<AccessorInfo> Accessors::ArrayLengthInfo(
       Isolate* isolate, PropertyAttributes attributes) {
-  return MakeAccessor(isolate,
-                      isolate->factory()->length_string(),
-                      &ArrayLengthGetter,
-                      &ArrayLengthSetter,
-                      attributes);
+  return MakeAccessor(isolate, isolate->factory()->length_string(),
+                      &ArrayLengthGetter, &ArrayLengthSetter, attributes,
+                      false);
 }
 
 //
 // Accessors::ModuleNamespaceEntry
 //
 
 void Accessors::ModuleNamespaceEntryGetter(
     v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(info.GetIsolate());
   HandleScope scope(isolate);
@@ skipping 23 matching lines @@
         i::Object::TypeOf(isolate, holder), holder));
     isolate->OptionalRescheduleException(false);
   } else {
     info.GetReturnValue().Set(false);
   }
 }
 
 Handle<AccessorInfo> Accessors::ModuleNamespaceEntryInfo(
     Isolate* isolate, Handle<String> name, PropertyAttributes attributes) {
   return MakeAccessor(isolate, name, &ModuleNamespaceEntryGetter,
-                      &ModuleNamespaceEntrySetter, attributes);
+                      &ModuleNamespaceEntrySetter, attributes, false);
 }
 
 
 //
 // Accessors::StringLength
 //
 
 void Accessors::StringLengthGetter(
     v8::Local<v8::Name> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
@@ skipping 15 matching lines @@
     value = JSValue::cast(*Utils::OpenHandle(*info.Holder()))->value();
   }
   Object* result = Smi::FromInt(String::cast(value)->length());
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(result, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::StringLengthInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->length_string(),
-                      &StringLengthGetter, nullptr, attributes);
+                      &StringLengthGetter, nullptr, attributes, false);
 }
 
 
 //
 // Accessors::ScriptColumnOffset
 //
 
 
 void Accessors::ScriptColumnOffsetGetter(
     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);
   Object* object = *Utils::OpenHandle(*info.Holder());
   Object* res = Smi::FromInt(
       Script::cast(JSValue::cast(object)->value())->column_offset());
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(res, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptColumnOffsetInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   Handle<String> name(isolate->factory()->InternalizeOneByteString(
       STATIC_CHAR_VECTOR("column_offset")));
   return MakeAccessor(isolate, name, &ScriptColumnOffsetGetter, nullptr,
-                      attributes);
+                      attributes, false);
 }
 
 
 //
 // Accessors::ScriptId
 //
 
 
 void Accessors::ScriptIdGetter(
     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);
   Object* object = *Utils::OpenHandle(*info.Holder());
   Object* id = Smi::FromInt(Script::cast(JSValue::cast(object)->value())->id());
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(id, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptIdInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   Handle<String> name(
       isolate->factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("id")));
-  return MakeAccessor(isolate, name, &ScriptIdGetter, nullptr, attributes);
+  return MakeAccessor(isolate, name, &ScriptIdGetter, nullptr, attributes,
+                      false);
 }
 
 
 //
 // Accessors::ScriptName
 //
 
 
 void Accessors::ScriptNameGetter(
     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);
   Object* object = *Utils::OpenHandle(*info.Holder());
   Object* source = Script::cast(JSValue::cast(object)->value())->name();
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(source, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptNameInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->name_string(),
-                      &ScriptNameGetter, nullptr, attributes);
+                      &ScriptNameGetter, nullptr, attributes, false);
 }
 
 
 //
 // Accessors::ScriptSource
 //
 
 
 void Accessors::ScriptSourceGetter(
     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);
   Object* object = *Utils::OpenHandle(*info.Holder());
   Object* source = Script::cast(JSValue::cast(object)->value())->source();
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(source, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptSourceInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->source_string(),
-                      &ScriptSourceGetter, nullptr, attributes);
+                      &ScriptSourceGetter, nullptr, attributes, false);
 }
 
 
 //
 // Accessors::ScriptLineOffset
 //
 
 
 void Accessors::ScriptLineOffsetGetter(
     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);
   Object* object = *Utils::OpenHandle(*info.Holder());
   Object* res =
       Smi::FromInt(Script::cast(JSValue::cast(object)->value())->line_offset());
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(res, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptLineOffsetInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   Handle<String> name(isolate->factory()->InternalizeOneByteString(
       STATIC_CHAR_VECTOR("line_offset")));
   return MakeAccessor(isolate, name, &ScriptLineOffsetGetter, nullptr,
-                      attributes);
+                      attributes, false);
 }
 
 
 //
 // Accessors::ScriptType
 //
 
 
 void Accessors::ScriptTypeGetter(
     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);
   Object* object = *Utils::OpenHandle(*info.Holder());
   Object* res =
       Smi::FromInt(Script::cast(JSValue::cast(object)->value())->type());
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(res, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptTypeInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   Handle<String> name(
       isolate->factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("type")));
-  return MakeAccessor(isolate, name, &ScriptTypeGetter, nullptr, attributes);
+  return MakeAccessor(isolate, name, &ScriptTypeGetter, nullptr, attributes,
+                      false);
 }
 
 
 //
 // Accessors::ScriptCompilationType
 //
 
 
 void Accessors::ScriptCompilationTypeGetter(
     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);
   Object* object = *Utils::OpenHandle(*info.Holder());
   Object* res = Smi::FromInt(
       Script::cast(JSValue::cast(object)->value())->compilation_type());
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(res, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptCompilationTypeInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   Handle<String> name(isolate->factory()->InternalizeOneByteString(
       STATIC_CHAR_VECTOR("compilation_type")));
   return MakeAccessor(isolate, name, &ScriptCompilationTypeGetter, nullptr,
-                      attributes);
+                      attributes, false);
 }
 
 
 //
 // Accessors::ScriptGetLineEnds
 //
 
 
 void Accessors::ScriptLineEndsGetter(
     v8::Local<v8::Name> name,
@@ skipping 12 matching lines @@
   Handle<JSArray> js_array =
       isolate->factory()->NewJSArrayWithElements(line_ends);
   info.GetReturnValue().Set(Utils::ToLocal(js_array));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptLineEndsInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   Handle<String> name(isolate->factory()->InternalizeOneByteString(
       STATIC_CHAR_VECTOR("line_ends")));
-  return MakeAccessor(isolate, name, &ScriptLineEndsGetter, nullptr,
-                      attributes);
+  return MakeAccessor(isolate, name, &ScriptLineEndsGetter, nullptr, attributes,
+                      false);
 }
 
 
 //
 // Accessors::ScriptSourceUrl
 //
 
 
 void Accessors::ScriptSourceUrlGetter(
     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);
   Object* object = *Utils::OpenHandle(*info.Holder());
   Object* url = Script::cast(JSValue::cast(object)->value())->source_url();
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(url, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptSourceUrlInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->source_url_string(),
-                      &ScriptSourceUrlGetter, nullptr, attributes);
+                      &ScriptSourceUrlGetter, nullptr, attributes, false);
 }
 
 
 //
 // Accessors::ScriptSourceMappingUrl
 //
 
 
 void Accessors::ScriptSourceMappingUrlGetter(
     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);
   Object* object = *Utils::OpenHandle(*info.Holder());
   Object* url =
       Script::cast(JSValue::cast(object)->value())->source_mapping_url();
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(url, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptSourceMappingUrlInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->source_mapping_url_string(),
-                      &ScriptSourceMappingUrlGetter, nullptr, attributes);
+                      &ScriptSourceMappingUrlGetter, nullptr, attributes,
+                      false);
 }
 
 
 //
 // Accessors::ScriptIsEmbedderDebugScript
 //
 
 
 void Accessors::ScriptIsEmbedderDebugScriptGetter(
     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);
   Object* object = *Utils::OpenHandle(*info.Holder());
   bool is_embedder_debug_script = Script::cast(JSValue::cast(object)->value())
                                       ->origin_options()
                                       .IsEmbedderDebugScript();
   Object* res = *isolate->factory()->ToBoolean(is_embedder_debug_script);
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(res, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptIsEmbedderDebugScriptInfo(
     Isolate* isolate, PropertyAttributes attributes) {
   Handle<String> name(isolate->factory()->InternalizeOneByteString(
       STATIC_CHAR_VECTOR("is_debugger_script")));
   return MakeAccessor(isolate, name, &ScriptIsEmbedderDebugScriptGetter,
-                      nullptr, attributes);
+                      nullptr, attributes, false);
 }
 
 
 //
 // Accessors::ScriptGetContextData
 //
 
 
 void Accessors::ScriptContextDataGetter(
     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);
   Object* object = *Utils::OpenHandle(*info.Holder());
   Object* res = Script::cast(JSValue::cast(object)->value())->context_data();
   info.GetReturnValue().Set(Utils::ToLocal(Handle<Object>(res, isolate)));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptContextDataInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   Handle<String> name(isolate->factory()->InternalizeOneByteString(
       STATIC_CHAR_VECTOR("context_data")));
   return MakeAccessor(isolate, name, &ScriptContextDataGetter, nullptr,
-                      attributes);
+                      attributes, false);
 }
 
 
 //
 // Accessors::ScriptGetEvalFromScript
 //
 
 
 void Accessors::ScriptEvalFromScriptGetter(
     v8::Local<v8::Name> name,
@@ skipping 15 matching lines @@
 
   info.GetReturnValue().Set(Utils::ToLocal(result));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptEvalFromScriptInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   Handle<String> name(isolate->factory()->InternalizeOneByteString(
       STATIC_CHAR_VECTOR("eval_from_script")));
   return MakeAccessor(isolate, name, &ScriptEvalFromScriptGetter, nullptr,
-                      attributes);
+                      attributes, false);
 }
 
 
 //
 // Accessors::ScriptGetEvalFromScriptPosition
 //
 
 
 void Accessors::ScriptEvalFromScriptPositionGetter(
     v8::Local<v8::Name> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(info.GetIsolate());
   HandleScope scope(isolate);
   Handle<Object> object = Utils::OpenHandle(*info.Holder());
   Handle<Script> script(
       Script::cast(Handle<JSValue>::cast(object)->value()), isolate);
   Handle<Object> result = isolate->factory()->undefined_value();
   if (script->compilation_type() == Script::COMPILATION_TYPE_EVAL) {
     result = Handle<Object>(Smi::FromInt(script->GetEvalPosition()), isolate);
   }
   info.GetReturnValue().Set(Utils::ToLocal(result));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptEvalFromScriptPositionInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   Handle<String> name(isolate->factory()->InternalizeOneByteString(
       STATIC_CHAR_VECTOR("eval_from_script_position")));
   return MakeAccessor(isolate, name, &ScriptEvalFromScriptPositionGetter,
-                      nullptr, attributes);
+                      nullptr, attributes, false);
 }
 
 
 //
 // Accessors::ScriptGetEvalFromFunctionName
 //
 
 
 void Accessors::ScriptEvalFromFunctionNameGetter(
     v8::Local<v8::Name> name,
@@ skipping 16 matching lines @@
   }
   info.GetReturnValue().Set(Utils::ToLocal(result));
 }
 
 
 Handle<AccessorInfo> Accessors::ScriptEvalFromFunctionNameInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   Handle<String> name(isolate->factory()->InternalizeOneByteString(
       STATIC_CHAR_VECTOR("eval_from_function_name")));
   return MakeAccessor(isolate, name, &ScriptEvalFromFunctionNameGetter, nullptr,
-                      attributes);
+                      attributes, false);
 }
 
 
 //
 // Accessors::FunctionPrototype
 //
 
 static Handle<Object> GetFunctionPrototype(Isolate* isolate,
                                            Handle<JSFunction> function) {
   if (!function->has_prototype()) {
@@ skipping 44 matching lines @@
   if (SetFunctionPrototype(isolate, object, value).is_null()) {
     isolate->OptionalRescheduleException(false);
   } else {
     info.GetReturnValue().Set(true);
   }
 }
 
 
 Handle<AccessorInfo> Accessors::FunctionPrototypeInfo(
       Isolate* isolate, PropertyAttributes attributes) {
-  return MakeAccessor(isolate,
-                      isolate->factory()->prototype_string(),
-                      &FunctionPrototypeGetter,
-                      &FunctionPrototypeSetter,
-                      attributes);
+  return MakeAccessor(isolate, isolate->factory()->prototype_string(),
+                      &FunctionPrototypeGetter, &FunctionPrototypeSetter,
+                      attributes, false);
 }
 
 
 //
 // Accessors::FunctionLength
 //
 
 
 void Accessors::FunctionLengthGetter(
     v8::Local<v8::Name> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(info.GetIsolate());
   HandleScope scope(isolate);
   Handle<JSFunction> function =
       Handle<JSFunction>::cast(Utils::OpenHandle(*info.Holder()));
   Handle<Object> result;
   if (!JSFunction::GetLength(isolate, function).ToHandle(&result)) {
     result = handle(Smi::kZero, isolate);
     isolate->OptionalRescheduleException(false);
   }
 
   info.GetReturnValue().Set(Utils::ToLocal(result));
 }
 
 Handle<AccessorInfo> Accessors::FunctionLengthInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->length_string(),
-                      &FunctionLengthGetter, &ReconfigureToDataProperty,
-                      attributes);
+                      &FunctionLengthGetter, nullptr, attributes, true);

[Toon Verwaest, 2016/10/28 14:05:21]

This technically all works, but it won't give good perf / memory at all :)

 }
 
 
 //
 // Accessors::FunctionName
 //
 
 
 void Accessors::FunctionNameGetter(
     v8::Local<v8::Name> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(info.GetIsolate());
   HandleScope scope(isolate);
   Handle<JSFunction> function =
       Handle<JSFunction>::cast(Utils::OpenHandle(*info.Holder()));
   Handle<Object> result = JSFunction::GetName(isolate, function);
   info.GetReturnValue().Set(Utils::ToLocal(result));
 }
 
 Handle<AccessorInfo> Accessors::FunctionNameInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->name_string(),
-                      &FunctionNameGetter, &ReconfigureToDataProperty,
-                      attributes);
+                      &FunctionNameGetter, nullptr, attributes, true);
 }
 
 
 //
 // Accessors::FunctionArguments
 //
 
 
 static Handle<Object> ArgumentsForInlinedFunction(
     JavaScriptFrame* frame,
@@ skipping 126 matching lines @@
       function->shared()->native()
           ? Handle<Object>::cast(isolate->factory()->null_value())
           : GetFunctionArguments(isolate, function);
   info.GetReturnValue().Set(Utils::ToLocal(result));
 }
 
 
 Handle<AccessorInfo> Accessors::FunctionArgumentsInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->arguments_string(),
-                      &FunctionArgumentsGetter, nullptr, attributes);
+                      &FunctionArgumentsGetter, nullptr, attributes, false);
 }
 
 
 //
 // Accessors::FunctionCaller
 //
 
 
 static inline bool AllowAccessToFunction(Context* current_context,
                                          JSFunction* function) {
@@ skipping 112 matching lines @@
   } else {
     result = isolate->factory()->null_value();
   }
   info.GetReturnValue().Set(Utils::ToLocal(result));
 }
 
 
 Handle<AccessorInfo> Accessors::FunctionCallerInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->caller_string(),
-                      &FunctionCallerGetter, nullptr, attributes);
+                      &FunctionCallerGetter, nullptr, attributes, false);
 }
 
 
 //
 // Accessors::BoundFunctionLength
 //
 
 void Accessors::BoundFunctionLengthGetter(
     v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(info.GetIsolate());
@@ skipping 16 matching lines @@
   int bound_length = function->bound_arguments()->length();
   int length = Max(0, target_length->value() - bound_length);
 
   Handle<Object> result(Smi::FromInt(length), isolate);
   info.GetReturnValue().Set(Utils::ToLocal(result));
 }
 
 Handle<AccessorInfo> Accessors::BoundFunctionLengthInfo(
     Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->length_string(),
-                      &BoundFunctionLengthGetter, &ReconfigureToDataProperty,
-                      attributes);
+                      &BoundFunctionLengthGetter, nullptr, attributes, true);
 }
 
 //
 // Accessors::BoundFunctionName
 //
 
 void Accessors::BoundFunctionNameGetter(
     v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(info.GetIsolate());
   RuntimeCallTimerScope timer(
       isolate, &RuntimeCallStats::AccessorNameGetterCallback_BoundFunctionName);
   HandleScope scope(isolate);
   Handle<JSBoundFunction> function =
       Handle<JSBoundFunction>::cast(Utils::OpenHandle(*info.Holder()));
   Handle<Object> result;
   if (!JSBoundFunction::GetName(isolate, function).ToHandle(&result)) {
     isolate->OptionalRescheduleException(false);
     return;
   }
   info.GetReturnValue().Set(Utils::ToLocal(result));
 }
 
 Handle<AccessorInfo> Accessors::BoundFunctionNameInfo(
     Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->name_string(),
-                      &BoundFunctionNameGetter, &ReconfigureToDataProperty,
-                      attributes);
+                      &BoundFunctionNameGetter, nullptr, attributes, true);
 }
 
 //
 // Accessors::ErrorStack
 //
 
 namespace {
 
 MaybeHandle<JSReceiver> ClearInternalStackTrace(Isolate* isolate,
                                                 Handle<JSObject> error) {
@@ skipping 94 matching lines @@
     ClearInternalStackTrace(isolate, obj);
   }
 
   Accessors::ReconfigureToDataProperty(name, val, info);
 }
 
 Handle<AccessorInfo> Accessors::ErrorStackInfo(Isolate* isolate,
                                                PropertyAttributes attributes) {
   Handle<AccessorInfo> info =
       MakeAccessor(isolate, isolate->factory()->stack_string(),
-                   &ErrorStackGetter, &ErrorStackSetter, attributes);
+                   &ErrorStackGetter, &ErrorStackSetter, attributes, false);
   return info;
 }
 
 }  // namespace internal
 }  // namespace v8