[mlir] Avoid GCC naming conflict.

[gysit]

Summary

Rename AbstractType to AbstractTy to avoid naming GCC naming conflict after https://reviews.llvm.org/D104234.

mlir/include/mlir/IR/Attributes.h

public:
   /// Utility class for implementing attributes.
   template <typename ConcreteType, typename BaseType, typename StorageType,
             template <typename T> class... Traits>
   using AttrBase = detail::StorageUserBase<ConcreteType, BaseType, StorageType,
                                            detail::AttributeUniquer, Traits...>;
 
   using ImplType = AttributeStorage;
   using ValueType = void;
-  using AbstractType = AbstractAttribute;
+  using AbstractTy = AbstractAttribute;
 
   constexpr Attribute() : impl(nullptr) {}
   /* implicit */ Attribute(const ImplType *impl)
       : impl(const_cast<ImplType *>(impl)) {}
 
   Attribute(const Attribute &other) = default;
   Attribute &operator=(const Attribute &other) = default;
 
public:
   /// Construct an attribute from the opaque pointer representation.
   static Attribute getFromOpaquePointer(const void *ptr) {
     return Attribute(reinterpret_cast<const ImplType *>(ptr));
   }
 
   friend ::llvm::hash_code hash_value(Attribute arg);
 
   /// Return the abstract descriptor for this attribute.
-  const AbstractAttribute &getAbstractAttribute() const {
+  const AbstractTy &getAbstractAttribute() const {
     return impl->getAbstractAttribute();
   }
 
 protected:
   ImplType *impl;
 };
 
 inline raw_ostream &operator<<(raw_ostream &os, Attribute attr) {

mlir/include/mlir/IR/StorageUniquerSupport.h

public:
   }
 
   /// Attach the given models as implementations of the corresponding interfaces
   /// for the concrete storage user class. The type must be registered with the
   /// context, i.e. the dialect to which the type belongs must be loaded. The
   /// call will abort otherwise.
   template <typename... IfaceModels>
   static void attachInterface(MLIRContext &context) {
-    typename ConcreteT::AbstractType *abstract =
-        ConcreteT::AbstractType::lookupMutable(TypeID::get<ConcreteT>(),
-                                               &context);
+    typename ConcreteT::AbstractTy *abstract =
+        ConcreteT::AbstractTy::lookupMutable(TypeID::get<ConcreteT>(),
     if (!abstract)
       llvm::report_fatal_error("Registering an interface for an attribute/type "
                                "that is not itself registered.");
     abstract->interfaceMap.template insert<IfaceModels...>();
   }
 
   /// Get or create a new ConcreteT instance within the ctx. This
   /// function is guaranteed to return a non null object and will assert if

mlir/include/mlir/IR/Types.h

public:
   /// Utility class for implementing types.
   template <typename ConcreteType, typename BaseType, typename StorageType,
             template <typename T> class... Traits>
   using TypeBase = detail::StorageUserBase<ConcreteType, BaseType, StorageType,
                                            detail::TypeUniquer, Traits...>;
 
   using ImplType = TypeStorage;
 
-  using AbstractType = AbstractType;
+  using AbstractTy = AbstractType;
 
   constexpr Type() : impl(nullptr) {}
   /* implicit */ Type(const ImplType *impl)
       : impl(const_cast<ImplType *>(impl)) {}
 
   Type(const Type &other) = default;
   Type &operator=(const Type &other) = default;
 
public:
   const void *getAsOpaquePointer() const {
     return static_cast<const void *>(impl);
   }
   static Type getFromOpaquePointer(const void *pointer) {
     return Type(reinterpret_cast<ImplType *>(const_cast<void *>(pointer)));
   }
 
   /// Return the abstract type descriptor for this type.
-  const AbstractType &getAbstractType() { return impl->getAbstractType(); }
+  const AbstractTy &getAbstractType() { return impl->getAbstractType(); }
 
 protected:
   ImplType *impl;
 };
 
 inline raw_ostream &operator<<(raw_ostream &os, Type type) {
   type.print(os);
   return os;