react-native-windows 0.81.32 → 0.81.35

package/external/folly/folly/lang/Extern.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+//  FOLLY_CREATE_EXTERN_ACCESSOR
+//
+//  Defines a variable template which holds the address of an object or null
+//  given a condition which identifies whether that object is expected to have
+//  a definition.
+//
+//  Example:
+//
+//      extern void foobar(int); // may be defined in another library
+//      inline constexpr bool has_foobar = // ...
+//
+//      namespace myapp {
+//      FOLLY_CREATE_EXTERN_ACCESSOR(access_foobar_v, ::foobar);
+//      void try_foobar(int num) {
+//        if (auto ptr = access_foobar_v<has_foobar>) {
+//          ptr(num);
+//        }
+//      }
+//      }
+//
+//  Remarks:
+//
+//  This can be done more simply using weak symbols. But weak symbols are non-
+//  portable and the rules around the use of weak symbols are complex.
+#define FOLLY_CREATE_EXTERN_ACCESSOR(varname, name) \
+  struct __folly_extern_accessor_##varname {        \
+    template <bool E, typename N>                   \
+    static constexpr N* get() noexcept {            \
+      if constexpr (E) {                            \
+        return &name;                               \
+      } else {                                      \
+        return nullptr;                             \
+      }                                             \
+    }                                               \
+  };                                                \
+  template <bool E, typename N = decltype(name)>    \
+  inline constexpr N* varname = __folly_extern_accessor_##varname::get<E, N>()

package/external/folly/folly/lang/Hint-inl.h

@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace folly {
+
+FOLLY_ALWAYS_INLINE void compiler_may_unsafely_assume(bool cond) {
+  FOLLY_SAFE_DCHECK(cond, "compiler-hint assumption fails at runtime");
+#if defined(__clang__)
+  __builtin_assume(cond);
+#elif defined(__GNUC__)
+  if (!cond) {
+    __builtin_unreachable();
+  }
+#elif defined(_MSC_VER)
+  __assume(cond);
+#else
+  while (!cond)
+    ;
+#endif
+}
+
+[[noreturn]] FOLLY_ALWAYS_INLINE void
+compiler_may_unsafely_assume_unreachable() {
+  FOLLY_SAFE_DCHECK(false, "compiler-hint unreachability reached at runtime");
+#if defined(__GNUC__)
+  __builtin_unreachable();
+#elif defined(_MSC_VER)
+  __assume(0);
+#else
+  while (!0)
+    ;
+#endif
+}
+
+FOLLY_ALWAYS_INLINE void compiler_may_unsafely_assume_separate_storage(
+    void const* const a, void const* const b) {
+  FOLLY_SAFE_DCHECK(
+      a != b, "compiler-hint separate storage assumption fails at runtime");
+#if FOLLY_HAS_BUILTIN(__builtin_assume_separate_storage)
+  __builtin_assume_separate_storage(a, b);
+#endif
+}
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+namespace detail {
+
+#pragma optimize("", off)
+
+inline void compiler_must_force_sink(void const*) {}
+
+#pragma optimize("", on)
+
+} // namespace detail
+
+template <typename T>
+FOLLY_ALWAYS_INLINE void compiler_must_not_elide_fn::operator()(
+    T const& t) const noexcept {
+  detail::compiler_must_force_sink(&t);
+}
+
+template <typename T>
+FOLLY_ALWAYS_INLINE void compiler_must_not_predict_fn::operator()(
+    T& t) const noexcept {
+  detail::compiler_must_force_sink(&t);
+}
+
+#else
+
+namespace detail {
+
+template <typename T, typename D = std::decay_t<T>>
+using compiler_must_force_indirect = std::bool_constant<
+    !std::is_trivially_copyable_v<D> || //
+    sizeof(long) < sizeof(D) || //
+    std::is_pointer<D>::value>;
+
+template <typename T>
+FOLLY_ALWAYS_INLINE void compiler_must_not_elide(T const& t, std::false_type) {
+  // the "r" constraint forces the compiler to make the value available in a
+  // register to the asm block, which means that it must first have been
+  // computed or loaded
+  //
+  // used for small trivial values which the compiler will put into registers
+  //
+  // avoided for pointers to avoid fallout in calling code which mistakenly
+  // applies the hint to the address of a value but not to the value itself
+  asm volatile("" : : "r"(t));
+}
+
+template <typename T>
+FOLLY_ALWAYS_INLINE void compiler_must_not_elide(T const& t, std::true_type) {
+  // tells the compiler that the asm block will read the value from memory,
+  // and that in addition it might read or write from any memory location
+  //
+  // if the memory clobber could be split into input and output, that would be
+  // preferrable
+  asm volatile("" : : "m"(t) : "memory");
+}
+
+template <typename T>
+FOLLY_ALWAYS_INLINE void compiler_must_not_predict(T& t, std::false_type) {
+  asm volatile("" : "+r"(t));
+}
+
+template <typename T>
+FOLLY_ALWAYS_INLINE void compiler_must_not_predict(T& t, std::true_type) {
+  asm volatile("" : : "m"(t) : "memory");
+}
+
+} // namespace detail
+
+template <typename T>
+FOLLY_ALWAYS_INLINE void compiler_must_not_elide_fn::operator()(
+    T const& t) const noexcept {
+  using i = detail::compiler_must_force_indirect<T>;
+  detail::compiler_must_not_elide(t, i{});
+}
+
+template <typename T>
+FOLLY_ALWAYS_INLINE void compiler_must_not_predict_fn::operator()(
+    T& t) const noexcept {
+  using i = detail::compiler_must_force_indirect<T>;
+  detail::compiler_must_not_predict(t, i{});
+}
+
+#endif
+
+} // namespace folly

