[llvm][STLExtras] Add various type_trait utilities currently present in MLIR

[rriddle]

Summary

This revision moves several type_trait utilities from MLIR into LLVM. Namely, this revision adds:
is_detected - This matches the experimental std::is_detected
is_invocable - This matches the c++17 std::is_invocable
function_traits - A utility traits class for getting the argument and result types of a callable type

Depends On D78057

[lattner]

LGTM (assuming the test failures being spurious).

Would it be possible/reasonable to split up LLVM's STLExtras.h?

[rriddle]

In D78059#1979209, @lattner wrote:

LGTM (assuming the test failures being spurious).

Would it be possible/reasonable to split up LLVM's STLExtras.h?

I think it would depend on what dependencies are specifically needed/desired, which isn't exactly clear(at least to me) at the moment. A majority of STLExtras.h is the various range classes, which would presumably still be in the same file after splitting.

[lattner]

Yeah it was just a thought - much of STLExtras is conceptually "iterator like", so moving them to IteratorExtras.h or something could make the rest stand out. There is also a cluster that could go to AlgorithmExtras.h etc.

[dblaikie]

Not sure if the other LLVM type traits have tests - but could you check & probably add some static_assert tests to demonstrate/validate the functionality being added here?

llvm/include/llvm/ADT/STLExtras.h

109–145

Use of this device makes me a bit uncomfortable - such a thing would be incompatible with overloading, default arguments, etc.

A general idea that's gone around inside Google but I can't find a good reference for it externally, is to only depend on the "call only interface" (ie: never take the address of a function you don't own - only call it with whatever types it was intended to have and treat it as though it returns the type it's documented to return). This ensures maximum flexibility for the function vendor to refactor it - add default arguments or overload the function as part of migrating/improving/refactoring the API, etc.

Is there any chance the existing uses of the mlir-equivalent of this trait could reasonably avoid it & instead rely on the call-only contract when interacting with functions/functors?

[rriddle]

llvm/include/llvm/ADT/STLExtras.h

109–145

Thanks for the comment David. In all of the usages in MLIR, we aren't necessarily concerned about overloading/default arguments/etc. The general usage is that there is an API that takes a callback(generally expected to be a lambda), and then switches depending on the type of the function argument. Removing the ability to do that would greatly uglify a large amount of code. Is there a way to do that without doing the above? I'm open to any suggestions you might have.

[dblaikie]

llvm/include/llvm/ADT/STLExtras.h

109–145

When you say "switches depending on the type of the function argument" - would it be possible to use overloads instead? (eg: func(function_ref<void(T1)>); func(function_ref<void(T2)>); etc... )

[rriddle]

llvm/include/llvm/ADT/STLExtras.h

109–145

I tried that originally, but when using overloads even the most trivial examples fail due to ambiguity:

void bar(llvm::function_ref<void(int)> fn);
void bar(llvm::function_ref<void(bool)> fn);

void foo() {
  bar([](int i) {});
}

<source>:8:3: error: call to 'bar' is ambiguous

  bar([](int i) {});

  ^~~

<source>:4:6: note: candidate function

void bar(llvm::function_ref<void(int)> fn);

     ^

<source>:5:6: note: candidate function

void bar(llvm::function_ref<void(bool)> fn);

     ^

https://godbolt.org/z/JDTFtn

[dblaikie]

llvm/include/llvm/ADT/STLExtras.h

109–145

Fair point - though are you dealing with situations where there is such an ambiguity, and you still want different behavior based on those two ambiguous alternatives? That seems like quite subtle code that might be good to avoid.

[rriddle]

llvm/include/llvm/ADT/STLExtras.h

109–145

int and bool are definitely contrived examples, but they were only meant to demonstrate the current state of overload detection. The most common situation we deal with is w.r.t Operations vs. *Op classes. MLIR Ops are like smart pointers that provide an interface into a generic Operation*. Depending on the situation and availability, it is much more convenient to interface with an *Op than an Operation. For example, MLIR has visitor methods that allow for walking nested operations. These are widely used, and extremely convenient:

