[mlir] Replace usages of Identifier with StringAttr

[rriddle]

Summary

Identifier and StringAttr essentially serve the same purpose,
i.e. to hold a string value. Keeping these seemingly identical
pieces of functionality separate has caused problems in certain situations:

• Identifier has nice accessors that StringAttr doesn't
• Identifier can't be used as an Attribute, meaning strings are often duplicated between Identifier/StringAttr (e.g. in PDL)

The only thing that Identifier has that StringAttr doesn't is support
for caching a dialect that is referenced by the string (e.g. dialect.foo).
This functionality is added to StringAttr, as this is useful for StringAttr
in generally the same ways it was useful for Identifier.

[lattner]

Awesome, this is a great direction that will simplify things. Thank you!

mlir/include/mlir/IR/BuiltinAttributes.h

926

Randomly, this alone will be really handy. I have built a lot of densemaps with "attribute" as the key instead of StringAttr just to work around this :-)

mlir/include/mlir/IR/BuiltinAttributes.td

935

Should this be size_t instead of unsigned?

[mehdi_amini]

LG, thanks River!

[bondhugula]

mlir/include/mlir/IR/BuiltinAttributes.td

918

is a -> is

919

Add a trailing "null otherwise"?

[rriddle]

Thanks for the review!

mlir/include/mlir/IR/BuiltinAttributes.td

935

Thanks for catching this, copy over from the old Identifier class.

mlir/include/mlir/CAPI/IR.h

 DEFINE_C_API_PTR_METHODS(MlirDialect, mlir::Dialect)
 DEFINE_C_API_PTR_METHODS(MlirOperation, mlir::Operation)
 DEFINE_C_API_PTR_METHODS(MlirBlock, mlir::Block)
 DEFINE_C_API_PTR_METHODS(MlirOpPrintingFlags, mlir::OpPrintingFlags)
 DEFINE_C_API_PTR_METHODS(MlirRegion, mlir::Region)
 DEFINE_C_API_PTR_METHODS(MlirSymbolTable, mlir::SymbolTable)
 
 DEFINE_C_API_METHODS(MlirAttribute, mlir::Attribute)
-DEFINE_C_API_METHODS(MlirIdentifier, mlir::Identifier)
+DEFINE_C_API_METHODS(MlirIdentifier, mlir::StringAttr)
 DEFINE_C_API_METHODS(MlirLocation, mlir::Location)
 DEFINE_C_API_METHODS(MlirModule, mlir::ModuleOp)
 DEFINE_C_API_METHODS(MlirType, mlir::Type)
 DEFINE_C_API_METHODS(MlirTypeID, mlir::TypeID)
 DEFINE_C_API_METHODS(MlirValue, mlir::Value)
 
 #endif // MLIR_CAPI_IR_H

