[api] Add DefineProperty() method that skips interceptors.

src/objects.cc

 // Copyright 2015 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/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <memory>
 #include <sstream>
@@ skipping 4465 matching lines @@
         }
         if (PropertyDescriptor::IsAccessorDescriptor(&desc) ||
             !desc.writable()) {
           return RedefineIncompatibleProperty(isolate, it->GetName(), value,
                                               should_throw);
         }
 
         PropertyDescriptor value_desc;
         value_desc.set_value(value);
         return JSReceiver::DefineOwnProperty(isolate, receiver, it->GetName(),
-                                             &value_desc, should_throw);
+                                             &value_desc, should_throw, false);
       }
 
       case LookupIterator::NOT_FOUND:
       case LookupIterator::TRANSITION:
         UNREACHABLE();
     }
   }
 
   return AddDataProperty(&own_lookup, value, NONE, should_throw, store_mode);
 }
@@ skipping 1597 matching lines @@
                                                 LanguageMode language_mode) {
   LookupIterator it = LookupIterator::PropertyOrElement(
       name->GetIsolate(), object, name, object, LookupIterator::OWN);
   return DeleteProperty(&it, language_mode);
 }
 
 // ES6 19.1.2.4
 // static
 Object* JSReceiver::DefineProperty(Isolate* isolate, Handle<Object> object,
                                    Handle<Object> key,
-                                   Handle<Object> attributes) {
+                                   Handle<Object> attributes,
+                                   bool bypass_interceptor) {
   // 1. If Type(O) is not Object, throw a TypeError exception.
   if (!object->IsJSReceiver()) {
     Handle<String> fun_name =
         isolate->factory()->InternalizeUtf8String("Object.defineProperty");
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kCalledOnNonObject, fun_name));
   }
   // 2. Let key be ToPropertyKey(P).
   // 3. ReturnIfAbrupt(key).
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, key, ToPropertyKey(isolate, key));
   // 4. Let desc be ToPropertyDescriptor(Attributes).
   // 5. ReturnIfAbrupt(desc).
   PropertyDescriptor desc;
   if (!PropertyDescriptor::ToPropertyDescriptor(isolate, attributes, &desc)) {
     return isolate->heap()->exception();
   }
   // 6. Let success be DefinePropertyOrThrow(O,key, desc).
-  Maybe<bool> success = DefineOwnProperty(
-      isolate, Handle<JSReceiver>::cast(object), key, &desc, THROW_ON_ERROR);
+  Maybe<bool> success =
+      DefineOwnProperty(isolate, Handle<JSReceiver>::cast(object), key, &desc,
+                        THROW_ON_ERROR, bypass_interceptor);
   // 7. ReturnIfAbrupt(success).
   MAYBE_RETURN(success, isolate->heap()->exception());
   CHECK(success.FromJust());
   // 8. Return O.
   return *object;
 }
 
-
 // ES6 19.1.2.3.1
 // static
 MaybeHandle<Object> JSReceiver::DefineProperties(Isolate* isolate,
                                                  Handle<Object> object,
                                                  Handle<Object> properties) {
   // 1. If Type(O) is not Object, throw a TypeError exception.
   if (!object->IsJSReceiver()) {
     Handle<String> fun_name =
         isolate->factory()->InternalizeUtf8String("Object.defineProperties");
     THROW_NEW_ERROR(isolate,
@@ skipping 63 matching lines @@
   // 9. Return o.
   return object;
 }
 
 
 // static
 Maybe<bool> JSReceiver::DefineOwnProperty(Isolate* isolate,
                                           Handle<JSReceiver> object,
                                           Handle<Object> key,
                                           PropertyDescriptor* desc,
-                                          ShouldThrow should_throw) {
+                                          ShouldThrow should_throw,
+                                          bool bypass_interceptor) {
   if (object->IsJSArray()) {
     return JSArray::DefineOwnProperty(isolate, Handle<JSArray>::cast(object),
-                                      key, desc, should_throw);
+                                      key, desc, should_throw,
+                                      bypass_interceptor);
   }
   if (object->IsJSProxy()) {
     return JSProxy::DefineOwnProperty(isolate, Handle<JSProxy>::cast(object),
-                                      key, desc, should_throw);
+                                      key, desc, should_throw,
+                                      bypass_interceptor);
   }
   if (object->IsJSTypedArray()) {
     return JSTypedArray::DefineOwnProperty(
-        isolate, Handle<JSTypedArray>::cast(object), key, desc, should_throw);
+        isolate, Handle<JSTypedArray>::cast(object), key, desc, should_throw,
+        bypass_interceptor);
   }
   // TODO(neis): Special case for JSModuleNamespace?
 
   // OrdinaryDefineOwnProperty, by virtue of calling
   // DefineOwnPropertyIgnoreAttributes, can handle arguments
   // (ES#sec-arguments-exotic-objects-defineownproperty-p-desc).
   return OrdinaryDefineOwnProperty(isolate, Handle<JSObject>::cast(object), key,
-                                   desc, should_throw);
+                                   desc, should_throw, bypass_interceptor);
 }
 