ModuleOp module = ...;

// Walk *all* operations within the module opaquely.
module.walk([](Operation *op) { ... });

// Wall only functions, or gpu modules, within the module.
module.walk([](FuncOp func) { ... });
module.walk([](GPUModuleOp gpuModule) { ... });

// Walk all operations that provide the memory effect interface.
module.walk([](MemoryEffectOpInterface memoryInterface) { ... });

[rriddle]

Add tests for type traits

[dblaikie]

llvm/include/llvm/ADT/STLExtras.h

109–145

Fair enough - I'm a little apprehensive about adding such a general tool to LLVM's core libraries & how it might get used, but I guess we'll leave that up to code review.

(one possible other way to have structured your callback API might've been to use "moduel.walk<GPUModuleOp>([](auto gpuModule) { ... });" etc... awkward in its own way, to be sure)

[rriddle]

llvm/include/llvm/ADT/STLExtras.h

109–145

I 100% agree with you that this should only really be used for specific scenarios and not a "let's slap this everywhere". Some of this was guarded by the fact that we didn't have C++14 until recently.

[davezarzycki]

FYI – This is generating new warnings with top-of-tree clang. That being said, the warning itself might be faulty:

/usr/local/include/llvm/ADT/STLExtras.h:115:58: warning: HTML tag 'i' requires an end tag [-Wdocumentation-html]
///   * To access the type of an argument: Traits::arg_t<i>
                                                        ~^~
1 warning generated.

llvm/include/llvm/ADT/STLExtras.h

using type =
       typename std::add_pointer<typename std::add_const<T>::type>::type;
 };
 
 template <typename T> struct make_const_ref {
   using type = typename std::add_lvalue_reference<
       typename std::add_const<T>::type>::type;
 };
 