mlir/include/mlir/IR/AttributeSupport.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_ATTRIBUTESUPPORT_H
 #define MLIR_IR_ATTRIBUTESUPPORT_H
 
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StorageUniquerSupport.h"
+#include "mlir/IR/Types.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/Twine.h"
 
 namespace mlir {
 class MLIRContext;
 class Type;
 
 //===----------------------------------------------------------------------===//

 /// Base storage class appearing in an attribute. Derived storage classes should
 /// only be constructed within the context of the AttributeUniquer.
 class alignas(8) AttributeStorage : public StorageUniquer::BaseStorage {
   friend detail::AttributeUniquer;
   friend StorageUniquer;
 
 public:
   /// Get the type of this attribute.
-  Type getType() const;
+  Type getType() const { return type; }
 
   /// Return the abstract descriptor for this attribute.
   const AbstractAttribute &getAbstractAttribute() const {
     assert(abstractAttribute && "Malformed attribute storage object.");
     return *abstractAttribute;
   }
 
 protected:
   /// Construct a new attribute storage instance with the given type.
   /// Note: All attributes require a valid type. If no type is provided here,
   ///       the type of the attribute will automatically default to NoneType
   ///       upon initialization in the uniquer.
-  AttributeStorage(Type type);
-  AttributeStorage();
+  AttributeStorage(Type type = nullptr) : type(type) {}
 
   /// Set the type of this attribute.
-  void setType(Type type);
+  void setType(Type newType) { type = newType; }
 
-  // Set the abstract attribute for this storage instance. This is used by the
-  // AttributeUniquer when initializing a newly constructed storage object.
-  void initialize(const AbstractAttribute &abstractAttr) {
+  /// Set the abstract attribute for this storage instance. This is used by the
+  /// AttributeUniquer when initializing a newly constructed storage object.
+  void initializeAbstractAttribute(const AbstractAttribute &abstractAttr) {
     abstractAttribute = &abstractAttr;
   }
 
+  /// Default initialization for attribute storage classes that require no
+  /// additional initialization.
+  void initialize(MLIRContext *context) {}
+
 private:
+  /// The type of the attribute value.
+  Type type;
+
   /// The abstract descriptor for this attribute.
   const AbstractAttribute *abstractAttribute;
-
-  /// The opaque type of the attribute value.
-  const void *type;
 };
 
 /// Default storage type for attributes that require no additional
 /// initialization or storage.
 using DefaultAttributeStorage = AttributeStorage;
 
 //===----------------------------------------------------------------------===//
 // AttributeStorageAllocator
if (!ctx->getAttributeUniquer().isParametricStorageInitialized(
           llvm::Twine("can't create Attribute '") + llvm::getTypeName<T>() +
           "' because storage uniquer isn't initialized: the dialect was likely "
           "not loaded, or the attribute wasn't added with addAttributes<...>() "
           "in the Dialect::initialize() method.");
 #endif
     return ctx->getAttributeUniquer().get<typename T::ImplType>(
         [ctx](AttributeStorage *storage) {
           initializeAttributeStorage(storage, ctx, T::getTypeID());
+
+          // Execute any additional attribute storage initialization with the
+          // context.
+          static_cast<typename T::ImplType *>(storage)->initialize(ctx);
         },
         T::getTypeID(), std::forward<Args>(args)...);
   }
   /// Get an uniqued instance of a singleton attribute T.
   template <typename T>
   static typename std::enable_if_t<
       std::is_same<typename T::ImplType, AttributeStorage>::value, T>
   get(MLIRContext *ctx) {

mlir/include/mlir/IR/Attributes.h

 //===- Attributes.h - MLIR Attribute Classes --------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_ATTRIBUTES_H
 #define MLIR_IR_ATTRIBUTES_H
 
 #include "mlir/IR/AttributeSupport.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 
 namespace mlir {
-class Identifier;
+class StringAttr;
+
+// TODO: Remove this when all usages have been replaced with StringAttr.
+using Identifier = StringAttr;
 
 /// Attributes are known-constant values of operations.
 ///
 /// Instances of the Attribute class are references to immortal key-value pairs
 /// with immutable, uniqued keys owned by MLIRContext. As such, an Attribute is
 /// a thin wrapper around an underlying storage pointer. Attributes are usually
 /// passed by value.
 class Attribute {
public:
   // Support dyn_cast'ing Attribute to itself.
   static bool classof(Attribute) { return true; }
 
   /// Return a unique identifier for the concrete attribute type. This is used
   /// to support dynamic type casting.
   TypeID getTypeID() { return impl->getAbstractAttribute().getTypeID(); }
 
   /// Return the type of this attribute.
-  Type getType() const;
+  Type getType() const { return impl->getType(); }
 
   /// Return the context this attribute belongs to.
   MLIRContext *getContext() const;
 
   /// Get the dialect this attribute is registered to.
   Dialect &getDialect() const {
     return impl->getAbstractAttribute().getDialect();
   }
template <typename U> U Attribute::dyn_cast_or_null() const {
   return (impl && isa<U>()) ? U(impl) : U(nullptr);
 }
 template <typename U> U Attribute::cast() const {
   assert(isa<U>());
   return U(impl);
 }
 
 inline ::llvm::hash_code hash_value(Attribute arg) {
-  return ::llvm::hash_value(arg.impl);
+  return DenseMapInfo<const Attribute::ImplType *>::getHashValue(arg.impl);
 }
 
 //===----------------------------------------------------------------------===//
 // NamedAttribute
 //===----------------------------------------------------------------------===//
 
 /// NamedAttribute is combination of a name, represented by an Identifier, and a
 /// value, represented by an Attribute. The attribute pointer should always be

mlir/include/mlir/IR/BuiltinAttributes.h

std::function<T(ptrdiff_t)> mapFn =
         for (unsigned i = 0, e = flatSparseIndices.size(); i != e; ++i)
           if (flatSparseIndices[i] == index)
             return *std::next(valueIt, i);
         // Otherwise, return the zero value.
         return zeroValue;
       };
   return iterator<T>(llvm::seq<ptrdiff_t>(0, getNumElements()).begin(), mapFn);
 }
-} // end namespace mlir.
+
+//===----------------------------------------------------------------------===//
+// StringAttr
+//===----------------------------------------------------------------------===//
+
+/// Define comparisons for StringAttr against nullptr and itself to avoid the
+/// StringRef overloads from being chosen when not desirable.
+inline bool operator==(StringAttr lhs, std::nullptr_t) { return !lhs; }
+inline bool operator!=(StringAttr lhs, std::nullptr_t) {
+  return static_cast<bool>(lhs);
+}
+inline bool operator==(StringAttr lhs, StringAttr rhs) {
+  return (Attribute)lhs == (Attribute)rhs;
+}
+inline bool operator!=(StringAttr lhs, StringAttr rhs) { return !(lhs == rhs); }
+
+/// Allow direct comparison with StringRef.
+inline bool operator==(StringAttr lhs, StringRef rhs) {
+  return lhs.getValue() == rhs;
+}
+inline bool operator!=(StringAttr lhs, StringRef rhs) { return !(lhs == rhs); }
+inline bool operator==(StringRef lhs, StringAttr rhs) {
+  return rhs.getValue() == lhs;
+}
+inline bool operator!=(StringRef lhs, StringAttr rhs) { return !(lhs == rhs); }
+
+inline Type StringAttr::getType() const { return Attribute::getType(); }
+
+} // end namespace mlir
 
 //===----------------------------------------------------------------------===//
 // Attribute Utilities
 //===----------------------------------------------------------------------===//
 
 namespace llvm {
 
 template <>
+struct DenseMapInfo<mlir::StringAttr> : public DenseMapInfo<mlir::Attribute> {
+  static mlir::StringAttr getEmptyKey() {
+    const void *pointer = llvm::DenseMapInfo<const void *>::getEmptyKey();
+    return mlir::StringAttr::getFromOpaquePointer(pointer);
+  }
+  static mlir::StringAttr getTombstoneKey() {
+    const void *pointer = llvm::DenseMapInfo<const void *>::getTombstoneKey();
+    return mlir::StringAttr::getFromOpaquePointer(pointer);
+  }
+};
+template <>
+struct PointerLikeTypeTraits<mlir::StringAttr>
+    : public PointerLikeTypeTraits<mlir::Attribute> {
+  static inline mlir::StringAttr getFromVoidPointer(void *p) {
+    return mlir::StringAttr::getFromOpaquePointer(p);
+  }
+};
+
+template <>
 struct PointerLikeTypeTraits<mlir::SymbolRefAttr>
     : public PointerLikeTypeTraits<mlir::Attribute> {
   static inline mlir::SymbolRefAttr getFromVoidPointer(void *ptr) {
-    return PointerLikeTypeTraits<mlir::Attribute>::getFromVoidPointer(ptr)
-        .cast<mlir::SymbolRefAttr>();
+    return mlir::SymbolRefAttr::getFromOpaquePointer(ptr);
   }
 };
 
 } // namespace llvm
 
 #endif // MLIR_IR_BUILTINATTRIBUTES_H

mlir/include/mlir/IR/BuiltinAttributes.td

let builders = [
     /// Build an string attr with NoneType.
     AttrBuilder<(ins "const Twine &":$bytes)>,
     /// Build an empty string attr with NoneType.
     AttrBuilder<(ins)>
   ];
   let extraClassDeclaration = [{
     using ValueType = StringRef;
 
+    /// If the value of this string is prefixed with a dialect namespace,
+    /// returns the dialect corresponding to that namespace if it is loaded,
+    /// nullptr otherwise. For example, the string `llvm.fastmathflags` would
+    /// return the LLVM dialect, assuming it is loaded in the context.
+    Dialect *getReferencedDialect() const;
+
+    /// Enable conversion to StringRef.
+    operator StringRef() const { return getValue(); }
+
+    /// Returns the underlying string value
+    StringRef strref() const { return getValue(); }
+
+    /// Convert the underling value to an std::string.
+    std::string str() const { return getValue().str(); }
+
+    /// Return a pointer to the start of the string data.
+    const char *data() const { return getValue().data(); }
+
+    /// Return the number of bytes in this string.
+    size_t size() const { return getValue().size(); }
+
+    /// Iterate over the underlying string data.
+    StringRef::iterator begin() const { return getValue().begin(); }
+    StringRef::iterator end() const { return getValue().end(); }
+
+    /// Compare the underlying string value to the one in `rhs`.
+    int compare(StringAttr rhs) const {
+      if (*this == rhs)
+        return 0;
+      return getValue().compare(rhs.getValue());
+    }
+
+    /// FIXME: Defined as part of transition of Identifier->StringAttr. Prefer
+    /// using the other `get` methods instead.
+    static StringAttr get(const Twine &str, MLIRContext *context) {
+      return get(context, str);
+    }
+
   private:
     /// Return an empty StringAttr with NoneType type. This is a special variant
     /// of the `get` method that is used by the MLIRContext to cache the
     /// instance.
     static StringAttr getEmptyStringAttrUnchecked(MLIRContext *context);
     friend MLIRContext;
   public:
   }];
+  let genStorageClass = 0;
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolRefAttr
 //===----------------------------------------------------------------------===//
 
 def Builtin_SymbolRefAttr : Builtin_Attr<"SymbolRef"> {

mlir/include/mlir/IR/BuiltinTypes.h

 namespace llvm {
 struct fltSemantics;
 } // namespace llvm
 
 namespace mlir {
 class AffineExpr;
 class AffineMap;
 class FloatType;
-class Identifier;
 class IndexType;
 class IntegerType;
+class StringAttr;
 class TypeRange;
 
+// TODO: Remove this when all usages have been replaced with StringAttr.
+using Identifier = StringAttr;
+
 //===----------------------------------------------------------------------===//
 // FloatType
 //===----------------------------------------------------------------------===//
 
 class FloatType : public Type {
 public:
   using Type::Type;
 

mlir/include/mlir/IR/Diagnostics.h

 namespace llvm {
 class MemoryBuffer;
 class SMLoc;
 class SourceMgr;
 } // end namespace llvm
 
 namespace mlir {
 class DiagnosticEngine;
-class Identifier;
 struct LogicalResult;
 class MLIRContext;
 class Operation;
 class OperationName;
 class OpPrintingFlags;
 class Type;
 class Value;
 
public:
   typename std::enable_if<
       !std::is_convertible<Arg, StringRef>::value &&
           std::is_constructible<DiagnosticArgument, Arg>::value,
       Diagnostic &>::type
   operator<<(Arg &&val) {
     arguments.push_back(DiagnosticArgument(std::forward<Arg>(val)));
     return *this;
   }
+  Diagnostic &operator<<(StringAttr val);
 
   /// Stream in a string literal.
   Diagnostic &operator<<(const char *val) {
     arguments.push_back(DiagnosticArgument(val));
     return *this;
   }
 
   /// Stream in a Twine argument.
   Diagnostic &operator<<(char val);
   Diagnostic &operator<<(const Twine &val);
   Diagnostic &operator<<(Twine &&val);
 
-  /// Stream in an Identifier.
-  Diagnostic &operator<<(Identifier val);
-
   /// Stream in an OperationName.
   Diagnostic &operator<<(OperationName val);
 
   /// Stream in an Operation.
   Diagnostic &operator<<(Operation &val);
   Diagnostic &operator<<(Operation *val) {
     return *this << *val;
   }

mlir/include/mlir/IR/FunctionSupport.h

for (unsigned i = 0; i != numArgs; ++i) {
 
       // Verify that all of the argument attributes are dialect attributes, i.e.
       // that they contain a dialect prefix in their name.  Call the dialect, if
       // registered, to verify the attributes themselves.
       for (auto attr : argAttrs) {
         if (!attr.first.strref().contains('.'))
           return funcOp.emitOpError(
               "arguments may only have dialect attributes");
-        if (Dialect *dialect = attr.first.getDialect()) {
+        if (Dialect *dialect = attr.first.getReferencedDialect()) {
           if (failed(dialect->verifyRegionArgAttribute(op, /*regionIndex=*/0,
                                                        /*argIndex=*/i, attr)))
             return failure();
         }
       }
     }
   }
   if (ArrayAttr allResultAttrs = funcOp.getAllResultAttrs()) {
for (unsigned i = 0; i != numResults; ++i) {
       }
 
       // Verify that all of the result attributes are dialect attributes, i.e.
       // that they contain a dialect prefix in their name.  Call the dialect, if
       // registered, to verify the attributes themselves.
       for (auto attr : resultAttrs) {
         if (!attr.first.strref().contains('.'))
           return funcOp.emitOpError("results may only have dialect attributes");
-        if (Dialect *dialect = attr.first.getDialect()) {
+        if (Dialect *dialect = attr.first.getReferencedDialect()) {
           if (failed(dialect->verifyRegionResultAttribute(op, /*regionIndex=*/0,
                                                           /*resultIndex=*/i,
                                                           attr)))
             return failure();
         }
       }
     }
   }

mlir/include/mlir/IR/Identifier.h

 //===- Identifier.h - MLIR Identifier Class ---------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_IDENTIFIER_H
 #define MLIR_IR_IDENTIFIER_H
 
-#include "mlir/Support/LLVM.h"
-#include "llvm/ADT/DenseMapInfo.h"
-#include "llvm/ADT/PointerUnion.h"
-#include "llvm/ADT/StringMapEntry.h"
-#include "llvm/ADT/Twine.h"
-#include "llvm/Support/PointerLikeTypeTraits.h"
+#include "mlir/IR/BuiltinAttributes.h"
 
 namespace mlir {
-class Dialect;
-class MLIRContext;
-
-/// This class represents a uniqued string owned by an MLIRContext.  Strings
-/// represented by this type cannot contain nul characters, and may not have a
-/// zero length.
-///
-/// This is a POD type with pointer size, so it should be passed around by
-/// value. The underlying data is owned by MLIRContext and is thus immortal for
-/// almost all clients.
-///
-/// An Identifier may be prefixed with a dialect namespace followed by a single
-/// dot `.`. This is particularly useful when used as a key in a NamedAttribute
-/// to differentiate a dependent attribute (specific to an operation) from a
-/// generic attribute defined by the dialect (in general applicable to multiple
-/// operations).
-class Identifier {
-  using EntryType =
-      llvm::StringMapEntry<PointerUnion<Dialect *, MLIRContext *>>;
-
-public:
-  /// Return an identifier for the specified string.
-  static Identifier get(const Twine &string, MLIRContext *context);
-
-  Identifier(const Identifier &) = default;
-  Identifier &operator=(const Identifier &other) = default;
-
-  /// Return a StringRef for the string.
-  StringRef strref() const { return entry->first(); }
-
-  /// Identifiers implicitly convert to StringRefs.
-  operator StringRef() const { return strref(); }
-
-  /// Return an std::string.
-  std::string str() const { return strref().str(); }
-
-  /// Return a null terminated C string.
-  const char *c_str() const { return entry->getKeyData(); }
-
-  /// Return a pointer to the start of the string data.
-  const char *data() const { return entry->getKeyData(); }
-
-  /// Return the number of bytes in this string.
-  unsigned size() const { return entry->getKeyLength(); }
-
-  /// Return the dialect loaded in the context for this identifier or nullptr if
-  /// this identifier isn't prefixed with a loaded dialect. For example the
-  /// `llvm.fastmathflags` identifier would return the LLVM dialect here,
-  /// assuming it is loaded in the context.
-  Dialect *getDialect();
-
-  /// Return the current MLIRContext associated with this identifier.
-  MLIRContext *getContext();
-
-  const char *begin() const { return data(); }
-  const char *end() const { return entry->getKeyData() + size(); }
-
-  bool operator==(Identifier other) const { return entry == other.entry; }
-  bool operator!=(Identifier rhs) const { return !(*this == rhs); }
-
-  void print(raw_ostream &os) const;
-  void dump() const;
-
-  const void *getAsOpaquePointer() const {
-    return static_cast<const void *>(entry);
-  }
-  static Identifier getFromOpaquePointer(const void *entry) {
-    return Identifier(static_cast<const EntryType *>(entry));
-  }
-
-  /// Compare the underlying StringRef.
-  int compare(Identifier rhs) const { return strref().compare(rhs.strref()); }
-
-private:
-  /// This contains the bytes of the string, which is guaranteed to be nul
-  /// terminated.
-  const EntryType *entry;
-  explicit Identifier(const EntryType *entry) : entry(entry) {}
-};
-
-inline raw_ostream &operator<<(raw_ostream &os, Identifier identifier) {
-  identifier.print(os);
-  return os;
-}
-
-// Identifier/Identifier equality comparisons are defined inline.
-inline bool operator==(Identifier lhs, StringRef rhs) {
-  return lhs.strref() == rhs;
-}
-inline bool operator!=(Identifier lhs, StringRef rhs) { return !(lhs == rhs); }
-
-inline bool operator==(StringRef lhs, Identifier rhs) {
-  return rhs.strref() == lhs;
-}
-inline bool operator!=(StringRef lhs, Identifier rhs) { return !(lhs == rhs); }
-
-// Make identifiers hashable.
-inline llvm::hash_code hash_value(Identifier arg) {
-  // Identifiers are uniqued, so we can just hash the pointer they contain.
-  return llvm::hash_value(arg.getAsOpaquePointer());
-}
+/// NOTICE: Identifier is deprecated and usages of it should be replaced with
+/// StringAttr.
+using Identifier = StringAttr;
 } // end namespace mlir
 
-namespace llvm {
-// Identifiers hash just like pointers, there is no need to hash the bytes.
-template <>
-struct DenseMapInfo<mlir::Identifier> {
-  static mlir::Identifier getEmptyKey() {
-    auto pointer = llvm::DenseMapInfo<const void *>::getEmptyKey();
-    return mlir::Identifier::getFromOpaquePointer(pointer);
-  }
-  static mlir::Identifier getTombstoneKey() {
-    auto pointer = llvm::DenseMapInfo<const void *>::getTombstoneKey();
-    return mlir::Identifier::getFromOpaquePointer(pointer);
-  }
-  static unsigned getHashValue(mlir::Identifier val) {
-    return mlir::hash_value(val);
-  }
-  static bool isEqual(mlir::Identifier lhs, mlir::Identifier rhs) {
-    return lhs == rhs;
-  }
-};
-
-/// The pointer inside of an identifier comes from a StringMap, so its alignment
-/// is always at least 4 and probably 8 (on 64-bit machines).  Allow LLVM to
-/// steal the low bits.
-template <>
-struct PointerLikeTypeTraits<mlir::Identifier> {
-public:
-  static inline void *getAsVoidPointer(mlir::Identifier i) {
-    return const_cast<void *>(i.getAsOpaquePointer());
-  }
-  static inline mlir::Identifier getFromVoidPointer(void *p) {
-    return mlir::Identifier::getFromOpaquePointer(p);
-  }
-  static constexpr int NumLowBitsAvailable = 2;
-};
-
-} // end namespace llvm
 #endif

mlir/include/mlir/IR/Location.h

 #ifndef MLIR_IR_LOCATION_H
 #define MLIR_IR_LOCATION_H
 
 #include "mlir/IR/Attributes.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 
 namespace mlir {
 
-class Identifier;
 class Location;
 class WalkResult;
 
 //===----------------------------------------------------------------------===//
 // LocationAttr
 //===----------------------------------------------------------------------===//
 
 /// Location objects represent source locations information in MLIR.

mlir/include/mlir/IR/OperationSupport.h

public:
   /// Return the name of the dialect this operation is registered to.
   StringRef getDialectNamespace() const;
 
   /// Return the dialect this operation is registered to if the dialect is
   /// loaded in the context, or nullptr if the dialect isn't loaded.
   Dialect *getDialect() const {
     if (const auto *abstractOp = getAbstractOperation())
       return &abstractOp->dialect;
-    return representation.get<Identifier>().getDialect();
+    return representation.get<Identifier>().getReferencedDialect();
   }
 
   /// Return the operation name with dialect name stripped, if it has one.
   StringRef stripDialect() const;
 
   /// Return the name of this operation. This always succeeds.
   StringRef getStringRef() const;
 

mlir/include/mlir/IR/StorageUniquerSupport.h

static ConcreteT getChecked(function_ref<InFlightDiagnostic()> emitErrorFn,
     // If the construction invariants fail then we return a null attribute.
     if (failed(ConcreteT::verify(emitErrorFn, args...)))
       return ConcreteT();
     return UniquerT::template get<ConcreteT>(ctx, args...);
   }
 
   /// Get an instance of the concrete type from a void pointer.
   static ConcreteT getFromOpaquePointer(const void *ptr) {
-    return ptr ? BaseT::getFromOpaquePointer(ptr).template cast<ConcreteT>()
-               : nullptr;
+    return ConcreteT((const typename BaseT::ImplType *)ptr);
   }
 
 protected:
   /// Mutate the current storage instance. This will not change the unique key.
   /// The arguments are forwarded to 'ConcreteT::mutate'.
   template <typename... Args> LogicalResult mutate(Args &&...args) {
     return UniquerT::template mutate<ConcreteT>(this->getContext(), getImpl(),
                                                 std::forward<Args>(args)...);

mlir/include/mlir/IR/SymbolTable.h

 #define MLIR_IR_SYMBOLTABLE_H
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/OpDefinition.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringMap.h"
 
 namespace mlir {
-class Identifier;
-class Operation;
 
 /// This class allows for representing and managing the symbol table used by
 /// operations with the 'SymbolTable' trait. Inserting into and erasing from
 /// this SymbolTable will also insert and erase from the Operation given to it
 /// at construction.
 class SymbolTable {
 public:
   /// Build a symbol table with the symbols within the given operation.

mlir/include/mlir/Pass/PassManager.h

 #include <vector>
 
 namespace llvm {
 class Any;
 } // end namespace llvm
 
 namespace mlir {
 class AnalysisManager;
-class Identifier;
 class MLIRContext;
 class Operation;
 class Pass;
 class PassInstrumentation;
 class PassInstrumentor;
+class StringAttr;
+
+// TODO: Remove this when all usages have been replaced with StringAttr.
+using Identifier = StringAttr;
 
 namespace detail {
 struct OpPassManagerImpl;
 class OpToOpPassAdaptor;
 class PassCrashReproducerGenerator;
 struct PassExecutionState;
 } // end namespace detail
 

mlir/include/mlir/Support/StorageUniquer.h

template <typename T> ArrayRef<T> copyInto(ArrayRef<T> elements) {
       auto result = allocator.Allocate<T>(elements.size());
       std::uninitialized_copy(elements.begin(), elements.end(), result);
       return ArrayRef<T>(result, elements.size());
     }
 
     /// Copy the provided string into memory managed by our bump pointer
     /// allocator.
     StringRef copyInto(StringRef str) {
-      auto result = copyInto(ArrayRef<char>(str.data(), str.size()));
-      return StringRef(result.data(), str.size());
+      if (str.empty())
+        return StringRef();
+
+      char *result = allocator.Allocate<char>(str.size() + 1);
+      std::uninitialized_copy(str.begin(), str.end(), result);
+      result[str.size()] = 0;
+      return StringRef(result, str.size());
     }
 
     /// Allocate an instance of the provided type.
     template <typename T> T *allocate() { return allocator.Allocate<T>(); }
 
     /// Allocate 'size' bytes of 'alignment' aligned memory.
     void *allocate(size_t size, size_t alignment) {
       return allocator.Allocate(size, alignment);

mlir/include/mlir/Target/LLVMIR/LLVMTranslationInterface.h

public:
   }
 
   /// Acts on the given operation using the interface implemented by the dialect
   /// of one of the operation's dialect attributes.
   virtual LogicalResult
   amendOperation(Operation *op, NamedAttribute attribute,
                  LLVM::ModuleTranslation &moduleTranslation) const {
     if (const LLVMTranslationDialectInterface *iface =
-            getInterfaceFor(attribute.first.getDialect())) {
+            getInterfaceFor(attribute.first.getReferencedDialect())) {
       return iface->amendOperation(op, attribute, moduleTranslation);
     }
     return success();
   }
 };
 
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_LLVMTRANSLATIONINTERFACE_H

mlir/lib/Bindings/Python/IRCore.cpp

PyNamedAttribute dunderGetItemIndexed(intptr_t index) {
     if (index < 0 || index >= dunderLen()) {
       throw SetPyError(PyExc_IndexError,
                        "attempt to access out of bounds attribute");
     }
     MlirNamedAttribute namedAttr =
         mlirOperationGetAttribute(operation->get(), index);
     return PyNamedAttribute(
         namedAttr.attribute,
-        std::string(mlirIdentifierStr(namedAttr.name).data));
+        std::string(mlirIdentifierStr(namedAttr.name).data,
+                    mlirIdentifierStr(namedAttr.name).length));
   }
 
   void dunderSetItem(const std::string &name, PyAttribute attr) {
     mlirOperationSetAttributeByName(operation->get(), toMlirStringRef(name),
                                     attr);
   }
 
   void dunderDelItem(const std::string &name) {
void mlir::python::populateIRCore(py::module &m) {
   // Mapping of PyNamedAttribute
   //----------------------------------------------------------------------------
   py::class_<PyNamedAttribute>(m, "NamedAttribute", py::module_local())
       .def("__repr__",
            [](PyNamedAttribute &self) {
              PyPrintAccumulator printAccum;
              printAccum.parts.append("NamedAttribute(");
              printAccum.parts.append(
-                 mlirIdentifierStr(self.namedAttr.name).data);
+                 py::str(mlirIdentifierStr(self.namedAttr.name).data,
+                         mlirIdentifierStr(self.namedAttr.name).length));
              printAccum.parts.append("=");
              mlirAttributePrint(self.namedAttr.attribute,
                                 printAccum.getCallback(),
                                 printAccum.getUserData());
              printAccum.parts.append(")");
              return printAccum.join();
            })
       .def_property_readonly(

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

 // String attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAString(MlirAttribute attr) {
   return unwrap(attr).isa<StringAttr>();
 }
 
 MlirAttribute mlirStringAttrGet(MlirContext ctx, MlirStringRef str) {
-  return wrap(StringAttr::get(unwrap(ctx), unwrap(str)));
+  return wrap((Attribute)StringAttr::get(unwrap(ctx), unwrap(str)));
 }
 
 MlirAttribute mlirStringAttrTypedGet(MlirType type, MlirStringRef str) {
-  return wrap(StringAttr::get(unwrap(str), unwrap(type)));
+  return wrap((Attribute)StringAttr::get(unwrap(str), unwrap(type)));
 }
 
 MlirStringRef mlirStringAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<StringAttr>().getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolRef attribute.

mlir/lib/CAPI/IR/IR.cpp

 
 MlirOperation mlirSymbolTableLookup(MlirSymbolTable symbolTable,
                                     MlirStringRef name) {
   return wrap(unwrap(symbolTable)->lookup(StringRef(name.data, name.length)));
 }
 
 MlirAttribute mlirSymbolTableInsert(MlirSymbolTable symbolTable,
                                     MlirOperation operation) {
-  return wrap(unwrap(symbolTable)->insert(unwrap(operation)));
+  return wrap((Attribute)unwrap(symbolTable)->insert(unwrap(operation)));
 }
 
 void mlirSymbolTableErase(MlirSymbolTable symbolTable,
                           MlirOperation operation) {
   unwrap(symbolTable)->erase(unwrap(operation));
 }

mlir/lib/Dialect/DLTI/DLTI.cpp

DataLayoutSpecAttr::verify(function_ref<InFlightDiagnostic()> emitError,
   DenseSet<Identifier> ids;
   for (DataLayoutEntryInterface entry : entries) {
     if (auto type = entry.getKey().dyn_cast<Type>()) {
       if (!types.insert(type).second)
         return emitError() << "repeated layout entry key: " << type;
     } else {
       auto id = entry.getKey().get<Identifier>();
       if (!ids.insert(id).second)
-        return emitError() << "repeated layout entry key: " << id;
+        return emitError() << "repeated layout entry key: " << id.getValue();
     }
   }
   return success();
 }
 
 /// Given a list of old and a list of new entries, overwrites old entries with
 /// new ones if they have matching keys, appends new entries to the old entry
 /// list otherwise.
for (const auto &kvp : newEntriesForType) {
     if (!interface.areCompatible(entriesForType.lookup(kvp.first), kvp.second))
       return failure();
 
     overwriteDuplicateEntries(entriesForType[kvp.first], kvp.second);
   }
 
   for (const auto &kvp : newEntriesForID) {
     Identifier id = kvp.second.getKey().get<Identifier>();
-    Dialect *dialect = id.getDialect();
+    Dialect *dialect = id.getReferencedDialect();
     if (!entriesForID.count(id)) {
       entriesForID[id] = kvp.second;
       continue;
     }
 
     // Attempt to combine the enties using the dialect interface. If the
     // dialect is not loaded for some reason, use the default combinator
     // that conservatively accepts identical entries only.
if (!attr.second.isa<DataLayoutSpecAttr>()) {
       return op->emitError() << "'" << DLTIDialect::kDataLayoutAttrName
                              << "' is expected to be a #dlti.dl_spec attribute";
     }
     if (isa<ModuleOp>(op))
       return detail::verifyDataLayoutOp(op);
     return success();
   }
 
-  return op->emitError() << "attribute '" << attr.first
+  return op->emitError() << "attribute '" << attr.first.getValue()
                          << "' not supported by dialect";
 }

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

auto newOp = rewriter.create<GenericOp>(
         genericOp.getLoc(), genericOp->getResultTypes(), newInputOperands,
         outputOperands, rewriter.getAffineMapArrayAttr(newIndexingMaps),
         genericOp.iterator_types(), genericOp.docAttr(),
         genericOp.library_callAttr());
 
     // Copy over unknown attributes. They might be load bearing for some flow.
     ArrayRef<StringRef> odsAttrs = genericOp.getAttributeNames();
     for (NamedAttribute kv : genericOp->getAttrs()) {
-      if (!llvm::is_contained(odsAttrs, kv.first.c_str())) {
+      if (!llvm::is_contained(odsAttrs, kv.first.getValue())) {
         newOp->setAttr(kv.first, kv.second);
       }
     }
 
     rewriter.inlineRegionBefore(genericOp.region(), newOp.region(),
                                 newOp.region().begin());
 
     // Repair the payload entry block by RAUW'ing redundant arguments and

mlir/lib/IR/AsmPrinter.cpp

 #include "llvm/Support/Regex.h"
 #include "llvm/Support/SaveAndRestore.h"
 
 #include <tuple>
 
 using namespace mlir;
 using namespace mlir::detail;
 
-void Identifier::print(raw_ostream &os) const { os << str(); }
-
-void Identifier::dump() const { print(llvm::errs()); }
-
 void OperationName::print(raw_ostream &os) const { os << getStringRef(); }
 
 void OperationName::dump() const { print(llvm::errs()); }
 
 //===--------------------------------------------------------------------===//
 // AsmParser
 //===--------------------------------------------------------------------===//
 
TypeSwitch<LocationAttr>(loc)
       .Case<UnknownLoc>([&](UnknownLoc loc) {
         if (pretty)
           os << "[unknown]";
         else
           os << "unknown";
       })
       .Case<FileLineColLoc>([&](FileLineColLoc loc) {
         if (pretty) {
-          os << loc.getFilename();
+          os << loc.getFilename().getValue();
         } else {
           os << "\"";
           printEscapedString(loc.getFilename(), os);
           os << "\"";
         }
         os << ':' << loc.getLine() << ':' << loc.getColumn();
       })
       .Case<NameLoc>([&](NameLoc loc) {
for (FlatSymbolRefAttr nestedRef : refAttr.getNestedReferences()) {
       os << "::";
       printSymbolReference(nestedRef.getValue(), os);
     }
 
   } else if (auto opaqueAttr = attr.dyn_cast<OpaqueElementsAttr>()) {
     if (printerFlags.shouldElideElementsAttr(opaqueAttr)) {
       printElidedElementsAttr(os);
     } else {
-      os << "opaque<\"" << opaqueAttr.getDialect() << "\", \"0x"
+      os << "opaque<" << opaqueAttr.getDialect() << ", \"0x"
          << llvm::toHex(opaqueAttr.getValue()) << "\">";
     }
 
   } else if (auto intOrFpEltAttr = attr.dyn_cast<DenseIntOrFPElementsAttr>()) {
     if (printerFlags.shouldElideElementsAttr(intOrFpEltAttr)) {
       printElidedElementsAttr(os);
     } else {
       os << "dense<";

mlir/lib/IR/AttributeDetail.h

construct(AttributeStorageAllocator &allocator, KeyTy key) {
 
     return new (allocator.allocate<DenseStringElementsAttrStorage>())
         DenseStringElementsAttrStorage(key.type, copy, key.isSplat);
   }
 
   ArrayRef<StringRef> data;
 };
 
+//===----------------------------------------------------------------------===//
+// StringAttr
+//===----------------------------------------------------------------------===//
+
+struct StringAttrStorage : public AttributeStorage {
+  StringAttrStorage(StringRef value, Type type)
+      : AttributeStorage(type), value(value), referencedDialect(nullptr) {}
+
+  /// The hash key is a tuple of the parameter types.
+  using KeyTy = std::pair<StringRef, Type>;
+  bool operator==(const KeyTy &key) const {
+    return value == key.first && getType() == key.second;
+  }
+  static ::llvm::hash_code hashKey(const KeyTy &key) {
+    return DenseMapInfo<KeyTy>::getHashValue(key);
+  }
+
+  /// Define a construction method for creating a new instance of this
+  /// storage.
+  static StringAttrStorage *construct(AttributeStorageAllocator &allocator,
+                                      const KeyTy &key) {
+    return new (allocator.allocate<StringAttrStorage>())
+        StringAttrStorage(allocator.copyInto(key.first), key.second);
+  }
+
+  /// Initialize the storage given an MLIRContext.
+  void initialize(MLIRContext *context);
+
+  /// The raw string value.
+  StringRef value;
+  /// If the string value contains a dialect namespace prefix (e.g.
+  /// dialect.blah), this is the dialect referenced.
+  Dialect *referencedDialect;
+};
+
 } // namespace detail
 } // namespace mlir
 
 #endif // ATTRIBUTEDETAIL_H_

mlir/lib/IR/Attributes.cpp

 //===- Attributes.cpp - MLIR Affine Expr Classes --------------------------===//
 //
 // 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 "mlir/IR/Attributes.h"
 #include "mlir/IR/Dialect.h"
 
 using namespace mlir;
 using namespace mlir::detail;
 
 //===----------------------------------------------------------------------===//
-// AttributeStorage
-//===----------------------------------------------------------------------===//
-
-AttributeStorage::AttributeStorage(Type type)
-    : type(type.getAsOpaquePointer()) {}
-AttributeStorage::AttributeStorage() : type(nullptr) {}
-
-Type AttributeStorage::getType() const {
-  return Type::getFromOpaquePointer(type);
-}
-void AttributeStorage::setType(Type newType) {
-  type = newType.getAsOpaquePointer();
-}
-
-//===----------------------------------------------------------------------===//
 // Attribute
 //===----------------------------------------------------------------------===//
 
-/// Return the type of this attribute.
-Type Attribute::getType() const { return impl->getType(); }
-
 /// Return the context this attribute belongs to.
 MLIRContext *Attribute::getContext() const { return getDialect().getContext(); }
 
 //===----------------------------------------------------------------------===//
 // NamedAttribute
 //===----------------------------------------------------------------------===//
 
 bool mlir::operator<(const NamedAttribute &lhs, const NamedAttribute &rhs) {
-  return strcmp(lhs.first.data(), rhs.first.data()) < 0;
+  return lhs.first.compare(rhs.first) < 0;
 }
 bool mlir::operator<(const NamedAttribute &lhs, StringRef rhs) {
-  // This is correct even when attr.first.data()[name.size()] is not a zero
-  // string terminator, because we only care about a less than comparison.
-  // This can't use memcmp, because it doesn't guarantee that it will stop
-  // reading both buffers if one is shorter than the other, even if there is
-  // a difference.
-  return strncmp(lhs.first.data(), rhs.data(), rhs.size()) < 0;
+  return lhs.first.getValue().compare(rhs) < 0;
 }

mlir/lib/IR/BuiltinAttributes.cpp

 }
 
 /// Twine support for StringAttr.
 StringAttr StringAttr::get(const Twine &twine, Type type) {
   SmallVector<char, 32> tempStr;
   return Base::get(type.getContext(), twine.toStringRef(tempStr), type);
 }
 
+StringRef StringAttr::getValue() const { return getImpl()->value; }
+
+Dialect *StringAttr::getReferencedDialect() const {
+  return getImpl()->referencedDialect;
+}
+
 //===----------------------------------------------------------------------===//
 // FloatAttr
 //===----------------------------------------------------------------------===//
 
 double FloatAttr::getValueAsDouble() const {
   return getValueAsDouble(getValue());
 }
 double FloatAttr::getValueAsDouble(APFloat value) {
return attr.isa<DenseElementsAttr>() &&
          attr.getType().cast<ShapedType>().getElementType().isIntOrIndex();
 }
 
 //===----------------------------------------------------------------------===//
 // OpaqueElementsAttr
 //===----------------------------------------------------------------------===//
 
 bool OpaqueElementsAttr::decode(ElementsAttr &result) {
-  Dialect *dialect = getDialect().getDialect();
+  Dialect *dialect = getContext()->getLoadedDialect(getDialect());
   if (!dialect)
     return true;
   auto *interface =
       dialect->getRegisteredInterface<DialectDecodeAttributesInterface>();
   if (!interface)
     return true;
   return failed(interface->decode(*this, result));
 }

mlir/lib/IR/BuiltinDialect.cpp

static LogicalResult verify(ModuleOp op) {
   for (auto attr : op->getAttrs()) {
     if (!attr.first.strref().contains('.') &&
         !llvm::is_contained(
             ArrayRef<StringRef>{mlir::SymbolTable::getSymbolAttrName(),
                                 mlir::SymbolTable::getVisibilityAttrName()},
             attr.first.strref()))
       return op.emitOpError() << "can only contain attributes with "
                                  "dialect-prefixed names, found: '"
-                              << attr.first << "'";
+                              << attr.first.getValue() << "'";
   }
 
   // Check that there is at most one data layout spec attribute.
   StringRef layoutSpecAttrName;
   DataLayoutSpecInterface layoutSpec;
   for (const NamedAttribute &na : op->getAttrs()) {
     if (auto spec = na.second.dyn_cast<DataLayoutSpecInterface>()) {
       if (layoutSpec) {
         InFlightDiagnostic diag =
             op.emitOpError() << "expects at most one data layout attribute";
         diag.attachNote() << "'" << layoutSpecAttrName
                           << "' is a data layout attribute";
-        diag.attachNote() << "'" << na.first << "' is a data layout attribute";
+        diag.attachNote() << "'" << na.first.getValue()
+                          << "' is a data layout attribute";
       }
       layoutSpecAttrName = na.first.strref();
       layoutSpec = spec;
     }
   }
 
   return success();
 }

mlir/lib/IR/Diagnostics.cpp

 //===- Diagnostics.cpp - MLIR Diagnostics ---------------------------------===//
 //
 // 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 "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Attributes.h"
-#include "mlir/IR/Identifier.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/TypeSwitch.h"
Diagnostic &Diagnostic::operator<<(const Twine &val) {
   arguments.push_back(DiagnosticArgument(twineToStrRef(val, strings)));
   return *this;
 }
 Diagnostic &Diagnostic::operator<<(Twine &&val) {
   arguments.push_back(DiagnosticArgument(twineToStrRef(val, strings)));
   return *this;
 }
 
-/// Stream in an Identifier.
-Diagnostic &Diagnostic::operator<<(Identifier val) {
-  // An identifier is stored in the context, so we don't need to worry about the
-  // lifetime of its data.
-  arguments.push_back(DiagnosticArgument(val.strref()));
+Diagnostic &Diagnostic::operator<<(StringAttr val) {
+  arguments.push_back(DiagnosticArgument(val));
   return *this;
 }
 
 /// Stream in an OperationName.
 Diagnostic &Diagnostic::operator<<(OperationName val) {
   // An OperationName is stored in the context, so we don't need to worry about
   // the lifetime of its data.
   arguments.push_back(DiagnosticArgument(val.getStringRef()));
if (smloc.isValid())
       return mgr.PrintMessage(os, smloc, getDiagKind(kind), message);
   }
 
   // If the conversion was unsuccessful, create a diagnostic with the file
   // information. We manually combine the line and column to avoid asserts in
   // the constructor of SMDiagnostic that takes a location.
   std::string locStr;
   llvm::raw_string_ostream locOS(locStr);
-  locOS << fileLoc->getFilename() << ":" << fileLoc->getLine() << ":"
+  locOS << fileLoc->getFilename().getValue() << ":" << fileLoc->getLine() << ":"
         << fileLoc->getColumn();
   llvm::SMDiagnostic diag(locOS.str(), getDiagKind(kind), message.str());
   diag.print(nullptr, os);
 }
 
 /// Emit the given diagnostic with the held source manager.
 void SourceMgrDiagnosticHandler::emitDiagnostic(Diagnostic &diag) {
   SmallVector<std::pair<Location, StringRef>> locationStack;

mlir/lib/IR/MLIRContext.cpp

 #include "IntegerSetDetail.h"
 #include "TypeDetail.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
-#include "mlir/IR/Identifier.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Support/DebugAction.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/Mutex.h"
 #include "llvm/Support/RWMutex.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 
 #define DEBUG_TYPE "mlircontext"
 
 using namespace mlir;
public:
   //===--------------------------------------------------------------------===//
   // Debugging
   //===--------------------------------------------------------------------===//
 
   /// An action manager for use within the context.
   DebugActionManager debugActionManager;
 
   //===--------------------------------------------------------------------===//
-  // Identifier uniquing
-  //===--------------------------------------------------------------------===//
-
-  // Identifier allocator and mutex for thread safety.
-  llvm::BumpPtrAllocator identifierAllocator;
-  llvm::sys::SmartRWMutex<true> identifierMutex;
-
-  //===--------------------------------------------------------------------===//
   // Diagnostics
   //===--------------------------------------------------------------------===//
   DiagnosticEngine diagEngine;
 
   //===--------------------------------------------------------------------===//
   // Options
   //===--------------------------------------------------------------------===//
 
#endif
   /// The MLIRContext owns the objects.
   DenseMap<StringRef, std::unique_ptr<Dialect>> loadedDialects;
   DialectRegistry dialectsRegistry;
 
   /// This is a mapping from operation name to AbstractOperation for registered
   /// operations.
   llvm::StringMap<AbstractOperation> registeredOperations;
 
-  /// Identifiers are uniqued by string value and use the internal string set
-  /// for storage.
-  llvm::StringMap<PointerUnion<Dialect *, MLIRContext *>,
-                  llvm::BumpPtrAllocator &>
-      identifiers;
-
   /// An allocator used for AbstractAttribute and AbstractType objects.
   llvm::BumpPtrAllocator abstractDialectSymbolAllocator;
 
   //===--------------------------------------------------------------------===//
   // Affine uniquing
   //===--------------------------------------------------------------------===//
 
   // Affine allocator and mutex for thread safety.
#endif
 
   /// Cached Attribute Instances.
   BoolAttr falseAttr, trueAttr;
   UnitAttr unitAttr;
   UnknownLoc unknownLocAttr;
   DictionaryAttr emptyDictionaryAttr;
   StringAttr emptyStringAttr;
 
+  /// Map of string attributes that may reference a dialect, that are awaiting
+  /// that dialect to be loaded.
+  llvm::sys::SmartMutex<true> dialectRefStrAttrMutex;
+  DenseMap<StringRef, SmallVector<StringAttrStorage *>>
+      dialectReferencingStrAttrs;
+
 public:
   MLIRContextImpl(bool threadingIsEnabled)
-      : threadingIsEnabled(threadingIsEnabled),
-        identifiers(identifierAllocator) {
+      : threadingIsEnabled(threadingIsEnabled) {
     if (threadingIsEnabled) {
       ownedThreadPool = std::make_unique<llvm::ThreadPool>();
       threadPool = ownedThreadPool.get();
     }
   }
   ~MLIRContextImpl() {
     for (auto typeMapping : registeredTypes)
       typeMapping.second->~AbstractType();
if (impl.multiThreadedExecutionContext != 0)
           "missing `dependentDialects` in a pass for example.");
 #endif
     dialect = ctor();
     assert(dialect && "dialect ctor failed");
 
     // Refresh all the identifiers dialect field, this catches cases where a
     // dialect may be loaded after identifier prefixed with this dialect name
     // were already created.
-    llvm::SmallString<32> dialectPrefix(dialectNamespace);
-    dialectPrefix.push_back('.');
-    for (auto &identifierEntry : impl.identifiers)
-      if (identifierEntry.second.is<MLIRContext *>() &&
-          identifierEntry.first().startswith(dialectPrefix))
-        identifierEntry.second = dialect.get();
+    auto stringAttrsIt = impl.dialectReferencingStrAttrs.find(dialectNamespace);
+    if (stringAttrsIt != impl.dialectReferencingStrAttrs.end()) {
+      for (StringAttrStorage *storage : stringAttrsIt->second)
+        storage->referencedDialect = dialect.get();
+      impl.dialectReferencingStrAttrs.erase(stringAttrsIt);
+    }
 
     // Actually register the interfaces with delayed registration.
     impl.dialectsRegistry.registerDelayedInterfaces(dialect.get());
     return dialect.get();
   }
 
   // Abort if dialect with namespace has already been registered.
   if (dialect->getTypeID() != dialectID)
void AbstractOperation::insert(
   assert(impl.multiThreadedExecutionContext == 0 &&
          "Registering a new operation kind while in a multi-threaded execution "
          "context");
 
   // Register the attribute names of this operation.
   MutableArrayRef<Identifier> cachedAttrNames;
   if (!attrNames.empty()) {
     cachedAttrNames = MutableArrayRef<Identifier>(
-        impl.identifierAllocator.Allocate<Identifier>(attrNames.size()),
+        impl.abstractDialectSymbolAllocator.Allocate<Identifier>(
+            attrNames.size()),
         attrNames.size());
     for (unsigned i : llvm::seq<unsigned>(0, attrNames.size()))
       new (&cachedAttrNames[i]) Identifier(Identifier::get(attrNames[i], ctx));
   }
 
   // Register the information for this operation.
   AbstractOperation opInfo(
       name, dialect, typeID, std::move(parseAssembly), std::move(printAssembly),
AbstractType *AbstractType::lookupMutable(TypeID typeID, MLIRContext *context) {
   auto &impl = context->getImpl();
   auto it = impl.registeredTypes.find(typeID);
   if (it == impl.registeredTypes.end())
     return nullptr;
   return it->second;
 }
 
 //===----------------------------------------------------------------------===//
-// Identifier uniquing
-//===----------------------------------------------------------------------===//
-
-/// Return an identifier for the specified string.
-Identifier Identifier::get(const Twine &string, MLIRContext *context) {
-  SmallString<32> tempStr;
-  StringRef str = string.toStringRef(tempStr);
-
-  // Check invariants after seeing if we already have something in the
-  // identifier table - if we already had it in the table, then it already
-  // passed invariant checks.
-  assert(!str.empty() && "Cannot create an empty identifier");
-  assert(!str.contains('\0') &&
-         "Cannot create an identifier with a nul character");
-
-  auto getDialectOrContext = [&]() {
-    PointerUnion<Dialect *, MLIRContext *> dialectOrContext = context;
-    auto dialectNamePair = str.split('.');
-    if (!dialectNamePair.first.empty())
-      if (Dialect *dialect = context->getLoadedDialect(dialectNamePair.first))
-        dialectOrContext = dialect;
-    return dialectOrContext;
-  };
-
-  auto &impl = context->getImpl();
-  if (!context->isMultithreadingEnabled()) {
-    auto insertedIt = impl.identifiers.insert({str, nullptr});
-    if (insertedIt.second)
-      insertedIt.first->second = getDialectOrContext();
-    return Identifier(&*insertedIt.first);
-  }
-
-  // Check for an existing identifier in read-only mode.
-  {
-    llvm::sys::SmartScopedReader<true> contextLock(impl.identifierMutex);
-    auto it = impl.identifiers.find(str);
-    if (it != impl.identifiers.end())
-      return Identifier(&*it);
-  }
-
-  // Acquire a writer-lock so that we can safely create the new instance.
-  llvm::sys::SmartScopedWriter<true> contextLock(impl.identifierMutex);
-  auto it = impl.identifiers.insert({str, getDialectOrContext()}).first;
-  return Identifier(&*it);
-}
-
-Dialect *Identifier::getDialect() {
-  return entry->second.dyn_cast<Dialect *>();
-}
-
-MLIRContext *Identifier::getContext() {
-  if (Dialect *dialect = getDialect())
-    return dialect->getContext();
-  return entry->second.get<MLIRContext *>();
-}
-
-//===----------------------------------------------------------------------===//
 // Type uniquing
 //===----------------------------------------------------------------------===//
 
 /// Returns the storage uniquer used for constructing type storage instances.
 /// This should not be used directly.
 StorageUniquer &MLIRContext::getTypeUniquer() { return getImpl().typeUniquer; }
 
 BFloat16Type BFloat16Type::get(MLIRContext *context) {

 StorageUniquer &MLIRContext::getAttributeUniquer() {
   return getImpl().attributeUniquer;
 }
 
 /// Initialize the given attribute storage instance.
 void AttributeUniquer::initializeAttributeStorage(AttributeStorage *storage,
                                                   MLIRContext *ctx,
                                                   TypeID attrID) {
-  storage->initialize(AbstractAttribute::lookup(attrID, ctx));
+  storage->initializeAbstractAttribute(AbstractAttribute::lookup(attrID, ctx));
 
   // If the attribute did not provide a type, then default to NoneType.
   if (!storage->getType())
     storage->setType(NoneType::get(ctx));
 }
 
 BoolAttr BoolAttr::get(MLIRContext *context, bool value) {
   return value ? context->getImpl().trueAttr : context->getImpl().falseAttr;
 }
 
 UnitAttr UnitAttr::get(MLIRContext *context) {
   return context->getImpl().unitAttr;
 }
 
 UnknownLoc UnknownLoc::get(MLIRContext *context) {
   return context->getImpl().unknownLocAttr;
 }
 
 /// Return empty dictionary.
 DictionaryAttr DictionaryAttr::getEmpty(MLIRContext *context) {
   return context->getImpl().emptyDictionaryAttr;
 }
 
+void StringAttrStorage::initialize(MLIRContext *context) {
+  // Check for a dialect namespace prefix, if there isn't one we don't need to
+  // do any additional initialization.
+  auto dialectNamePair = value.split('.');
+  if (dialectNamePair.first.empty() || dialectNamePair.second.empty())
+    return;
+
+  // If one exists, we check to see if this dialect is loaded. If it is, we set
+  // the dialect now, if it isn't we record this storage for initialization
+  // later if the dialect ever gets loaded.
+  if ((referencedDialect = context->getLoadedDialect(dialectNamePair.first)))
+    return;
+
+  MLIRContextImpl &impl = context->getImpl();
+  llvm::sys::SmartScopedLock<true> lock(impl.dialectRefStrAttrMutex);
+  impl.dialectReferencingStrAttrs[dialectNamePair.first].push_back(this);
+}
+
 /// Return an empty string.
 StringAttr StringAttr::get(MLIRContext *context) {
   return context->getImpl().emptyStringAttr;
 }
 
 //===----------------------------------------------------------------------===//
 // AffineMap uniquing
 //===----------------------------------------------------------------------===//

mlir/lib/IR/OperationSupport.cpp

 /// Replaces the attributes with new list of attributes.
 void NamedAttrList::assign(const_iterator in_start, const_iterator in_end) {
   DictionaryAttr::sort(ArrayRef<NamedAttribute>{in_start, in_end}, attrs);
   dictionarySorted.setPointerAndInt(nullptr, true);
 }
 
 void NamedAttrList::push_back(NamedAttribute newAttribute) {
   assert(newAttribute.second && "unexpected null attribute");
-  if (isSorted())
-    dictionarySorted.setInt(
-        attrs.empty() ||
-        strcmp(attrs.back().first.data(), newAttribute.first.data()) < 0);
+  if (isSorted()) {
+    dictionarySorted.setInt(attrs.empty() ||
+                            attrs.back().first.compare(newAttribute.first) < 0);
+  }
   dictionarySorted.setPointer(nullptr);
   attrs.push_back(newAttribute);
 }
 
 /// Return the specified attribute if present, null otherwise.
 Attribute NamedAttrList::get(StringRef name) const {
   auto it = findAttr(*this, name);
   return it.second ? it.first->second : Attribute();

mlir/lib/IR/Verifier.cpp

LogicalResult OperationVerifier::verifyOperation(
   // Check that operands are non-nil and structurally ok.
   for (auto operand : op.getOperands())
     if (!operand)
       return op.emitError("null operand found");
 
   /// Verify that all of the attributes are okay.
   for (auto attr : op.getAttrs()) {
     // Check for any optional dialect specific attributes.
-    if (auto *dialect = attr.first.getDialect())
+    if (auto *dialect = attr.first.getReferencedDialect())
       if (failed(dialect->verifyOperationAttribute(&op, attr)))
         return failure();
   }
 
   // If we can get operation info for this, check the custom hook.
   OperationName opName = op.getName();
   auto *opInfo = opName.getAbstractOperation();
   if (opInfo && failed(opInfo->verifyInvariants(&op)))

mlir/lib/Interfaces/DataLayoutInterfaces.cpp

if (!dlType)
       return emitError(loc)
              << "data layout specified for a type that does not support it";
     if (failed(dlType.verifyEntries(kvp.second, loc)))
       return failure();
   }
 
   for (const auto &kvp : ids) {
     Identifier identifier = kvp.second.getKey().get<Identifier>();
-    Dialect *dialect = identifier.getDialect();
+    Dialect *dialect = identifier.getReferencedDialect();
 
     // Ignore attributes that belong to an unknown dialect, the dialect may
     // actually implement the relevant interface but we don't know about that.
     if (!dialect)
       continue;
 
     const auto *iface =
         dialect->getRegisteredInterface<DataLayoutDialectInterface>();

mlir/lib/Parser/AttributeParser.cpp

if (getToken().is(Token::string))
       nameId = builder.getIdentifier(getToken().getStringValue());
     else if (getToken().isAny(Token::bare_identifier, Token::inttype) ||
              getToken().isKeyword())
       nameId = builder.getIdentifier(getTokenSpelling());
     else
       return emitError("expected attribute name");
     if (!seenKeys.insert(*nameId).second)
       return emitError("duplicate key '")
-             << *nameId << "' in dictionary attribute";
+             << nameId->getValue() << "' in dictionary attribute";
     consumeToken();
 
     // Lazy load a dialect in the context if there is a possible namespace.
     auto splitName = nameId->strref().split('.');
     if (!splitName.second.empty())
       getContext()->getOrLoadDialect(splitName.first);
 
     // Try to parse the '=' for the attribute value.

mlir/lib/Parser/Parser.cpp

if (parseAssembly(*this, opState))
       return failure();
     // Verify that the parsed attributes does not have duplicate attributes.
     // This can happen if an attribute set during parsing is also specified in
     // the attribute dictionary in the assembly, or the attribute is set
     // multiple during parsing.
     Optional<NamedAttribute> duplicate = opState.attributes.findDuplicate();
     if (duplicate)
       return emitError(getNameLoc(), "attribute '")
-             << duplicate->first
+             << duplicate->first.getValue()
              << "' occurs more than once in the attribute list";
     return success();
   }
 
   Operation *parseGenericOperation(Block *insertBlock,
                                    Block::iterator insertPt) final {
     return parser.parseGenericOperation(insertBlock, insertPt);
   }

mlir/lib/Target/Cpp/TranslateToCpp.cpp

for (NamedAttribute attr : op.getAttrs()) {
         break;
       }
     }
   }
   // Emit attributes.
   auto emitNamedAttribute = [&](NamedAttribute attr) -> LogicalResult {
     if (llvm::is_contained(exclude, attr.first.strref()))
       return success();
-    os << "/* " << attr.first << " */";
+    os << "/* " << attr.first.getValue() << " */";
     if (failed(emitAttribute(op.getLoc(), attr.second)))
       return failure();
     return success();
   };
   return interleaveCommaWithError(op.getAttrs(), os, emitNamedAttribute);
 }
 
 LogicalResult CppEmitter::emitVariableAssignment(OpResult result) {

mlir/lib/Transforms/ViewOpGraph.cpp

return strFromOs([&](raw_ostream &os) {
         os << truncateString(ss.str()) << ")";
         os << ")";
       }
 
       // Print attributes.
       if (printAttrs) {
         os << "\n";
         for (const NamedAttribute &attr : op->getAttrs()) {
-          os << '\n' << attr.first << ": ";
+          os << '\n' << attr.first.getValue() << ": ";
           emitMlirAttr(os, attr.second);
         }
       }
     });
   }
 
   /// Generate a label for a block argument.
   std::string getLabel(BlockArgument arg) {

mlir/test/lib/Dialect/Linalg/TestLinalgTransforms.cpp

cyclicNprocsEqNiters.distributionMethod.resize(2,
                                                    DistributionMethod::Cyclic);
     cyclicNprocsEqNiters.procInfo =
         getGpuProcIds<gpu::BlockIdOp, gpu::GridDimOp>;
     patterns.add<LinalgTilingPattern<MatmulOp>>(
         context,
         LinalgTilingOptions()
             .setTileSizes({8, 8, 4})
             .setLoopType(LinalgTilingLoopType::Loops)
-            .setDistributionOptions(cyclicNprocsEqNiters),
         LinalgTransformationFilter(
             Identifier::get("tensors_distribute1", context),
             Identifier::get("tensors_after_distribute1", context)));
   }
 }
 
 static void
 applyMatmulToVectorPatterns(FuncOp funcOp,
                             bool testMatmulToVectorPatterns1dTiling,
                             bool testMatmulToVectorPatterns2dTiling) {
   MLIRContext *ctx = funcOp.getContext();
   SmallVector<RewritePatternSet, 4> stage1Patterns;
   if (testMatmulToVectorPatterns1dTiling) {
-    fillL1TilingAndMatmulToVectorPatterns(funcOp, Identifier::get("START", ctx),
-                                          stage1Patterns);
+    fillL1TilingAndMatmulToVectorPatterns(funcOp, "START", stage1Patterns);
   } else if (testMatmulToVectorPatterns2dTiling) {
     stage1Patterns.emplace_back(
         ctx, std::make_unique<LinalgTilingPattern<MatmulOp>>(
                  ctx,
                  LinalgTilingOptions()
                      .setTileSizes({768, 264, 768})
                      .setInterchange({1, 2, 0}),
                  LinalgTransformationFilter(Identifier::get("START", ctx),
                                             Identifier::get("L2", ctx))));
-    fillL1TilingAndMatmulToVectorPatterns(funcOp, Identifier::get("L2", ctx),
-                                          stage1Patterns);
+    fillL1TilingAndMatmulToVectorPatterns(funcOp, "L2", stage1Patterns);
   }
   {
     // Canonicalization patterns
     RewritePatternSet canonicalizationPatterns(funcOp.getContext());
     vector::populateVectorTransferPermutationMapLoweringPatterns(
         canonicalizationPatterns);
     vector::populateVectorReductionToContractPatterns(canonicalizationPatterns);
     stage1Patterns.push_back(std::move(canonicalizationPatterns));

mlir/test/lib/Dialect/Test/TestPatterns.cpp

 } // end anonymous namespace
 
 void TestDerivedAttributeDriver::runOnFunction() {
   getFunction().walk([](DerivedAttributeOpInterface dOp) {
     auto dAttr = dOp.materializeDerivedAttributes();
     if (!dAttr)
       return;
     for (auto d : dAttr)
-      dOp.emitRemark() << d.first << " = " << d.second;
+      dOp.emitRemark() << d.first.getValue() << " = " << d.second;
   });
 }
 
 //===----------------------------------------------------------------------===//
 // Legalization Driver.
 //===----------------------------------------------------------------------===//
 
 namespace {

mlir/test/lib/IR/TestPrintNesting.cpp

void printOperation(Operation *op) {
     // Print the operation itself and some of its properties
     printIndent() << "visiting op: '" << op->getName() << "' with "
                   << op->getNumOperands() << " operands and "
                   << op->getNumResults() << " results\n";
     // Print the operation attributes
     if (!op->getAttrs().empty()) {
       printIndent() << op->getAttrs().size() << " attributes:\n";
       for (NamedAttribute attr : op->getAttrs())
-        printIndent() << " - '" << attr.first << "' : '" << attr.second
-                      << "'\n";
+        printIndent() << " - '" << attr.first.getValue() << "' : '"
+                      << attr.second << "'\n";
     }
 
     // Recurse into each of the regions attached to the operation.
     printIndent() << " " << op->getNumRegions() << " nested regions:\n";
     auto indent = pushIndent();
     for (Region &region : op->getRegions())
       printRegion(region);
   }