[ADT] Extend EnableIfCallable for callables with incomplete returns

[math-fehr]

Summary

std::is_convertible has no defined behavior when its arguments
are incomplete, even if they are equal. In practice, it returns false.
Adding std::is_same allows us to use the constructor using a callable,
even if the return value is incomplete. We also check the case where
we convert a T into a const T.

[math-fehr]

Fix formatting

[math-fehr]

Fix formatting

[DaniilSuchkov]

LGTM

[math-fehr]

Fix compilation on windows by introducing and using llvm::conjuctions

[DaniilSuchkov]

1. Since you're replacing an OR chain you need to re-implement std::disjunction, not std::conjunction (no s at the end), which you mostly did, except for the name and the (2).
2. According to the specification std::disjunction should return std::false_type for an empty argument list. I.e. here you should use std::false_type instead:

template <typename... Conds> struct conjunctions : std::true_type {};

Also please add a couple of tests for your llvm::disjunction implementation to llvm/unittests/Support/TypeTraitsTest.cpp.

[math-fehr]

Remove llvm::conjunctions, and use llvm::disjunction

[math-fehr]

Oh yes, thanks for that!
I realized that there was also already a llvm::disjunction in ADT/STLForwardCompat.h, so I used it.

[DaniilSuchkov]

LGTM

[math-fehr]

Hey! I do not have commit access, could someone commit this patch?

[DaniilSuchkov]

I'll commit it.

llvm/include/llvm/ADT/FunctionExtras.h

 template <typename T>
 using EnableIfTrivial =
     std::enable_if_t<llvm::is_trivially_move_constructible<T>::value &&
                      std::is_trivially_destructible<T>::value>;
 template <typename CallableT, typename ThisT>
 using EnableUnlessSameType =
     std::enable_if_t<!std::is_same<remove_cvref_t<CallableT>, ThisT>::value>;
 template <typename CallableT, typename Ret, typename... Params>
-using EnableIfCallable =
-    std::enable_if_t<std::is_void<Ret>::value ||
-                     std::is_convertible<decltype(std::declval<CallableT>()(
-                                             std::declval<Params>()...)),
-                                         Ret>::value>;
+using EnableIfCallable = std::enable_if_t<llvm::disjunction<
+    std::is_void<Ret>,
+    std::is_same<decltype(std::declval<CallableT>()(std::declval<Params>()...)),
+                 Ret>,
+    std::is_same<const decltype(std::declval<CallableT>()(
+                     std::declval<Params>()...)),
+                 Ret>,
+                        Ret>>::value>;
 
 template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
 protected:
   static constexpr size_t InlineStorageSize = sizeof(void *) * 3;
 
   template <typename T, class = void>
   struct IsSizeLessThanThresholdT : std::false_type {};
 

llvm/unittests/ADT/FunctionExtrasTest.cpp

TEST(UniqueFunctionTest, IncompleteTypes) {
   unique_function<void(Templated<Incomplete> &)>
       IncompleteArgumentLValueReference;
   unique_function<void(Templated<Incomplete> *)> IncompleteArgumentPointer;
   unique_function<Templated<Incomplete> &()> IncompleteResultLValueReference;
   unique_function<Templated<Incomplete> && ()> IncompleteResultRValueReference2;
   unique_function<Templated<Incomplete> *()> IncompleteResultPointer;
 }
 
+// Incomplete function returning an incomplete type
+Incomplete incompleteFunction();
+const Incomplete incompleteFunctionConst();
+
+// Check that we can assign a callable to a unique_function when the
+// callable return value is incomplete.
+TEST(UniqueFunctionTest, IncompleteCallableType) {
+  unique_function<Incomplete()> IncompleteReturnInCallable{incompleteFunction};
+  unique_function<const Incomplete()> IncompleteReturnInCallableConst{
+      incompleteFunctionConst};
+  unique_function<const Incomplete()> IncompleteReturnInCallableConstConversion{
+      incompleteFunction};
+}
+
+// Define the incomplete function
+class Incomplete {};
+Incomplete incompleteFunction() { return {}; }
+const Incomplete incompleteFunctionConst() { return {}; }
+
 } // anonymous namespace