package/external/folly/folly/lang/Hint.h

@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <type_traits>
+
+#include <folly/Portability.h>
+#include <folly/Traits.h>
+#include <folly/lang/SafeAssert.h>
+
+namespace folly {
+
+//  compiler_may_unsafely_assume
+//
+//  Unsafe. Avoid when not absolutely necessary.
+//
+//  Permits the compiler to assume the truth of the provided expression and to
+//  optimize the surrounding code as if that expression were true.
+//
+//  Causes every possible kind of subtle, irreproducible, non-debuggable failure
+//  if the provided expression is ever, for any reason, false: random crashes,
+//  silent memory corruptions, arbitrary code execution, privacy violation, etc.
+//
+//  Must only be used on conditions that are provable internal logic invariants.
+//
+//  Must not be used on conditions which depend on external inputs. For such
+//  cases, an assertion or exception may be used instead.
+void compiler_may_unsafely_assume(bool cond);
+
+//  compiler_may_unsafely_assume_unreachable
+//
+//  Unsafe. Avoid when not absolutely necessary.
+//
+//  Permits the compiler to assume that the given statement cannot be reached
+//  and to optimize the surrounding code accordingly. Permits call sites to omit
+//  return statements in non-void-returning functions without compiler error.
+//
+//  Causes every possible kind of subtle, irreproducible, non-debuggable failure
+//  if the given statement is ever, for any reason, reached: random crashes,
+//  silent memory corruptions, arbitrary code execution, privacy violation, etc.
+//
+//  Must only be used on conditions that are provable internal logic invariants.
+//
+//  Must not be used on conditions which depend on external inputs. For such
+//  cases, an assertion or exception may be used instead.
+[[noreturn]] void compiler_may_unsafely_assume_unreachable();
+
+//  compiler_may_unsafely_assume_separate_storage
+//
+//  Unsafe. Avoid when not absolutely necessary.
+//
+//  Permits the compiler to assume that the given pointers point into regions
+//  that were allocated separately, and that therefore any pointers at any
+//  offset relative to one is never equal to any pointer at any offset relative
+//  to the other.
+//
+//  Regions being allocated separately means that they are separate global
+//  variables, thread-local variables, stack variables, or heap allocations.
+//
+//  This can be helpful when some library has an ownership model that is opaque
+//  to the compiler. For example, modifying some_vector[0] never modifies the
+//  vector itself; changes to parser state don't need to be stored to memory
+//  before reading the next byte of data to be parsed, etc.
+void compiler_may_unsafely_assume_separate_storage(
+    const void* a, const void* b);
+
+//  compiler_must_not_elide
+//
+//  Ensures that the referred-to value will be computed even when an optimizing
+//  compiler might otherwise remove the computation. Note: this hint takes its
+//  value parameter by reference.
+//
+//  Useful for values that are computed during benchmarking but otherwise are
+//  unused. The compiler tends to do a good job at eliminating unused variables,
+//  which can affect benchmark results, and this hint instructs the compiler to
+//  treat the value as though it were used.
+struct compiler_must_not_elide_fn {
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void operator()(T const& t) const noexcept;
+};
+inline constexpr compiler_must_not_elide_fn compiler_must_not_elide{};
+
+//  compiler_must_not_predict
+//
+//  Ensures that the compiler will not use its knowledge of the referred-to
+//  value to optimize or otherwise shape the following code. Note: this hint
+//  takes its value parameter by reference.
+//
+//  Useful when constant propagation or power reduction is possible in a
+//  benchmark but not in real use cases. Optimizations done to benchmarked code
+//  which cannot be done to real code can affect benchmark results, and this
+//  hint instructs the compiler to treat value which it can predict as though it
+//  were unpredictable.
+struct compiler_must_not_predict_fn {
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void operator()(T& t) const noexcept;
+};
+inline constexpr compiler_must_not_predict_fn compiler_must_not_predict{};
+
+//  ----
+
+namespace detail {
+
+template <typename T>
+using detect_folly_is_unsafe_for_async_usage =
+    typename T::folly_is_unsafe_for_async_usage;
+
+//  is_unsafe_for_async_usage_v
+//
+//  Whether a type is directly marked as unsafe for async usage with a member
+//  type alias. See unsafe_for_async_usage below.
+template <typename T>
+inline constexpr bool is_unsafe_for_async_usage_v = detected_or_t<
+    std::false_type,
+    detail::detect_folly_is_unsafe_for_async_usage,
+    T>::value;
+
+} // namespace detail
+
+//  unsafe_for_async_usage
+//
+//  Defines member type alias folly_is_unsafe_for_async_usage, which is the tag
+//  marking the class as unsafe for async usage. Serves as a convenience wrapper
+//  around the tag.
+//
+//  The meaning of the tag is that the current thread must not be yielded in any
+//  way during the lifetime of any tagged object.
+//
+//  The most common form of yielding the current thread during the lifetime of
+//  an object is where the lifetime of the object crosses a coroutine suspension
+//  point. Example:
+//
+//    struct unsafe : private unsafe_for_async_usage {};
+//    Task<> sink();
+//    Task<> go() {
+//      unsafe object; // object is tagged as unsafe for async usage
+//      co_await sink(); // but crossing the co_await is async usage
+//    }
+//
+//  Some objects, especially some which are intended for use with the RAII
+//  pattern, may be thread-sensitive and permit access only on one single thread
+//  throughout their lifetimes. Or they may be non-reentrant and may permit only
+//  well-nested accesses or may not permit any reentrant accesses at all. In
+//  either case, they do not permit yielding the current thread during their
+//  lifetimes. Examples:
+//  * Some objects that rely internally on thread-locals.
+//    * In particular, the storage defined by FOLLY_DECLARE_REUSED.
+//  * lock_guards for most mutexes.
+//  * Some advanced concurrency primitives.
+//    * In particular, hazard-pointers and rcu-guards.
+//
+//  Note that the current thread being yielded refers to any form of cooperative
+//  multitasking, such as coroutines, as compared with the kernel preempting the
+//  current thread and then resuming it later.
+//
+//  In order to mark a class type, either:
+//  * Declare a member type alias
+//    `using folly_is_unsafe_for_async_usage = std::true_type`.
+//  * Declare either a non-static data member or a base which is marked. As a
+//    convenience, unsafe_for_async_usage is marked and may be used as that non-
+//    static data member or base. If using a non-static data member, it is ideal
+//    to declare it with attribute [[no_unique_address]], possibly as wrapped in
+//    FOLLY_ATTR_NO_UNIQUE_ADDRESS, to avoid increasing the size of the class.
+//  * std::lock_guard/unique_lock/scoped_lock are considered unsafe unless the
+//    underlying mutex has a typedef `folly_coro_aware_mutex`.
+//
+// NOTE: you can explicitly opt out from a check for a type by having
+//       `folly_is_unsafe_for_async_usage` be `std::false_type`.
+//
+//  It is recommended to use a non-static data member or a base which is marked,
+//  in preference to using a member type alias, since it is impossible to typo
+//  the spelling of a non-static data member or base while it is easy to typo
+//  the spelling of a member type alias.
+//
+//  Example:
+//
+//    struct thread_counter {
+//      static thread_local int value;
+//    };
+//    struct thread_counter_raii : private unsafe_for_async_usage {
+//      thread_counter_raii() { ++thread_counter::value; }
+//      ~thread_counter_raii() { --thread_counter::value; }
+//    };
+//    coroutine callee();
+//    coroutine caller() {
+//      thread_counter_raii g;
+//      co_await callee(); // static analysis might warn here
+//    }
+//
+//  This marker can be used to implement a static analysis that detects misuses
+//  with objects of classes marked with this tag, namely, where the current
+//  thread may be yielded in any way during the lifetimes of such objects.
+struct unsafe_for_async_usage { // a convenience wrapper for the marker below:
+  // the marker member type alias
+  using folly_is_unsafe_for_async_usage = std::true_type;
+};
+static_assert(detail::is_unsafe_for_async_usage_v<unsafe_for_async_usage>, "");
+
+namespace detail {
+
+template <typename T>
+using detect_folly_is_coro_aware_mutex = typename T::folly_coro_aware_mutex;
+
+} // namespace detail
+
+// Inheriting or having a member `unsafe_for_async_usage_if` will conditionally
+// tag the type.
+template <bool If>
+struct unsafe_for_async_usage_if {};
+
+template <>
+struct unsafe_for_async_usage_if<true> {
+  using folly_is_unsafe_for_async_usage = std::true_type;
+};
+
+// Detects the presense of folly_coro_aware_mutex nested typedef.
+// This helps custom lock guards have the same behavior as std::lock_guard.
+template <typename T>
+constexpr bool is_coro_aware_mutex_v =
+    is_detected_v<detail::detect_folly_is_coro_aware_mutex, T>;
+
+} // namespace folly
+
+#include <folly/lang/Hint-inl.h>

