libv8-node 21.7.2.0-aarch64-linux-musl → 24.12.0.0-aarch64-linux-musl

data/vendor/v8/include/v8-function-callback.h

@@ -5,6 +5,10 @@
 #ifndef INCLUDE_V8_FUNCTION_CALLBACK_H_
 #define INCLUDE_V8_FUNCTION_CALLBACK_H_
 
+#include <cstdint>
+#include <limits>
+
+#include "v8-internal.h"      // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8-primitive.h"     // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
@@ -28,6 +32,11 @@ namespace debug {
 class ConsoleCallArguments;
 }  // namespace debug
 
+namespace api_internal {
+V8_EXPORT v8::Local<v8::Value> GetFunctionTemplateData(
+    v8::Isolate* isolate, v8::Local<v8::Data> raw_target);
+}  // namespace api_internal
+
 template <typename T>
 class ReturnValue {
  public:
@@ -35,21 +44,32 @@ class ReturnValue {
   V8_INLINE ReturnValue(const ReturnValue<S>& that) : value_(that.value_) {
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
-  // Local setters
+  // Handle-based setters.
   template <typename S>
   V8_INLINE void Set(const Global<S>& handle);
   template <typename S>
+  V8_INLINE void SetNonEmpty(const Global<S>& handle);
+  template <typename S>
   V8_INLINE void Set(const BasicTracedReference<S>& handle);
   template <typename S>
+  V8_INLINE void SetNonEmpty(const BasicTracedReference<S>& handle);
+  template <typename S>
   V8_INLINE void Set(const Local<S> handle);
-  // Fast primitive setters
+  template <typename S>
+  V8_INLINE void SetNonEmpty(const Local<S> handle);
+  // Fast primitive number setters.
   V8_INLINE void Set(bool value);
   V8_INLINE void Set(double i);
+  V8_INLINE void Set(int16_t i);
   V8_INLINE void Set(int32_t i);
+  V8_INLINE void Set(int64_t i);
+  V8_INLINE void Set(uint16_t i);
   V8_INLINE void Set(uint32_t i);
+  V8_INLINE void Set(uint64_t i);
   // Fast JS primitive setters
   V8_INLINE void SetNull();
   V8_INLINE void SetUndefined();
+  V8_INLINE void SetFalse();
   V8_INLINE void SetEmptyString();
   // Convenience getter for Isolate
   V8_INLINE Isolate* GetIsolate() const;
@@ -72,8 +92,14 @@ class ReturnValue {
   friend class PropertyCallbackInfo;
   template <class F, class G, class H>
   friend class PersistentValueMapBase;
-  V8_INLINE void SetInternal(internal::Address value) { *value_ = value; }
-  V8_INLINE internal::Address GetDefaultValue();
+  V8_INLINE void SetInternal(internal::Address value);
+  // Default value depends on <T>:
+  //  - <void> -> true_value,
+  //  - <v8::Boolean> -> true_value,
+  //  - <v8::Integer> -> 0,
+  //  - <v8::Value> -> undefined_value,
+  //  - <v8::Array> -> undefined_value.
+  V8_INLINE void SetDefaultValue();
   V8_INLINE explicit ReturnValue(internal::Address* slot);
 
   // See FunctionCallbackInfo.
@@ -100,17 +126,6 @@ class FunctionCallbackInfo {
   V8_INLINE Local<Value> operator[](int i) const;
   /** Returns the receiver. This corresponds to the "this" value. */
   V8_INLINE Local<Object> This() const;
-  /**
-   * If the callback was created without a Signature, this is the same
-   * value as This(). If there is a signature, and the signature didn't match
-   * This() but one of its hidden prototypes, this will be the respective
-   * hidden prototype.
-   *
-   * Note that this is not the prototype of This() on which the accessor
-   * referencing this callback was found (which in V8 internally is often
-   * referred to as holder [sic]).
-   */
-  V8_INLINE Local<Object> Holder() const;
   /** For construct calls, this returns the "new.target" value. */
   V8_INLINE Local<Value> NewTarget() const;
   /** Indicates whether this is a regular call or a construct call. */
@@ -126,12 +141,16 @@ class FunctionCallbackInfo {
   friend class internal::FunctionCallbackArguments;
   friend class internal::CustomArguments<FunctionCallbackInfo>;
   friend class debug::ConsoleCallArguments;
+  friend void internal::PrintFunctionCallbackInfo(void*);
 
-  static constexpr int kHolderIndex = 0;
+  // TODO(ishell, http://crbug.com/326505377): in case of non-constructor
+  // call, don't pass kNewTarget and kUnused. Add IsConstructCall flag to
+  // kIsolate field.
+  static constexpr int kUnusedIndex = 0;
   static constexpr int kIsolateIndex = 1;
-  static constexpr int kUnusedIndex = 2;
+  static constexpr int kContextIndex = 2;
   static constexpr int kReturnValueIndex = 3;
-  static constexpr int kDataIndex = 4;
+  static constexpr int kTargetIndex = 4;
   static constexpr int kNewTargetIndex = 5;
   static constexpr int kArgsLength = 6;
 
@@ -151,9 +170,13 @@ class FunctionCallbackInfo {
 
   V8_INLINE FunctionCallbackInfo(internal::Address* implicit_args,
                                  internal::Address* values, int length);
+
+  // TODO(https://crbug.com/326505377): flatten the v8::FunctionCallbackInfo
+  // object to avoid indirect loads through values_ and implicit_args_ and
+  // reduce the number of instructions in the CallApiCallback builtin.
   internal::Address* implicit_args_;
   internal::Address* values_;
-  int length_;
+  internal::Address length_;
 };
 
 /**
@@ -227,8 +250,23 @@ class PropertyCallbackInfo {
    *
    * \note For security reasons, do not pass the object back into the runtime.
    */
+  V8_DEPRECATE_SOON(
+      "V8 will stop providing access to hidden prototype (i.e. "
+      "JSGlobalObject). Use HolderV2() instead. \n"
+      "DO NOT try to workaround this by accessing JSGlobalObject via "
+      "v8::Object::GetPrototype() - it'll be deprecated soon too. \n"
+      "See http://crbug.com/333672197. ")
   V8_INLINE Local<Object> Holder() const;
 
+  /**
+   * \return The object in the prototype chain of the receiver that has the
+   * interceptor. Suppose you have `x` and its prototype is `y`, and `y`
+   * has an interceptor. Then `info.This()` is `x` and `info.Holder()` is `y`.
+   * In case the property is installed on the global object the Holder()
+   * would return the global proxy.
+   */
+  V8_INLINE Local<Object> HolderV2() const;
+
   /**
    * \return The return value of the callback.
    * Can be changed by calling Set().
@@ -249,24 +287,28 @@ class PropertyCallbackInfo {
   V8_INLINE bool ShouldThrowOnError() const;
 
  private:
+  template <typename U>
+  friend class PropertyCallbackInfo;
   friend class MacroAssembler;
   friend class internal::PropertyCallbackArguments;
   friend class internal::CustomArguments<PropertyCallbackInfo>;
-  static constexpr int kShouldThrowOnErrorIndex = 0;
-  static constexpr int kHolderIndex = 1;
-  static constexpr int kIsolateIndex = 2;
-  static constexpr int kUnusedIndex = 3;
-  static constexpr int kReturnValueIndex = 4;
-  static constexpr int kDataIndex = 5;
-  static constexpr int kThisIndex = 6;
-  static constexpr int kArgsLength = 7;
+  friend void internal::PrintPropertyCallbackInfo(void*);
+
+  static constexpr int kPropertyKeyIndex = 0;
+  static constexpr int kShouldThrowOnErrorIndex = 1;
+  static constexpr int kHolderIndex = 2;
+  static constexpr int kIsolateIndex = 3;
+  static constexpr int kHolderV2Index = 4;
+  static constexpr int kReturnValueIndex = 5;
+  static constexpr int kDataIndex = 6;
+  static constexpr int kThisIndex = 7;
+  static constexpr int kArgsLength = 8;
 
-  static constexpr int kSize = 1 * internal::kApiSystemPointerSize;
+  static constexpr int kSize = kArgsLength * internal::kApiSystemPointerSize;
 
-  V8_INLINE explicit PropertyCallbackInfo(internal::Address* args)
-      : args_(args) {}
+  PropertyCallbackInfo() = default;
 
-  internal::Address* args_;
+  mutable internal::Address args_[kArgsLength];
 };
 
 using FunctionCallback = void (*)(const FunctionCallbackInfo<Value>& info);
@@ -276,73 +318,194 @@ using FunctionCallback = void (*)(const FunctionCallbackInfo<Value>& info);
 template <typename T>
 ReturnValue<T>::ReturnValue(internal::Address* slot) : value_(slot) {}
 
+template <typename T>
+void ReturnValue<T>::SetInternal(internal::Address value) {
+#if V8_STATIC_ROOTS_BOOL
+  using I = internal::Internals;
+  // Ensure that the upper 32-bits are not modified. Compiler should be
+  // able to optimize this to a store of a lower 32-bits of the value.
+  // This is fine since the callback can return only JavaScript values which
+  // are either Smis or heap objects allocated in the main cage.
+  *value_ = I::DecompressTaggedField(*value_, I::CompressTagged(value));
+#else
+  *value_ = value;
+#endif  // V8_STATIC_ROOTS_BOOL
+}
+
 template <typename T>
 template <typename S>
 void ReturnValue<T>::Set(const Global<S>& handle) {
   static_assert(std::is_base_of<T, S>::value, "type check");
   if (V8_UNLIKELY(handle.IsEmpty())) {
-    *value_ = GetDefaultValue();
+    SetDefaultValue();
   } else {
-    *value_ = handle.ptr();
+    SetInternal(handle.ptr());
   }
 }
 
+template <typename T>
+template <typename S>
+void ReturnValue<T>::SetNonEmpty(const Global<S>& handle) {
+  static_assert(std::is_base_of<T, S>::value, "type check");
+#ifdef V8_ENABLE_CHECKS
+  internal::VerifyHandleIsNonEmpty(handle.IsEmpty());
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(handle.ptr());
+}
+
 template <typename T>
 template <typename S>
 void ReturnValue<T>::Set(const BasicTracedReference<S>& handle) {
   static_assert(std::is_base_of<T, S>::value, "type check");
   if (V8_UNLIKELY(handle.IsEmpty())) {
-    *value_ = GetDefaultValue();
+    SetDefaultValue();
   } else {
-    *value_ = handle.ptr();
+    SetInternal(handle.ptr());
   }
 }
 
+template <typename T>
+template <typename S>
+void ReturnValue<T>::SetNonEmpty(const BasicTracedReference<S>& handle) {
+  static_assert(std::is_base_of<T, S>::value, "type check");
+#ifdef V8_ENABLE_CHECKS
+  internal::VerifyHandleIsNonEmpty(handle.IsEmpty());
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(handle.ptr());
+}
+
 template <typename T>
 template <typename S>
 void ReturnValue<T>::Set(const Local<S> handle) {
-  static_assert(std::is_void<T>::value || std::is_base_of<T, S>::value,
-                "type check");
+  // "V8_DEPRECATE_SOON" this method if |T| is |void|.
+#ifdef V8_IMMINENT_DEPRECATION_WARNINGS
+  static constexpr bool is_allowed_void = false;
+  static_assert(!std::is_void<T>::value,
+                "ReturnValue<void>::Set(const Local<S>) is deprecated. "
+                "Do nothing to indicate that the operation succeeded or use "
+                "SetFalse() to indicate that the operation failed (don't "
+                "forget to handle info.ShouldThrowOnError()). "
+                "See http://crbug.com/348660658 for details.");
+#else
+  static constexpr bool is_allowed_void = std::is_void<T>::value;
+#endif  // V8_IMMINENT_DEPRECATION_WARNINGS
+  static_assert(is_allowed_void || std::is_base_of<T, S>::value, "type check");
   if (V8_UNLIKELY(handle.IsEmpty())) {
-    *value_ = GetDefaultValue();
+    SetDefaultValue();
+  } else if constexpr (is_allowed_void) {
+    // Simulate old behaviour for "v8::AccessorSetterCallback" for which
+    // it was possible to set the return value even for ReturnValue<void>.
+    Set(handle->BooleanValue(GetIsolate()));
   } else {
-    *value_ = handle.ptr();
+    SetInternal(handle.ptr());
+  }
+}
+
+template <typename T>
+template <typename S>
+void ReturnValue<T>::SetNonEmpty(const Local<S> handle) {
+  // "V8_DEPRECATE_SOON" this method if |T| is |void|.
+#ifdef V8_IMMINENT_DEPRECATION_WARNINGS
+  static constexpr bool is_allowed_void = false;
+  static_assert(!std::is_void<T>::value,
+                "ReturnValue<void>::SetNonEmpty(const Local<S>) is deprecated. "
+                "Do nothing to indicate that the operation succeeded or use "
+                "SetFalse() to indicate that the operation failed (don't "
+                "forget to handle info.ShouldThrowOnError()). "
+                "See http://crbug.com/348660658 for details.");
+#else
+  static constexpr bool is_allowed_void = std::is_void<T>::value;
+#endif  // V8_IMMINENT_DEPRECATION_WARNINGS
+  static_assert(is_allowed_void || std::is_base_of<T, S>::value, "type check");
+#ifdef V8_ENABLE_CHECKS
+  internal::VerifyHandleIsNonEmpty(handle.IsEmpty());
+#endif  // V8_ENABLE_CHECKS
+  if constexpr (is_allowed_void) {
+    // Simulate old behaviour for "v8::AccessorSetterCallback" for which
+    // it was possible to set the return value even for ReturnValue<void>.
+    Set(handle->BooleanValue(GetIsolate()));
+  } else {
+    SetInternal(handle.ptr());
   }
 }
 
 template <typename T>
 void ReturnValue<T>::Set(double i) {
   static_assert(std::is_base_of<T, Number>::value, "type check");
-  Set(Number::New(GetIsolate(), i));
+  SetNonEmpty(Number::New(GetIsolate(), i));
 }
 
 template <typename T>
-void ReturnValue<T>::Set(int32_t i) {
+void ReturnValue<T>::Set(int16_t i) {
   static_assert(std::is_base_of<T, Integer>::value, "type check");
   using I = internal::Internals;
-  if (V8_LIKELY(I::IsValidSmi(i))) {
-    *value_ = I::IntToSmi(i);
+  static_assert(I::IsValidSmi(std::numeric_limits<int16_t>::min()));
+  static_assert(I::IsValidSmi(std::numeric_limits<int16_t>::max()));
+  SetInternal(I::IntegralToSmi(i));
+}
+
+template <typename T>
+void ReturnValue<T>::Set(int32_t i) {
+  static_assert(std::is_base_of<T, Integer>::value, "type check");
+  if (const auto result = internal::Internals::TryIntegralToSmi(i)) {
+    SetInternal(*result);
     return;
   }
-  Set(Integer::New(GetIsolate(), i));
+  SetNonEmpty(Integer::New(GetIsolate(), i));
+}
+
+template <typename T>
+void ReturnValue<T>::Set(int64_t i) {
+  static_assert(std::is_base_of<T, Integer>::value, "type check");
+  if (const auto result = internal::Internals::TryIntegralToSmi(i)) {
+    SetInternal(*result);
+    return;
+  }
+  SetNonEmpty(Number::New(GetIsolate(), static_cast<double>(i)));
+}
+
+template <typename T>
+void ReturnValue<T>::Set(uint16_t i) {
+  static_assert(std::is_base_of<T, Integer>::value, "type check");
+  using I = internal::Internals;
+  static_assert(I::IsValidSmi(std::numeric_limits<uint16_t>::min()));
+  static_assert(I::IsValidSmi(std::numeric_limits<uint16_t>::max()));
+  SetInternal(I::IntegralToSmi(i));
 }
 
 template <typename T>
 void ReturnValue<T>::Set(uint32_t i) {
   static_assert(std::is_base_of<T, Integer>::value, "type check");
-  // Can't simply use INT32_MAX here for whatever reason.
-  bool fits_into_int32_t = (i & (1U << 31)) == 0;
-  if (V8_LIKELY(fits_into_int32_t)) {
-    Set(static_cast<int32_t>(i));
+  if (const auto result = internal::Internals::TryIntegralToSmi(i)) {
+    SetInternal(*result);
+    return;
+  }
+  SetNonEmpty(Integer::NewFromUnsigned(GetIsolate(), i));
+}
+
+template <typename T>
+void ReturnValue<T>::Set(uint64_t i) {
+  static_assert(std::is_base_of<T, Integer>::value, "type check");
+  if (const auto result = internal::Internals::TryIntegralToSmi(i)) {
+    SetInternal(*result);
     return;
   }
-  Set(Integer::NewFromUnsigned(GetIsolate(), i));
+  SetNonEmpty(Number::New(GetIsolate(), static_cast<double>(i)));
 }
 
 template <typename T>
 void ReturnValue<T>::Set(bool value) {
-  static_assert(std::is_base_of<T, Boolean>::value, "type check");
+  static_assert(std::is_void<T>::value || std::is_base_of<T, Boolean>::value,
+                "type check");
   using I = internal::Internals;
+#if V8_STATIC_ROOTS_BOOL
+#ifdef V8_ENABLE_CHECKS
+  internal::PerformCastCheck(
+      internal::ValueHelper::SlotAsValue<Value, true>(value_));
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(value ? I::StaticReadOnlyRoot::kTrueValue
+                    : I::StaticReadOnlyRoot::kFalseValue);
+#else
   int root_index;
   if (value) {
     root_index = I::kTrueValueRootIndex;
@@ -350,27 +513,85 @@ void ReturnValue<T>::Set(bool value) {
     root_index = I::kFalseValueRootIndex;
   }
   *value_ = I::GetRoot(GetIsolate(), root_index);
+#endif  // V8_STATIC_ROOTS_BOOL
+}
+
+template <typename T>
+void ReturnValue<T>::SetDefaultValue() {
+  using I = internal::Internals;
+  if constexpr (std::is_same_v<void, T> || std::is_same_v<v8::Boolean, T>) {
+    Set(true);
+  } else if constexpr (std::is_same_v<v8::Integer, T>) {
+    SetInternal(I::IntegralToSmi(0));
+  } else {
+    static_assert(std::is_same_v<v8::Value, T> || std::is_same_v<v8::Array, T>);
+#if V8_STATIC_ROOTS_BOOL
+    SetInternal(I::StaticReadOnlyRoot::kUndefinedValue);
+#else
+    *value_ = I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);
+#endif  // V8_STATIC_ROOTS_BOOL
+  }
 }
 
 template <typename T>
 void ReturnValue<T>::SetNull() {
   static_assert(std::is_base_of<T, Primitive>::value, "type check");
   using I = internal::Internals;
+#if V8_STATIC_ROOTS_BOOL
+#ifdef V8_ENABLE_CHECKS
+  internal::PerformCastCheck(
+      internal::ValueHelper::SlotAsValue<Value, true>(value_));
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(I::StaticReadOnlyRoot::kNullValue);
+#else
   *value_ = I::GetRoot(GetIsolate(), I::kNullValueRootIndex);
+#endif  // V8_STATIC_ROOTS_BOOL
 }
 
 template <typename T>
 void ReturnValue<T>::SetUndefined() {
   static_assert(std::is_base_of<T, Primitive>::value, "type check");
   using I = internal::Internals;
+#if V8_STATIC_ROOTS_BOOL
+#ifdef V8_ENABLE_CHECKS
+  internal::PerformCastCheck(
+      internal::ValueHelper::SlotAsValue<Value, true>(value_));
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(I::StaticReadOnlyRoot::kUndefinedValue);
+#else
   *value_ = I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);
+#endif  // V8_STATIC_ROOTS_BOOL
+}
+
+template <typename T>
+void ReturnValue<T>::SetFalse() {
+  static_assert(std::is_void<T>::value || std::is_base_of<T, Boolean>::value,
+                "type check");
+  using I = internal::Internals;
+#if V8_STATIC_ROOTS_BOOL
+#ifdef V8_ENABLE_CHECKS
+  internal::PerformCastCheck(
+      internal::ValueHelper::SlotAsValue<Value, true>(value_));
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(I::StaticReadOnlyRoot::kFalseValue);
+#else
+  *value_ = I::GetRoot(GetIsolate(), I::kFalseValueRootIndex);
+#endif  // V8_STATIC_ROOTS_BOOL
 }
 
 template <typename T>
 void ReturnValue<T>::SetEmptyString() {
   static_assert(std::is_base_of<T, String>::value, "type check");
   using I = internal::Internals;
+#if V8_STATIC_ROOTS_BOOL
+#ifdef V8_ENABLE_CHECKS
+  internal::PerformCastCheck(
+      internal::ValueHelper::SlotAsValue<Value, true>(value_));
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(I::StaticReadOnlyRoot::kEmptyString);
+#else
   *value_ = I::GetRoot(GetIsolate(), I::kEmptyStringRootIndex);
+#endif  // V8_STATIC_ROOTS_BOOL
 }
 
 template <typename T>
@@ -380,15 +601,8 @@ Isolate* ReturnValue<T>::GetIsolate() const {
 
 template <typename T>
 Local<Value> ReturnValue<T>::Get() const {
-  using I = internal::Internals;
-#if V8_STATIC_ROOTS_BOOL
-  if (I::is_identical(*value_, I::StaticReadOnlyRoot::kTheHoleValue)) {
-#else
-  if (*value_ == I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex)) {
-#endif
-    return Undefined(GetIsolate());
-  }
-  return Local<Value>::New(GetIsolate(), reinterpret_cast<Value*>(value_));
+  return Local<Value>::New(GetIsolate(),
+                           internal::ValueHelper::SlotAsValue<Value>(value_));
 }
 
 template <typename T>
@@ -397,12 +611,6 @@ void ReturnValue<T>::Set(S* whatever) {
   static_assert(sizeof(S) < 0, "incompilable to prevent inadvertent misuse");
 }
 
-template <typename T>
-internal::Address ReturnValue<T>::GetDefaultValue() {
-  using I = internal::Internals;
-  return I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex);
-}
-
 template <typename T>
 FunctionCallbackInfo<T>::FunctionCallbackInfo(internal::Address* implicit_args,
                                               internal::Address* values,
@@ -412,7 +620,7 @@ FunctionCallbackInfo<T>::FunctionCallbackInfo(internal::Address* implicit_args,
 template <typename T>
 Local<Value> FunctionCallbackInfo<T>::operator[](int i) const {
   // values_ points to the first argument (not the receiver).
-  if (i < 0 || length_ <= i) return Undefined(GetIsolate());
+  if (i < 0 || Length() <= i) return Undefined(GetIsolate());
   return Local<Value>::FromSlot(values_ + i);
 }
 
@@ -422,11 +630,6 @@ Local<Object> FunctionCallbackInfo<T>::This() const {
   return Local<Object>::FromSlot(values_ + kThisValuesIndex);
 }
 
-template <typename T>
-Local<Object> FunctionCallbackInfo<T>::Holder() const {
-  return Local<Object>::FromSlot(&implicit_args_[kHolderIndex]);
-}
-
 template <typename T>
 Local<Value> FunctionCallbackInfo<T>::NewTarget() const {
   return Local<Value>::FromSlot(&implicit_args_[kNewTargetIndex]);
@@ -434,7 +637,8 @@ Local<Value> FunctionCallbackInfo<T>::NewTarget() const {
 
 template <typename T>
 Local<Value> FunctionCallbackInfo<T>::Data() const {
-  return Local<Value>::FromSlot(&implicit_args_[kDataIndex]);
+  auto target = Local<v8::Data>::FromSlot(&implicit_args_[kTargetIndex]);
+  return api_internal::GetFunctionTemplateData(GetIsolate(), target);
 }
 
 template <typename T>
@@ -454,7 +658,7 @@ bool FunctionCallbackInfo<T>::IsConstructCall() const {
 
 template <typename T>
 int FunctionCallbackInfo<T>::Length() const {
-  return length_;
+  return static_cast<int>(length_);
 }
 
 template <typename T>
@@ -477,6 +681,23 @@ Local<Object> PropertyCallbackInfo<T>::Holder() const {
   return Local<Object>::FromSlot(&args_[kHolderIndex]);
 }
 
+namespace api_internal {
+// Returns JSGlobalProxy if holder is JSGlobalObject or unmodified holder
+// otherwise.
+V8_EXPORT internal::Address ConvertToJSGlobalProxyIfNecessary(
+    internal::Address holder);
+}  // namespace api_internal
+
+template <typename T>
+Local<Object> PropertyCallbackInfo<T>::HolderV2() const {
+  using I = internal::Internals;
+  if (!I::HasHeapObjectTag(args_[kHolderV2Index])) {
+    args_[kHolderV2Index] =
+        api_internal::ConvertToJSGlobalProxyIfNecessary(args_[kHolderIndex]);
+  }
+  return Local<Object>::FromSlot(&args_[kHolderV2Index]);
+}
+
 template <typename T>
 ReturnValue<T> PropertyCallbackInfo<T>::GetReturnValue() const {
   return ReturnValue<T>(&args_[kReturnValueIndex]);
@@ -486,8 +707,8 @@ template <typename T>
 bool PropertyCallbackInfo<T>::ShouldThrowOnError() const {
   using I = internal::Internals;
   if (args_[kShouldThrowOnErrorIndex] !=
-      I::IntToSmi(I::kInferShouldThrowMode)) {
-    return args_[kShouldThrowOnErrorIndex] != I::IntToSmi(I::kDontThrow);
+      I::IntegralToSmi(I::kInferShouldThrowMode)) {
+    return args_[kShouldThrowOnErrorIndex] != I::IntegralToSmi(I::kDontThrow);
   }
   return v8::internal::ShouldThrowOnError(
       reinterpret_cast<v8::internal::Isolate*>(GetIsolate()));

data/vendor/v8/include/v8-function.h

@@ -18,6 +18,7 @@
 namespace v8 {
 
 class Context;
+class Location;
 class UnboundScript;
 
 /**
@@ -52,6 +53,10 @@ class V8_EXPORT Function : public Object {
       Local<Context> context, int argc, Local<Value> argv[],
       SideEffectType side_effect_type = SideEffectType::kHasSideEffect) const;
 
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> Call(v8::Isolate* isolate,
+                                               Local<Context> context,
+                                               Local<Value> recv, int argc,
+                                               Local<Value> argv[]);
   V8_WARN_UNUSED_RESULT MaybeLocal<Value> Call(Local<Context> context,
                                                Local<Value> recv, int argc,
                                                Local<Value> argv[]);
@@ -59,9 +64,6 @@ class V8_EXPORT Function : public Object {
   void SetName(Local<String> name);
   Local<Value> GetName() const;
 
-  V8_DEPRECATED("No direct replacement")
-  MaybeLocal<UnboundScript> GetUnboundScript() const;
-
   /**
    * Name inferred from variable or property assignment of this function.
    * Used to facilitate debugging and profiling of JavaScript code written
@@ -87,6 +89,12 @@ class V8_EXPORT Function : public Object {
    */
   int GetScriptColumnNumber() const;
 
+  /**
+   * Returns zero based line and column number of function body, else returns
+   * {-1, -1}.
+   */
+  Location GetScriptLocation() const;
+
   /**
    * Returns zero based start position (character offset) of function body and
    * kLineOffsetNotFound if no information available.