[mlir] Forward arguments of `pair` in `SubElementInterface::replaceImmediateSubElementsImpl`

[uenoku]

Summary

SubElementInterface::replaceImmediateSubElementsImpl specializes tuples so that
arguments are forwarded to type getter. However currently pairs are not supported even though
an example in documents uses a pair as a key type: https://mlir.llvm.org/docs/DefiningDialects/AttributesAndTypes/#defining-a-storage-class
This patch adds support for pairs as well.

mlir/include/mlir/IR/AttrTypeSubElements.h

struct AttrTypeSubElementHandler<
   }
 };
 
 namespace detail {
 template <typename T>
 struct is_tuple : public std::false_type {};
 template <typename... Ts>
 struct is_tuple<std::tuple<Ts...>> : public std::true_type {};
+
+template <typename T>
+struct is_pair : public std::false_type {};
+template <typename... Ts>
+struct is_pair<std::pair<Ts...>> : public std::true_type {};
+
 template <typename T, typename... Ts>
 using has_get_method = decltype(T::get(std::declval<Ts>()...));
 template <typename T, typename... Ts>
 using has_get_as_key = decltype(std::declval<T>().getAsKey());
 
 /// This function provides the underlying implementation for the
 /// SubElementInterface walk method, using the key type of the derived
 /// attribute/type to interact with the individual parameters.
if constexpr (llvm::is_detected<has_get_as_key, ImplT>::value) {
     // If we don't have any sub-elements, we can just return the original.
     if constexpr (!has_sub_attr_or_type_v<decltype(key)>) {
       return derived;
 
       // Otherwise, we need to replace any necessary sub-elements.
     } else {
       // Functor used to build the replacement on success.
       auto buildReplacement = [&](auto newKey, MLIRContext *ctx) {
-        if constexpr (is_tuple<decltype(key)>::value) {
+        if constexpr (is_tuple<decltype(key)>::value ||
+                      is_pair<decltype(key)>::value) {
           return std::apply(
               [&](auto &&...params) {
                 return constructSubElementReplacement<T>(
                     ctx, std::forward<decltype(params)>(params)...);
               },
               newKey);
         } else {
           return constructSubElementReplacement<T>(ctx, newKey);