libv8-node 15.14.0.1-x86_64-linux-musl → 16.10.0.0-x86_64-linux-musl

data/vendor/v8/include/v8-fast-api-calls.h

@@ -18,6 +18,38 @@
  *                              &v8::CFunction::Make(FastMethod));
  * \endcode
  *
+ * By design, fast calls are limited by the following requirements, which
+ * the embedder should enforce themselves:
+ *   - they should not allocate on the JS heap;
+ *   - they should not trigger JS execution.
+ * To enforce them, the embedder could use the existing
+ * v8::Isolate::DisallowJavascriptExecutionScope and a utility similar to
+ * Blink's NoAllocationScope:
+ * https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/platform/heap/thread_state_scopes.h;l=16
+ *
+ * Due to these limitations, it's not directly possible to report errors by
+ * throwing a JS exception or to otherwise do an allocation. There is an
+ * alternative way of creating fast calls that supports falling back to the
+ * slow call and then performing the necessary allocation. When one creates
+ * the fast method by using CFunction::MakeWithFallbackSupport instead of
+ * CFunction::Make, the fast callback gets as last parameter an output variable,
+ * through which it can request falling back to the slow call. So one might
+ * declare their method like:
+ *
+ * \code
+ *    void FastMethodWithFallback(int param, FastApiCallbackOptions& options);
+ * \endcode
+ *
+ * If the callback wants to signal an error condition or to perform an
+ * allocation, it must set options.fallback to true and do an early return from
+ * the fast method. Then V8 checks the value of options.fallback and if it's
+ * true, falls back to executing the SlowCallback, which is capable of reporting
+ * the error (either by throwing a JS exception or logging to the console) or
+ * doing the allocation. It's the embedder's responsibility to ensure that the
+ * fast callback is idempotent up to the point where error and fallback
+ * conditions are checked, because otherwise executing the slow callback might
+ * produce visible side-effects twice.
+ *
  * An example for custom embedder type support might employ a way to wrap/
  * unwrap various C++ types in JSObject instances, e.g:
  *
@@ -38,8 +70,7 @@
  *        return GetInternalField<CustomEmbedderType,
  *                                kV8EmbedderWrapperObjectIndex>(wrapper);
  *      }
