[ADT] Use "inline static" to initialize CallbacksHolder (NFC) (llvm#160003)

In C++17, we can initialize a static member variable with
"inline static" as part of the class definition.  With this, we can
eliminate the out-of-line static initializers that are a bit hard to
decipher.

Author: kazutakahirata

llvm/include/llvm/ADT/FunctionExtras.h

@@ -231,22 +231,22 @@ template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
 
   // The pointers to call/move/destroy functions are determined for each
   // callable type (and called-as type, which determines the overload chosen).
-  // (definitions are out-of-line).
 
   // By default, we need an object that contains all the different
   // type erased behaviors needed. Create a static instance of the struct type
   // here and each instance will contain a pointer to it.
   // Wrap in a struct to avoid https://gcc.gnu.org/PR71954
   template <typename CallableT, typename CalledAs, typename Enable = void>
   struct CallbacksHolder {
-    static NonTrivialCallbacks Callbacks;
+    inline static NonTrivialCallbacks Callbacks = {
+        &CallImpl<CalledAs>, &MoveImpl<CallableT>, &DestroyImpl<CallableT>};
   };
   // See if we can create a trivial callback. We need the callable to be
   // trivially moved and trivially destroyed so that we don't have to store
   // type erased callbacks for those operations.
   template <typename CallableT, typename CalledAs>
   struct CallbacksHolder<CallableT, CalledAs, EnableIfTrivial<CallableT>> {
-    static TrivialCallback Callbacks;
+    inline static TrivialCallback Callbacks = {&CallImpl<CalledAs>};
   };
 
   // A simple tag type so the call-as type to be passed to the constructor.
@@ -344,19 +344,6 @@ template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
   }
 };
 
-template <typename R, typename... P>
-template <typename CallableT, typename CalledAsT, typename Enable>
-typename UniqueFunctionBase<R, P...>::NonTrivialCallbacks UniqueFunctionBase<
-    R, P...>::CallbacksHolder<CallableT, CalledAsT, Enable>::Callbacks = {
-    &CallImpl<CalledAsT>, &MoveImpl<CallableT>, &DestroyImpl<CallableT>};
-
-template <typename R, typename... P>
-template <typename CallableT, typename CalledAsT>
-typename UniqueFunctionBase<R, P...>::TrivialCallback
-    UniqueFunctionBase<R, P...>::CallbacksHolder<
-        CallableT, CalledAsT, EnableIfTrivial<CallableT>>::Callbacks{
-        &CallImpl<CalledAsT>};
-
 } // namespace detail
 
 template <typename R, typename... P>