[mlir] Convert NamedAttribute to be a class

[rriddle]

Summary

NamedAttribute is currently represented as an std::pair, but this
creates an extremely clunky .first/.second API. This commit
converts it to a class, with better accessors (getName/getValue)
and also opens the door for more convenient API in the future.

[mehdi_amini]

Nice! This std::pair was fairly annoying to me :)

[rriddle]

fix flang

[aartbik]

LGTM sparse/vector

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

 }
 
 def LLVM_OneResultOpBuilder :
   OpBuilder<(ins "Type":$resultType, "ValueRange":$operands,
     CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
     if (resultType) $_state.addTypes(resultType);
     $_state.addOperands(operands);
-    for (auto namedAttr : attributes) {
-      $_state.addAttribute(namedAttr.first, namedAttr.second);
-    }
+    for (auto namedAttr : attributes)
+      $_state.addAttribute(namedAttr.getName(), namedAttr.getValue());
   }]>;
 
 def LLVM_ZeroResultOpBuilder :
   OpBuilder<(ins "ValueRange":$operands,
     CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
     $_state.addOperands(operands);
-    for (auto namedAttr : attributes) {
-      $_state.addAttribute(namedAttr.first, namedAttr.second);
-    }
+    for (auto namedAttr : attributes)
+      $_state.addAttribute(namedAttr.getName(), namedAttr.getValue());
   }]>;
 
 // Compatibility builder that takes an instance of wrapped llvm::VoidType
 // to indicate no result.
 def LLVM_VoidResultTypeOpBuilder :
   OpBuilder<(ins "Type":$resultType, "ValueRange":$operands,
     CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{

mlir/include/mlir/IR/Attributes.h

 inline ::llvm::hash_code hash_value(Attribute arg) {
   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
-/// non-null.
-using NamedAttribute = std::pair<Identifier, Attribute>;
+/// NamedAttribute represents a combination of a name and an Attribute value.
+class NamedAttribute {
+public:
+  NamedAttribute(StringAttr name, Attribute value);
+
+  /// Return the name of the attribute.
+  StringAttr getName() const;
+
+  /// Return the dialect of the name of this attribute, if the name is prefixed
+  /// by a dialect namespace. For example, `llvm.fast_math` would return the
+  /// LLVM dialect (if it is loaded). Returns nullptr if the dialect isn't
+  /// loaded, or if the name is not prefixed by a dialect namespace.
+  Dialect *getNameDialect() const;
 
-bool operator<(const NamedAttribute &lhs, const NamedAttribute &rhs);
-bool operator<(const NamedAttribute &lhs, StringRef rhs);
+  /// Return the value of the attribute.
+  Attribute getValue() const { return value; }
+
+  /// Set the name of this attribute.
+  void setName(StringAttr newName);
+
+  /// Set the value of this attribute.
+  void setValue(Attribute newValue) {
+    assert(value && "expected valid attribute value");
+    value = newValue;
+  }
+
+  /// Compare this attribute to the provided attribute, ordering by name.
+  bool operator<(const NamedAttribute &rhs) const;
+  /// Compare this attribute to the provided string, ordering by name.
+  bool operator<(StringRef rhs) const;
+
+  bool operator==(const NamedAttribute &rhs) const {
+    return name == rhs.name && value == rhs.value;
+  }
+  bool operator!=(const NamedAttribute &rhs) const { return !(*this == rhs); }
+
+private:
+  NamedAttribute(Attribute name, Attribute value) : name(name), value(value) {}
+
+  /// Allow access to internals to enable hashing.
+  friend ::llvm::hash_code hash_value(const NamedAttribute &arg);
+  friend struct DenseMapInfo<mlir::NamedAttribute>;
+
+  /// The name of the attribute. This is represented as a StringAttr, but
+  /// type-erased to Attribute in the field.
+  Attribute name;
+  /// The value of the attribute.
+  Attribute value;
+};
+
+inline ::llvm::hash_code hash_value(const NamedAttribute &arg) {
+  using AttrPairT = std::pair<Attribute, Attribute>;
+  return DenseMapInfo<AttrPairT>::getHashValue(AttrPairT(arg.name, arg.value));
+}
 
 //===----------------------------------------------------------------------===//
 // AttributeTraitBase
 //===----------------------------------------------------------------------===//
 
 namespace AttributeTrait {
 /// This class represents the base of an attribute trait.
 template <typename ConcreteType, template <typename> class TraitType>
template <> struct PointerLikeTypeTraits<mlir::Attribute> {
   }
   static inline mlir::Attribute getFromVoidPointer(void *ptr) {
     return mlir::Attribute::getFromOpaquePointer(ptr);
   }
   static constexpr int NumLowBitsAvailable = llvm::PointerLikeTypeTraits<
       mlir::AttributeStorage *>::NumLowBitsAvailable;
 };
 
+template <>
+struct DenseMapInfo<mlir::NamedAttribute> {
+  static mlir::NamedAttribute getEmptyKey() {
+    auto emptyAttr = llvm::DenseMapInfo<mlir::Attribute>::getEmptyKey();
+    return mlir::NamedAttribute(emptyAttr, emptyAttr);
+  }
+  static mlir::NamedAttribute getTombstoneKey() {
+    auto tombAttr = llvm::DenseMapInfo<mlir::Attribute>::getTombstoneKey();
+    return mlir::NamedAttribute(tombAttr, tombAttr);
+  }
+  static unsigned getHashValue(mlir::NamedAttribute val) {
+    return mlir::hash_value(val);
+  }
+  static bool isEqual(mlir::NamedAttribute lhs, mlir::NamedAttribute rhs) {
+    return lhs == rhs;
+  }
+};
+
 } // namespace llvm
 
 #endif

mlir/include/mlir/IR/FunctionSupport.h

for (unsigned i = 0; i != numArgs; ++i) {
                                        "to be a DictionaryAttr, but got `"
                                     << allArgAttrs[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('.'))
+        if (!attr.getName().strref().contains('.'))
           return funcOp.emitOpError(
               "arguments may only have dialect attributes");
-        if (Dialect *dialect = attr.first.getReferencedDialect()) {
+        if (Dialect *dialect = attr.getNameDialect()) {
           if (failed(dialect->verifyRegionArgAttribute(op, /*regionIndex=*/0,
                                                        /*argIndex=*/i, attr)))
             return failure();
         }
       }
     }
   }
   if (ArrayAttr allResultAttrs = funcOp.getAllResultAttrs()) {
for (unsigned i = 0; i != numResults; ++i) {
                                        "to be a DictionaryAttr, but got `"
                                     << allResultAttrs[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('.'))
+        if (!attr.getName().strref().contains('.'))
           return funcOp.emitOpError("results may only have dialect attributes");
-        if (Dialect *dialect = attr.first.getReferencedDialect()) {
+        if (Dialect *dialect = attr.getNameDialect()) {
           if (failed(dialect->verifyRegionResultAttribute(op, /*regionIndex=*/0,
                                                           /*resultIndex=*/i,
                                                           attr)))
             return failure();
         }
       }
     }
   }

mlir/include/mlir/IR/Operation.h

public:
   }
 
   /// A utility iterator that filters out non-dialect attributes.
   class dialect_attr_iterator
       : public llvm::filter_iterator<ArrayRef<NamedAttribute>::iterator,
                                      bool (*)(NamedAttribute)> {
     static bool filter(NamedAttribute attr) {
       // Dialect attributes are prefixed by the dialect name, like operations.
-      return attr.first.strref().count('.');
+      return attr.getName().strref().count('.');
     }
 
     explicit dialect_attr_iterator(ArrayRef<NamedAttribute>::iterator it,
                                    ArrayRef<NamedAttribute>::iterator end)
         : llvm::filter_iterator<ArrayRef<NamedAttribute>::iterator,
                                 bool (*)(NamedAttribute)>(it, end, &filter) {}
 
     // Allow access to the constructor.
public:
   }
 
   /// Set the dialect attributes for this operation, and preserve all dependent.
   template <typename DialectAttrT>
   void setDialectAttrs(DialectAttrT &&dialectAttrs) {
     NamedAttrList attrs;
     attrs.append(std::begin(dialectAttrs), std::end(dialectAttrs));
     for (auto attr : getAttrs())
-      if (!attr.first.strref().contains('.'))
+      if (!attr.getName().strref().contains('.'))
         attrs.push_back(attr);
     setAttrs(attrs.getDictionary(getContext()));
   }
 
   //===--------------------------------------------------------------------===//
   // Blocks
   //===--------------------------------------------------------------------===//
 

mlir/include/mlir/IR/OperationSupport.h

 /// lookup functions.
 namespace impl {
 
 /// Unsorted string search or identifier lookups are linear scans.
 template <typename IteratorT, typename NameT>
 std::pair<IteratorT, bool> findAttrUnsorted(IteratorT first, IteratorT last,
                                             NameT name) {
   for (auto it = first; it != last; ++it)
-    if (it->first == name)
+    if (it->getName() == name)
       return {it, true};
   return {last, false};
 }
 
 /// Using llvm::lower_bound requires an extra string comparison to check whether
 /// the returned iterator points to the found element or whether it indicates
 /// the lower bound. Skip this redundant comparison by checking if `compare ==
 /// 0` during the binary search.
 template <typename IteratorT>
 std::pair<IteratorT, bool> findAttrSorted(IteratorT first, IteratorT last,
                                           StringRef name) {
   ptrdiff_t length = std::distance(first, last);
 
   while (length > 0) {
     ptrdiff_t half = length / 2;
     IteratorT mid = first + half;
-    int compare = mid->first.strref().compare(name);
+    int compare = mid->getName().strref().compare(name);
     if (compare < 0) {
       first = mid + 1;
       length = length - half - 1;
     } else if (compare > 0) {
       length = half;
     } else {
       return {mid, true};
     }

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.getReferencedDialect())) {
+            getInterfaceFor(attribute.getNameDialect())) {
       return iface->amendOperation(op, attribute, moduleTranslation);
     }
     return success();
   }
 };
 
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_LLVMTRANSLATIONINTERFACE_H

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

 intptr_t mlirDictionaryAttrGetNumElements(MlirAttribute attr) {
   return static_cast<intptr_t>(unwrap(attr).cast<DictionaryAttr>().size());
 }
 
 MlirNamedAttribute mlirDictionaryAttrGetElement(MlirAttribute attr,
                                                 intptr_t pos) {
   NamedAttribute attribute =
       unwrap(attr).cast<DictionaryAttr>().getValue()[pos];
-  return {wrap(attribute.first), wrap(attribute.second)};
+  return {wrap(attribute.getName()), wrap(attribute.getValue())};
 }
 
 MlirAttribute mlirDictionaryAttrGetElementByName(MlirAttribute attr,
                                                  MlirStringRef name) {
   return wrap(unwrap(attr).cast<DictionaryAttr>().get(unwrap(name)));
 }
 
 //===----------------------------------------------------------------------===//