+/// Utilities for detecting if a given trait holds for some set of arguments
+/// 'Args'. For example, the given trait could be used to detect if a given type
+/// has a copy assignment operator:
+///   template<class T>
+///   using has_copy_assign_t = decltype(std::declval<T&>()
+///                                                 = std::declval<const T&>());
+///   bool fooHasCopyAssign = is_detected<has_copy_assign_t, FooClass>::value;
+namespace detail {
+template <typename...> using void_t = void;
+template <class, template <class...> class Op, class... Args> struct detector {
+  using value_t = std::false_type;
+};
+template <template <class...> class Op, class... Args>
+struct detector<void_t<Op<Args...>>, Op, Args...> {
+  using value_t = std::true_type;
+};
+} // end namespace detail
+
+template <template <class...> class Op, class... Args>
+using is_detected = typename detail::detector<void, Op, Args...>::value_t;
+
+/// Check if a Callable type can be invoked with the given set of arg types.
+namespace detail {
+template <typename Callable, typename... Args>
+using is_invocable =
+    decltype(std::declval<Callable &>()(std::declval<Args>()...));
+} // namespace detail
+
+template <typename Callable, typename... Args>
+using is_invocable = is_detected<detail::is_invocable, Callable, Args...>;
+
+/// This class provides various trait information about a callable object.
+///   * To access the number of arguments: Traits::num_args
+///   * To access the type of an argument: Traits::arg_t<i>
+///   * To access the type of the result:  Traits::result_t
+template <typename T, bool isClass = std::is_class<T>::value>
+struct function_traits : public function_traits<decltype(&T::operator())> {};
+
+/// Overload for class function types.
+template <typename ClassType, typename ReturnType, typename... Args>
+struct function_traits<ReturnType (ClassType::*)(Args...) const, false> {
+  /// The number of arguments to this function.
+  enum { num_args = sizeof...(Args) };
+
+  /// The result type of this function.
+  using result_t = ReturnType;
+
+  /// The type of an argument to this function.
+  template <size_t i>
+  using arg_t = typename std::tuple_element<i, std::tuple<Args...>>::type;
+};
+/// Overload for class function types.
+template <typename ClassType, typename ReturnType, typename... Args>
+struct function_traits<ReturnType (ClassType::*)(Args...), false>
+    : function_traits<ReturnType (ClassType::*)(Args...) const> {};
+/// Overload for non-class function types.
+template <typename ReturnType, typename... Args>
+struct function_traits<ReturnType (*)(Args...), false> {
+  /// The number of arguments to this function.
+  enum { num_args = sizeof...(Args) };
+
+  /// The result type of this function.
+  using result_t = ReturnType;
+
+  /// The type of an argument to this function.
+  template <size_t i>
+  using arg_t = typename std::tuple_element<i, std::tuple<Args...>>::type;
+};
+/// Overload for non-class function type references.
+template <typename ReturnType, typename... Args>
+struct function_traits<ReturnType (&)(Args...), false>
+    : public function_traits<ReturnType (*)(Args...)> {};
+
 //===----------------------------------------------------------------------===//
 //     Extra additions to <functional>
 //===----------------------------------------------------------------------===//
 
 template <class Ty> struct identity {
   using argument_type = Ty;
 
   Ty &operator()(Ty &self) const {

llvm/unittests/ADT/CMakeLists.txt

add_llvm_unittest(ADTTests
   StringExtrasTest.cpp
   StringMapTest.cpp
   StringRefTest.cpp
   StringSetTest.cpp
   StringSwitchTest.cpp
   TinyPtrVectorTest.cpp
   TripleTest.cpp
   TwineTest.cpp
+  TypeTraitsTest.cpp
   WaymarkingTest.cpp
   )
 
 target_link_libraries(ADTTests PRIVATE LLVMTestingSupport)
 
 add_dependencies(ADTTests intrinsics_gen)

llvm/unittests/ADT/TypeTraitsTest.cpp

+//===- TypeTraitsTest.cpp - type_traits unit tests ------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/STLExtras.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+//===----------------------------------------------------------------------===//
+// function_traits
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// Check a callable type of the form `bool(const int &)`.
+template <typename CallableT> struct CheckFunctionTraits {
+  static_assert(
+      std::is_same<typename function_traits<CallableT>::result_t, bool>::value,
+      "expected result_t to be `bool`");
+  static_assert(
+      std::is_same<typename function_traits<CallableT>::template arg_t<0>,
+                   const int &>::value,
+      "expected arg_t<0> to be `const int &`");
+  static_assert(function_traits<CallableT>::num_args == 1,
+                "expected num_args to be 1");
+};
+
+/// Test function pointers.
+using FuncType = bool (*)(const int &);
+struct CheckFunctionPointer : CheckFunctionTraits<FuncType> {};
+
+static bool func(const int &v);
+struct CheckFunctionPointer2 : CheckFunctionTraits<decltype(&func)> {};
+
+/// Test method pointers.
+struct Foo {
+  bool func(const int &v);
+};
+struct CheckMethodPointer : CheckFunctionTraits<decltype(&Foo::func)> {};
+
+/// Test lambda references.
+auto lambdaFunc = [](const int &v) -> bool { return true; };
+struct CheckLambda : CheckFunctionTraits<decltype(lambdaFunc)> {};
+
+} // end anonymous namespace
+
+//===----------------------------------------------------------------------===//
+// is_detected
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct HasFooMethod {
+  void foo() {}
+};
+struct NoFooMethod {};
+
+template <class T> using has_foo_method_t = decltype(std::declval<T &>().foo());
+
+static_assert(is_detected<has_foo_method_t, HasFooMethod>::value,
+              "expected foo method to be detected");
+static_assert(!is_detected<has_foo_method_t, NoFooMethod>::value,
+              "expected no foo method to be detected");
+} // end anonymous namespace
+
+//===----------------------------------------------------------------------===//
+// is_invocable
+//===----------------------------------------------------------------------===//
+
+static void invocable_fn(int) {}
+
+static_assert(is_invocable<decltype(invocable_fn), int>::value,
+              "expected function to be invocable");
+static_assert(!is_invocable<decltype(invocable_fn), void *>::value,
+              "expected function not to be invocable");
+static_assert(!is_invocable<decltype(invocable_fn), int, int>::value,
+              "expected function not to be invocable");

