[ADT] Allow IsSizeLessThanThresholdT for incomplete types. NFC

[yrouban]

Summary

If the type T is incomplete then sizeof(T) results in C++ compilation error at line:

static constexpr bool value = sizeof(T) <= (2 * sizeof(void *));

This patch allows incomplete types in parameters of function. Example:

using SomeFunc = void(SomeIncompleteType &);
llvm::unique_function<SomeFuncType> SomeFunc;

[yrouban]

@chandlerc, @fedor.sergeev, @vvereschaka, @DaniilSuchkov, please review or suggest who can review.

[yrouban]

@chandlerc could you please review or suggest someone who can do it.
This patch is needed for D81555 and D81558.

[DaniilSuchkov]

I checked it and it looks like if it compiles, everything should work just fine in presence of incomplete types.
LGTM

[vvereschaka]

I have tested the patch with VS2017/cl 19.16 build + clang/llvm tests and clang/llvm unit tests.
It looks fine.

Used the same build configurations as for the following builders:

• http://lab.llvm.org:8011/builders/llvm-clang-win-x-armv7l
• http://lab.llvm.org:8011/builders/llvm-clang-x86_64-win-fast

llvm/include/llvm/ADT/FunctionExtras.h

 using EnableIfTrivial =
     std::enable_if_t<llvm::is_trivially_move_constructible<T>::value &&
                      std::is_trivially_destructible<T>::value>;
 
 template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
 protected:
   static constexpr size_t InlineStorageSize = sizeof(void *) * 3;
 
-  // MSVC has a bug and ICEs if we give it a particular dependent value
-  // expression as part of the `std::conditional` below. To work around this,
-  // we build that into a template struct's constexpr bool.
-  template <typename T> struct IsSizeLessThanThresholdT {
-    static constexpr bool value = sizeof(T) <= (2 * sizeof(void *));
-  };
+  template <typename T, class = void>
+  struct IsSizeLessThanThresholdT : std::false_type {};
+
+  template <typename T>
+  struct IsSizeLessThanThresholdT<
+      T, std::enable_if_t<sizeof(T) <= 2 * sizeof(void *)>> : std::true_type {};
 
   // Provide a type function to map parameters that won't observe extra copies
   // or moves and which are small enough to likely pass in register to values
   // and all other types to l-value reference types. We use this to compute the
   // types used in our erased call utility to minimize copies and moves unless
   // doing so would force things unnecessarily into memory.
   //
   // The heuristic used is related to common ABI register passing conventions.