-
 // static
 Maybe<bool> JSReceiver::OrdinaryDefineOwnProperty(Isolate* isolate,
                                                   Handle<JSObject> object,
                                                   Handle<Object> key,
                                                   PropertyDescriptor* desc,
-                                                  ShouldThrow should_throw) {
+                                                  ShouldThrow should_throw,
+                                                  bool bypass_interceptor) {
   bool success = false;
   DCHECK(key->IsName() || key->IsNumber());  // |key| is a PropertyKey...
-  LookupIterator it = LookupIterator::PropertyOrElement(
-      isolate, object, key, &success, LookupIterator::OWN);
+
+  LookupIterator::Configuration ItBase = LookupIterator::OWN;

[Franzi, 2017/05/10 09:17:52]

Can we name this iterator_config or config?

+  if (bypass_interceptor) {
+    ItBase = LookupIterator::OWN_SKIP_INTERCEPTOR;
+  }
+
+  LookupIterator it =
+      LookupIterator::PropertyOrElement(isolate, object, key, &success, ItBase);
+
   DCHECK(success);  // ...so creating a LookupIterator can't fail.
 
   // Deal with access checks first.
   if (it.state() == LookupIterator::ACCESS_CHECK) {
     if (!it.HasAccess()) {
       isolate->ReportFailedAccessCheck(it.GetHolder<JSObject>());
       RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate, Nothing<bool>());
       return Just(true);
     }
     it.Next();
   }
 

[Franzi, 2017/05/10 09:17:52]

I think if OWN_SKIP_INTERCEPTOR was used, the state is never INTERCEPTOR? Could
you check if removing that if breaks the tests?

-  // Handle interceptor
-  if (it.state() == LookupIterator::INTERCEPTOR) {
-    if (it.HolderIsReceiverOrHiddenPrototype()) {
-      Maybe<bool> result = DefinePropertyWithInterceptorInternal(
-          &it, it.GetInterceptor(), should_throw, *desc);
-      if (result.IsNothing() || result.FromJust()) {
-        return result;
+  if (!bypass_interceptor) {
+    // Handle interceptor
+    if (it.state() == LookupIterator::INTERCEPTOR) {
+      if (it.HolderIsReceiverOrHiddenPrototype()) {
+        Maybe<bool> result = DefinePropertyWithInterceptorInternal(
+            &it, it.GetInterceptor(), should_throw, *desc);
+        if (result.IsNothing() || result.FromJust()) {
+          return result;
+        }
       }
     }
   }
 
   return OrdinaryDefineOwnProperty(&it, desc, should_throw);
 }
 
 
 // ES6 9.1.6.1
 // static
@@ skipping 303 matching lines @@
     return JSObject::CreateDataProperty(it, value, should_throw);  // Shortcut.
   }
 
   PropertyDescriptor new_desc;
   new_desc.set_value(value);
   new_desc.set_writable(true);
   new_desc.set_enumerable(true);
   new_desc.set_configurable(true);
 
   return JSReceiver::DefineOwnProperty(isolate, receiver, it->GetName(),
-                                       &new_desc, should_throw);
+                                       &new_desc, should_throw, false);

[Franzi, 2017/05/10 09:17:52]

Do we need the last parameter? I thought it has a default value. 

 }
 
 Maybe<bool> JSObject::CreateDataProperty(LookupIterator* it,
                                          Handle<Object> value,
                                          ShouldThrow should_throw) {
   DCHECK(it->GetReceiver()->IsJSObject());
   MAYBE_RETURN(JSReceiver::GetPropertyAttributes(it), Nothing<bool>());
   Handle<JSReceiver> receiver = Handle<JSReceiver>::cast(it->GetReceiver());
   Isolate* isolate = receiver->GetIsolate();
 
@@ skipping 33 matching lines @@
 bool PropertyKeyToArrayIndex(Handle<Object> index_obj, uint32_t* output) {
   return PropertyKeyToArrayLength(index_obj, output) && *output != kMaxUInt32;
 }
 
 
 // ES6 9.4.2.1
 // static
 Maybe<bool> JSArray::DefineOwnProperty(Isolate* isolate, Handle<JSArray> o,
                                        Handle<Object> name,
                                        PropertyDescriptor* desc,
-                                       ShouldThrow should_throw) {
+                                       ShouldThrow should_throw,
+                                       bool bypass_interceptor) {
   // 1. Assert: IsPropertyKey(P) is true. ("P" is |name|.)
   // 2. If P is "length", then:
   // TODO(jkummerow): Check if we need slow string comparison.
   if (*name == isolate->heap()->length_string()) {
     // 2a. Return ArraySetLength(A, Desc).
-    return ArraySetLength(isolate, o, desc, should_throw);
+    return ArraySetLength(isolate, o, desc, should_throw, bypass_interceptor);
   }
   // 3. Else if P is an array index, then:
   uint32_t index = 0;
   if (PropertyKeyToArrayIndex(name, &index)) {
     // 3a. Let oldLenDesc be OrdinaryGetOwnProperty(A, "length").
     PropertyDescriptor old_len_desc;
     Maybe<bool> success = GetOwnPropertyDescriptor(
         isolate, o, isolate->factory()->length_string(), &old_len_desc);
     // 3b. (Assert)
     DCHECK(success.FromJust());
     USE(success);
     // 3c. Let oldLen be oldLenDesc.[[Value]].
     uint32_t old_len = 0;
     CHECK(old_len_desc.value()->ToArrayLength(&old_len));
     // 3d. Let index be ToUint32(P).
     // (Already done above.)
     // 3e. (Assert)
     // 3f. If index >= oldLen and oldLenDesc.[[Writable]] is false,
     //     return false.
     if (index >= old_len && old_len_desc.has_writable() &&
         !old_len_desc.writable()) {
       RETURN_FAILURE(isolate, should_throw,
                      NewTypeError(MessageTemplate::kDefineDisallowed, name));
     }
     // 3g. Let succeeded be OrdinaryDefineOwnProperty(A, P, Desc).
-    Maybe<bool> succeeded =
-        OrdinaryDefineOwnProperty(isolate, o, name, desc, should_throw);
+    Maybe<bool> succeeded = OrdinaryDefineOwnProperty(
+        isolate, o, name, desc, should_throw, bypass_interceptor);
     // 3h. Assert: succeeded is not an abrupt completion.
     //     In our case, if should_throw == THROW_ON_ERROR, it can be!
     // 3i. If succeeded is false, return false.
     if (succeeded.IsNothing() || !succeeded.FromJust()) return succeeded;
     // 3j. If index >= oldLen, then:
     if (index >= old_len) {
       // 3j i. Set oldLenDesc.[[Value]] to index + 1.
       old_len_desc.set_value(isolate->factory()->NewNumberFromUint(index + 1));
       // 3j ii. Let succeeded be
       //        OrdinaryDefineOwnProperty(A, "length", oldLenDesc).
-      succeeded = OrdinaryDefineOwnProperty(isolate, o,
-                                            isolate->factory()->length_string(),
-                                            &old_len_desc, should_throw);
+      succeeded = OrdinaryDefineOwnProperty(
+          isolate, o, isolate->factory()->length_string(), &old_len_desc,
+          should_throw, bypass_interceptor);
       // 3j iii. Assert: succeeded is true.
       DCHECK(succeeded.FromJust());
       USE(succeeded);
     }
     // 3k. Return true.
     return Just(true);
   }
 
   // 4. Return OrdinaryDefineOwnProperty(A, P, Desc).
-  return OrdinaryDefineOwnProperty(isolate, o, name, desc, should_throw);
+  return OrdinaryDefineOwnProperty(isolate, o, name, desc, should_throw,
+                                   bypass_interceptor);
 }
 
 
 // Part of ES6 9.4.2.4 ArraySetLength.
 // static
 bool JSArray::AnythingToArrayLength(Isolate* isolate,
                                     Handle<Object> length_object,
                                     uint32_t* output) {
   // Fast path: check numbers and strings that can be converted directly
   // and unobservably.
@@ skipping 24 matching lines @@
   }
   CHECK(uint32_v->ToArrayLength(output));
   return true;
 }
 
 
 // ES6 9.4.2.4
 // static
 Maybe<bool> JSArray::ArraySetLength(Isolate* isolate, Handle<JSArray> a,
                                     PropertyDescriptor* desc,
-                                    ShouldThrow should_throw) {
+                                    ShouldThrow should_throw,
+                                    bool bypass_interceptor = false) {
   // 1. If the [[Value]] field of Desc is absent, then
   if (!desc->has_value()) {
     // 1a. Return OrdinaryDefineOwnProperty(A, "length", Desc).
-    return OrdinaryDefineOwnProperty(
-        isolate, a, isolate->factory()->length_string(), desc, should_throw);
+    return OrdinaryDefineOwnProperty(isolate, a,
+                                     isolate->factory()->length_string(), desc,
+                                     should_throw, bypass_interceptor);
   }
   // 2. Let newLenDesc be a copy of Desc.
   // (Actual copying is not necessary.)
   PropertyDescriptor* new_len_desc = desc;
   // 3. - 7. Convert Desc.[[Value]] to newLen.
   uint32_t new_len = 0;
   if (!AnythingToArrayLength(isolate, desc->value(), &new_len)) {
     DCHECK(isolate->has_pending_exception());
     return Nothing<bool>();
   }
   // 8. Set newLenDesc.[[Value]] to newLen.
   // (Done below, if needed.)
   // 9. Let oldLenDesc be OrdinaryGetOwnProperty(A, "length").
   PropertyDescriptor old_len_desc;
   Maybe<bool> success = GetOwnPropertyDescriptor(
       isolate, a, isolate->factory()->length_string(), &old_len_desc);
   // 10. (Assert)
   DCHECK(success.FromJust());
   USE(success);
   // 11. Let oldLen be oldLenDesc.[[Value]].
   uint32_t old_len = 0;
   CHECK(old_len_desc.value()->ToArrayLength(&old_len));
   // 12. If newLen >= oldLen, then
   if (new_len >= old_len) {
     // 8. Set newLenDesc.[[Value]] to newLen.
     // 12a. Return OrdinaryDefineOwnProperty(A, "length", newLenDesc).
     new_len_desc->set_value(isolate->factory()->NewNumberFromUint(new_len));
-    return OrdinaryDefineOwnProperty(isolate, a,
-                                     isolate->factory()->length_string(),
-                                     new_len_desc, should_throw);
+    return OrdinaryDefineOwnProperty(
+        isolate, a, isolate->factory()->length_string(), new_len_desc,
+        should_throw, bypass_interceptor);
   }
   // 13. If oldLenDesc.[[Writable]] is false, return false.
   if (!old_len_desc.writable()) {
     RETURN_FAILURE(isolate, should_throw,
                    NewTypeError(MessageTemplate::kRedefineDisallowed,
                                 isolate->factory()->length_string()));
   }
   // 14. If newLenDesc.[[Writable]] is absent or has the value true,
   // let newWritable be true.
   bool new_writable = false;
   if (!new_len_desc->has_writable() || new_len_desc->writable()) {
     new_writable = true;
   } else {
     // 15. Else,
     // 15a. Need to defer setting the [[Writable]] attribute to false in case
     //      any elements cannot be deleted.
     // 15b. Let newWritable be false. (It's initialized as "false" anyway.)
     // 15c. Set newLenDesc.[[Writable]] to true.
     // (Not needed.)
   }
   // Most of steps 16 through 19 is implemented by JSArray::SetLength.
   JSArray::SetLength(a, new_len);
   // Steps 19d-ii, 20.
   if (!new_writable) {
     PropertyDescriptor readonly;
     readonly.set_writable(false);
     Maybe<bool> success = OrdinaryDefineOwnProperty(
         isolate, a, isolate->factory()->length_string(), &readonly,
-        should_throw);
+        should_throw, bypass_interceptor);
     DCHECK(success.FromJust());
     USE(success);
   }
   uint32_t actual_new_len = 0;
   CHECK(a->length()->ToArrayLength(&actual_new_len));
   // Steps 19d-v, 21. Return false if there were non-deletable elements.
   bool result = actual_new_len == new_len;
   if (!result) {
     RETURN_FAILURE(
         isolate, should_throw,
         NewTypeError(MessageTemplate::kStrictDeleteProperty,
                      isolate->factory()->NewNumberFromUint(actual_new_len - 1),
                      a));
   }
   return Just(result);
 }
 
 
 // ES6 9.5.6
 // static
 Maybe<bool> JSProxy::DefineOwnProperty(Isolate* isolate, Handle<JSProxy> proxy,
                                        Handle<Object> key,
                                        PropertyDescriptor* desc,
-                                       ShouldThrow should_throw) {
+                                       ShouldThrow should_throw,
+                                       bool bypass_interceptor) {
   STACK_CHECK(isolate, Nothing<bool>());
   if (key->IsSymbol() && Handle<Symbol>::cast(key)->IsPrivate()) {
     return SetPrivateProperty(isolate, proxy, Handle<Symbol>::cast(key), desc,
                               should_throw);
   }
   Handle<String> trap_name = isolate->factory()->defineProperty_string();
   // 1. Assert: IsPropertyKey(P) is true.
   DCHECK(key->IsName() || key->IsNumber());
   // 2. Let handler be the value of the [[ProxyHandler]] internal slot of O.
   Handle<Object> handler(proxy->handler(), isolate);
   // 3. If handler is null, throw a TypeError exception.
   // 4. Assert: Type(handler) is Object.
   if (proxy->IsRevoked()) {
     isolate->Throw(*isolate->factory()->NewTypeError(
         MessageTemplate::kProxyRevoked, trap_name));
     return Nothing<bool>();
   }
   // 5. Let target be the value of the [[ProxyTarget]] internal slot of O.
   Handle<JSReceiver> target(proxy->target(), isolate);
   // 6. Let trap be ? GetMethod(handler, "defineProperty").
   Handle<Object> trap;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap,
       Object::GetMethod(Handle<JSReceiver>::cast(handler), trap_name),
       Nothing<bool>());
   // 7. If trap is undefined, then:
   if (trap->IsUndefined(isolate)) {
     // 7a. Return target.[[DefineOwnProperty]](P, Desc).
     return JSReceiver::DefineOwnProperty(isolate, target, key, desc,
-                                         should_throw);
+                                         should_throw, bypass_interceptor);
   }
   // 8. Let descObj be FromPropertyDescriptor(Desc).
   Handle<Object> desc_obj = desc->ToObject(isolate);
   // 9. Let booleanTrapResult be
   //    ToBoolean(? Call(trap, handler, «target, P, descObj»)).
   Handle<Name> property_name =
       key->IsName()
           ? Handle<Name>::cast(key)
           : Handle<Name>::cast(isolate->factory()->NumberToString(key));
   // Do not leak private property names.