mlir/include/mlir/ADT/TypeSwitch.h

return derived.template Case<CaseT>(caseFn)
         .template Case<CaseT2, CaseTs...>(caseFn);
   }
 
   /// Invoke a case on the derived class, inferring the type of the Case from
   /// the first input of the given callable.
   /// Note: This inference rules for this overload are very simple: strip
   ///       pointers and references.
   template <typename CallableT> DerivedT &Case(CallableT &&caseFn) {
-    using Traits = FunctionTraits<std::decay_t<CallableT>>;
+    using Traits = llvm::function_traits<std::decay_t<CallableT>>;
     using CaseT = std::remove_cv_t<std::remove_pointer_t<
         std::remove_reference_t<typename Traits::template arg_t<0>>>>;
 
     DerivedT &derived = static_cast<DerivedT &>(*this);
     return derived.template Case<CaseT>(std::forward<CallableT>(caseFn));
   }
 
 protected:
   /// Trait to check whether `ValueT` provides a 'dyn_cast' method with type
   /// `CastT`.
   template <typename ValueT, typename CastT>
   using has_dyn_cast_t =
       decltype(std::declval<ValueT &>().template dyn_cast<CastT>());
 
   /// Attempt to dyn_cast the given `value` to `CastT`. This overload is
   /// selected if `value` already has a suitable dyn_cast method.
   template <typename CastT, typename ValueT>
-  static auto castValue(
-      ValueT value,
+  static auto
+  castValue(ValueT value,
             typename std::enable_if_t<
-          is_detected<has_dyn_cast_t, ValueT, CastT>::value> * = nullptr) {
+                llvm::is_detected<has_dyn_cast_t, ValueT, CastT>::value> * =
+                nullptr) {
     return value.template dyn_cast<CastT>();
   }
 
   /// Attempt to dyn_cast the given `value` to `CastT`. This overload is
   /// selected if llvm::dyn_cast should be used.
   template <typename CastT, typename ValueT>
-  static auto castValue(
-      ValueT value,
+  static auto
+  castValue(ValueT value,
             typename std::enable_if_t<
-          !is_detected<has_dyn_cast_t, ValueT, CastT>::value> * = nullptr) {
+                !llvm::is_detected<has_dyn_cast_t, ValueT, CastT>::value> * =
+                nullptr) {
     return dyn_cast<CastT>(value);
   }
 
   /// The root value we are switching on.
   const T value;
 };
 } // end namespace detail
 

mlir/include/mlir/IR/Matchers.h

 /// Trait to check whether T provides a 'match' method with type
 /// `OperationOrValue`.
 template <typename T, typename OperationOrValue>
 using has_operation_or_value_matcher_t =
     decltype(std::declval<T>().match(std::declval<OperationOrValue>()));
 
 /// Statically switch to a Value matcher.
 template <typename MatcherClass>
-typename std::enable_if_t<is_detected<detail::has_operation_or_value_matcher_t,
-                                      MatcherClass, Value>::value,
-                          bool>
+typename std::enable_if_t<
+    llvm::is_detected<detail::has_operation_or_value_matcher_t, MatcherClass,
+                      Value>::value,
 matchOperandOrValueAtIndex(Operation *op, unsigned idx, MatcherClass &matcher) {
   return matcher.match(op->getOperand(idx));
 }
 
 /// Statically switch to an Operation matcher.
 template <typename MatcherClass>
