Fix IFNDR circular dependency in not_null conversion operator SFINAE

Summary:
The `is_not_null_castable` and `is_not_null_move_castable` traits used `std::integral_constant<bool, A && B>` where B contains
`std::is_convertible<not_null<PtrT>&, ToT>`. Since template arguments to `std::integral_constant` are eagerly instantiated regardless of short-circuit semantics, checking `std::is_convertible<not_null<PtrT>, U>` would instantiate `operator U()`, whose SFINAE constraint instantiates `is_not_null_castable`, which recursively instantiates `std::is_convertible<not_null<PtrT>, U>`, causing unbounded template recursion.

This manifests under libc++ when libraries like `nlohmann::json` perform exhaustive SFINAE probing of `is_convertible` for arbitrary type combinations.

The fix replaces `std::integral_constant<bool, A && B>` with `std::conjunction<A, B>`. Per [meta.logical], `std::conjunction` implements short-circuit instantiation: if any argument is `false_type`, subsequent arguments are not instantiated. This breaks the cycle since when `is_convertible<PtrT&, ToT>` yields false_type, the second trait containing the recursive `is_convertible<not_null<...>, ToT>` check is never instantiated.

Note: D74599633 attempted to fix this. However, the `check_constraint_if_not wrapper` in `operator U()` only prevents instantiation of `is_not_null_castable` when U is the same type as PtrT:

  template <
      typename U,
      typename = std::enable_if_t<detail::check_constraint_if_not<
          std::is_same_v<PtrT, folly::remove_cvref_t<U>>,  // Only skips when U == PtrT
          detail::is_not_null_castable>::template apply<PtrT, U>>>
  operator U() const& ...

The problem is the recursion happens for types other than `PtrT`. The `check_constraint_if_not mechanism` only breaks the cycle for the `U == Ptr`T case (which would cause ambiguity with `operator const PtrT&()`). It doesn't help when U is an unrelated type like `string_view`.

Reviewed By: yfeldblum

Differential Revision: D92435995

fbshipit-source-id: f8af523c5f323ef26e2f333ccff2d1025ffa5f2a

Author: yuxuanchen1997

third-party/folly/src/folly/memory/not_null-inl.h

@@ -88,26 +88,33 @@ struct secret_guaranteed_not_null : guaranteed_not_null_provider {
 //  - It must not already be castable, otherwise the compiler will raise an
 //    ambiguity error
 //  - PtrT must be castable to ToT
+//
+// NOTE: We use std::conjunction for short-circuit evaluation to avoid infinite
+// template recursion. With std::integral_constant<bool, A && B>, both operands
+// are instantiated even when A is false. When external code checks
+// std::is_convertible<not_null<PtrT>, U>, this instantiates operator U(),
+// whose SFINAE constraint instantiates is_not_null_castable, which would check
+// std::is_convertible<not_null<PtrT>, U> again, causing unbounded recursion.
+// std::conjunction short-circuits: if the first trait is false_type, the second
+// trait is not instantiated, breaking the cycle.
 template <typename FromPtrT, typename ToT>
 struct is_not_null_castable
-    : std::integral_constant<
-          bool,
-          std::is_convertible_v<const FromPtrT&, ToT> &&
-              !std::is_convertible_v<
-                  // No need to specialize based on null handler as it doesn't
-                  // affect the result.
-                  const not_null<FromPtrT, default_null_handler>&,
-                  ToT>> {};
+    : std::conjunction<
+          std::is_convertible<const FromPtrT&, ToT>,
+          std::negation<std::is_convertible<
+              // No need to specialize based on null handler as it doesn't
+              // affect the result.
+              const not_null<FromPtrT, default_null_handler>&,
+              ToT>>> {};
 template <typename FromPtrT, typename ToT>
 struct is_not_null_move_castable
-    : std::integral_constant<
-          bool,
-          std::is_convertible_v<FromPtrT&&, ToT> &&
-              !std::is_convertible_v<
-                  // No need to specialize based on null handler as it doesn't
-                  // affect the result.
-                  not_null<FromPtrT, default_null_handler>&&,
-                  ToT>> {};
+    : std::conjunction<
+          std::is_convertible<FromPtrT&&, ToT>,
+          std::negation<std::is_convertible<
+              // No need to specialize based on null handler as it doesn't
+              // affect the result.
+              not_null<FromPtrT, default_null_handler>&&,
+              ToT>>> {};
 
 template <typename T, typename = decltype(*std::declval<T*>() == nullptr)>
 inline std::true_type is_comparable_to_nullptr_fn(const T&) {