[mlir] Use std::is_invocable instead of llvm::is_invocable

[jloser]

Summary

Now that MLIR is built with C++17, use the standard library equivalent of
llvm::is_invocable: std::is_invocable.

[jloser]

clang-format

[Mogball]

Should the latter be removed from ADT?

[Mogball]

Thanks!

mlir/include/mlir/Transforms/DialectConversion.h

765

This reminds me that we can use the _v versions of many of the STL templates too now.

[jloser]

In D132318#3737676, @Mogball wrote:

Should the latter be removed from ADT?

The only callers outside of mlir are just the ADT unit tests for the trait - so I'll mark it as deprecated or remove it outright from ADT as a follow-up patch if that works with you.

mlir/include/mlir/Transforms/DialectConversion.h

765

Yep, might as well make the switch if I'm already touching this neighborhood of code. :)

mlir/include/mlir/Support/DebugAction.h

 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Support/TypeID.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/TypeName.h"
 #include "llvm/Support/raw_ostream.h"
 #include <functional>
+#include <type_traits>
 
 namespace mlir {
 
 //===----------------------------------------------------------------------===//
 // DebugActionManager
 //===----------------------------------------------------------------------===//
 
 /// This class represents manages debug actions, and orchestrates the
public:
     }
   };
 
 private:
   /// Returns true if the action can be handled within the given set of
   /// parameter types.
   template <typename... CallerParameterTs>
   static constexpr bool canHandleWith() {
-    return llvm::is_invocable<function_ref<void(ParameterTs...)>,
-                              CallerParameterTs...>::value;
+    return std::is_invocable_v<function_ref<void(ParameterTs...)>,
+                               CallerParameterTs...>;
   }
 
   /// Allow access to `canHandleWith`.
   friend class DebugActionManager;
 };
 
 } // namespace mlir
 
 #endif // MLIR_SUPPORT_DEBUGACTION_H

mlir/include/mlir/Transforms/DialectConversion.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TRANSFORMS_DIALECTCONVERSION_H_
 #define MLIR_TRANSFORMS_DIALECTCONVERSION_H_
 
 #include "mlir/Rewrite/FrozenRewritePatternSet.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringMap.h"
+#include <type_traits>
 
 namespace mlir {
 
 // Forward declarations.
 class Block;
 class ConversionPatternRewriter;
 class MLIRContext;
 class Operation;
private:
   Value materializeConversion(
       MutableArrayRef<MaterializationCallbackFn> materializations,
       OpBuilder &builder, Location loc, Type resultType, ValueRange inputs);
 
   /// 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<llvm::is_invocable<FnT, T>::value, ConversionCallbackFn>
+  std::enable_if_t<std::is_invocable_v<FnT, T>, ConversionCallbackFn>
   wrapCallback(FnT &&callback) {
     return wrapCallback<T>(
         [callback = std::forward<FnT>(callback)](
             T type, SmallVectorImpl<Type> &results, ArrayRef<Type>) {
           if (Optional<Type> resultOpt = callback(type)) {
             bool wasSuccess = static_cast<bool>(resultOpt.value());
             if (wasSuccess)
               results.push_back(resultOpt.value());
             return Optional<LogicalResult>(success(wasSuccess));
           }
           return Optional<LogicalResult>();
         });
   }
   /// With callback of form: `Optional<LogicalResult>(T, SmallVectorImpl<Type>
   /// &)`
   template <typename T, typename FnT>
-  std::enable_if_t<llvm::is_invocable<FnT, T, SmallVectorImpl<Type> &>::value,
+  std::enable_if_t<std::is_invocable_v<FnT, T, SmallVectorImpl<Type> &>,
                    ConversionCallbackFn>
   wrapCallback(FnT &&callback) {
     return wrapCallback<T>(
         [callback = std::forward<FnT>(callback)](
             T type, SmallVectorImpl<Type> &results, ArrayRef<Type>) {
           return callback(type, results);
         });
   }
   /// With callback of form: `Optional<LogicalResult>(T, SmallVectorImpl<Type>
   /// &, ArrayRef<Type>)`.
   template <typename T, typename FnT>
-  std::enable_if_t<llvm::is_invocable<FnT, T, SmallVectorImpl<Type> &,
-                                      ArrayRef<Type>>::value,
+  std::enable_if_t<std::is_invocable_v<FnT, T, SmallVectorImpl<Type> &,
+                                      ArrayRef<Type>>,
                    ConversionCallbackFn>
   wrapCallback(FnT &&callback) {
     return [callback = std::forward<FnT>(callback)](
                Type type, SmallVectorImpl<Type> &results,
                ArrayRef<Type> callStack) -> Optional<LogicalResult> {
       T derivedType = type.dyn_cast<T>();
       if (!derivedType)
         return llvm::None;
public:
   }
   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<
-      !llvm::is_invocable<Callable, Operation *>::value>::type
+      !std::is_invocable_v<Callable, Operation *>>::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.
   void addIllegalOp(OperationName op) {
public:
   }
   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<
-      !llvm::is_invocable<Callable, Operation *>::value>::type
+      !std::is_invocable_v<Callable, Operation *>>::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);