-typename std::enable_if_t<is_detected<detail::has_operation_or_value_matcher_t,
-                                      MatcherClass, Operation *>::value,
-                          bool>
+typename std::enable_if_t<
+    llvm::is_detected<detail::has_operation_or_value_matcher_t, MatcherClass,
+                      Operation *>::value,
 matchOperandOrValueAtIndex(Operation *op, unsigned idx, MatcherClass &matcher) {
   if (auto defOp = op->getOperand(idx).getDefiningOp())
     return matcher.match(defOp);
   return false;
 }
 
 /// Terminal matcher, always returns true.
 struct AnyValueMatcher {

mlir/include/mlir/IR/OpDefinition.h

private:
   struct InterfaceLookup {
     /// Trait to check if T provides a static 'getInterfaceID' method.
     template <typename T, typename... Args>
     using has_get_interface_id = decltype(T::getInterfaceID());
 
     /// If 'T' is the same interface as 'interfaceID' return the concept
     /// instance.
     template <typename T>
-    static typename std::enable_if<is_detected<has_get_interface_id, T>::value,
-                                   void *>::type
+    static typename std::enable_if<
+        llvm::is_detected<has_get_interface_id, T>::value, void *>::type
     lookup(TypeID interfaceID) {
       return (T::getInterfaceID() == interfaceID) ? &T::instance() : nullptr;
     }
 
     /// 'T' is known to not be an interface, return nullptr.
     template <typename T>
-    static typename std::enable_if<!is_detected<has_get_interface_id, T>::value,
-                                   void *>::type
+    static typename std::enable_if<
+        !llvm::is_detected<has_get_interface_id, T>::value, void *>::type
     lookup(TypeID) {
       return nullptr;
     }
 
     template <typename T, typename T2, typename... Ts>
     static void *lookup(TypeID interfaceID) {
       auto *concept = lookup<T>(interfaceID);
       return concept ? concept : lookup<T2, Ts...>(interfaceID);

mlir/include/mlir/Pass/AnalysisManager.h

 namespace analysis_impl {
 /// Trait to check if T provides a static 'isInvalidated' method.
 template <typename T, typename... Args>
 using has_is_invalidated = decltype(std::declval<T &>().isInvalidated(
     std::declval<const PreservedAnalyses &>()));
 
 /// Implementation of 'isInvalidated' if the analysis provides a definition.
 template <typename AnalysisT>
-std::enable_if_t<is_detected<has_is_invalidated, AnalysisT>::value, bool>
+std::enable_if_t<llvm::is_detected<has_is_invalidated, AnalysisT>::value, bool>
 isInvalidated(AnalysisT &analysis, const PreservedAnalyses &pa) {
   return analysis.isInvalidated(pa);
 }
 /// Default implementation of 'isInvalidated'.
 template <typename AnalysisT>
-std::enable_if_t<!is_detected<has_is_invalidated, AnalysisT>::value, bool>
+std::enable_if_t<!llvm::is_detected<has_is_invalidated, AnalysisT>::value, bool>
 isInvalidated(AnalysisT &analysis, const PreservedAnalyses &pa) {
   return !pa.isPreserved<AnalysisT>();
 }
 } // end namespace analysis_impl
 
 /// The abstract polymorphic base class representing an analysis.
 struct AnalysisConcept {
   virtual ~AnalysisConcept() = default;

mlir/include/mlir/Support/STLExtras.h

inline void interleaveComma(const Container &c, raw_ostream &os,
   interleave(c, os, each_fn, ", ");
 }
 template <typename Container, typename raw_ostream,
           typename T = detail::ValueOfRange<Container>>
 inline void interleaveComma(const Container &c, raw_ostream &os) {
   interleaveComma(c, os, [&](const T &a) { os << a; });
 }
 
-/// Utilities for detecting if a given trait holds for some set of arguments
-/// 'Args'. For example, the given trait could be used to detect if a given type
-/// has a copy assignment operator:
-///   template<class T>
-///   using has_copy_assign_t = decltype(std::declval<T&>()
-///                                                 = std::declval<const T&>());
-///   bool fooHasCopyAssign = is_detected<has_copy_assign_t, FooClass>::value;
-namespace detail {
-template <typename...> using void_t = void;
-template <class, template <class...> class Op, class... Args> struct detector {
-  using value_t = std::false_type;
-};
-template <template <class...> class Op, class... Args>
-struct detector<void_t<Op<Args...>>, Op, Args...> {
-  using value_t = std::true_type;
-};
-} // end namespace detail
-
-template <template <class...> class Op, class... Args>
-using is_detected = typename detail::detector<void, Op, Args...>::value_t;
-
-/// Check if a Callable type can be invoked with the given set of arg types.
-namespace detail {
-template <typename Callable, typename... Args>
-using is_invocable =
-    decltype(std::declval<Callable &>()(std::declval<Args>()...));
-} // namespace detail
-
-template <typename Callable, typename... Args>
-using is_invocable = is_detected<detail::is_invocable, Callable, Args...>;
-
 //===----------------------------------------------------------------------===//
 //     Extra additions to <iterator>
 //===----------------------------------------------------------------------===//
 
 /// A utility class used to implement an iterator that contains some base object
 /// and an index. The iterator moves the index but keeps the base constant.
 template <typename DerivedT, typename BaseT, typename T,
           typename PointerT = T *, typename ReferenceT = T &>

 }
 
 /// Returns true of the given range only contains a single element.
 template <typename ContainerTy> bool has_single_element(ContainerTy &&c) {
   auto it = std::begin(c), e = std::end(c);
   return it != e && std::next(it) == e;
 }
 
-//===----------------------------------------------------------------------===//
-//     Extra additions to <type_traits>
-//===----------------------------------------------------------------------===//
-
-/// This class provides various trait information about a callable object.
-///   * To access the number of arguments: Traits::num_args
-///   * To access the type of an argument: Traits::arg_t<i>
-///   * To access the type of the result: Traits::result_t<i>
-template <typename T, bool isClass = std::is_class<T>::value>
-struct FunctionTraits : public FunctionTraits<decltype(&T::operator())> {};
-
-/// Overload for class function types.
-template <typename ClassType, typename ReturnType, typename... Args>
-struct FunctionTraits<ReturnType (ClassType::*)(Args...) const, false> {
-  /// The number of arguments to this function.
-  enum { num_args = sizeof...(Args) };
-
-  /// The result type of this function.
-  using result_t = ReturnType;
-
-  /// The type of an argument to this function.
-  template <size_t i>
-  using arg_t = typename std::tuple_element<i, std::tuple<Args...>>::type;
-};
-/// Overload for non-class function types.
-template <typename ReturnType, typename... Args>
-struct FunctionTraits<ReturnType (*)(Args...), false> {
-  /// The number of arguments to this function.
-  enum { num_args = sizeof...(Args) };
-
-  /// The result type of this function.
-  using result_t = ReturnType;
-
-  /// The type of an argument to this function.
-  template <size_t i>
-  using arg_t = typename std::tuple_element<i, std::tuple<Args...>>::type;
-};
-/// Overload for non-class function type references.
-template <typename ReturnType, typename... Args>
-struct FunctionTraits<ReturnType (&)(Args...), false>
-    : public FunctionTraits<ReturnType (*)(Args...)> {};
 } // end namespace mlir
 
 #endif // MLIR_SUPPORT_STLEXTRAS_H

mlir/include/mlir/Support/StorageUniquer.h

private:
   //===--------------------------------------------------------------------===//
   // Key Construction
   //===--------------------------------------------------------------------===//
 
   /// Used to construct an instance of 'ImplTy::KeyTy' if there is an
   /// 'ImplTy::getKey' function for the provided arguments.
   template <typename ImplTy, typename... Args>
   static typename std::enable_if<
-      is_detected<detail::has_impltype_getkey_t, ImplTy, Args...>::value,
+      llvm::is_detected<detail::has_impltype_getkey_t, ImplTy, Args...>::value,
       typename ImplTy::KeyTy>::type
   getKey(Args &&... args) {
     return ImplTy::getKey(args...);
   }
   /// If there is no 'ImplTy::getKey' method, then we try to directly construct
   /// the 'ImplTy::KeyTy' with the provided arguments.
   template <typename ImplTy, typename... Args>
   static typename std::enable_if<
-      !is_detected<detail::has_impltype_getkey_t, ImplTy, Args...>::value,
+      !llvm::is_detected<detail::has_impltype_getkey_t, ImplTy, Args...>::value,
       typename ImplTy::KeyTy>::type
   getKey(Args &&... args) {
     return typename ImplTy::KeyTy(args...);
   }
 
   //===--------------------------------------------------------------------===//
   // Key and Kind Hashing
   //===--------------------------------------------------------------------===//
 
   /// Used to generate a hash for the 'ImplTy::KeyTy' and kind of a storage
   /// instance if there is an 'ImplTy::hashKey' overload for 'DerivedKey'.
   template <typename ImplTy, typename DerivedKey>
   static typename std::enable_if<
-      is_detected<detail::has_impltype_hash_t, ImplTy, DerivedKey>::value,
+      llvm::is_detected<detail::has_impltype_hash_t, ImplTy, DerivedKey>::value,
       ::llvm::hash_code>::type
   getHash(unsigned kind, const DerivedKey &derivedKey) {
     return llvm::hash_combine(kind, ImplTy::hashKey(derivedKey));
   }
   /// If there is no 'ImplTy::hashKey' default to using the
   /// 'llvm::DenseMapInfo' definition for 'DerivedKey' for generating a hash.
   template <typename ImplTy, typename DerivedKey>
-  static typename std::enable_if<
-      !is_detected<detail::has_impltype_hash_t, ImplTy, DerivedKey>::value,
+  static typename std::enable_if<!llvm::is_detected<detail::has_impltype_hash_t,
+                                                    ImplTy, DerivedKey>::value,
                                  ::llvm::hash_code>::type
   getHash(unsigned kind, const DerivedKey &derivedKey) {
     return llvm::hash_combine(
         kind, DenseMapInfo<DerivedKey>::getHashValue(derivedKey));
   }
 };
 } // end namespace mlir
 
 #endif