mlir/lib/CAPI/IR/IR.cpp

 }
 
 intptr_t mlirOperationGetNumAttributes(MlirOperation op) {
   return static_cast<intptr_t>(unwrap(op)->getAttrs().size());
 }
 
 MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos) {
   NamedAttribute attr = unwrap(op)->getAttrs()[pos];
-  return MlirNamedAttribute{wrap(attr.first), wrap(attr.second)};
+  return MlirNamedAttribute{wrap(attr.getName()), wrap(attr.getValue())};
 }
 
 MlirAttribute mlirOperationGetAttributeByName(MlirOperation op,
                                               MlirStringRef name) {
   return wrap(unwrap(op)->getAttr(unwrap(name)));
 }
 
 void mlirOperationSetAttributeByName(MlirOperation op, MlirStringRef name,

mlir/lib/Conversion/GPUCommon/GPUOpsLowering.cpp

TypeConverter::SignatureConversion signatureConversion(
       gpuFuncOp.front().getNumArguments());
   getTypeConverter()->convertFunctionSignature(
       gpuFuncOp.getType(), /*isVariadic=*/false, signatureConversion);
 
   // Create the new function operation. Only copy those attributes that are
   // not specific to function modeling.
   SmallVector<NamedAttribute, 4> attributes;
   for (const auto &attr : gpuFuncOp->getAttrs()) {
-    if (attr.first == SymbolTable::getSymbolAttrName() ||
-        attr.first == function_like_impl::getTypeAttrName() ||
-        attr.first == gpu::GPUFuncOp::getNumWorkgroupAttributionsAttrName())
+    if (attr.getName() == SymbolTable::getSymbolAttrName() ||
+        attr.getName() == function_like_impl::getTypeAttrName() ||
+        attr.getName() == gpu::GPUFuncOp::getNumWorkgroupAttributionsAttrName())
       continue;
     attributes.push_back(attr);
   }
   // Add a dialect specific kernel attribute in addition to GPU kernel
   // attribute. The former is necessary for further translation while the
   // latter is expected by gpu.launch_func.
   if (gpuFuncOp.isKernel())
     attributes.emplace_back(kernelAttributeName, rewriter.getUnitAttr());

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp

for (auto argType : enumerate(funcOp.getType().getInputs())) {
       signatureConverter.addInputs(argType.index(), convertedType);
     }
   }
   auto newFuncOp = rewriter.create<spirv::FuncOp>(
       funcOp.getLoc(), funcOp.getName(),
       rewriter.getFunctionType(signatureConverter.getConvertedTypes(),
                                llvm::None));
   for (const auto &namedAttr : funcOp->getAttrs()) {
-    if (namedAttr.first == function_like_impl::getTypeAttrName() ||
-        namedAttr.first == SymbolTable::getSymbolAttrName())
+    if (namedAttr.getName() == function_like_impl::getTypeAttrName() ||
+        namedAttr.getName() == SymbolTable::getSymbolAttrName())
       continue;
-    newFuncOp->setAttr(namedAttr.first, namedAttr.second);
+    newFuncOp->setAttr(namedAttr.getName(), namedAttr.getValue());
   }
 
   rewriter.inlineRegionBefore(funcOp.getBody(), newFuncOp.getBody(),
                               newFuncOp.end());
   if (failed(rewriter.convertRegionTypes(&newFuncOp.getBody(), typeConverter,
                                          &signatureConverter)))
     return nullptr;
   rewriter.eraseOp(funcOp);

mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp

if (isMappedToProcessor(processor)) {
       worklist.push_back(launchOp.getOperation());
     }
     cloningMap.map(iv, newIndex);
   }
 
   // Propagate custom user defined optional attributes, that can be used at
   // later stage, such as extension data for GPU kernel dispatch
   for (const auto &namedAttr : parallelOp->getAttrs()) {
-    if (namedAttr.first == gpu::getMappingAttrName() ||
-        namedAttr.first == ParallelOp::getOperandSegmentSizeAttr())
+    if (namedAttr.getName() == gpu::getMappingAttrName() ||
+        namedAttr.getName() == ParallelOp::getOperandSegmentSizeAttr())
       continue;
-    launchOp->setAttr(namedAttr.first, namedAttr.second);
+    launchOp->setAttr(namedAttr.getName(), namedAttr.getValue());
   }
 
   Block *body = parallelOp.getBody();
   worklist.reserve(worklist.size() + body->getOperations().size());
   for (Operation &op : llvm::reverse(body->without_terminator()))
     worklist.push_back(&op);
   return success();
 }

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 
 /// Only retain those attributes that are not constructed by
 /// `LLVMFuncOp::build`. If `filterArgAttrs` is set, also filter out argument
 /// attributes.
 static void filterFuncAttributes(ArrayRef<NamedAttribute> attrs,
                                  bool filterArgAttrs,
                                  SmallVectorImpl<NamedAttribute> &result) {
   for (const auto &attr : attrs) {
-    if (attr.first == SymbolTable::getSymbolAttrName() ||
-        attr.first == function_like_impl::getTypeAttrName() ||
-        attr.first == "std.varargs" ||
+    if (attr.getName() == SymbolTable::getSymbolAttrName() ||
+        attr.getName() == function_like_impl::getTypeAttrName() ||
+        attr.getName() == "std.varargs" ||
         (filterArgAttrs &&
-         attr.first == function_like_impl::getArgDictAttrName()))
+         attr.getName() == function_like_impl::getArgDictAttrName()))
       continue;
     result.push_back(attr);
   }
 }
 
 /// Creates an auxiliary function with pointer-to-memref-descriptor-struct
 /// arguments instead of unpacked arguments. This function can be called from C
 /// by passing a pointer to a C struct corresponding to a memref descriptor.