package/external/folly/folly/lang/Keep.h

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/CPortability.h>
+
+//  FOLLY_KEEP
+//
+//  When applied to a function, prevents removal of the function. Useful for
+//  marking functions which it is desirable to keep.
+//
+//  A common use-case is for keeping unused functions in test or benchmark
+//  programs which serve as convenient targets for inspecting how the compiler
+//  translates source code to machine code. Such functions may be disassembled
+//  for inspection in the debugger of with the objdump tool, and are often, for
+//  lack of imagination, called check functions in test and benchmark programs.
+//
+//  Example:
+//
+//      extern "C" FOLLY_KEEP void check_throw_int_0() {
+//        throw 0;
+//      }
+//
+//      $ objdump -dCM intel-mnemonic path/to/binary | less
+//      # less permits searching for check_throw_int_0
+//
+//      $ gdb path/to/binary -q -batch -ex 'disassemble check_throw_int_0'
+//
+//  Functions may be removed when building with both function-sections and
+//  gc-sections. It is tricky to keep them; this utility captures the steps
+//  required.
+//
+//  In order for this mechanism to work, this header must be included. This
+//  mechanism relies on the hidden global variable below.
+//
+//  The linker, when asked to with --gc-sections, may throw out unreferenced
+//  sections. When the compiler emits each function into its own section, as it
+//  does when asked to with -ffunction-sections, the linker will throw out
+//  unreferenced functions. The key is to move all kept functions into a single
+//  section, avoiding the behavior of -ffunction-sections, and then force the
+//  compiler to emit some reference to at least one function in that section.
+//  This way, the linker will see at least one reference to the kept section,
+//  and so will not throw it out.
+#if __GNUC__ && __linux__
+#define FOLLY_KEEP [[gnu::section(".text.folly.keep")]]
+#else
+#define FOLLY_KEEP
+#endif
+
+#if __GNUC__ && __linux__
+#if defined(__clang__) || FOLLY_ARM || FOLLY_AARCH64
+#define FOLLY_KEEP_DETAIL_ATTR_NAKED [[gnu::naked]]
+#else
+#define FOLLY_KEEP_DETAIL_ATTR_NAKED
+#endif
+#define FOLLY_KEEP_DETAIL_ATTR_NOINLINE [[gnu::noinline]]
+#else
+#define FOLLY_KEEP_DETAIL_ATTR_NAKED
+#define FOLLY_KEEP_DETAIL_ATTR_NOINLINE
+#endif
+
+namespace folly {
+namespace detail {
+
+//  marking this as [[gnu::naked]] gets clang not to emit any text for this
+FOLLY_KEEP FOLLY_KEEP_DETAIL_ATTR_NAKED static void keep_anchor() {}
+
+class keep {
+ public:
+  //  must accept the anchor function as an argument
+  FOLLY_KEEP_DETAIL_ATTR_NOINLINE explicit keep(void (*)()) noexcept {}
+};
+
+//  noinline ctor and trivial dtor minimize the text size of this
+static keep keep_instance{keep_anchor};
+
+//  weak and noinline to prevent the compiler from eliding calls
+template <typename... T>
+FOLLY_ATTR_WEAK FOLLY_NOINLINE void keep_sink(T&&...) {}
+template <typename... T>
+FOLLY_ATTR_WEAK FOLLY_NOINLINE void keep_sink_nx(T&&...) noexcept {}
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/lang/New.h

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <new>
+
+#include <folly/CppAttributes.h>
+#include <folly/Portability.h>
+#include <folly/functional/Invoke.h>
+
+namespace folly {
+
+namespace detail {
+
+#if defined(__cpp_aligned_new)
+constexpr auto cpp_aligned_new_ = __cpp_aligned_new >= 201606;
+#else
+constexpr auto cpp_aligned_new_ = false;
+#endif
+
+#if defined(__cpp_sized_deallocation)
+constexpr auto cpp_sized_deallocation_ = __cpp_sized_deallocation >= 201309L;
+#else
+constexpr auto cpp_sized_deallocation_ = false;
+#endif
+
+//  https://clang.llvm.org/docs/LanguageExtensions.html#builtin-operator-new-and-builtin-operator-delete
+
+constexpr auto op_new_builtin_ =
+    FOLLY_HAS_BUILTIN(__builtin_operator_new) >= 201802L;
+constexpr auto op_del_builtin_ =
+    FOLLY_HAS_BUILTIN(__builtin_operator_del) >= 201802L;
+
+FOLLY_CREATE_QUAL_INVOKER(op_new_builtin_fn_, __builtin_operator_new);
+FOLLY_CREATE_QUAL_INVOKER(op_new_library_fn_, ::operator new);
+
+FOLLY_CREATE_QUAL_INVOKER(op_del_builtin_fn_, __builtin_operator_delete);
+FOLLY_CREATE_QUAL_INVOKER(op_del_library_fn_, ::operator delete);
+
+template <bool Usual, bool C = (Usual && op_new_builtin_)>
+constexpr conditional_t<C, op_new_builtin_fn_, op_new_library_fn_> op_new_;
+
+template <bool Usual, bool C = (Usual && op_del_builtin_)>
+constexpr conditional_t<C, op_del_builtin_fn_, op_del_library_fn_> op_del_;
+
+template <bool Usual, typename... A>
+FOLLY_ERASE void do_op_del_sized_(
+    void* const p, std::size_t const s, A const... a) {
+  if constexpr (detail::cpp_sized_deallocation_) {
+    return op_del_<Usual>(p, s, a...);
+  } else {
+    return op_del_<Usual>(p, a...);
+  }
+}
+
+} // namespace detail
+
+//  operator_new
+struct operator_new_fn {
+  FOLLY_NODISCARD FOLLY_ERASE void* operator()( //
+      std::size_t const s) const //
+      noexcept(noexcept(::operator new(0))) {
+    return detail::op_new_<true>(s);
+  }
+  FOLLY_NODISCARD FOLLY_ERASE void* operator()( //
+      std::size_t const s,
+      std::nothrow_t const& nt) const noexcept {
+    return detail::op_new_<true>(s, nt);
+  }
+  FOLLY_NODISCARD FOLLY_ERASE void* operator()( //
+      std::size_t const s,
+      std::align_val_t const a) const //
+      noexcept(noexcept(::operator new(0))) {
+    return detail::op_new_<detail::cpp_aligned_new_>(s, a);
+  }
+  FOLLY_NODISCARD FOLLY_ERASE void* operator()( //
+      std::size_t const s,
+      std::align_val_t const a,
+      std::nothrow_t const& nt) const noexcept {
+    return detail::op_new_<detail::cpp_aligned_new_>(s, a, nt);
+  }
+};
+inline constexpr operator_new_fn operator_new{};
+
+//  operator_delete
+struct operator_delete_fn {
+  FOLLY_ERASE void operator()( //
+      void* const p) const noexcept {
+    return detail::op_del_<true>(p);
+  }
+  FOLLY_ERASE void operator()( //
+      void* const p,
+      std::size_t const s) const noexcept {
+    return detail::do_op_del_sized_<true>(p, s);
+  }
+  FOLLY_ERASE void operator()( //
+      void* const p,
+      std::align_val_t const a) const noexcept {
+    return detail::op_del_<detail::cpp_aligned_new_>(p, a);
+  }
+  FOLLY_ERASE void operator()( //
+      void* const p,
+      std::size_t const s,
+      std::align_val_t const a) const noexcept {
+    return detail::do_op_del_sized_<detail::cpp_aligned_new_>(p, s, a);
+  }
+};
+inline constexpr operator_delete_fn operator_delete{};
+
+} // namespace folly