mlir/include/mlir/Transforms/DialectConversion.h

public:
   ///       `failure` or `llvm::None` to signify a failed conversion. If the new
   ///       set of types is empty, the type is removed and any usages of the
   ///       existing value are expected to be removed during conversion. If
   ///       `llvm::None` is returned, the converter is allowed to try another
   ///       conversion function to perform the conversion.
   /// Note: When attempting to convert a type, e.g. via 'convertType', the
   ///       mostly recently added conversions will be invoked first.
   template <typename FnT,
-            typename T = typename FunctionTraits<FnT>::template arg_t<0>>
+            typename T = typename llvm::function_traits<FnT>::template arg_t<0>>
   void addConversion(FnT &&callback) {
     registerConversion(wrapCallback<T>(std::forward<FnT>(callback)));
   }
 
   /// Convert the given type. This function should return failure if no valid
   /// conversion exists, success otherwise. If the new set of types is empty,
   /// the type is removed and any usages of the existing value are expected to
   /// be removed during conversion.
private:
   /// are expected to be removed during conversion.
   using ConversionCallbackFn =
       std::function<Optional<LogicalResult>(Type, SmallVectorImpl<Type> &)>;
 
   /// Generate a wrapper for the given callback. This allows for accepting
   /// different callback forms, that all compose into a single version.
   /// With callback of form: `Optional<Type>(T)`
   template <typename T, typename FnT>
-  std::enable_if_t<is_invocable<FnT, T>::value, ConversionCallbackFn>
+  std::enable_if_t<llvm::is_invocable<FnT, T>::value, ConversionCallbackFn>
   wrapCallback(FnT &&callback) {
     return wrapCallback<T>([callback = std::forward<FnT>(callback)](
                                T type, SmallVectorImpl<Type> &results) {
       if (Optional<Type> resultOpt = callback(type)) {
         bool wasSuccess = static_cast<bool>(resultOpt.getValue());
         if (wasSuccess)
           results.push_back(resultOpt.getValue());
         return Optional<LogicalResult>(success(wasSuccess));
       }
       return Optional<LogicalResult>();
     });
   }
   /// With callback of form: `Optional<LogicalResult>(T, SmallVectorImpl<> &)`
   template <typename T, typename FnT>
-  std::enable_if_t<!is_invocable<FnT, T>::value, ConversionCallbackFn>
+  std::enable_if_t<!llvm::is_invocable<FnT, T>::value, ConversionCallbackFn>
   wrapCallback(FnT &&callback) {
     return [callback = std::forward<FnT>(callback)](
                Type type,
                SmallVectorImpl<Type> &results) -> Optional<LogicalResult> {
       T derivedType = type.dyn_cast<T>();
       if (!derivedType)
         return llvm::None;
       return callback(derivedType, results);
void addDynamicallyLegalOp(const DynamicLegalityCallbackFn &callback) {
     setLegalityCallback(opName, callback);
   }
   template <typename OpT, typename OpT2, typename... OpTs>
   void addDynamicallyLegalOp(const DynamicLegalityCallbackFn &callback) {
     addDynamicallyLegalOp<OpT>(callback);
     addDynamicallyLegalOp<OpT2, OpTs...>(callback);
   }
   template <typename OpT, class Callable>
-  typename std::enable_if<!is_invocable<Callable, Operation *>::value>::type
+  typename std::enable_if<
+      !llvm::is_invocable<Callable, Operation *>::value>::type
   addDynamicallyLegalOp(Callable &&callback) {
     addDynamicallyLegalOp<OpT>(
         [=](Operation *op) { return callback(cast<OpT>(op)); });
   }
 
   /// Register the given operation as illegal, i.e. this operation is known to
   /// not be supported by this target.
   template <typename OpT> void addIllegalOp() {
void markOpRecursivelyLegal(const DynamicLegalityCallbackFn &callback = {}) {
     markOpRecursivelyLegal(opName, callback);
   }
   template <typename OpT, typename OpT2, typename... OpTs>
   void markOpRecursivelyLegal(const DynamicLegalityCallbackFn &callback = {}) {
     markOpRecursivelyLegal<OpT>(callback);
     markOpRecursivelyLegal<OpT2, OpTs...>(callback);
   }
   template <typename OpT, class Callable>
-  typename std::enable_if<!is_invocable<Callable, Operation *>::value>::type
+  typename std::enable_if<
+      !llvm::is_invocable<Callable, Operation *>::value>::type
   markOpRecursivelyLegal(Callable &&callback) {
     markOpRecursivelyLegal<OpT>(
         [=](Operation *op) { return callback(cast<OpT>(op)); });
   }
 
   /// Register a legality action for the given dialects.
   void setDialectAction(ArrayRef<StringRef> dialectNames,
                         LegalizationAction action);

mlir/lib/IR/SymbolTable.cpp

 /// operation itself, just its contained operations. A scope ends at leaf
 /// operations or another symbol table operation.
 struct SymbolScope {
   /// Walk the symbol uses within this scope, invoking the given callback.
   /// This variant is used when the callback type matches that expected by
   /// 'walkSymbolUses'.
   template <typename CallbackT,
             typename std::enable_if_t<!std::is_same<
-                typename FunctionTraits<CallbackT>::result_t, void>::value> * =
-                nullptr>
+                typename llvm::function_traits<CallbackT>::result_t,
+                void>::value> * = nullptr>
   Optional<WalkResult> walk(CallbackT cback) {
     if (Region *region = limit.dyn_cast<Region *>())
       return walkSymbolUses(*region, cback);
     return walkSymbolUses(limit.get<Operation *>(), cback);
   }
   /// This variant is used when the callback type matches a stripped down type:
   /// void(SymbolTable::SymbolUse use)
   template <typename CallbackT,
             typename std::enable_if_t<std::is_same<
-                typename FunctionTraits<CallbackT>::result_t, void>::value> * =
-                nullptr>
+                typename llvm::function_traits<CallbackT>::result_t,
+                void>::value> * = nullptr>
   Optional<WalkResult> walk(CallbackT cback) {
     return walk([=](SymbolTable::SymbolUse use, ArrayRef<int>) {
       return cback(use), WalkResult::advance();
     });
   }
 
   /// The representation of the symbol within this scope.
   SymbolRefAttr symbol;