if (ArrayAttr argAttrDicts = funcOp.getAllArgAttrs()) {
         for (size_t j = 0; j < mapping->size; ++j)
           newArgAttrs[mapping->inputNo + j] = argAttrDicts[i];
       }
       attributes.push_back(
           rewriter.getNamedAttr(function_like_impl::getArgDictAttrName(),
                                 rewriter.getArrayAttr(newArgAttrs)));
     }
     for (auto pair : llvm::enumerate(attributes)) {
-      if (pair.value().first == "llvm.linkage") {
+      if (pair.value().getName() == "llvm.linkage") {
         attributes.erase(attributes.begin() + pair.index());
         break;
       }
     }
 
     // Create an LLVM function, use external linkage by default until MLIR
     // functions have linkage.
     LLVM::Linkage linkage = LLVM::Linkage::External;
matchAndRewrite(ConstantOp op, OpAdaptor adaptor,
     if (auto symbolRef = op.getValue().dyn_cast<FlatSymbolRefAttr>()) {
       auto type = typeConverter->convertType(op.getResult().getType());
       if (!type || !LLVM::isCompatibleType(type))
         return rewriter.notifyMatchFailure(op, "failed to convert result type");
 
       auto newOp = rewriter.create<LLVM::AddressOfOp>(op.getLoc(), type,
                                                       symbolRef.getValue());
       for (const NamedAttribute &attr : op->getAttrs()) {
-        if (attr.first.strref() == "value")
+        if (attr.getName().strref() == "value")
           continue;
-        newOp->setAttr(attr.first, attr.second);
+        newOp->setAttr(attr.getName(), attr.getValue());
       }
       rewriter.replaceOp(op, newOp->getResults());
       return success();
     }
 
     // Calling into other scopes (non-flat reference) is not supported in LLVM.
     if (op.getValue().isa<SymbolRefAttr>())
       return rewriter.notifyMatchFailure(

mlir/lib/Dialect/Affine/Transforms/SimplifyAffineStructures.cpp

void SimplifyAffineStructures::runOnFunction() {
   AffineIfOp::getCanonicalizationPatterns(patterns, func.getContext());
   FrozenRewritePatternSet frozenPatterns(std::move(patterns));
 
   // The simplification of affine attributes will likely simplify the op. Try to
   // fold/apply canonicalization patterns when we have affine dialect ops.
   SmallVector<Operation *> opsToSimplify;
   func.walk([&](Operation *op) {
     for (auto attr : op->getAttrs()) {
-      if (auto mapAttr = attr.second.dyn_cast<AffineMapAttr>())
-        simplifyAndUpdateAttribute(op, attr.first, mapAttr);
-      else if (auto setAttr = attr.second.dyn_cast<IntegerSetAttr>())
-        simplifyAndUpdateAttribute(op, attr.first, setAttr);
+      if (auto mapAttr = attr.getValue().dyn_cast<AffineMapAttr>())
+        simplifyAndUpdateAttribute(op, attr.getName(), mapAttr);
+      else if (auto setAttr = attr.getValue().dyn_cast<IntegerSetAttr>())
+        simplifyAndUpdateAttribute(op, attr.getName(), setAttr);
     }
 
     if (isa<AffineForOp, AffineIfOp, AffineApplyOp>(op))
       opsToSimplify.push_back(op);
   });
   (void)applyOpPatternsAndFold(opsToSimplify, frozenPatterns, /*strict=*/true);
 }

mlir/lib/Dialect/DLTI/DLTI.cpp

void DLTIDialect::printAttribute(Attribute attr, DialectAsmPrinter &os) const {
   llvm::TypeSwitch<Attribute>(attr)
       .Case<DataLayoutEntryAttr, DataLayoutSpecAttr>(
           [&](auto a) { a.print(os); })
       .Default([](Attribute) { llvm_unreachable("unknown attribute kind"); });
 }
 
 LogicalResult DLTIDialect::verifyOperationAttribute(Operation *op,
                                                     NamedAttribute attr) {
-  if (attr.first == DLTIDialect::kDataLayoutAttrName) {
-    if (!attr.second.isa<DataLayoutSpecAttr>()) {
+  if (attr.getName() == DLTIDialect::kDataLayoutAttrName) {
+    if (!attr.getValue().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.getValue()
+  return op->emitError() << "attribute '" << attr.getName().getValue()
                          << "' not supported by dialect";
 }

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

TypeSwitch<Type>(type)
         os << shape.back() << 'x' << fragTy.getElementType();
         os << ", \"" << fragTy.getOperand() << "\"" << '>';
       })
       .Default([](Type) { llvm_unreachable("unexpected 'gpu' type kind"); });
 }
 
 LogicalResult GPUDialect::verifyOperationAttribute(Operation *op,
                                                    NamedAttribute attr) {
-  if (!attr.second.isa<UnitAttr>() ||
-      attr.first != getContainerModuleAttrName())
+  if (!attr.getValue().isa<UnitAttr>() ||
+      attr.getName() != getContainerModuleAttrName())
     return success();
 
   auto module = dyn_cast<ModuleOp>(op);
   if (!module)
     return op->emitError("expected '")
            << getContainerModuleAttrName() << "' attribute to be attached to '"
            << ModuleOp::getOperationName() << '\'';
 

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

 #include "mlir/Dialect/LLVMIR/LLVMOpsEnums.cpp.inc"
 #include "mlir/Dialect/LLVMIR/LLVMOpsInterfaces.cpp.inc"
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/LLVMIR/LLVMOpsAttrDefs.cpp.inc"
 
 static auto processFMFAttr(ArrayRef<NamedAttribute> attrs) {
   SmallVector<NamedAttribute, 8> filteredAttrs(
       llvm::make_filter_range(attrs, [&](NamedAttribute attr) {
-        if (attr.first == "fastmathFlags") {
-          auto defAttr = FMFAttr::get(attr.second.getContext(), {});
-          return defAttr != attr.second;
+        if (attr.getName() == "fastmathFlags") {
+          auto defAttr = FMFAttr::get(attr.getValue().getContext(), {});
+          return defAttr != attr.getValue();
         }
         return true;
       }));
   return filteredAttrs;
 }
 
 static ParseResult parseLLVMOpAttrs(OpAsmParser &parser,
                                     NamedAttrList &result) {
if (parser.parseOperand(arraySize) || parser.parseKeyword("x") ||
       parser.parseType(elemType) ||
       parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
       parser.getCurrentLocation(&trailingTypeLoc) || parser.parseType(type))
     return failure();
 
   Optional<NamedAttribute> alignmentAttr =
       result.attributes.getNamed("alignment");
   if (alignmentAttr.hasValue()) {
-    auto alignmentInt = alignmentAttr.getValue().second.dyn_cast<IntegerAttr>();
+    auto alignmentInt =
+        alignmentAttr.getValue().getValue().dyn_cast<IntegerAttr>();
     if (!alignmentInt)
       return parser.emitError(parser.getNameLoc(),
                               "expected integer alignment");
     if (alignmentInt.getValue().isNullValue())
       result.attributes.erase("alignment");
   }
 
   // Extract the result type from the trailing function type.
LogicalResult LLVMDialect::verifyDataLayoutString(
   return failure();
 }
 
 /// Verify LLVM dialect attributes.
 LogicalResult LLVMDialect::verifyOperationAttribute(Operation *op,
                                                     NamedAttribute attr) {
   // If the `llvm.loop` attribute is present, enforce the following structure,
   // which the module translation can assume.
-  if (attr.first.strref() == LLVMDialect::getLoopAttrName()) {
-    auto loopAttr = attr.second.dyn_cast<DictionaryAttr>();
+  if (attr.getName() == LLVMDialect::getLoopAttrName()) {
+    auto loopAttr = attr.getValue().dyn_cast<DictionaryAttr>();
     if (!loopAttr)
       return op->emitOpError() << "expected '" << LLVMDialect::getLoopAttrName()
                                << "' to be a dictionary attribute";
     Optional<NamedAttribute> parallelAccessGroup =
         loopAttr.getNamed(LLVMDialect::getParallelAccessAttrName());
     if (parallelAccessGroup.hasValue()) {
-      auto accessGroups = parallelAccessGroup->second.dyn_cast<ArrayAttr>();
+      auto accessGroups = parallelAccessGroup->getValue().dyn_cast<ArrayAttr>();
       if (!accessGroups)
         return op->emitOpError()
                << "expected '" << LLVMDialect::getParallelAccessAttrName()
                << "' to be an array attribute";
       for (Attribute attr : accessGroups) {
         auto accessGroupRef = attr.dyn_cast<SymbolRefAttr>();
         if (!accessGroupRef)
           return op->emitOpError()
if (parallelAccessGroup.hasValue()) {
         if (!accessGroupOp)
           return op->emitOpError()
                  << "expected '" << attr << "' to reference an access_group op";
       }
     }
 
     Optional<NamedAttribute> loopOptions =
         loopAttr.getNamed(LLVMDialect::getLoopOptionsAttrName());
-    if (loopOptions.hasValue() && !loopOptions->second.isa<LoopOptionsAttr>())
+    if (loopOptions.hasValue() &&
+        !loopOptions->getValue().isa<LoopOptionsAttr>())
       return op->emitOpError()
              << "expected '" << LLVMDialect::getLoopOptionsAttrName()
              << "' to be a `loopopts` attribute";
   }
 
   // If the data layout attribute is present, it must use the LLVM data layout
   // syntax. Try parsing it and report errors in case of failure. Users of this
   // attribute may assume it is well-formed and can pass it to the (asserting)
   // llvm::DataLayout constructor.
-  if (attr.first.strref() != LLVM::LLVMDialect::getDataLayoutAttrName())
+  if (attr.getName() != LLVM::LLVMDialect::getDataLayoutAttrName())
     return success();
-  if (auto stringAttr = attr.second.dyn_cast<StringAttr>())
+  if (auto stringAttr = attr.getValue().dyn_cast<StringAttr>())
     return verifyDataLayoutString(
         stringAttr.getValue(),
         [op](const Twine &message) { op->emitOpError() << message.str(); });
 
   return op->emitOpError() << "expected '"
                            << LLVM::LLVMDialect::getDataLayoutAttrName()
                            << "' to be a string attribute";
 }
 
 /// Verify LLVMIR function argument attributes.
 LogicalResult LLVMDialect::verifyRegionArgAttribute(Operation *op,
                                                     unsigned regionIdx,
                                                     unsigned argIdx,
                                                     NamedAttribute argAttr) {
   // Check that llvm.noalias is a unit attribute.
-  if (argAttr.first == LLVMDialect::getNoAliasAttrName() &&
-      !argAttr.second.isa<UnitAttr>())
+  if (argAttr.getName() == LLVMDialect::getNoAliasAttrName() &&
+      !argAttr.getValue().isa<UnitAttr>())
     return op->emitError()
            << "expected llvm.noalias argument attribute to be a unit attribute";
   // Check that llvm.align is an integer attribute.
-  if (argAttr.first == LLVMDialect::getAlignAttrName() &&
-      !argAttr.second.isa<IntegerAttr>())
+  if (argAttr.getName() == LLVMDialect::getAlignAttrName() &&
+      !argAttr.getValue().isa<IntegerAttr>())
     return op->emitError()
            << "llvm.align argument attribute of non integer type";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Utility functions.
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp

static ParseResult parseNVVMShflSyncBflyOp(OpAsmParser &parser,
   Type resultType;
   if (parser.parseOperandList(ops) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(resultType) ||
       parser.addTypeToList(resultType, result.types))
     return failure();
 
   for (auto &attr : result.attributes) {
-    if (attr.first != "return_value_and_is_valid")
+    if (attr.getName() != "return_value_and_is_valid")
       continue;
     auto structType = resultType.dyn_cast<LLVM::LLVMStructType>();
     if (structType && !structType.getBody().empty())
       resultType = structType.getBody()[0];
     break;
   }
 
   auto int32Ty = IntegerType::get(parser.getContext(), 32);
#include "mlir/Dialect/LLVMIR/NVVMOps.cpp.inc"
   // Support unknown operations because not all NVVM operations are
   // registered.
   allowUnknownOperations();
 }
 
 LogicalResult NVVMDialect::verifyOperationAttribute(Operation *op,
                                                     NamedAttribute attr) {
   // Kernel function attribute should be attached to functions.
-  if (attr.first == NVVMDialect::getKernelFuncAttrName()) {
+  if (attr.getName() == NVVMDialect::getKernelFuncAttrName()) {
     if (!isa<LLVM::LLVMFuncOp>(op)) {
       return op->emitError() << "'" << NVVMDialect::getKernelFuncAttrName()
                              << "' attribute attached to unexpected op";
     }
   }
   return success();
 }
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/NVVMOps.cpp.inc"

mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp

#include "mlir/Dialect/LLVMIR/ROCDLOps.cpp.inc"
 
   // Support unknown operations because not all ROCDL operations are registered.
   allowUnknownOperations();
 }
 
 LogicalResult ROCDLDialect::verifyOperationAttribute(Operation *op,
                                                      NamedAttribute attr) {
   // Kernel function attribute should be attached to functions.
-  if (attr.first == ROCDLDialect::getKernelFuncAttrName()) {
+  if (attr.getName() == ROCDLDialect::getKernelFuncAttrName()) {
     if (!isa<LLVM::LLVMFuncOp>(op)) {
       return op->emitError() << "'" << ROCDLDialect::getKernelFuncAttrName()
                              << "' attribute attached to unexpected op";
     }
   }
   return success();
 }
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/ROCDLOps.cpp.inc"

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

static void print(OpAsmPrinter &p, GenericOp op) {
 
   // Print extra attributes.
   auto genericAttrNames = op.linalgTraitAttrNames();
 
   llvm::StringSet<> genericAttrNamesSet;
   genericAttrNamesSet.insert(genericAttrNames.begin(), genericAttrNames.end());
   SmallVector<NamedAttribute, 8> genericAttrs;
   for (auto attr : op->getAttrs())
-    if (genericAttrNamesSet.count(attr.first.strref()) > 0)
+    if (genericAttrNamesSet.count(attr.getName().strref()) > 0)
       genericAttrs.push_back(attr);
   if (!genericAttrs.empty()) {
     auto genericDictAttr = DictionaryAttr::get(op.getContext(), genericAttrs);
     p << genericDictAttr;
   }
 
   // Printing is shared with named ops, except for the region and attributes
   printCommonStructuredOpParts(p, op);
 
   genericAttrNames.push_back("operand_segment_sizes");
   genericAttrNamesSet.insert(genericAttrNames.back());
 
   bool hasExtraAttrs = false;
   for (NamedAttribute n : op->getAttrs()) {
-    if ((hasExtraAttrs = !genericAttrNamesSet.contains(n.first.strref())))
+    if ((hasExtraAttrs = !genericAttrNamesSet.contains(n.getName().strref())))
       break;
   }
   if (hasExtraAttrs) {
     p << " attrs = ";
     p.printOptionalAttrDict(op->getAttrs(), /*elidedAttrs=*/genericAttrNames);
   }
 
   // Print region.
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.getValue())) {
-        newOp->setAttr(kv.first, kv.second);
+      if (!llvm::is_contained(odsAttrs, kv.getName().getValue())) {
+        newOp->setAttr(kv.getName(), kv.getValue());
       }
     }
 
     rewriter.inlineRegionBefore(genericOp.region(), newOp.region(),
                                 newOp.region().begin());
 
     // Repair the payload entry block by RAUW'ing redundant arguments and
     // erasing them.

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

void mlir::linalg::LinalgDialect::printType(Type type,
                                             DialectAsmPrinter &os) const {
   print(type.cast<RangeType>(), os);
 }
 
 LogicalResult LinalgDialect::verifyOperationAttribute(Operation *op,
                                                       NamedAttribute attr) {
   using comprehensive_bufferize::BufferizableOpInterface;
 
-  if (attr.first == BufferizableOpInterface::kInplaceableAttrName) {
-    if (!attr.second.isa<BoolAttr>()) {
+  if (attr.getName() == BufferizableOpInterface::kInplaceableAttrName) {
+    if (!attr.getValue().isa<BoolAttr>()) {
       return op->emitError()
              << "'" << BufferizableOpInterface::kInplaceableAttrName
              << "' is expected to be a boolean attribute";
     }
     if (!op->hasTrait<OpTrait::FunctionLike>())
-      return op->emitError() << "expected " << attr.first
+      return op->emitError() << "expected " << attr.getName()
                              << " to be used on function-like operations";
     return success();
   }
-  if (attr.first == BufferizableOpInterface::kBufferLayoutAttrName) {
-    if (!attr.second.isa<AffineMapAttr>()) {
+  if (attr.getName() == BufferizableOpInterface::kBufferLayoutAttrName) {
+    if (!attr.getValue().isa<AffineMapAttr>()) {
       return op->emitError()
              << "'" << BufferizableOpInterface::kBufferLayoutAttrName
              << "' is expected to be a affine map attribute";
     }
     if (!op->hasTrait<OpTrait::FunctionLike>())
-      return op->emitError() << "expected " << attr.first
+      return op->emitError() << "expected " << attr.getName()
                              << " to be used on function-like operations";
     return success();
   }
-  if (attr.first == LinalgDialect::kMemoizedIndexingMapsAttrName)
+  if (attr.getName() == LinalgDialect::kMemoizedIndexingMapsAttrName)
     return success();
-  return op->emitError() << "attribute '" << attr.first
+  return op->emitError() << "attribute '" << attr.getName()
                          << "' not supported by the linalg dialect";
 }

mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Shader Interface ABI
 //===----------------------------------------------------------------------===//
 
 LogicalResult SPIRVDialect::verifyOperationAttribute(Operation *op,
                                                      NamedAttribute attribute) {
-  StringRef symbol = attribute.first.strref();
-  Attribute attr = attribute.second;
+  StringRef symbol = attribute.getName().strref();
+  Attribute attr = attribute.getValue();
 
   // TODO: figure out a way to generate the description from the
   // StructAttr definition.
   if (symbol == spirv::getEntryPointABIAttrName()) {
     if (!attr.isa<spirv::EntryPointABIAttr>())
       return op->emitError("'")
              << symbol
              << "' attribute must be a dictionary attribute containing one "
                 "32-bit integer elements attribute: 'local_size'";
   } else if (symbol == spirv::getTargetEnvAttrName()) {
     if (!attr.isa<spirv::TargetEnvAttr>())
       return op->emitError("'") << symbol << "' must be a spirv::TargetEnvAttr";
   } else {
     return op->emitError("found unsupported '")
            << symbol << "' attribute on operation";
   }
 
   return success();
 }
 
 /// Verifies the given SPIR-V `attribute` attached to a value of the given
 /// `valueType` is valid.
 static LogicalResult verifyRegionAttribute(Location loc, Type valueType,
                                            NamedAttribute attribute) {
-  StringRef symbol = attribute.first.strref();
-  Attribute attr = attribute.second;
+  StringRef symbol = attribute.getName().strref();
+  Attribute attr = attribute.getValue();
 
   if (symbol != spirv::getInterfaceVarABIAttrName())
     return emitError(loc, "found unsupported '")
            << symbol << "' attribute on region argument";
 
   auto varABIAttr = attr.dyn_cast<spirv::InterfaceVarABIAttr>();
   if (!varABIAttr)
     return emitError(loc, "'")

mlir/lib/Dialect/SPIRV/Linking/ModuleCombiner/ModuleCombiner.cpp

 ///
 /// Note: We use the operation's name (not the symbol name) as part of the hash
 /// computation. This prevents, for example, mistakenly considering a global
 /// variable and a spec constant as duplicates because their descriptor set +
 /// binding and spec_id, respectively, happen to hash to the same value.
 static llvm::hash_code computeHash(SymbolOpInterface symbolOp) {
   auto range =
       llvm::make_filter_range(symbolOp->getAttrs(), [](NamedAttribute attr) {
-        return attr.first != SymbolTable::getSymbolAttrName();
+        return attr.getName() != SymbolTable::getSymbolAttrName();
       });
 
   return llvm::hash_combine(
       symbolOp->getName(),
       llvm::hash_combine_range(range.begin(), range.end()));
 }
 
 namespace mlir {

mlir/lib/Dialect/SPIRV/Transforms/DecorateCompositeTypeLayoutPass.cpp

LogicalResult matchAndRewrite(spirv::GlobalVariableOp op,
     if (!structType)
       return failure();
 
     auto decoratedType =
         spirv::PointerType::get(structType, ptrType.getStorageClass());
 
     // Save all named attributes except "type" attribute.
     for (const auto &attr : op->getAttrs()) {
-      if (attr.first == "type") {
+      if (attr.getName() == "type")
         continue;
-      }
       globalVarAttrs.push_back(attr);
     }
 
     rewriter.replaceOpWithNewOp<spirv::GlobalVariableOp>(
         op, TypeAttr::get(decoratedType), globalVarAttrs);
     return success();
   }
 };

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

FuncOpConversion::matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor,
   auto newFuncOp = rewriter.create<spirv::FuncOp>(
       funcOp.getLoc(), funcOp.getName(),
       rewriter.getFunctionType(signatureConverter.getConvertedTypes(),
                                resultType ? TypeRange(resultType)
                                           : TypeRange()));
 
   // Copy over all attributes other than the function name and type.
   for (const auto &namedAttr : funcOp->getAttrs()) {
-    if (namedAttr.first != function_like_impl::getTypeAttrName() &&
-        namedAttr.first != SymbolTable::getSymbolAttrName())
-      newFuncOp->setAttr(namedAttr.first, namedAttr.second);
+    if (namedAttr.getName() != function_like_impl::getTypeAttrName() &&
+        namedAttr.getName() != SymbolTable::getSymbolAttrName())
+      newFuncOp->setAttr(namedAttr.getName(), namedAttr.getValue());
   }
 
   rewriter.inlineRegionBefore(funcOp.getBody(), newFuncOp.getBody(),
                               newFuncOp.end());
   if (failed(rewriter.convertRegionTypes(
           &newFuncOp.getBody(), *getTypeConverter(), &signatureConverter)))
     return failure();
   rewriter.eraseOp(funcOp);

mlir/lib/Dialect/Shape/IR/Shape.cpp

TypeSwitch<Type>(type)
       .Case<ValueShapeType>([&](Type) { os << "value_shape"; })
       .Case<WitnessType>([&](Type) { os << "witness"; })
       .Default([](Type) { llvm_unreachable("unexpected 'shape' type kind"); });
 }
 
 LogicalResult ShapeDialect::verifyOperationAttribute(Operation *op,
                                                      NamedAttribute attribute) {
   // Verify shape.lib attribute.
-  if (attribute.first == "shape.lib") {
+  if (attribute.getName() == "shape.lib") {
     if (!op->hasTrait<OpTrait::SymbolTable>())
       return op->emitError(
           "shape.lib attribute may only be on op implementing SymbolTable");
 
-    if (auto symbolRef = attribute.second.dyn_cast<SymbolRefAttr>()) {
+    if (auto symbolRef = attribute.getValue().dyn_cast<SymbolRefAttr>()) {
       auto *symbol = SymbolTable::lookupSymbolIn(op, symbolRef);
       if (!symbol)
         return op->emitError("shape function library ")
                << symbolRef << " not found";
       return isa<shape::FunctionLibraryOp>(symbol)
                  ? success()
                  : op->emitError()
                        << symbolRef << " required to be shape function library";
     }
 
-    if (auto arr = attribute.second.dyn_cast<ArrayAttr>()) {
+    if (auto arr = attribute.getValue().dyn_cast<ArrayAttr>()) {
       // Verify all entries are function libraries and mappings in libraries
       // refer to unique ops.
       DenseSet<Identifier> key;
       for (auto it : arr) {
         if (!it.isa<SymbolRefAttr>())
           return op->emitError(
               "only SymbolRefAttr allowed in shape.lib attribute array");
 
         auto shapeFnLib = dyn_cast<shape::FunctionLibraryOp>(
             SymbolTable::lookupSymbolIn(op, it.cast<SymbolRefAttr>()));
         if (!shapeFnLib)
           return op->emitError()
                  << it << " does not refer to FunctionLibraryOp";
         for (auto mapping : shapeFnLib.getMapping()) {
-          if (!key.insert(mapping.first).second) {
+          if (!key.insert(mapping.getName()).second) {
             return op->emitError("only one op to shape mapping allowed, found "
                                  "multiple for `")
-                   << mapping.first << "`";
+                   << mapping.getName() << "`";
           }
         }
       }
       return success();
     }
 
     return op->emitError("only SymbolRefAttr or array of SymbolRefAttrs "
                          "allowed as shape.lib attribute");

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

Attribute SparseTensorEncodingAttr::parse(AsmParser &parser, Type type) {
   if (failed(parser.parseGreater()))
     return {};
   // Process the data from the parsed dictionary value into struct-like data.
   SmallVector<SparseTensorEncodingAttr::DimLevelType, 4> dlt;
   AffineMap map = {};
   unsigned ptr = 0;
   unsigned ind = 0;
   for (const NamedAttribute &attr : dict) {
-    if (attr.first == "dimLevelType") {
-      auto arrayAttr = attr.second.dyn_cast<ArrayAttr>();
+    if (attr.getName() == "dimLevelType") {
+      auto arrayAttr = attr.getValue().dyn_cast<ArrayAttr>();
       if (!arrayAttr) {
         parser.emitError(parser.getNameLoc(),
                          "expected an array for dimension level types");
         return {};
       }
       for (unsigned i = 0, e = arrayAttr.size(); i < e; i++) {
         auto strAttr = arrayAttr[i].dyn_cast<StringAttr>();
         if (!strAttr) {
if (attr.getName() == "dimLevelType") {
           dlt.push_back(SparseTensorEncodingAttr::DimLevelType::Singleton);
         } else {
           parser.emitError(parser.getNameLoc(),
                            "unexpected dimension level type: ")
               << strVal;
           return {};
         }
       }
-    } else if (attr.first == "dimOrdering") {
-      auto affineAttr = attr.second.dyn_cast<AffineMapAttr>();
+    } else if (attr.getName() == "dimOrdering") {
+      auto affineAttr = attr.getValue().dyn_cast<AffineMapAttr>();
       if (!affineAttr) {
         parser.emitError(parser.getNameLoc(),
                          "expected an affine map for dimension ordering");
         return {};
       }
       map = affineAttr.getValue();
-    } else if (attr.first == "pointerBitWidth") {
-      auto intAttr = attr.second.dyn_cast<IntegerAttr>();
+    } else if (attr.getName() == "pointerBitWidth") {
+      auto intAttr = attr.getValue().dyn_cast<IntegerAttr>();
       if (!intAttr) {
         parser.emitError(parser.getNameLoc(),
                          "expected an integral pointer bitwidth");
         return {};
       }
       ptr = intAttr.getInt();
-    } else if (attr.first == "indexBitWidth") {
-      auto intAttr = attr.second.dyn_cast<IntegerAttr>();
+    } else if (attr.getName() == "indexBitWidth") {
+      auto intAttr = attr.getValue().dyn_cast<IntegerAttr>();
       if (!intAttr) {
         parser.emitError(parser.getNameLoc(),
                          "expected an integral index bitwidth");
         return {};
       }
       ind = intAttr.getInt();
     } else {
       parser.emitError(parser.getNameLoc(), "unexpected key: ")
-          << attr.first.str();
+          << attr.getName().strref();
       return {};
     }
   }
   // Construct struct-like storage for attribute.
   return parser.getChecked<SparseTensorEncodingAttr>(parser.getContext(), dlt,
                                                      map, ptr, ind);
 }
 

mlir/lib/Dialect/Vector/VectorOps.cpp

 
 static void print(OpAsmPrinter &p, ContractionOp op) {
   // TODO: Unify printing code with linalg ops.
   auto attrNames = op.getTraitAttrNames();
   llvm::StringSet<> traitAttrsSet;
   traitAttrsSet.insert(attrNames.begin(), attrNames.end());
   SmallVector<NamedAttribute, 8> attrs;
   for (auto attr : op->getAttrs())
-    if (traitAttrsSet.count(attr.first.strref()) > 0)
+    if (traitAttrsSet.count(attr.getName().strref()) > 0)
       attrs.push_back(attr);
 
   auto dictAttr = DictionaryAttr::get(op.getContext(), attrs);
   p << " " << dictAttr << " " << op.lhs() << ", ";
   p << op.rhs() << ", " << op.acc();
   if (op.masks().size() == 2)
     p << ", " << op.masks();
 

mlir/lib/IR/AsmPrinter.cpp

void printGenericOp(Operation *op, bool printOpName = true) override {
     // Visit all the types used in the operation.
     for (Type type : op->getOperandTypes())
       printType(type);
     for (Type type : op->getResultTypes())
       printType(type);
 
     // Consider the attributes of the operation for aliases.
     for (const NamedAttribute &attr : op->getAttrs())
-      printAttribute(attr.second);
+      printAttribute(attr.getValue());
   }
 
   /// Print the given block. If 'printBlockArgs' is false, the arguments of the
   /// block are not printed. If 'printBlockTerminator' is false, the terminator
   /// operation of the block is not printed.
   void print(Block *block, bool printBlockArgs = true,
              bool printBlockTerminator = true) {
     // Consider the types of the block arguments for aliases if 'printBlockArgs'
private:
   /// Print the given set of attributes with names not included within
   /// 'elidedAttrs'.
   void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
                              ArrayRef<StringRef> elidedAttrs = {}) override {
     if (attrs.empty())
       return;
     if (elidedAttrs.empty()) {
       for (const NamedAttribute &attr : attrs)
-        printAttribute(attr.second);
+        printAttribute(attr.getValue());
       return;
     }
     llvm::SmallDenseSet<StringRef> elidedAttrsSet(elidedAttrs.begin(),
                                                   elidedAttrs.end());
     for (const NamedAttribute &attr : attrs)
-      if (!elidedAttrsSet.contains(attr.first.strref()))
-        printAttribute(attr.second);
+      if (!elidedAttrsSet.contains(attr.getName().strref()))
+        printAttribute(attr.getValue());
   }
   void printOptionalAttrDictWithKeyword(
       ArrayRef<NamedAttribute> attrs,
       ArrayRef<StringRef> elidedAttrs = {}) override {
     printOptionalAttrDict(attrs, elidedAttrs);
   }
 
   /// Return a null stream as the output stream, this will ignore any data fed
void AsmPrinter::Impl::printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
   // If no attributes are elided, we can directly print with no filtering.
   if (elidedAttrs.empty())
     return printFilteredAttributesFn(attrs);
 
   // Otherwise, filter out any attributes that shouldn't be included.
   llvm::SmallDenseSet<StringRef> elidedAttrsSet(elidedAttrs.begin(),
                                                 elidedAttrs.end());
   auto filteredAttrs = llvm::make_filter_range(attrs, [&](NamedAttribute attr) {
-    return !elidedAttrsSet.contains(attr.first.strref());
+    return !elidedAttrsSet.contains(attr.getName().strref());
   });
   if (!filteredAttrs.empty())
     printFilteredAttributesFn(filteredAttrs);
 }
 
 void AsmPrinter::Impl::printNamedAttribute(NamedAttribute attr) {
-  assert(attr.first.size() != 0 && "expected valid named attribute");
-
   // Print the name without quotes if possible.
-  ::printKeywordOrString(attr.first.strref(), os);
+  ::printKeywordOrString(attr.getName().strref(), os);
 
   // Pretty printing elides the attribute value for unit attributes.
-  if (attr.second.isa<UnitAttr>())
+  if (attr.getValue().isa<UnitAttr>())
     return;
 
   os << " = ";
-  printAttribute(attr.second);
+  printAttribute(attr.getValue());
 }
 
 void AsmPrinter::Impl::printDialectAttribute(Attribute attr) {
   auto &dialect = attr.getDialect();
 
   // Ask the dialect to serialize the attribute to a string.
   std::string attrName;
   {

mlir/lib/IR/Attributes.cpp

 
 /// 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 lhs.first.compare(rhs.first) < 0;
+NamedAttribute::NamedAttribute(StringAttr name, Attribute value)
+    : name(name), value(value) {
+  assert(name && value && "expected valid attribute name and value");
+  assert(name.size() != 0 && "expected valid attribute name");
 }
-bool mlir::operator<(const NamedAttribute &lhs, StringRef rhs) {
-  return lhs.first.getValue().compare(rhs) < 0;
+
+StringAttr NamedAttribute::getName() const { return name.cast<StringAttr>(); }
+
+Dialect *NamedAttribute::getNameDialect() const {
+  return getName().getReferencedDialect();
+}
+
+void NamedAttribute::setName(StringAttr newName) {
+  assert(name && "expected valid attribute name");
+  name = newName;
+}
+
+bool NamedAttribute::operator<(const NamedAttribute &rhs) const {
+  return getName().compare(rhs.getName()) < 0;
+}
+
+bool NamedAttribute::operator<(StringRef rhs) const {
+  return getName().getValue().compare(rhs) < 0;
 }

mlir/lib/IR/BuiltinAttributes.cpp

 /// attributes. Returns llvm::None if all elements have unique names.
 static Optional<NamedAttribute>
 findDuplicateElement(ArrayRef<NamedAttribute> value) {
   const Optional<NamedAttribute> none{llvm::None};
   if (value.size() < 2)
     return none;
 
   if (value.size() == 2)
-    return value[0].first == value[1].first ? value[0] : none;
+    return value[0].getName() == value[1].getName() ? value[0] : none;
 
-  auto it = std::adjacent_find(
-      value.begin(), value.end(),
-      [](NamedAttribute l, NamedAttribute r) { return l.first == r.first; });
+  auto it = std::adjacent_find(value.begin(), value.end(),
+                               [](NamedAttribute l, NamedAttribute r) {
+                                 return l.getName() == r.getName();
+                               });
   return it != value.end() ? *it : none;
 }
 
 bool DictionaryAttr::sort(ArrayRef<NamedAttribute> value,
                           SmallVectorImpl<NamedAttribute> &storage) {
   bool isSorted = dictionaryAttrSort</*inPlace=*/false>(value, storage);
   assert(!findDuplicateElement(storage) &&
          "DictionaryAttr element names must be unique");
if (!isSorted)
     dictionaryAttrSort</*inPlace=*/true>(array, array);
   return findDuplicateElement(array);
 }
 
 DictionaryAttr DictionaryAttr::get(MLIRContext *context,
                                    ArrayRef<NamedAttribute> value) {
   if (value.empty())
     return DictionaryAttr::getEmpty(context);
-  assert(llvm::all_of(value,
-                      [](const NamedAttribute &attr) { return attr.second; }) &&
-         "value cannot have null entries");
 
   // We need to sort the element list to canonicalize it.
   SmallVector<NamedAttribute, 8> storage;
   if (dictionaryAttrSort</*inPlace=*/false>(value, storage))
     value = storage;
   assert(!findDuplicateElement(value) &&
          "DictionaryAttr element names must be unique");
   return Base::get(context, value);
 }
 /// Construct a dictionary with an array of values that is known to already be
 /// sorted by name and uniqued.
 DictionaryAttr DictionaryAttr::getWithSorted(MLIRContext *context,
                                              ArrayRef<NamedAttribute> value) {
   if (value.empty())
     return DictionaryAttr::getEmpty(context);
   // Ensure that the attribute elements are unique and sorted.
-  assert(llvm::is_sorted(value,
-                         [](NamedAttribute l, NamedAttribute r) {
-                           return l.first.strref() < r.first.strref();
-                         }) &&
+  assert(llvm::is_sorted(
+             value, [](NamedAttribute l, NamedAttribute r) { return l < r; }) &&
          "expected attribute values to be sorted");
   assert(!findDuplicateElement(value) &&
          "DictionaryAttr element names must be unique");
   return Base::get(context, value);
 }
 
 /// Return the specified attribute if present, null otherwise.
 Attribute DictionaryAttr::get(StringRef name) const {
   auto it = impl::findAttrSorted(begin(), end(), name);
-  return it.second ? it.first->second : Attribute();
+  return it.second ? it.first->getValue() : Attribute();
 }
 Attribute DictionaryAttr::get(Identifier name) const {
   auto it = impl::findAttrSorted(begin(), end(), name);
-  return it.second ? it.first->second : Attribute();
+  return it.second ? it.first->getValue() : Attribute();
 }
 
 /// Return the specified named attribute if present, None otherwise.
 Optional<NamedAttribute> DictionaryAttr::getNamed(StringRef name) const {
   auto it = impl::findAttrSorted(begin(), end(), name);
   return it.second ? *it.first : Optional<NamedAttribute>();
 }
 Optional<NamedAttribute> DictionaryAttr::getNamed(Identifier name) const {

 
 DictionaryAttr DictionaryAttr::getEmptyUnchecked(MLIRContext *context) {
   return Base::get(context, ArrayRef<NamedAttribute>());
 }
 
 void DictionaryAttr::walkImmediateSubElements(
     function_ref<void(Attribute)> walkAttrsFn,
     function_ref<void(Type)> walkTypesFn) const {
-  for (Attribute attr : llvm::make_second_range(getValue()))
-    walkAttrsFn(attr);
+  for (const NamedAttribute &attr : getValue())
+    walkAttrsFn(attr.getValue());
 }
 
 SubElementAttrInterface DictionaryAttr::replaceImmediateSubAttribute(
     ArrayRef<std::pair<size_t, Attribute>> replacements) const {
   std::vector<NamedAttribute> vec = getValue().vec();
-  for (auto &it : replacements) {
-    vec[it.first].second = it.second;
-  }
+  for (auto &it : replacements)
+    vec[it.first].setValue(it.second);
+
   // The above only modifies the mapped value, but not the key, and therefore
   // not the order of the elements. It remains sorted
   return getWithSorted(getContext(), vec);
 }
 
 //===----------------------------------------------------------------------===//
 // StringAttr
 //===----------------------------------------------------------------------===//

mlir/lib/IR/BuiltinDialect.cpp

static LogicalResult verify(FuncOp op) {
 
   return success();
 }
 
 /// Clone the internal blocks from this function into dest and all attributes
 /// from this function to dest.
 void FuncOp::cloneInto(FuncOp dest, BlockAndValueMapping &mapper) {
   // Add the attributes of this function to dest.
-  llvm::MapVector<Identifier, Attribute> newAttrs;
+  llvm::MapVector<Identifier, Attribute> newAttrMap;
   for (const auto &attr : dest->getAttrs())
-    newAttrs.insert(attr);
+    newAttrMap.insert({attr.getName(), attr.getValue()});
   for (const auto &attr : (*this)->getAttrs())
-    newAttrs.insert(attr);
-  dest->setAttrs(DictionaryAttr::get(getContext(), newAttrs.takeVector()));
+    newAttrMap.insert({attr.getName(), attr.getValue()});
+
+  auto newAttrs = llvm::to_vector(llvm::map_range(
+      newAttrMap, [](std::pair<Identifier, Attribute> attrPair) {
+        return NamedAttribute(attrPair.first, attrPair.second);
+      }));
+  dest->setAttrs(DictionaryAttr::get(getContext(), newAttrs));
 
   // Clone the body.
   getBody().cloneInto(&dest.getBody(), mapper);
 }
 
 /// Create a deep copy of this function and all of its blocks, remapping
 /// any operands that use values outside of the function using the map that is
 /// provided (leaving them alone if no entry is present). Replaces references
ModuleOp ModuleOp::create(Location loc, Optional<StringRef> name) {
   OpBuilder builder(loc->getContext());
   return builder.create<ModuleOp>(loc, name);
 }
 
 DataLayoutSpecInterface ModuleOp::getDataLayoutSpec() {
   // Take the first and only (if present) attribute that implements the
   // interface. This needs a linear search, but is called only once per data
   // layout object construction that is used for repeated queries.
-  for (Attribute attr : llvm::make_second_range(getOperation()->getAttrs())) {
-    if (auto spec = attr.dyn_cast<DataLayoutSpecInterface>())
+  for (NamedAttribute attr : getOperation()->getAttrs())
+    if (auto spec = attr.getValue().dyn_cast<DataLayoutSpecInterface>())
       return spec;
-  }
   return {};
 }
 
 static LogicalResult verify(ModuleOp op) {
   // Check that none of the attributes are non-dialect attributes, except for
   // the symbol related attributes.
   for (auto attr : op->getAttrs()) {
-    if (!attr.first.strref().contains('.') &&
+    if (!attr.getName().strref().contains('.') &&
         !llvm::is_contained(
             ArrayRef<StringRef>{mlir::SymbolTable::getSymbolAttrName(),
                                 mlir::SymbolTable::getVisibilityAttrName()},
-            attr.first.strref()))
+            attr.getName().strref()))
       return op.emitOpError() << "can only contain attributes with "
                                  "dialect-prefixed names, found: '"
-                              << attr.first.getValue() << "'";
+                              << attr.getName().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 (auto spec = na.getValue().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.getValue()
+        diag.attachNote() << "'" << na.getName().getValue()
                           << "' is a data layout attribute";
       }
-      layoutSpecAttrName = na.first.strref();
+      layoutSpecAttrName = na.getName().strref();
       layoutSpec = spec;
     }
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//

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() ||
-                            attrs.back().first.compare(newAttribute.first) < 0);
-  }
+  if (isSorted())
+    dictionarySorted.setInt(attrs.empty() || attrs.back() < newAttribute);
   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();
+  return it.second ? it.first->getValue() : Attribute();
 }
 Attribute NamedAttrList::get(Identifier name) const {
   auto it = findAttr(*this, name);
-  return it.second ? it.first->second : Attribute();
+  return it.second ? it.first->getValue() : Attribute();
 }
 
 /// Return the specified named attribute if present, None otherwise.
 Optional<NamedAttribute> NamedAttrList::getNamed(StringRef name) const {
   auto it = findAttr(*this, name);
   return it.second ? *it.first : Optional<NamedAttribute>();
 }
 Optional<NamedAttribute> NamedAttrList::getNamed(Identifier name) const {
   auto it = findAttr(*this, name);
   return it.second ? *it.first : Optional<NamedAttribute>();
 }
 
 /// If the an attribute exists with the specified name, change it to the new
 /// value.  Otherwise, add a new attribute with the specified name/value.
 Attribute NamedAttrList::set(Identifier name, Attribute value) {
   assert(value && "attributes may never be null");
 
   // Look for an existing attribute with the given name, and set its value
   // in-place. Return the previous value of the attribute, if there was one.
   auto it = findAttr(*this, name);
   if (it.second) {
     // Update the existing attribute by swapping out the old value for the new
     // value. Return the old value.
-    if (it.first->second != value) {
-      std::swap(it.first->second, value);
+    Attribute oldValue = it.first->getValue();
+    if (it.first->getValue() != value) {
+      it.first->setValue(value);
+
       // If the attributes have changed, the dictionary is invalidated.
       dictionarySorted.setPointer(nullptr);
     }
-    return value;
+    return oldValue;
   }
   // Perform a string lookup to insert the new attribute into its sorted
   // position.
   if (isSorted())
     it = findAttr(*this, name.strref());
   attrs.insert(it.first, {name, value});
   // Invalidate the dictionary. Return null as there was no previous value.
   dictionarySorted.setPointer(nullptr);
   return Attribute();
 }
 
 Attribute NamedAttrList::set(StringRef name, Attribute value) {
   assert(value && "attributes may never be null");
   return set(mlir::Identifier::get(name, value.getContext()), value);
 }
 
 Attribute
 NamedAttrList::eraseImpl(SmallVectorImpl<NamedAttribute>::iterator it) {
   // Erasing does not affect the sorted property.
-  Attribute attr = it->second;
+  Attribute attr = it->getValue();
   attrs.erase(it);
   dictionarySorted.setPointer(nullptr);
   return attr;
 }
 
 Attribute NamedAttrList::erase(Identifier name) {
   auto it = findAttr(*this, name);
   return it.second ? eraseImpl(it.first) : Attribute();

 
 /// Update the length of this range to the one provided.
 void MutableOperandRange::updateLength(unsigned newLength) {
   int32_t diff = int32_t(newLength) - int32_t(length);
   length = newLength;
 
   // Update any of the provided segment attributes.
   for (OperandSegment &segment : operandSegments) {
-    auto attr = segment.second.second.cast<DenseIntElementsAttr>();
+    auto attr = segment.second.getValue().cast<DenseIntElementsAttr>();
     SmallVector<int32_t, 8> segments(attr.getValues<int32_t>());
     segments[segment.first] += diff;
-    segment.second.second = DenseIntElementsAttr::get(attr.getType(), segments);
-    owner->setAttr(segment.second.first, segment.second.second);
+    segment.second.setValue(
+        DenseIntElementsAttr::get(attr.getType(), segments));
+    owner->setAttr(segment.second.getName(), segment.second.getValue());
   }
 }
 
 //===----------------------------------------------------------------------===//
 // MutableOperandRangeRange
 
 MutableOperandRangeRange::MutableOperandRangeRange(
     const MutableOperandRange &operands, NamedAttribute operandSegmentAttr)
     : MutableOperandRangeRange(
           OwnerT(operands, operandSegmentAttr), 0,
-          operandSegmentAttr.second.cast<DenseElementsAttr>().size()) {}
+          operandSegmentAttr.getValue().cast<DenseElementsAttr>().size()) {}
 
 MutableOperandRange MutableOperandRangeRange::join() const {
   return getBase().first;
 }
 
 MutableOperandRangeRange::operator OperandRangeRange() const {
-  return OperandRangeRange(getBase().first,
-                           getBase().second.second.cast<DenseElementsAttr>());
+  return OperandRangeRange(
+      getBase().first, getBase().second.getValue().cast<DenseElementsAttr>());
 }
 
 MutableOperandRange MutableOperandRangeRange::dereference(const OwnerT &object,
                                                           ptrdiff_t index) {
   auto sizeData =
-      object.second.second.cast<DenseElementsAttr>().getValues<uint32_t>();
+      object.second.getValue().cast<DenseElementsAttr>().getValues<uint32_t>();
   uint32_t startIndex =
       std::accumulate(sizeData.begin(), sizeData.begin() + index, 0);
   return object.first.slice(
       startIndex, *(sizeData.begin() + index),
       MutableOperandRange::OperandSegment(index, object.second));
 }
 
 //===----------------------------------------------------------------------===//

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.getReferencedDialect())
+    if (auto *dialect = attr.getNameDialect())
       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/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.getValue()
+             << duplicate->getName().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

 LogicalResult
 CppEmitter::emitOperandsAndAttributes(Operation &op,
                                       ArrayRef<StringRef> exclude) {
   if (failed(emitOperands(op)))
     return failure();
   // Insert comma in between operands and non-filtered attributes if needed.
   if (op.getNumOperands() > 0) {
     for (NamedAttribute attr : op.getAttrs()) {
-      if (!llvm::is_contained(exclude, attr.first.strref())) {
+      if (!llvm::is_contained(exclude, attr.getName().strref())) {
         os << ", ";
         break;
       }
     }
   }
   // Emit attributes.
   auto emitNamedAttribute = [&](NamedAttribute attr) -> LogicalResult {
-    if (llvm::is_contained(exclude, attr.first.strref()))
+    if (llvm::is_contained(exclude, attr.getName().strref()))
       return success();
-    os << "/* " << attr.first.getValue() << " */";
-    if (failed(emitAttribute(op.getLoc(), attr.second)))
+    os << "/* " << attr.getName().getValue() << " */";
+    if (failed(emitAttribute(op.getLoc(), attr.getValue())))
       return failure();
     return success();
   };
   return interleaveCommaWithError(op.getAttrs(), os, emitNamedAttribute);
 }
 
 LogicalResult CppEmitter::emitVariableAssignment(OpResult result) {
   if (!hasValueInScope(result)) {

mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp

if (!loopMD) {
 
       auto loopAttr = attr.cast<DictionaryAttr>();
       auto parallelAccessGroup =
           loopAttr.getNamed(LLVMDialect::getParallelAccessAttrName());
       if (parallelAccessGroup.hasValue()) {
         SmallVector<llvm::Metadata *> parallelAccess;
         parallelAccess.push_back(
             llvm::MDString::get(ctx, "llvm.loop.parallel_accesses"));
-        for (SymbolRefAttr accessGroupRef :
-             parallelAccessGroup->second.cast<ArrayAttr>()
+        for (SymbolRefAttr accessGroupRef : parallelAccessGroup->getValue()
+                                                .cast<ArrayAttr>()
                                                 .getAsRange<SymbolRefAttr>())
           parallelAccess.push_back(
               moduleTranslation.getAccessGroup(opInst, accessGroupRef));
         loopOptions.push_back(llvm::MDNode::get(ctx, parallelAccess));
       }
 
       if (auto loopOptionsAttr = loopAttr.getAs<LoopOptionsAttr>(
               LLVMDialect::getLoopOptionsAttrName())) {
         for (auto option : loopOptionsAttr.getOptions())

mlir/lib/Target/LLVMIR/Dialect/NVVM/NVVMToLLVMIRTranslation.cpp

#include "mlir/Dialect/LLVMIR/NVVMConversions.inc"
 
     return failure();
   }
 
   /// Attaches module-level metadata for functions marked as kernels.
   LogicalResult
   amendOperation(Operation *op, NamedAttribute attribute,
                  LLVM::ModuleTranslation &moduleTranslation) const final {
-    if (attribute.first == NVVM::NVVMDialect::getKernelFuncAttrName()) {
+    if (attribute.getName() == NVVM::NVVMDialect::getKernelFuncAttrName()) {
       auto func = dyn_cast<LLVM::LLVMFuncOp>(op);
       if (!func)
         return failure();
 
       llvm::LLVMContext &llvmContext = moduleTranslation.getLLVMContext();
       llvm::Function *llvmFunc =
           moduleTranslation.lookupFunction(func.getName());
       llvm::Metadata *llvmMetadata[] = {

mlir/lib/Target/LLVMIR/Dialect/ROCDL/ROCDLToLLVMIRTranslation.cpp

#include "mlir/Dialect/LLVMIR/ROCDLConversions.inc"
 
     return failure();
   }
 
   /// Attaches module-level metadata for functions marked as kernels.
   LogicalResult
   amendOperation(Operation *op, NamedAttribute attribute,
                  LLVM::ModuleTranslation &moduleTranslation) const final {
-    if (attribute.first == ROCDL::ROCDLDialect::getKernelFuncAttrName()) {
+    if (attribute.getName() == ROCDL::ROCDLDialect::getKernelFuncAttrName()) {
       auto func = dyn_cast<LLVM::LLVMFuncOp>(op);
       if (!func)
         return failure();
 
       // For GPU kernels,
       // 1. Insert AMDGPU_KERNEL calling convention.
       // 2. Insert amdgpu-flat-workgroup-size(1, 1024) attribute.
       llvm::Function *llvmFunc =

mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp

 spirv::SpecConstantOp
 spirv::Deserializer::createSpecConstant(Location loc, uint32_t resultID,
                                         Attribute defaultValue) {
   auto symName = opBuilder.getStringAttr(getSpecConstantSymbol(resultID));
   auto op = opBuilder.create<spirv::SpecConstantOp>(unknownLoc, symName,
                                                     defaultValue);
   if (decorations.count(resultID)) {
     for (auto attr : decorations[resultID].getAttrs())
-      op->setAttr(attr.first, attr.second);
+      op->setAttr(attr.getName(), attr.getValue());
   }
   specConstMap[resultID] = op;
   return op;
 }
 
 LogicalResult
 spirv::Deserializer::processGlobalVariable(ArrayRef<uint32_t> operands) {
   unsigned wordIndex = 0;
spirv::Deserializer::processGlobalVariable(ArrayRef<uint32_t> operands) {
   }
   auto loc = createFileLineColLoc(opBuilder);
   auto varOp = opBuilder.create<spirv::GlobalVariableOp>(
       loc, TypeAttr::get(type), opBuilder.getStringAttr(variableName),
       initializer);
 
   // Decorations.
   if (decorations.count(variableID)) {
-    for (auto attr : decorations[variableID].getAttrs()) {
-      varOp->setAttr(attr.first, attr.second);
-    }
+    for (auto attr : decorations[variableID].getAttrs())
+      varOp->setAttr(attr.getName(), attr.getValue());
   }
   globalVariableMap[variableID] = varOp;
   return success();
 }
 
 IntegerAttr spirv::Deserializer::getConstantInt(uint32_t id) {
   auto constInfo = getConstant(id);
   if (!constInfo) {

mlir/lib/Target/SPIRV/Serialization/SerializeOps.cpp

if (!argID) {
       return emitError(op.getLoc(), "operand 0 has a use before def");
     }
     operands.push_back(argID);
   }
   (void)emitDebugLine(functionHeader, op.getLoc());
   (void)encodeInstructionInto(functionHeader, spirv::Opcode::OpVariable,
                               operands);
   for (auto attr : op->getAttrs()) {
-    if (llvm::any_of(elidedAttrs,
-                     [&](StringRef elided) { return attr.first == elided; })) {
+    if (llvm::any_of(elidedAttrs, [&](StringRef elided) {
+          return attr.getName() == elided;
+        })) {
       continue;
     }
     if (failed(processDecoration(op.getLoc(), resultID, attr))) {
       return failure();
     }
   }
   return success();
 }
Serializer::processGlobalVariableOp(spirv::GlobalVariableOp varOp) {
   if (failed(encodeInstructionInto(typesGlobalValues, spirv::Opcode::OpVariable,
                                    operands))) {
     elidedAttrs.push_back("initializer");
     return failure();
   }
 
   // Encode decorations.
   for (auto attr : varOp->getAttrs()) {
-    if (llvm::any_of(elidedAttrs,
-                     [&](StringRef elided) { return attr.first == elided; })) {
+    if (llvm::any_of(elidedAttrs, [&](StringRef elided) {
+          return attr.getName() == elided;
+        })) {
       continue;
     }
     if (failed(processDecoration(varOp.getLoc(), resultID, attr))) {
       return failure();
     }
   }
   return success();
 }

mlir/lib/Target/SPIRV/Serialization/Serializer.cpp

void Serializer::processMemoryModel() {
   uint32_t am = module->getAttrOfType<IntegerAttr>("addressing_model").getInt();
 
   (void)encodeInstructionInto(memoryModel, spirv::Opcode::OpMemoryModel,
                               {am, mm});
 }
 
 LogicalResult Serializer::processDecoration(Location loc, uint32_t resultID,
                                             NamedAttribute attr) {
-  auto attrName = attr.first.strref();
+  auto attrName = attr.getName().strref();
   auto decorationName = llvm::convertToCamelFromSnakeCase(attrName, true);
   auto decoration = spirv::symbolizeDecoration(decorationName);
   if (!decoration) {
     return emitError(
                loc, "non-argument attributes expected to have snake-case-ified "
                     "decoration name, unhandled attribute with name : ")
            << attrName;
   }
   SmallVector<uint32_t, 1> args;
   switch (decoration.getValue()) {
   case spirv::Decoration::Binding:
   case spirv::Decoration::DescriptorSet:
   case spirv::Decoration::Location:
-    if (auto intAttr = attr.second.dyn_cast<IntegerAttr>()) {
+    if (auto intAttr = attr.getValue().dyn_cast<IntegerAttr>()) {
       args.push_back(intAttr.getValue().getZExtValue());
       break;
     }
     return emitError(loc, "expected integer attribute for ") << attrName;
   case spirv::Decoration::BuiltIn:
-    if (auto strAttr = attr.second.dyn_cast<StringAttr>()) {
+    if (auto strAttr = attr.getValue().dyn_cast<StringAttr>()) {
       auto enumVal = spirv::symbolizeBuiltIn(strAttr.getValue());
       if (enumVal) {
         args.push_back(static_cast<uint32_t>(enumVal.getValue()));
         break;
       }
       return emitError(loc, "invalid ")
              << attrName << " attribute " << strAttr.getValue();
     }
     return emitError(loc, "expected string attribute for ") << attrName;
   case spirv::Decoration::Aliased:
   case spirv::Decoration::Flat:
   case spirv::Decoration::NonReadable:
   case spirv::Decoration::NonWritable:
   case spirv::Decoration::NoPerspective:
   case spirv::Decoration::Restrict:
   case spirv::Decoration::RelaxedPrecision:
     // For unit attributes, the args list has no values so we do nothing
-    if (auto unitAttr = attr.second.dyn_cast<UnitAttr>())
+    if (auto unitAttr = attr.getValue().dyn_cast<UnitAttr>())
       break;
     return emitError(loc, "expected unit attribute for ") << attrName;
   default:
     return emitError(loc, "unhandled decoration ") << decorationName;
   }
   return emitDecoration(resultID, decoration.getValue(), args);
 }
 

mlir/lib/Transforms/Utils/Utils.cpp

if (!allowNonDereferencingOps) {
       return failure();
     }
     op->setOperand(memRefOperandPos, newMemRef);
     return success();
   }
   // Perform index rewrites for the dereferencing op and then replace the op
   NamedAttribute oldMapAttrPair =
       affMapAccInterface.getAffineMapAttrForMemRef(oldMemRef);
-  AffineMap oldMap = oldMapAttrPair.second.cast<AffineMapAttr>().getValue();
+  AffineMap oldMap = oldMapAttrPair.getValue().cast<AffineMapAttr>().getValue();
   unsigned oldMapNumInputs = oldMap.getNumInputs();
   SmallVector<Value, 4> oldMapOperands(
       op->operand_begin() + memRefOperandPos + 1,
       op->operand_begin() + memRefOperandPos + 1 + oldMapNumInputs);
 
   // Apply 'oldMemRefOperands = oldMap(oldMapOperands)'.
   SmallVector<Value, 4> oldMemRefOperands;
   SmallVector<Value, 4> affineApplyOps;
LogicalResult mlir::replaceAllMemRefUsesWith(Value oldMemRef, Value newMemRef,
   // Result types don't change. Both memref's are of the same elemental type.
   state.types.reserve(op->getNumResults());
   for (auto result : op->getResults())
     state.types.push_back(result.getType());
 
   // Add attribute for 'newMap', other Attributes do not change.
   auto newMapAttr = AffineMapAttr::get(newMap);
   for (auto namedAttr : op->getAttrs()) {
-    if (namedAttr.first == oldMapAttrPair.first)
-      state.attributes.push_back({namedAttr.first, newMapAttr});
+    if (namedAttr.getName() == oldMapAttrPair.getName())
+      state.attributes.push_back({namedAttr.getName(), newMapAttr});
     else
       state.attributes.push_back(namedAttr);
   }
 
   // Create the new operation.
   auto *repOp = builder.createOperation(state);
   op->replaceAllUsesWith(repOp);
   op->erase();

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.getValue() << ": ";
-          emitMlirAttr(os, attr.second);
+          os << '\n' << attr.getName().getValue() << ": ";
+          emitMlirAttr(os, attr.getValue());
         }
       }
     });
   }
 
   /// Generate a label for a block argument.
   std::string getLabel(BlockArgument arg) {
     return "arg" + std::to_string(arg.getArgNumber());

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

void *TestDialect::getRegisteredInterfaceForOp(TypeID typeID,
   if (opName.getIdentifier() == "test.unregistered_side_effect_op" &&
       typeID == TypeID::get<TestEffectOpInterface>())
     return fallbackEffectOpInterfaces;
   return nullptr;
 }
 
 LogicalResult TestDialect::verifyOperationAttribute(Operation *op,
                                                     NamedAttribute namedAttr) {
-  if (namedAttr.first == "test.invalid_attr")
+  if (namedAttr.getName() == "test.invalid_attr")
     return op->emitError() << "invalid to use 'test.invalid_attr'";
   return success();
 }
 
 LogicalResult TestDialect::verifyRegionArgAttribute(Operation *op,
                                                     unsigned regionIndex,
                                                     unsigned argIndex,
                                                     NamedAttribute namedAttr) {
-  if (namedAttr.first == "test.invalid_attr")
+  if (namedAttr.getName() == "test.invalid_attr")
     return op->emitError() << "invalid to use 'test.invalid_attr'";
   return success();
 }
 
 LogicalResult
 TestDialect::verifyRegionResultAttribute(Operation *op, unsigned regionIndex,
                                          unsigned resultIndex,
                                          NamedAttribute namedAttr) {
-  if (namedAttr.first == "test.invalid_attr")
+  if (namedAttr.getName() == "test.invalid_attr")
     return op->emitError() << "invalid to use 'test.invalid_attr'";
   return success();
 }
 
 Optional<Dialect::ParseOpHook>
 TestDialect::getParseOperationHook(StringRef opName) const {
   if (opName == "test.dialect_custom_printer") {
     return ParseOpHook{[](OpAsmParser &parser, OperationState &state) {
for (size_t i = 0, e = parser.getNumResults(); i != e; ++i)
     result.addTypes(parser.getBuilder().getIntegerType(32));
 
   if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
     return failure();
 
   // If the attribute dictionary contains no 'names' attribute, infer it from
   // the SSA name (if specified).
   bool hadNames = llvm::any_of(result.attributes, [](NamedAttribute attr) {
-    return attr.first == "names";
+    return attr.getName() == "names";
   });
 
   // If there was no name specified, check to see if there was a useful name
   // specified in the asm file.
   if (hadNames || parser.getNumResults() == 0)
     return success();
 
   SmallVector<StringRef, 4> names;

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.getValue() << " = " << d.second;
+      dOp.emitRemark() << d.getName().getValue() << " = " << d.getValue();
   });
 }
 
 //===----------------------------------------------------------------------===//
 // Legalization Driver.
 //===----------------------------------------------------------------------===//
 
 namespace {

mlir/test/lib/IR/TestBuiltinAttributeInterfaces.cpp

struct TestElementsAttrInterface
     : public PassWrapper<TestElementsAttrInterface, OperationPass<ModuleOp>> {
   StringRef getArgument() const final { return "test-elements-attr-interface"; }
   StringRef getDescription() const final {
     return "Test ElementsAttr interface support.";
   }
   void runOnOperation() override {
     getOperation().walk([&](Operation *op) {
       for (NamedAttribute attr : op->getAttrs()) {
-        auto elementsAttr = attr.second.dyn_cast<ElementsAttr>();
+        auto elementsAttr = attr.getValue().dyn_cast<ElementsAttr>();
         if (!elementsAttr)
           continue;
         testElementsAttrIteration<uint64_t>(op, elementsAttr, "uint64_t");
         testElementsAttrIteration<APInt>(op, elementsAttr, "APInt");
         testElementsAttrIteration<IntegerAttr>(op, elementsAttr, "IntegerAttr");
       }
     });
   }

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.getValue() << "' : '"
-                      << attr.second << "'\n";
+        printIndent() << " - '" << attr.getName().getValue() << "' : '"
+                      << attr.getValue() << "'\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);
   }

mlir/test/mlir-tblgen/op-result.td

 def IntegerTypeAttr : TypeAttrBase<"IntegerType", "Integer type attribute">;
 def OpD : NS_Op<"type_attr_as_result_type", [FirstAttrDerivedResultType]> {
   let arguments = (ins I32:$x, IntegerTypeAttr:$attr, F32Attr:$f32);
   let results = (outs AnyTensor:$y);
 }
 
 // CHECK-LABEL: OpD definitions
 // CHECK: void OpD::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes)
-// CHECK: odsState.addTypes({attr.second.cast<::mlir::TypeAttr>().getValue()});
+// CHECK: odsState.addTypes({attr.getValue().cast<::mlir::TypeAttr>().getValue()});
 
 def OpE : NS_Op<"value_attr_as_result_type", [FirstAttrDerivedResultType]> {
   let arguments = (ins I32:$x, F32Attr:$attr);
   let results = (outs AnyTensor:$y);
 }
 
 // CHECK-LABEL: OpE definitions
 // CHECK: void OpE::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes)
-// CHECK: odsState.addTypes({attr.second.getType()});
+// CHECK: odsState.addTypes({attr.getValue().getType()});
 
 def OpF : NS_Op<"one_variadic_result_op", []> {
   let results = (outs Variadic<I32>:$x);
 }
 
 // CHECK-LABEL: void OpF::build
 // CHECK-SAME:    ::mlir::TypeRange x
 // CHECK-NOT:     assert

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

void OpEmitter::genUseAttrAsResultTypeBuilder() {
   // Push all result types to the operation state
   std::string resultType;
   const auto &namedAttr = op.getAttribute(0);
 
   body << "  auto attrName = " << op.getGetterName(namedAttr.name)
        << "AttrName(" << builderOpState
        << ".name);\n"
           "  for (auto attr : attributes) {\n"
-          "    if (attr.first != attrName) continue;\n";
+          "    if (attr.getName() != attrName) continue;\n";
   if (namedAttr.attr.isTypeAttr()) {
-    resultType = "attr.second.cast<::mlir::TypeAttr>().getValue()";
+    resultType = "attr.getValue().cast<::mlir::TypeAttr>().getValue()";
   } else {
-    resultType = "attr.second.getType()";
+    resultType = "attr.getValue().getType()";
   }
 
   // Operands
   body << "  " << builderOpState << ".addOperands(operands);\n";
 
   // Attributes
   body << "  " << builderOpState << ".addAttributes(attributes);\n";
 

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

 /// SPIR-V binary.
 static void emitDecorationSerialization(const Operator &op, StringRef tabs,
                                         StringRef opVar, StringRef elidedAttrs,
                                         StringRef resultID, raw_ostream &os) {
   if (op.getNumResults() == 1) {
     // All non-argument attributes translated into OpDecorate instruction
     os << tabs << formatv("for (auto attr : {0}->getAttrs()) {{\n", opVar);
     os << tabs
-       << formatv("  if (llvm::is_contained({0}, attr.first)) {{", elidedAttrs);
+       << formatv("  if (llvm::is_contained({0}, attr.getName())) {{",
+                  elidedAttrs);
     os << tabs << "    continue;\n";
     os << tabs << "  }\n";
     os << tabs
        << formatv(
               "  if (failed(processDecoration({0}.getLoc(), {1}, attr))) {{\n",
               opVar, resultID);
     os << tabs << "    return failure();\n";
     os << tabs << "  }\n";

mlir/unittests/IR/OperationSupportTest.cpp

TEST(NamedAttrListTest, TestAppendAssign) {
   NamedAttrList attrs;
   Builder b(&ctx);
 
   attrs.append("foo", b.getStringAttr("bar"));
   attrs.append("baz", b.getStringAttr("boo"));
 
   {
     auto it = attrs.begin();
-    EXPECT_EQ(it->first, b.getIdentifier("foo"));
-    EXPECT_EQ(it->second, b.getStringAttr("bar"));
+    EXPECT_EQ(it->getName(), b.getIdentifier("foo"));
+    EXPECT_EQ(it->getValue(), b.getStringAttr("bar"));
     ++it;
-    EXPECT_EQ(it->first, b.getIdentifier("baz"));
-    EXPECT_EQ(it->second, b.getStringAttr("boo"));
+    EXPECT_EQ(it->getName(), b.getIdentifier("baz"));
+    EXPECT_EQ(it->getValue(), b.getStringAttr("boo"));
   }
 
   attrs.append("foo", b.getStringAttr("zoo"));
   {
     auto dup = attrs.findDuplicate();
     ASSERT_TRUE(dup.hasValue());
   }
 
   SmallVector<NamedAttribute> newAttrs = {
       b.getNamedAttr("foo", b.getStringAttr("f")),
       b.getNamedAttr("zoo", b.getStringAttr("z")),
   };
   attrs.assign(newAttrs);
 
   auto dup = attrs.findDuplicate();
   ASSERT_FALSE(dup.hasValue());
 
   {
     auto it = attrs.begin();
-    EXPECT_EQ(it->first, b.getIdentifier("foo"));
-    EXPECT_EQ(it->second, b.getStringAttr("f"));
+    EXPECT_EQ(it->getName(), b.getIdentifier("foo"));
+    EXPECT_EQ(it->getValue(), b.getStringAttr("f"));
     ++it;
-    EXPECT_EQ(it->first, b.getIdentifier("zoo"));
-    EXPECT_EQ(it->second, b.getStringAttr("z"));
+    EXPECT_EQ(it->getName(), b.getIdentifier("zoo"));
+    EXPECT_EQ(it->getValue(), b.getStringAttr("z"));
   }
 
   attrs.assign({});
   ASSERT_TRUE(attrs.empty());
 }
 } // end namespace

mlir/unittests/TableGen/OpBuildGen.cpp

for (unsigned idx : llvm::seq(0U, op->getNumResults()))
       EXPECT_EQ(op->getResult(idx).getType(), resultTypes[idx]);
 
     EXPECT_EQ(op->getNumOperands(), operands.size());
     for (unsigned idx : llvm::seq(0U, op->getNumOperands()))
       EXPECT_EQ(op->getOperand(idx), operands[idx]);
 
     EXPECT_EQ(op->getAttrs().size(), attrs.size());
     for (unsigned idx : llvm::seq<unsigned>(0U, attrs.size()))
-      EXPECT_EQ(op->getAttr(attrs[idx].first.strref()), attrs[idx].second);
+      EXPECT_EQ(op->getAttr(attrs[idx].getName().strref()),
+                attrs[idx].getValue());
 
     concreteOp.erase();
   }
 
   // Helper method to test ops with inferred result types and single variadic
   // input.
   template <typename OpTy>
   void testSingleVariadicInputInferredType() {

mlir/unittests/TableGen/StructsGenTest.cpp

TEST(StructsGenTest, ClassofExtraFalse) {
   ASSERT_EQ(expectedValues.size(), 3u);
 
   // Copy the set of named attributes.
   llvm::SmallVector<mlir::NamedAttribute, 5> newValues(expectedValues.begin(),
                                                        expectedValues.end());
 
   // Add an extra NamedAttribute.
   auto wrongId = mlir::Identifier::get("wrong", &context);
-  auto wrongAttr = mlir::NamedAttribute(wrongId, expectedValues[0].second);
+  auto wrongAttr = mlir::NamedAttribute(wrongId, expectedValues[0].getValue());
   newValues.push_back(wrongAttr);
 
   // Make a new DictionaryAttr and validate.
   auto badDictionary = mlir::DictionaryAttr::get(&context, newValues);
   ASSERT_FALSE(test::TestStruct::classof(badDictionary));
 }
 
 /// Validates that test::TestStruct::classof fails when a NamedAttribute has an
 /// incorrect name.
 TEST(StructsGenTest, ClassofBadNameFalse) {
   mlir::MLIRContext context;
   mlir::DictionaryAttr structAttr = getTestStruct(&context);
   auto expectedValues = structAttr.getValue();
   ASSERT_EQ(expectedValues.size(), 3u);
 
   // Create a copy of all but the first NamedAttributes.
   llvm::SmallVector<mlir::NamedAttribute, 4> newValues(
       expectedValues.begin() + 1, expectedValues.end());
 
   // Add a copy of the first attribute with the wrong Identifier.
   auto wrongId = mlir::Identifier::get("wrong", &context);
-  auto wrongAttr = mlir::NamedAttribute(wrongId, expectedValues[0].second);
+  auto wrongAttr = mlir::NamedAttribute(wrongId, expectedValues[0].getValue());
   newValues.push_back(wrongAttr);
 
   auto badDictionary = mlir::DictionaryAttr::get(&context, newValues);
   ASSERT_FALSE(test::TestStruct::classof(badDictionary));
 }
 
 /// Validates that test::TestStruct::classof fails when a NamedAttribute has an
 /// incorrect type.
 TEST(StructsGenTest, ClassofBadTypeFalse) {
   mlir::MLIRContext context;
   mlir::DictionaryAttr structAttr = getTestStruct(&context);
   auto expectedValues = structAttr.getValue();
   ASSERT_EQ(expectedValues.size(), 3u);
 
   // Create a copy of all but the last NamedAttributes.
   llvm::SmallVector<mlir::NamedAttribute, 4> newValues(
       expectedValues.begin(), expectedValues.end() - 1);
 
   // Add a copy of the last attribute with the wrong type.
   auto i64Type = mlir::IntegerType::get(&context, 64);
   auto elementsType = mlir::RankedTensorType::get({3}, i64Type);
   auto elementsAttr =
       mlir::DenseIntElementsAttr::get(elementsType, ArrayRef<int64_t>{1, 2, 3});
-  mlir::Identifier id = expectedValues.back().first;
+  mlir::Identifier id = expectedValues.back().getName();
   auto wrongAttr = mlir::NamedAttribute(id, elementsAttr);
   newValues.push_back(wrongAttr);
 
   auto badDictionary = mlir::DictionaryAttr::get(&context, newValues);
   ASSERT_FALSE(test::TestStruct::classof(badDictionary));
 }
 
 /// Validates that test::TestStruct::classof fails when a NamedAttribute is