Remove special ExecutableAccessorInfo handling based on flag

src/objects.cc

 // Copyright 2013 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/accessors.h"
 #include "src/allocation-site-scopes.h"
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 4186 matching lines @@
 // callback setter removed.  The two lines looking up the LookupResult
 // result are also added.  If one of the functions is changed, the other
 // should be.
 MaybeHandle<Object> JSObject::SetOwnPropertyIgnoreAttributes(
     Handle<JSObject> object,
     Handle<Name> name,
     Handle<Object> value,
     PropertyAttributes attributes,
     StoreMode mode,
     ExtensibilityCheck extensibility_check,
-    StoreFromKeyed store_from_keyed,
-    ExecutableAccessorInfoHandling handling) {
+    StoreFromKeyed store_from_keyed) {
   Isolate* isolate = object->GetIsolate();
 
   // Make sure that the top context does not change when doing callbacks or
   // interceptor calls.
   AssertNoContextChange ncc(isolate);
 
   LookupResult lookup(isolate);
   object->LookupOwn(name, &lookup, true);
   if (!lookup.IsFound()) {
     object->map()->LookupTransition(*object, *name, &lookup);
@@ skipping 34 matching lines @@
   PropertyAttributes old_attributes = ABSENT;
   bool is_observed = object->map()->is_observed() &&
                      *name != isolate->heap()->hidden_string();
   if (is_observed && lookup.IsProperty()) {
     if (lookup.IsDataProperty()) {
       old_value = Object::GetPropertyOrElement(object, name).ToHandleChecked();
     }
     old_attributes = lookup.GetAttributes();
   }
 
-  bool executed_set_prototype = false;
-
   // Check of IsReadOnly removed from here in clone.
   if (lookup.IsTransition()) {
     Handle<Object> result;
     ASSIGN_RETURN_ON_EXCEPTION(
         isolate, result,
         SetPropertyUsingTransition(
             handle(lookup.holder()), &lookup, name, value, attributes),
         Object);
   } else {
     switch (lookup.type()) {
       case NORMAL:
         ReplaceSlowProperty(object, name, value, attributes);
         break;
       case FIELD:
         SetPropertyToFieldWithAttributes(&lookup, name, value, attributes);
         break;
       case CONSTANT:
         // Only replace the constant if necessary.
         if (lookup.GetAttributes() != attributes ||
             *value != lookup.GetConstant()) {
           SetPropertyToFieldWithAttributes(&lookup, name, value, attributes);
         }
         break;
-      case CALLBACKS:
-      {
+      case CALLBACKS: {
         Handle<Object> callback(lookup.GetCallbackObject(), isolate);
-        if (callback->IsExecutableAccessorInfo() &&
-            handling == DONT_FORCE_FIELD) {
+        if (callback->IsExecutableAccessorInfo()) {
           Handle<Object> result;
           ASSIGN_RETURN_ON_EXCEPTION(
               isolate, result,
               JSObject::SetPropertyWithCallback(object,
                                                 name,
                                                 value,
                                                 handle(lookup.holder()),
                                                 callback,
                                                 STRICT),
               Object);
 
-          if (attributes != lookup.GetAttributes()) {
-            Handle<ExecutableAccessorInfo> new_data =
-                Accessors::CloneAccessor(
-                    isolate, Handle<ExecutableAccessorInfo>::cast(callback));
-            new_data->set_property_attributes(attributes);
-            if (attributes & READ_ONLY) {
-              // This way we don't have to introduce a lookup to the setter,
-              // simply make it unavailable to reflect the attributes.
-              new_data->clear_setter();
+          if (attributes == lookup.GetAttributes()) return result;
+
+          Handle<ExecutableAccessorInfo> new_data =
+              Accessors::CloneAccessor(
+                  isolate, Handle<ExecutableAccessorInfo>::cast(callback));
+          new_data->set_property_attributes(attributes);
+          // This way we don't have to introduce a lookup to the setter, simply
+          // make it unavailable to reflect the attributes.
+          if (attributes & READ_ONLY) new_data->clear_setter();
+          SetPropertyCallback(object, name, new_data, attributes);
+
+          if (is_observed) {
+            Handle<Object> new_value =
+                Object::GetPropertyOrElement(object, name).ToHandleChecked();
+            if (old_value->SameValue(*new_value)) {
+              old_value = isolate->factory()->the_hole_value();
             }
+            EnqueueChangeRecord(object, "reconfigure", name, old_value);
+          }
 
-            SetPropertyCallback(object, name, new_data, attributes);
-          }
-          if (is_observed) {
-            // If we are setting the prototype of a function and are observed,
-            // don't send change records because the prototype handles that
-            // itself.
-            executed_set_prototype = object->IsJSFunction() &&
-                String::Equals(isolate->factory()->prototype_string(),
-                               Handle<String>::cast(name)) &&
-                Handle<JSFunction>::cast(object)->should_have_prototype();
-          }
-        } else {
-          ConvertAndSetOwnProperty(&lookup, name, value, attributes);
+          return result;
         }
+        ConvertAndSetOwnProperty(&lookup, name, value, attributes);
         break;
       }
       case NONEXISTENT:
       case HANDLER:
       case INTERCEPTOR:
         UNREACHABLE();
     }
   }
 
-  if (is_observed && !executed_set_prototype) {
+  if (is_observed) {
     if (lookup.IsTransition()) {
       EnqueueChangeRecord(object, "add", name, old_value);
     } else if (old_value->IsTheHole()) {
       EnqueueChangeRecord(object, "reconfigure", name, old_value);
     } else {
       LookupResult new_lookup(isolate);
       object->LookupOwn(name, &new_lookup, true);
       bool value_changed = false;
       if (new_lookup.IsDataProperty()) {
         Handle<Object> new_value =
@@ skipping 12594 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal