[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 6117 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,
+                                   CallInterceptors call_interceptors) {
   // 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, call_interceptors);
   // 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,
+                                          CallInterceptors call_interceptors) {
   if (object->IsJSArray()) {
     return JSArray::DefineOwnProperty(isolate, Handle<JSArray>::cast(object),
-                                      key, desc, should_throw);
+                                      key, desc, should_throw,
+                                      call_interceptors);
   }
   if (object->IsJSProxy()) {
     return JSProxy::DefineOwnProperty(isolate, Handle<JSProxy>::cast(object),
-                                      key, desc, should_throw);
+                                      key, desc, should_throw,
+                                      call_interceptors);
   }
   if (object->IsJSTypedArray()) {
     return JSTypedArray::DefineOwnProperty(
-        isolate, Handle<JSTypedArray>::cast(object), key, desc, should_throw);
+        isolate, Handle<JSTypedArray>::cast(object), key, desc, should_throw,
+        call_interceptors);
   }
   // 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, call_interceptors);
 }
 
-
 // static
-Maybe<bool> JSReceiver::OrdinaryDefineOwnProperty(Isolate* isolate,
-                                                  Handle<JSObject> object,
-                                                  Handle<Object> key,
-                                                  PropertyDescriptor* desc,
-                                                  ShouldThrow should_throw) {
+Maybe<bool> JSReceiver::OrdinaryDefineOwnProperty(
+    Isolate* isolate, Handle<JSObject> object, Handle<Object> key,
+    PropertyDescriptor* desc, ShouldThrow should_throw,
+    CallInterceptors call_interceptors) {
   bool success = false;
   DCHECK(key->IsName() || key->IsNumber());  // |key| is a PropertyKey...
+
+  LookupIterator::Configuration iterator_config = LookupIterator::OWN;
+  if (call_interceptors == CallInterceptors::kSkip) {
+    iterator_config = LookupIterator::OWN_SKIP_INTERCEPTOR;
+  }
+
   LookupIterator it = LookupIterator::PropertyOrElement(
-      isolate, object, key, &success, LookupIterator::OWN);
+      isolate, object, key, &success, iterator_config);
+
   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();
@@ skipping 376 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,
+                                       CallInterceptors call_interceptors) {
   // 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, call_interceptors);
   }
   // 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, call_interceptors);
     // 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, call_interceptors);
       // 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,
+                                   call_interceptors);
 }
 
 
 // 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,
+                                    CallInterceptors call_interceptors) {
   // 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, call_interceptors);
   }
   // 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, call_interceptors);
   }
   // 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, call_interceptors);
     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,
+                                       CallInterceptors call_interceptors) {
   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, call_interceptors);
   }
   // 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 10202 matching lines @@
     }
   }
   *index = result;
   return true;
 }
 
 }  // 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) {
+Maybe<bool> JSTypedArray::DefineOwnProperty(
+    Isolate* isolate, Handle<JSTypedArray> o, Handle<Object> key,
+    PropertyDescriptor* desc, ShouldThrow should_throw,
+    CallInterceptors call_interceptors) {
   // 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,
+                                   call_interceptors);
 }
 
 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 3189 matching lines @@
       // not
       // depend on this.
       return DICTIONARY_ELEMENTS;
     }
     DCHECK_LE(kind, LAST_ELEMENTS_KIND);
     return kind;
   }
 }
 }  // namespace internal
 }  // namespace v8