- *      static void FastMethod(v8::ApiObject receiver_obj, int param) {
- *        v8::Object* v8_object = reinterpret_cast<v8::Object*>(&api_object);
+ *      static void FastMethod(v8::Local<v8::Object> receiver_obj, int param) {
  *        CustomEmbedderType* receiver = static_cast<CustomEmbedderType*>(
  *          receiver_obj->GetAlignedPointerFromInternalField(
  *            kV8EmbedderWrapperObjectIndex));
@@ -116,23 +147,73 @@
  *   receiver := the {embedder_object} from above
  *   param := 42
  *
- * Currently only void return types are supported.
+ * Currently supported return types:
+ *   - void
+ *   - bool
+ *   - int32_t
+ *   - uint32_t
+ *   - float32_t
+ *   - float64_t
  * Currently supported argument types:
  *  - pointer to an embedder type
+ *  - JavaScript array of primitive types
  *  - bool
  *  - int32_t
  *  - uint32_t
  *  - int64_t
  *  - uint64_t
+ *  - float32_t
+ *  - float64_t
+ *
  * The 64-bit integer types currently have the IDL (unsigned) long long
  * semantics: https://heycam.github.io/webidl/#abstract-opdef-converttoint
  * In the future we'll extend the API to also provide conversions from/to
  * BigInt to preserve full precision.
+ * The floating point types currently have the IDL (unrestricted) semantics,
+ * which is the only one used by WebGL. We plan to add support also for
+ * restricted floats/doubles, similarly to the BigInt conversion policies.
+ * We also differ from the specific NaN bit pattern that WebIDL prescribes
+ * (https://heycam.github.io/webidl/#es-unrestricted-float) in that Blink
+ * passes NaN values as-is, i.e. doesn't normalize them.
+ *
  * To be supported types:
- *  - float32_t
- *  - float64_t
- *  - arrays of C types
+ *  - TypedArrays and ArrayBuffers
  *  - arrays of embedder types
+ *
+ *
+ * The API offers a limited support for function overloads:
+ *
+ * \code
+ *    void FastMethod_2Args(int param, bool another_param);
+ *    void FastMethod_3Args(int param, bool another_param, int third_param);
+ *
+ *    v8::CFunction fast_method_2args_c_func =
+ *         MakeV8CFunction(FastMethod_2Args);
+ *    v8::CFunction fast_method_3args_c_func =
+ *         MakeV8CFunction(FastMethod_3Args);
+ *    const v8::CFunction fast_method_overloads[] = {fast_method_2args_c_func,
+ *                                                   fast_method_3args_c_func};
+ *    Local<v8::FunctionTemplate> method_template =
+ *        v8::FunctionTemplate::NewWithCFunctionOverloads(
+ *            isolate, SlowCallback, data, signature, length,
+ *            constructor_behavior, side_effect_type,
+ *            {fast_method_overloads, 2});
+ * \endcode
+ *
+ * In this example a single FunctionTemplate is associated to multiple C++
+ * functions. The overload resolution is currently only based on the number of
+ * arguments passed in a call. For example, if this method_template is
+ * registered with a wrapper JS object as described above, a call with two
+ * arguments:
+ *    obj.method(42, true);
+ * will result in a fast call to FastMethod_2Args, while a call with three or
+ * more arguments:
+ *    obj.method(42, true, 11);
+ * will result in a fast call to FastMethod_3Args. Instead a call with less than
+ * two arguments, like:
+ *    obj.method(42);
+ * would not result in a fast call but would fall back to executing the
+ * associated SlowCallback.
  */
 
 #ifndef INCLUDE_V8_FAST_API_CALLS_H_
@@ -141,13 +222,19 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <tuple>
+#include <type_traits>
+
+#include "v8.h"        // NOLINT(build/include_directory)
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace v8 {
 
+class Isolate;
+
 class CTypeInfo {
  public:
-  enum class Type : char {
+  enum class Type : uint8_t {
     kVoid,
     kBool,
     kInt32,
@@ -157,232 +244,548 @@ class CTypeInfo {
     kFloat32,
     kFloat64,
     kV8Value,
+    kApiObject,  // This will be deprecated once all users have
+                 // migrated from v8::ApiObject to v8::Local<v8::Value>.
   };
 
-  enum class ArgFlags : uint8_t {
-    kNone = 0,
-    kIsArrayBit = 1 << 0,  // This argument is first in an array of values.
+  // kCallbackOptionsType is not part of the Type enum
+  // because it is only used internally. Use value 255 that is larger
+  // than any valid Type enum.
+  static constexpr Type kCallbackOptionsType = Type(255);
+
+  enum class SequenceType : uint8_t {
+    kScalar,
+    kIsSequence,    // sequence<T>
+    kIsTypedArray,  // TypedArray of T or any ArrayBufferView if T
+                    // is void
+    kIsArrayBuffer  // ArrayBuffer
   };
 
-  static CTypeInfo FromWrapperType(ArgFlags flags = ArgFlags::kNone) {
-    return CTypeInfo(static_cast<int>(flags) | kIsWrapperTypeBit);
-  }
+  enum class Flags : uint8_t {
+    kNone = 0,
+    kAllowSharedBit = 1 << 0,   // Must be an ArrayBuffer or TypedArray
+    kEnforceRangeBit = 1 << 1,  // T must be integral
+    kClampBit = 1 << 2,         // T must be integral
+    kIsRestrictedBit = 1 << 3,  // T must be float or double
+  };
 
-  static constexpr CTypeInfo FromCType(Type ctype,
-                                       ArgFlags flags = ArgFlags::kNone) {
-    // TODO(mslekova): Refactor the manual bit manipulations to use
-    // PointerWithPayload instead.
-    // ctype cannot be Type::kV8Value.
-    return CTypeInfo(
-        ((static_cast<uintptr_t>(ctype) << kTypeOffset) & kTypeMask) |
-        static_cast<int>(flags));
-  }
+  explicit constexpr CTypeInfo(
+      Type type, SequenceType sequence_type = SequenceType::kScalar,
+      Flags flags = Flags::kNone)
+      : type_(type), sequence_type_(sequence_type), flags_(flags) {}
 
-  const void* GetWrapperInfo() const;
+  constexpr Type GetType() const { return type_; }
+  constexpr SequenceType GetSequenceType() const { return sequence_type_; }
+  constexpr Flags GetFlags() const { return flags_; }
 
-  constexpr Type GetType() const {
-    if (payload_ & kIsWrapperTypeBit) {
-      return Type::kV8Value;
-    }
-    return static_cast<Type>((payload_ & kTypeMask) >> kTypeOffset);
+  static constexpr bool IsIntegralType(Type type) {
+    return type == Type::kInt32 || type == Type::kUint32 ||
+           type == Type::kInt64 || type == Type::kUint64;
   }
 
-  constexpr bool IsArray() const {
-    return payload_ & static_cast<int>(ArgFlags::kIsArrayBit);
+  static constexpr bool IsFloatingPointType(Type type) {
+    return type == Type::kFloat32 || type == Type::kFloat64;
   }
 
-  static const CTypeInfo& Invalid() {
-    static CTypeInfo invalid = CTypeInfo(0);
-    return invalid;
+  static constexpr bool IsPrimitive(Type type) {
+    return IsIntegralType(type) || IsFloatingPointType(type) ||
+           type == Type::kBool;
   }
 
  private:
-  explicit constexpr CTypeInfo(uintptr_t payload) : payload_(payload) {}
+  Type type_;
+  SequenceType sequence_type_;
+  Flags flags_;
+};
+
+template <typename T>
+struct FastApiTypedArray {
+  T* data;        // should include the typed array offset applied
+  size_t length;  // length in number of elements
+};
+
+// Any TypedArray. It uses kTypedArrayBit with base type void
+// Overloaded args of ArrayBufferView and TypedArray are not supported
+// (for now) because the generic “any” ArrayBufferView doesn’t have its
+// own instance type. It could be supported if we specify that
+// TypedArray<T> always has precedence over the generic ArrayBufferView,
+// but this complicates overload resolution.
+struct FastApiArrayBufferView {
+  void* data;
+  size_t byte_length;
+};
+
+struct FastApiArrayBuffer {
+  void* data;
+  size_t byte_length;
+};
+
+class V8_EXPORT CFunctionInfo {
+ public:
+  // Construct a struct to hold a CFunction's type information.
+  // |return_info| describes the function's return type.
+  // |arg_info| is an array of |arg_count| CTypeInfos describing the
+  //   arguments. Only the last argument may be of the special type
+  //   CTypeInfo::kCallbackOptionsType.
+  CFunctionInfo(const CTypeInfo& return_info, unsigned int arg_count,
+                const CTypeInfo* arg_info);
+
+  const CTypeInfo& ReturnInfo() const { return return_info_; }
+
+  // The argument count, not including the v8::FastApiCallbackOptions
+  // if present.
+  unsigned int ArgumentCount() const {
+    return HasOptions() ? arg_count_ - 1 : arg_count_;
+  }
 
-  // That must be the last bit after ArgFlags.
-  static constexpr uintptr_t kIsWrapperTypeBit = 1 << 1;
-  static constexpr uintptr_t kWrapperTypeInfoMask = static_cast<uintptr_t>(~0)
-                                                    << 2;
+  // |index| must be less than ArgumentCount().
+  //  Note: if the last argument passed on construction of CFunctionInfo
+  //  has type CTypeInfo::kCallbackOptionsType, it is not included in
+  //  ArgumentCount().
+  const CTypeInfo& ArgumentInfo(unsigned int index) const;
 
-  static constexpr unsigned int kTypeOffset = kIsWrapperTypeBit;
-  static constexpr unsigned int kTypeSize = 8 - kTypeOffset;
-  static constexpr uintptr_t kTypeMask =
-      (~(static_cast<uintptr_t>(~0) << kTypeSize)) << kTypeOffset;
+  bool HasOptions() const {
+    // The options arg is always the last one.
+    return arg_count_ > 0 && arg_info_[arg_count_ - 1].GetType() ==
+                                 CTypeInfo::kCallbackOptionsType;
+  }
 
-  const uintptr_t payload_;
+ private:
+  const CTypeInfo return_info_;
+  const unsigned int arg_count_;
+  const CTypeInfo* arg_info_;
 };
 
-class CFunctionInfo {
+class V8_EXPORT CFunction {
  public:
-  virtual const CTypeInfo& ReturnInfo() const = 0;
-  virtual unsigned int ArgumentCount() const = 0;
-  virtual const CTypeInfo& ArgumentInfo(unsigned int index) const = 0;
+  constexpr CFunction() : address_(nullptr), type_info_(nullptr) {}
+
+  const CTypeInfo& ReturnInfo() const { return type_info_->ReturnInfo(); }
+
+  const CTypeInfo& ArgumentInfo(unsigned int index) const {
+    return type_info_->ArgumentInfo(index);
+  }
+
+  unsigned int ArgumentCount() const { return type_info_->ArgumentCount(); }
+
+  const void* GetAddress() const { return address_; }
+  const CFunctionInfo* GetTypeInfo() const { return type_info_; }
+
+  enum class OverloadResolution { kImpossible, kAtRuntime, kAtCompileTime };
+
+  // Returns whether an overload between this and the given CFunction can
+  // be resolved at runtime by the RTTI available for the arguments or at
+  // compile time for functions with different number of arguments.
+  OverloadResolution GetOverloadResolution(const CFunction* other) {
+    // Runtime overload resolution can only deal with functions with the
+    // same number of arguments. Functions with different arity are handled
+    // by compile time overload resolution though.
+    if (ArgumentCount() != other->ArgumentCount()) {
+      return OverloadResolution::kAtCompileTime;
+    }
+
+    // The functions can only differ by a single argument position.
+    int diff_index = -1;
+    for (unsigned int i = 0; i < ArgumentCount(); ++i) {
+      if (ArgumentInfo(i).GetSequenceType() !=
+          other->ArgumentInfo(i).GetSequenceType()) {
+        if (diff_index >= 0) {
+          return OverloadResolution::kImpossible;
+        }
+        diff_index = i;
+
+        // We only support overload resolution between sequence types.
+        if (ArgumentInfo(i).GetSequenceType() ==
+                CTypeInfo::SequenceType::kScalar ||
+            other->ArgumentInfo(i).GetSequenceType() ==
+                CTypeInfo::SequenceType::kScalar) {
+          return OverloadResolution::kImpossible;
+        }
+      }
+    }
+
+    return OverloadResolution::kAtRuntime;
+  }
+
+  template <typename F>
+  static CFunction Make(F* func) {
+    return ArgUnwrap<F*>::Make(func);
+  }
+
+  template <typename F>
+  V8_DEPRECATED("Use CFunctionBuilder instead.")
+  static CFunction MakeWithFallbackSupport(F* func) {
+    return ArgUnwrap<F*>::Make(func);
+  }
+
+  CFunction(const void* address, const CFunctionInfo* type_info);
+
+ private:
+  const void* address_;
+  const CFunctionInfo* type_info_;
+
+  template <typename F>
+  class ArgUnwrap {
+    static_assert(sizeof(F) != sizeof(F),
+                  "CFunction must be created from a function pointer.");
+  };
+
+  template <typename R, typename... Args>
+  class ArgUnwrap<R (*)(Args...)> {
+   public:
+    static CFunction Make(R (*func)(Args...));
+  };
 };
 
 struct ApiObject {
   uintptr_t address;
 };
 
+/**
+ * A struct which may be passed to a fast call callback, like so:
+ * \code
+ *    void FastMethodWithOptions(int param, FastApiCallbackOptions& options);
+ * \endcode
+ */
+struct FastApiCallbackOptions {
+  /**
+   * Creates a new instance of FastApiCallbackOptions for testing purpose.  The
+   * returned instance may be filled with mock data.
+   */
+  static FastApiCallbackOptions CreateForTesting(Isolate* isolate) {
+    return {false, {0}};
+  }
+
+  /**
+   * If the callback wants to signal an error condition or to perform an
+   * allocation, it must set options.fallback to true and do an early return
+   * from the fast method. Then V8 checks the value of options.fallback and if
+   * it's true, falls back to executing the SlowCallback, which is capable of
+   * reporting the error (either by throwing a JS exception or logging to the
+   * console) or doing the allocation. It's the embedder's responsibility to
+   * ensure that the fast callback is idempotent up to the point where error and
+   * fallback conditions are checked, because otherwise executing the slow
+   * callback might produce visible side-effects twice.
+   */
+  bool fallback;
+
+  /**
+   * The `data` passed to the FunctionTemplate constructor, or `undefined`.
+   * `data_ptr` allows for default constructing FastApiCallbackOptions.
+   */
+  union {
+    uintptr_t data_ptr;
+    v8::Value data;
+  };
+};
+
 namespace internal {
 
-template <typename T>
-struct GetCType {
-  static constexpr CTypeInfo Get() {
-    return CTypeInfo::FromCType(CTypeInfo::Type::kV8Value);
+// Helper to count the number of occurances of `T` in `List`
+template <typename T, typename... List>
+struct count : std::integral_constant<int, 0> {};
+template <typename T, typename... Args>
+struct count<T, T, Args...>
+    : std::integral_constant<std::size_t, 1 + count<T, Args...>::value> {};
+template <typename T, typename U, typename... Args>
+struct count<T, U, Args...> : count<T, Args...> {};
+
+template <typename RetBuilder, typename... ArgBuilders>
+class CFunctionInfoImpl : public CFunctionInfo {
+  static constexpr int kOptionsArgCount =
+      count<FastApiCallbackOptions&, ArgBuilders...>();
+  static constexpr int kReceiverCount = 1;
+
+  static_assert(kOptionsArgCount == 0 || kOptionsArgCount == 1,
+                "Only one options parameter is supported.");
+
+  static_assert(sizeof...(ArgBuilders) >= kOptionsArgCount + kReceiverCount,
+                "The receiver or the options argument is missing.");
+
+ public:
+  constexpr CFunctionInfoImpl()
+      : CFunctionInfo(RetBuilder::Build(), sizeof...(ArgBuilders),
+                      arg_info_storage_),
+        arg_info_storage_{ArgBuilders::Build()...} {
+    constexpr CTypeInfo::Type kReturnType = RetBuilder::Build().GetType();
+    static_assert(kReturnType == CTypeInfo::Type::kVoid ||
+                      kReturnType == CTypeInfo::Type::kBool ||
+                      kReturnType == CTypeInfo::Type::kInt32 ||
+                      kReturnType == CTypeInfo::Type::kUint32 ||
+                      kReturnType == CTypeInfo::Type::kFloat32 ||
+                      kReturnType == CTypeInfo::Type::kFloat64,
+                  "64-bit int and api object values are not currently "
+                  "supported return types.");
   }
+
+ private:
+  const CTypeInfo arg_info_storage_[sizeof...(ArgBuilders)];
 };
 
-#define SPECIALIZE_GET_C_TYPE_FOR(ctype, ctypeinfo)            \
-  template <>                                                  \
-  struct GetCType<ctype> {                                     \
-    static constexpr CTypeInfo Get() {                         \
-      return CTypeInfo::FromCType(CTypeInfo::Type::ctypeinfo); \
-    }                                                          \
+template <typename T>
+struct TypeInfoHelper {
+  static_assert(sizeof(T) != sizeof(T), "This type is not supported");
+};
+
+#define SPECIALIZE_GET_TYPE_INFO_HELPER_FOR(T, Enum)                          \
+  template <>                                                                 \
+  struct TypeInfoHelper<T> {                                                  \
+    static constexpr CTypeInfo::Flags Flags() {                               \
+      return CTypeInfo::Flags::kNone;                                         \
+    }                                                                         \
+                                                                              \
+    static constexpr CTypeInfo::Type Type() { return CTypeInfo::Type::Enum; } \
+    static constexpr CTypeInfo::SequenceType SequenceType() {                 \
+      return CTypeInfo::SequenceType::kScalar;                                \
+    }                                                                         \
   };
 
-#define SUPPORTED_C_TYPES(V) \
-  V(void, kVoid)             \
+template <CTypeInfo::Type type>
+struct CTypeInfoTraits {};
+
+#define DEFINE_TYPE_INFO_TRAITS(CType, Enum)      \
+  template <>                                     \
+  struct CTypeInfoTraits<CTypeInfo::Type::Enum> { \
+    using ctype = CType;                          \
+  };
+
+#define PRIMITIVE_C_TYPES(V) \
   V(bool, kBool)             \
   V(int32_t, kInt32)         \
   V(uint32_t, kUint32)       \
   V(int64_t, kInt64)         \
   V(uint64_t, kUint64)       \
   V(float, kFloat32)         \
-  V(double, kFloat64)        \
-  V(ApiObject, kV8Value)
+  V(double, kFloat64)
+
+// Same as above, but includes deprecated types for compatibility.
+#define ALL_C_TYPES(V)               \
+  PRIMITIVE_C_TYPES(V)               \
+  V(void, kVoid)                     \
+  V(v8::Local<v8::Value>, kV8Value)  \
+  V(v8::Local<v8::Object>, kV8Value) \
+  V(ApiObject, kApiObject)
+
+// ApiObject was a temporary solution to wrap the pointer to the v8::Value.
+// Please use v8::Local<v8::Value> in new code for the arguments and
+// v8::Local<v8::Object> for the receiver, as ApiObject will be deprecated.
+
+ALL_C_TYPES(SPECIALIZE_GET_TYPE_INFO_HELPER_FOR)
+PRIMITIVE_C_TYPES(DEFINE_TYPE_INFO_TRAITS)
+
+#undef PRIMITIVE_C_TYPES
+#undef ALL_C_TYPES
+
+#define SPECIALIZE_GET_TYPE_INFO_HELPER_FOR_TA(T, Enum)                       \
+  template <>                                                                 \
+  struct TypeInfoHelper<FastApiTypedArray<T>> {                               \
+    static constexpr CTypeInfo::Flags Flags() {                               \
+      return CTypeInfo::Flags::kNone;                                         \
+    }                                                                         \
+                                                                              \
+    static constexpr CTypeInfo::Type Type() { return CTypeInfo::Type::Enum; } \
+    static constexpr CTypeInfo::SequenceType SequenceType() {                 \
+      return CTypeInfo::SequenceType::kIsTypedArray;                          \
+    }                                                                         \
+  };
 
-SUPPORTED_C_TYPES(SPECIALIZE_GET_C_TYPE_FOR)
+#define TYPED_ARRAY_C_TYPES(V) \
+  V(int32_t, kInt32)           \
+  V(uint32_t, kUint32)         \
+  V(int64_t, kInt64)           \
+  V(uint64_t, kUint64)         \
+  V(float, kFloat32)           \
+  V(double, kFloat64)
 
-// T* where T is a primitive (array of primitives).
-template <typename T, typename = void>
-struct GetCTypePointerImpl {
-  static constexpr CTypeInfo Get() {
-    return CTypeInfo::FromCType(GetCType<T>::Get().GetType(),
-                                CTypeInfo::ArgFlags::kIsArrayBit);
-  }
-};
+TYPED_ARRAY_C_TYPES(SPECIALIZE_GET_TYPE_INFO_HELPER_FOR_TA)
 
-// T* where T is an API object.
-template <typename T>
-struct GetCTypePointerImpl<T, void> {
-  static constexpr CTypeInfo Get() { return CTypeInfo::FromWrapperType(); }
-};
+#undef TYPED_ARRAY_C_TYPES
 
-// T** where T is a primitive. Not allowed.
-template <typename T, typename = void>
-struct GetCTypePointerPointerImpl {
-  static_assert(sizeof(T**) != sizeof(T**), "Unsupported type");
-};
+template <>
+struct TypeInfoHelper<v8::Local<v8::Array>> {
+  static constexpr CTypeInfo::Flags Flags() { return CTypeInfo::Flags::kNone; }
 
-// T** where T is an API object (array of API objects).
-template <typename T>
-struct GetCTypePointerPointerImpl<T, void> {
-  static constexpr CTypeInfo Get() {
-    return CTypeInfo::FromWrapperType(CTypeInfo::ArgFlags::kIsArrayBit);
+  static constexpr CTypeInfo::Type Type() { return CTypeInfo::Type::kVoid; }
+  static constexpr CTypeInfo::SequenceType SequenceType() {
+    return CTypeInfo::SequenceType::kIsSequence;
   }
 };
 
-template <typename T>
-struct GetCType<T**> : public GetCTypePointerPointerImpl<T> {};
-
-template <typename T>
-struct GetCType<T*> : public GetCTypePointerImpl<T> {};
+template <>
+struct TypeInfoHelper<v8::Local<v8::Uint32Array>> {
+  static constexpr CTypeInfo::Flags Flags() { return CTypeInfo::Flags::kNone; }
 
-template <typename R, bool RaisesException, typename... Args>
-class CFunctionInfoImpl : public CFunctionInfo {
- public:
-  static constexpr int kHasErrorArgCount = (RaisesException ? 1 : 0);
-  static constexpr int kReceiverCount = 1;
-  CFunctionInfoImpl()
-      : return_info_(internal::GetCType<R>::Get()),
-        arg_count_(sizeof...(Args) - kHasErrorArgCount),
-        arg_info_{internal::GetCType<Args>::Get()...} {
-    static_assert(sizeof...(Args) >= kHasErrorArgCount + kReceiverCount,
-                  "The receiver or the has_error argument is missing.");
-    static_assert(
-        internal::GetCType<R>::Get().GetType() == CTypeInfo::Type::kVoid,
-        "Only void return types are currently supported.");
+  static constexpr CTypeInfo::Type Type() { return CTypeInfo::Type::kUint32; }
+  static constexpr CTypeInfo::SequenceType SequenceType() {
+    return CTypeInfo::SequenceType::kIsTypedArray;
   }
+};
 
-  const CTypeInfo& ReturnInfo() const override { return return_info_; }
-  unsigned int ArgumentCount() const override { return arg_count_; }
-  const CTypeInfo& ArgumentInfo(unsigned int index) const override {
-    if (index >= ArgumentCount()) {
-      return CTypeInfo::Invalid();
-    }
-    return arg_info_[index];
-  }
+template <>
+struct TypeInfoHelper<FastApiCallbackOptions&> {
+  static constexpr CTypeInfo::Flags Flags() { return CTypeInfo::Flags::kNone; }
 
- private:
-  const CTypeInfo return_info_;
-  const unsigned int arg_count_;
-  const CTypeInfo arg_info_[sizeof...(Args)];
+  static constexpr CTypeInfo::Type Type() {
+    return CTypeInfo::kCallbackOptionsType;
+  }
+  static constexpr CTypeInfo::SequenceType SequenceType() {
+    return CTypeInfo::SequenceType::kScalar;
+  }
 };
 
-}  // namespace internal
+#define STATIC_ASSERT_IMPLIES(COND, ASSERTION, MSG) \
+  static_assert(((COND) == 0) || (ASSERTION), MSG)
 
-class V8_EXPORT CFunction {
+template <typename T, CTypeInfo::Flags... Flags>
+class CTypeInfoBuilder {
  public:
-  constexpr CFunction() : address_(nullptr), type_info_(nullptr) {}
-
-  const CTypeInfo& ReturnInfo() const { return type_info_->ReturnInfo(); }
-
-  const CTypeInfo& ArgumentInfo(unsigned int index) const {
-    return type_info_->ArgumentInfo(index);
+  using BaseType = T;
+
+  static constexpr CTypeInfo Build() {
+    constexpr CTypeInfo::Flags kFlags =
+        MergeFlags(TypeInfoHelper<T>::Flags(), Flags...);
+    constexpr CTypeInfo::Type kType = TypeInfoHelper<T>::Type();
+    constexpr CTypeInfo::SequenceType kSequenceType =
+        TypeInfoHelper<T>::SequenceType();
+
+    STATIC_ASSERT_IMPLIES(
+        uint8_t(kFlags) & uint8_t(CTypeInfo::Flags::kAllowSharedBit),
+        (kSequenceType == CTypeInfo::SequenceType::kIsTypedArray ||
+         kSequenceType == CTypeInfo::SequenceType::kIsArrayBuffer),
+        "kAllowSharedBit is only allowed for TypedArrays and ArrayBuffers.");
+    STATIC_ASSERT_IMPLIES(
+        uint8_t(kFlags) & uint8_t(CTypeInfo::Flags::kEnforceRangeBit),
+        CTypeInfo::IsIntegralType(kType),
+        "kEnforceRangeBit is only allowed for integral types.");
+    STATIC_ASSERT_IMPLIES(
+        uint8_t(kFlags) & uint8_t(CTypeInfo::Flags::kClampBit),
+        CTypeInfo::IsIntegralType(kType),
+        "kClampBit is only allowed for integral types.");
+    STATIC_ASSERT_IMPLIES(
+        uint8_t(kFlags) & uint8_t(CTypeInfo::Flags::kIsRestrictedBit),
+        CTypeInfo::IsFloatingPointType(kType),
+        "kIsRestrictedBit is only allowed for floating point types.");
+    STATIC_ASSERT_IMPLIES(kSequenceType == CTypeInfo::SequenceType::kIsSequence,
+                          kType == CTypeInfo::Type::kVoid,
+                          "Sequences are only supported from void type.");
+    STATIC_ASSERT_IMPLIES(
+        kSequenceType == CTypeInfo::SequenceType::kIsTypedArray,
+        CTypeInfo::IsPrimitive(kType) || kType == CTypeInfo::Type::kVoid,
+        "TypedArrays are only supported from primitive types or void.");
+
+    // Return the same type with the merged flags.
+    return CTypeInfo(TypeInfoHelper<T>::Type(),
+                     TypeInfoHelper<T>::SequenceType(), kFlags);
   }
 
-  unsigned int ArgumentCount() const { return type_info_->ArgumentCount(); }
+ private:
+  template <typename... Rest>
+  static constexpr CTypeInfo::Flags MergeFlags(CTypeInfo::Flags flags,
+                                               Rest... rest) {
+    return CTypeInfo::Flags(uint8_t(flags) | uint8_t(MergeFlags(rest...)));
+  }
+  static constexpr CTypeInfo::Flags MergeFlags() { return CTypeInfo::Flags(0); }
+};
 
-  const void* GetAddress() const { return address_; }
-  const CFunctionInfo* GetTypeInfo() const { return type_info_; }
+template <typename RetBuilder, typename... ArgBuilders>
+class CFunctionBuilderWithFunction {
+ public:
+  explicit constexpr CFunctionBuilderWithFunction(const void* fn) : fn_(fn) {}
 
-  template <typename F>
-  static CFunction Make(F* func) {
-    return ArgUnwrap<F*>::Make(func);
+  template <CTypeInfo::Flags... Flags>
+  constexpr auto Ret() {
+    return CFunctionBuilderWithFunction<
+        CTypeInfoBuilder<typename RetBuilder::BaseType, Flags...>,
+        ArgBuilders...>(fn_);
   }
 
-  template <typename F>
-  static CFunction MakeWithErrorSupport(F* func) {
-    return ArgUnwrap<F*>::MakeWithErrorSupport(func);
+  template <unsigned int N, CTypeInfo::Flags... Flags>
+  constexpr auto Arg() {
+    // Return a copy of the builder with the Nth arg builder merged with
+    // template parameter pack Flags.
+    return ArgImpl<N, Flags...>(
+        std::make_index_sequence<sizeof...(ArgBuilders)>());
   }
 
-  template <typename F>
-  static CFunction Make(F* func, const CFunctionInfo* type_info) {
-    return CFunction(reinterpret_cast<const void*>(func), type_info);
+  auto Build() {
+    static CFunctionInfoImpl<RetBuilder, ArgBuilders...> instance;
+    return CFunction(fn_, &instance);
   }
 
  private:
-  const void* address_;
-  const CFunctionInfo* type_info_;
+  template <bool Merge, unsigned int N, CTypeInfo::Flags... Flags>
+  struct GetArgBuilder;
+
+  // Returns the same ArgBuilder as the one at index N, including its flags.
+  // Flags in the template parameter pack are ignored.
+  template <unsigned int N, CTypeInfo::Flags... Flags>
+  struct GetArgBuilder<false, N, Flags...> {
+    using type =
+        typename std::tuple_element<N, std::tuple<ArgBuilders...>>::type;
+  };
 
-  CFunction(const void* address, const CFunctionInfo* type_info);
+  // Returns an ArgBuilder with the same base type as the one at index N,
+  // but merges the flags with the flags in the template parameter pack.
+  template <unsigned int N, CTypeInfo::Flags... Flags>
+  struct GetArgBuilder<true, N, Flags...> {
+    using type = CTypeInfoBuilder<
+        typename std::tuple_element<N,
+                                    std::tuple<ArgBuilders...>>::type::BaseType,
+        std::tuple_element<N, std::tuple<ArgBuilders...>>::type::Build()
+            .GetFlags(),
+        Flags...>;
+  };
 
-  template <typename R, bool RaisesException, typename... Args>
-  static CFunctionInfo* GetCFunctionInfo() {
-    static internal::CFunctionInfoImpl<R, RaisesException, Args...> instance;
-    return &instance;
+  // Return a copy of the CFunctionBuilder, but merges the Flags on
+  // ArgBuilder index N with the new Flags passed in the template parameter
+  // pack.
+  template <unsigned int N, CTypeInfo::Flags... Flags, size_t... I>
+  constexpr auto ArgImpl(std::index_sequence<I...>) {
+    return CFunctionBuilderWithFunction<
+        RetBuilder, typename GetArgBuilder<N == I, I, Flags...>::type...>(fn_);
   }
 
-  template <typename F>
-  class ArgUnwrap {
-    static_assert(sizeof(F) != sizeof(F),
-                  "CFunction must be created from a function pointer.");
-  };
+  const void* fn_;
+};
+
+class CFunctionBuilder {
+ public:
+  constexpr CFunctionBuilder() {}
 
   template <typename R, typename... Args>
-  class ArgUnwrap<R (*)(Args...)> {
-   public:
-    static CFunction Make(R (*func)(Args...)) {
-      return CFunction(reinterpret_cast<const void*>(func),
-                       GetCFunctionInfo<R, false, Args...>());
-    }
-    static CFunction MakeWithErrorSupport(R (*func)(Args...)) {
-      return CFunction(reinterpret_cast<const void*>(func),
-                       GetCFunctionInfo<R, true, Args...>());
-    }
-  };
+  constexpr auto Fn(R (*fn)(Args...)) {
+    return CFunctionBuilderWithFunction<CTypeInfoBuilder<R>,
+                                        CTypeInfoBuilder<Args>...>(
+        reinterpret_cast<const void*>(fn));
+  }
 };
 
+}  // namespace internal
+
+// static
+template <typename R, typename... Args>
+CFunction CFunction::ArgUnwrap<R (*)(Args...)>::Make(R (*func)(Args...)) {
+  return internal::CFunctionBuilder().Fn(func).Build();
+}
+
+using CFunctionBuilder = internal::CFunctionBuilder;
+
+/**
+ * Copies the contents of this JavaScript array to a C++ buffer with
+ * a given max_length. A CTypeInfo is passed as an argument,
+ * instructing different rules for conversion (e.g. restricted float/double).
+ * The element type T of the destination array must match the C type
+ * corresponding to the CTypeInfo (specified by CTypeInfoTraits).
+ * If the array length is larger than max_length or the array is of
+ * unsupported type, the operation will fail, returning false. Generally, an
+ * array which contains objects, undefined, null or anything not convertible
+ * to the requested destination type, is considered unsupported. The operation
+ * returns true on success. `type_info` will be used for conversions.
+ */
+template <const CTypeInfo* type_info, typename T>
+bool CopyAndConvertArrayToCppBuffer(Local<Array> src, T* dst,
+                                    uint32_t max_length);
+
 }  // namespace v8
 
 #endif  // INCLUDE_V8_FAST_API_CALLS_H_