@@ skipping 522 matching lines @@
   PropertyDescriptor no_conf;
   no_conf.set_configurable(false);
 
   PropertyDescriptor no_conf_no_write;
   no_conf_no_write.set_configurable(false);
   no_conf_no_write.set_writable(false);
 
   if (level == SEALED) {
     for (int i = 0; i < keys->length(); ++i) {
       Handle<Object> key(keys->get(i), isolate);
-      MAYBE_RETURN(
-          DefineOwnProperty(isolate, receiver, key, &no_conf, THROW_ON_ERROR),
-          Nothing<bool>());
+      MAYBE_RETURN(DefineOwnProperty(isolate, receiver, key, &no_conf,
+                                     THROW_ON_ERROR, false),
+                   Nothing<bool>());
     }
     return Just(true);
   }
 
   for (int i = 0; i < keys->length(); ++i) {
     Handle<Object> key(keys->get(i), isolate);
     PropertyDescriptor current_desc;
     Maybe<bool> owned = JSReceiver::GetOwnPropertyDescriptor(
         isolate, receiver, key, &current_desc);
     MAYBE_RETURN(owned, Nothing<bool>());
     if (owned.FromJust()) {
       PropertyDescriptor desc =
           PropertyDescriptor::IsAccessorDescriptor(&current_desc)
               ? no_conf
               : no_conf_no_write;
-      MAYBE_RETURN(
-          DefineOwnProperty(isolate, receiver, key, &desc, THROW_ON_ERROR),
-          Nothing<bool>());
+      MAYBE_RETURN(DefineOwnProperty(isolate, receiver, key, &desc,
+                                     THROW_ON_ERROR, false),
+                   Nothing<bool>());
     }
   }
   return Just(true);
 }
 
 
 Maybe<bool> JSReceiver::TestIntegrityLevel(Handle<JSReceiver> object,
                                            IntegrityLevel level) {
   DCHECK(level == SEALED || level == FROZEN);
   Isolate* isolate = object->GetIsolate();
@@ skipping 9719 matching lines @@
 }
 
 }  // anonymous namespace
 
 // ES#sec-integer-indexed-exotic-objects-defineownproperty-p-desc
 // static
 Maybe<bool> JSTypedArray::DefineOwnProperty(Isolate* isolate,
                                             Handle<JSTypedArray> o,
                                             Handle<Object> key,
                                             PropertyDescriptor* desc,
-                                            ShouldThrow should_throw) {
+                                            ShouldThrow should_throw,
+                                            bool bypass_interceptor) {
   // 1. Assert: IsPropertyKey(P) is true.
   DCHECK(key->IsName() || key->IsNumber());
   // 2. Assert: O is an Object that has a [[ViewedArrayBuffer]] internal slot.
   // 3. If Type(P) is String, then
   if (key->IsString() || key->IsSmi()) {
     // 3a. Let numericIndex be ! CanonicalNumericIndexString(P)
     // 3b. If numericIndex is not undefined, then
     Handle<Object> numeric_index;
     if (CanonicalNumericIndexString(isolate, key, &numeric_index)) {
       // 3b i. If IsInteger(numericIndex) is false, return false.
@@ skipping 40 matching lines @@
         RETURN_ON_EXCEPTION_VALUE(isolate,
                                   SetOwnElementIgnoreAttributes(
                                       o, index, value, desc->ToAttributes()),
                                   Nothing<bool>());
       }
       // 3b xi. Return true.
       return Just(true);
     }
   }
   // 4. Return ! OrdinaryDefineOwnProperty(O, P, Desc).
-  return OrdinaryDefineOwnProperty(isolate, o, key, desc, should_throw);
+  return OrdinaryDefineOwnProperty(isolate, o, key, desc, should_throw,
+                                   bypass_interceptor);
 }
 
 ExternalArrayType JSTypedArray::type() {
   switch (elements()->map()->instance_type()) {
 #define INSTANCE_TYPE_TO_ARRAY_TYPE(Type, type, TYPE, ctype, size)            \
     case FIXED_##TYPE##_ARRAY_TYPE:                                           \
       return kExternal##Type##Array;
 
     TYPED_ARRAYS(INSTANCE_TYPE_TO_ARRAY_TYPE)
 #undef INSTANCE_TYPE_TO_ARRAY_TYPE
@@ skipping 3182 matching lines @@
       // depend on this.
       return DICTIONARY_ELEMENTS;
     }
     DCHECK_LE(kind, LAST_ELEMENTS_KIND);
     return kind;
   }
 }
 
 }  // namespace internal
 }  // namespace v8