Rename NamedAttributeList to MutableDictionaryAttr BEGIN_PUBLIC Rename NamedAttributeList to MutableDictionaryAttr

[jpienaar]

Summary

Makes the relationship and function clearer. Accordingly rename getAttrList to getMutableAttrDict.

[rriddle]

mlir/include/mlir/IR/FunctionSupport.h

531–532

Not critical, but can we rename these attrList variables?

mlir/include/mlir/IR/Operation.h

285–286

Can we update this comment?

[jpienaar]

Update variable names and comments.

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

def LLVM_LLVMFuncOp
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &result, StringRef name, "
               "LLVMType type, LLVM::Linkage linkage = LLVM::Linkage::External, "
               "ArrayRef<NamedAttribute> attrs = {}, "
-              "ArrayRef<NamedAttributeList> argAttrs = {}">
+              "ArrayRef<MutableDictionaryAttr> argAttrs = {}">
   ];
 
   let extraClassDeclaration = [{
     // Add an entry block to an empty function, and set up the block arguments
     // to match the signature of the function.
     Block *addEntryBlock();
 
     LLVMType getType() {

mlir/include/mlir/IR/Attributes.h

 }
 
 // Make Attribute hashable.
 inline ::llvm::hash_code hash_value(Attribute arg) {
   return ::llvm::hash_value(arg.impl);
 }
 
 //===----------------------------------------------------------------------===//
-// NamedAttributeList
+// MutableDictionaryAttr
 //===----------------------------------------------------------------------===//
 
-/// A NamedAttributeList is a mutable wrapper around a DictionaryAttr. It
+/// A MutableDictionaryAttr is a mutable wrapper around a DictionaryAttr. It
 /// provides additional interfaces for adding, removing, replacing attributes
 /// within a DictionaryAttr.
 ///
 /// We assume there will be relatively few attributes on a given operation
 /// (maybe a dozen or so, but not hundreds or thousands) so we use linear
 /// searches for everything.
-class NamedAttributeList {
+class MutableDictionaryAttr {
 public:
-  NamedAttributeList(DictionaryAttr attrs = nullptr)
+  MutableDictionaryAttr(DictionaryAttr attrs = nullptr)
       : attrs((attrs && !attrs.empty()) ? attrs : nullptr) {}
-  NamedAttributeList(ArrayRef<NamedAttribute> attributes);
+  MutableDictionaryAttr(ArrayRef<NamedAttribute> attributes);
 
-  bool operator!=(const NamedAttributeList &other) const {
+  bool operator!=(const MutableDictionaryAttr &other) const {
     return !(*this == other);
   }
-  bool operator==(const NamedAttributeList &other) const {
+  bool operator==(const MutableDictionaryAttr &other) const {
     return attrs == other.attrs;
   }
 
   /// Return the underlying dictionary attribute. This may be null, if this list
   /// has no attributes.
   DictionaryAttr getDictionary() const { return attrs; }
 
   /// Return all of the attributes on this operation.

mlir/include/mlir/IR/Function.h

public:
   static StringRef getOperationName() { return "func"; }
 
   static FuncOp create(Location location, StringRef name, FunctionType type,
                        ArrayRef<NamedAttribute> attrs = {});
   static FuncOp create(Location location, StringRef name, FunctionType type,
                        iterator_range<dialect_attr_iterator> attrs);
   static FuncOp create(Location location, StringRef name, FunctionType type,
                        ArrayRef<NamedAttribute> attrs,
-                       ArrayRef<NamedAttributeList> argAttrs);
+                       ArrayRef<MutableDictionaryAttr> argAttrs);
 
   static void build(OpBuilder &builder, OperationState &result, StringRef name,
                     FunctionType type, ArrayRef<NamedAttribute> attrs);
   static void build(OpBuilder &builder, OperationState &result, StringRef name,
                     FunctionType type, ArrayRef<NamedAttribute> attrs,
-                    ArrayRef<NamedAttributeList> argAttrs);
+                    ArrayRef<MutableDictionaryAttr> argAttrs);
 
   /// Operation hooks.
   static ParseResult parse(OpAsmParser &parser, OperationState &result);
   void print(OpAsmPrinter &p);
   LogicalResult verify();
 
   /// Erase a single argument at `argIndex`.
   void eraseArgument(unsigned argIndex) { eraseArguments({argIndex}); }

mlir/include/mlir/IR/FunctionSupport.h

public:
   /// exist if they are non-empty.
 
   /// Return all of the attributes for the argument at 'index'.
   ArrayRef<NamedAttribute> getArgAttrs(unsigned index) {
     return ::mlir::impl::getArgAttrs(this->getOperation(), index);
   }
 
   /// Return all argument attributes of this function.
-  void getAllArgAttrs(SmallVectorImpl<NamedAttributeList> &result) {
+  void getAllArgAttrs(SmallVectorImpl<MutableDictionaryAttr> &result) {
     for (unsigned i = 0, e = getNumArguments(); i != e; ++i)
       result.emplace_back(getArgAttrDict(i));
   }
 
   /// Return the specified attribute, if present, for the argument at 'index',
   /// null otherwise.
   Attribute getArgAttr(unsigned index, Identifier name) {
     auto argDict = getArgAttrDict(index);
public:
   }
   template <typename AttrClass>
   AttrClass getArgAttrOfType(unsigned index, StringRef name) {
     return getArgAttr(index, name).template dyn_cast_or_null<AttrClass>();
   }
 
   /// Set the attributes held by the argument at 'index'.
   void setArgAttrs(unsigned index, ArrayRef<NamedAttribute> attributes);
-  void setArgAttrs(unsigned index, NamedAttributeList attributes);
-  void setAllArgAttrs(ArrayRef<NamedAttributeList> attributes) {
+  void setArgAttrs(unsigned index, MutableDictionaryAttr attributes);
+  void setAllArgAttrs(ArrayRef<MutableDictionaryAttr> attributes) {
     assert(attributes.size() == getNumArguments());
     for (unsigned i = 0, e = attributes.size(); i != e; ++i)
       setArgAttrs(i, attributes[i]);
   }
 
   /// 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.
   void setArgAttr(unsigned index, Identifier name, Attribute value);
   void setArgAttr(unsigned index, StringRef name, Attribute value) {
     setArgAttr(index, Identifier::get(name, this->getOperation()->getContext()),
                value);
   }
 
   /// Remove the attribute 'name' from the argument at 'index'.
-  NamedAttributeList::RemoveResult removeArgAttr(unsigned index,
+  MutableDictionaryAttr::RemoveResult removeArgAttr(unsigned index,
                                                     Identifier name);
 
   //===--------------------------------------------------------------------===//
   // Result Attributes
   //===--------------------------------------------------------------------===//
 
   /// FunctionLike operations allow for attaching attributes to each of the
   /// respective function results. These result attributes are stored as
   /// DictionaryAttrs in the main operation attribute dictionary. The name of
   /// these entries is `result` followed by the index of the result. These
   /// result attribute dictionaries are optional, and will generally only
   /// exist if they are non-empty.
 
   /// Return all of the attributes for the result at 'index'.
   ArrayRef<NamedAttribute> getResultAttrs(unsigned index) {
     return ::mlir::impl::getResultAttrs(this->getOperation(), index);
   }
 
   /// Return all result attributes of this function.
-  void getAllResultAttrs(SmallVectorImpl<NamedAttributeList> &result) {
+  void getAllResultAttrs(SmallVectorImpl<MutableDictionaryAttr> &result) {
     for (unsigned i = 0, e = getNumResults(); i != e; ++i)
       result.emplace_back(getResultAttrDict(i));
   }
 
   /// Return the specified attribute, if present, for the result at 'index',
   /// null otherwise.
   Attribute getResultAttr(unsigned index, Identifier name) {
     auto argDict = getResultAttrDict(index);
public:
   }
   template <typename AttrClass>
   AttrClass getResultAttrOfType(unsigned index, StringRef name) {
     return getResultAttr(index, name).template dyn_cast_or_null<AttrClass>();
   }
 
   /// Set the attributes held by the result at 'index'.
   void setResultAttrs(unsigned index, ArrayRef<NamedAttribute> attributes);
-  void setResultAttrs(unsigned index, NamedAttributeList attributes);
-  void setAllResultAttrs(ArrayRef<NamedAttributeList> attributes) {
+  void setResultAttrs(unsigned index, MutableDictionaryAttr attributes);
+  void setAllResultAttrs(ArrayRef<MutableDictionaryAttr> attributes) {
     assert(attributes.size() == getNumResults());
     for (unsigned i = 0, e = attributes.size(); i != e; ++i)
       setResultAttrs(i, attributes[i]);
   }
 
   /// 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.
   void setResultAttr(unsigned index, Identifier name, Attribute value);
   void setResultAttr(unsigned index, StringRef name, Attribute value) {
     setResultAttr(index,
                   Identifier::get(name, this->getOperation()->getContext()),
                   value);
   }
 
   /// Remove the attribute 'name' from the result at 'index'.
-  NamedAttributeList::RemoveResult removeResultAttr(unsigned index,
+  MutableDictionaryAttr::RemoveResult removeResultAttr(unsigned index,
                                                        Identifier name);
 
 protected:
   /// Returns the attribute entry name for the set of argument attributes at
   /// 'index'.
   static StringRef getArgAttrName(unsigned index, SmallVectorImpl<char> &out) {
     return ::mlir::impl::getArgAttrName(index, out);
   }
 
void FunctionLike<ConcreteType>::setArgAttrs(
   if (attributes.empty())
     return (void)static_cast<ConcreteType *>(this)->removeAttr(nameOut);
   Operation *op = this->getOperation();
   op->setAttr(nameOut, DictionaryAttr::get(attributes, op->getContext()));
 }
 
 template <typename ConcreteType>
 void FunctionLike<ConcreteType>::setArgAttrs(unsigned index,
-                                             NamedAttributeList attributes) {
+                                             MutableDictionaryAttr attributes) {
   assert(index < getNumArguments() && "invalid argument number");
   SmallString<8> nameOut;
   if (auto newAttr = attributes.getDictionary())
     return this->getOperation()->setAttr(getArgAttrName(index, nameOut),
                                          newAttr);
   static_cast<ConcreteType *>(this)->removeAttr(getArgAttrName(index, nameOut));
 }
 
 /// 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.
 template <typename ConcreteType>
 void FunctionLike<ConcreteType>::setArgAttr(unsigned index, Identifier name,
                                             Attribute value) {
   auto curAttr = getArgAttrDict(index);
-  NamedAttributeList attrList(curAttr);
-  attrList.set(name, value);
+  MutableDictionaryAttr attrDict(curAttr);
+  attrDict.set(name, value);
 
   // If the attribute changed, then set the new arg attribute list.
-  if (curAttr != attrList.getDictionary())
-    setArgAttrs(index, attrList);
+  if (curAttr != attrDict.getDictionary())
+    setArgAttrs(index, attrDict);
 }
 
 /// Remove the attribute 'name' from the argument at 'index'.
 template <typename ConcreteType>
-NamedAttributeList::RemoveResult
+MutableDictionaryAttr::RemoveResult
 FunctionLike<ConcreteType>::removeArgAttr(unsigned index, Identifier name) {
   // Build an attribute list and remove the attribute at 'name'.
-  NamedAttributeList attrList(getArgAttrDict(index));
-  auto result = attrList.remove(name);
+  MutableDictionaryAttr attrDict(getArgAttrDict(index));
+  auto result = attrDict.remove(name);
 
   // If the attribute was removed, then update the argument dictionary.
-  if (result == NamedAttributeList::RemoveResult::Removed)
-    setArgAttrs(index, attrList);
+  if (result == MutableDictionaryAttr::RemoveResult::Removed)
+    setArgAttrs(index, attrDict);
   return result;
 }
 
 //===----------------------------------------------------------------------===//
 // Function Result Attribute.
 //===----------------------------------------------------------------------===//
 
 /// Set the attributes held by the result at 'index'.
 template <typename ConcreteType>
 void FunctionLike<ConcreteType>::setResultAttrs(
     unsigned index, ArrayRef<NamedAttribute> attributes) {
   assert(index < getNumResults() && "invalid result number");
   SmallString<8> nameOut;
   getResultAttrName(index, nameOut);
 
   if (attributes.empty())
     return (void)static_cast<ConcreteType *>(this)->removeAttr(nameOut);
   Operation *op = this->getOperation();
   op->setAttr(nameOut, DictionaryAttr::get(attributes, op->getContext()));
 }
 
 template <typename ConcreteType>
-void FunctionLike<ConcreteType>::setResultAttrs(unsigned index,
-                                                NamedAttributeList attributes) {
+void FunctionLike<ConcreteType>::setResultAttrs(
+    unsigned index, MutableDictionaryAttr attributes) {
   assert(index < getNumResults() && "invalid result number");
   SmallString<8> nameOut;
   if (auto newAttr = attributes.getDictionary())
     return this->getOperation()->setAttr(getResultAttrName(index, nameOut),
                                          newAttr);
   static_cast<ConcreteType *>(this)->removeAttr(
       getResultAttrName(index, nameOut));
 }
 
 /// 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.
 template <typename ConcreteType>
 void FunctionLike<ConcreteType>::setResultAttr(unsigned index, Identifier name,
                                                Attribute value) {
   auto curAttr = getResultAttrDict(index);
-  NamedAttributeList attrList(curAttr);
-  attrList.set(name, value);
+  MutableDictionaryAttr attrDict(curAttr);
+  attrDict.set(name, value);
 
   // If the attribute changed, then set the new arg attribute list.
-  if (curAttr != attrList.getDictionary())
-    setResultAttrs(index, attrList);
+  if (curAttr != attrDict.getDictionary())
+    setResultAttrs(index, attrDict);
 }
 
 /// Remove the attribute 'name' from the result at 'index'.
 template <typename ConcreteType>
-NamedAttributeList::RemoveResult
+MutableDictionaryAttr::RemoveResult
 FunctionLike<ConcreteType>::removeResultAttr(unsigned index, Identifier name) {
   // Build an attribute list and remove the attribute at 'name'.
-  NamedAttributeList attrList(getResultAttrDict(index));
-  auto result = attrList.remove(name);
+  MutableDictionaryAttr attrDict(getResultAttrDict(index));
+  auto result = attrDict.remove(name);
 
   // If the attribute was removed, then update the result dictionary.
-  if (result == NamedAttributeList::RemoveResult::Removed)
-    setResultAttrs(index, attrList);
+  if (result == MutableDictionaryAttr::RemoveResult::Removed)
+    setResultAttrs(index, attrDict);
   return result;
 }
 
 } // end namespace OpTrait
 
 } // end namespace mlir
 
 #endif // MLIR_IR_FUNCTIONSUPPORT_H

mlir/include/mlir/IR/OpDefinition.h

public:
   void setAttr(StringRef name, Attribute value) {
     setAttr(Identifier::get(name, getContext()), value);
   }
 
   /// Set the attributes held by this operation.
   void setAttrs(ArrayRef<NamedAttribute> attributes) {
     state->setAttrs(attributes);
   }
-  void setAttrs(NamedAttributeList newAttrs) { state->setAttrs(newAttrs); }
+  void setAttrs(MutableDictionaryAttr newAttrs) { state->setAttrs(newAttrs); }
 
   /// Set the dialect attributes for this operation, and preserve all dependent.
   template <typename DialectAttrs> void setDialectAttrs(DialectAttrs &&attrs) {
     state->setDialectAttrs(std::move(attrs));
   }
 
   /// Remove the attribute with the specified name if it exists.  The return
   /// value indicates whether the attribute was present or not.
-  NamedAttributeList::RemoveResult removeAttr(Identifier name) {
+  MutableDictionaryAttr::RemoveResult removeAttr(Identifier name) {
     return state->removeAttr(name);
   }
-  NamedAttributeList::RemoveResult removeAttr(StringRef name) {
+  MutableDictionaryAttr::RemoveResult removeAttr(StringRef name) {
     return state->removeAttr(Identifier::get(name, getContext()));
   }
 
   /// Return true if there are no users of any results of this operation.
   bool use_empty() { return state->use_empty(); }
 
   /// Remove this operation from its parent block and delete it.
   void erase() { state->erase(); }

mlir/include/mlir/IR/Operation.h

: public llvm::ilist_node_with_parent<Operation, Block>,
                                     Region, detail::OperandStorage> {
 public:
   /// Create a new Operation with the specific fields.
   static Operation *create(Location location, OperationName name,
                            ArrayRef<Type> resultTypes, ArrayRef<Value> operands,
                            ArrayRef<NamedAttribute> attributes,
                            ArrayRef<Block *> successors, unsigned numRegions);
 
-  /// Overload of create that takes an existing NamedAttributeList to avoid
+  /// Overload of create that takes an existing MutableDictionaryAttr to avoid
   /// unnecessarily uniquing a list of attributes.
   static Operation *create(Location location, OperationName name,
                            ArrayRef<Type> resultTypes, ArrayRef<Value> operands,
-                           NamedAttributeList attributes,
+                           MutableDictionaryAttr attributes,
                            ArrayRef<Block *> successors, unsigned numRegions);
 
   /// Create a new Operation from the fields stored in `state`.
   static Operation *create(const OperationState &state);
 
   /// Create a new Operation with the specific fields.
   static Operation *create(Location location, OperationName name,
                            ArrayRef<Type> resultTypes, ArrayRef<Value> operands,
-                           NamedAttributeList attributes,
+                           MutableDictionaryAttr attributes,
                            ArrayRef<Block *> successors = {},
                            RegionRange regions = {});
 
   /// The name of an operation is the key identifier for it.
   OperationName getName() { return name; }
 
   /// If this operation has a registered operation description, return it.
   /// Otherwise return null.
public:
 
   // Operations may optionally carry a list of attributes that associate
   // constants to names.  Attributes may be dynamically added and removed over
   // the lifetime of an operation.
 
   /// Return all of the attributes on this operation.
   ArrayRef<NamedAttribute> getAttrs() { return attrs.getAttrs(); }
 
-  /// Return the internal attribute list on this operation.
-  NamedAttributeList &getAttrList() { return attrs; }
+  /// Return mutable container of all the attributes on this operation.
+  MutableDictionaryAttr &getMutableAttrDict() { return attrs; }
 
-  /// Set the attribute list on this operation.
-  /// Using a NamedAttributeList is more efficient as it does not require new
+  /// Set the attribute dictionary on this operation.
+  /// Using a MutableDictionaryAttr is more efficient as it does not require new
   /// uniquing in the MLIRContext.
-  void setAttrs(NamedAttributeList newAttrs) { attrs = newAttrs; }
+  void setAttrs(MutableDictionaryAttr newAttrs) { attrs = newAttrs; }
 
   /// Return the specified attribute if present, null otherwise.
   Attribute getAttr(Identifier name) { return attrs.get(name); }
   Attribute getAttr(StringRef name) { return attrs.get(name); }
 
   template <typename AttrClass> AttrClass getAttrOfType(Identifier name) {
     return getAttr(name).dyn_cast_or_null<AttrClass>();
   }
 
   template <typename AttrClass> AttrClass getAttrOfType(StringRef name) {
     return getAttr(name).dyn_cast_or_null<AttrClass>();
   }
 
   /// 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.
   void setAttr(Identifier name, Attribute value) { attrs.set(name, value); }
   void setAttr(StringRef name, Attribute value) {
     setAttr(Identifier::get(name, getContext()), value);
   }
 
   /// Remove the attribute with the specified name if it exists.  The return
   /// value indicates whether the attribute was present or not.
-  NamedAttributeList::RemoveResult removeAttr(Identifier name) {
+  MutableDictionaryAttr::RemoveResult removeAttr(Identifier name) {
     return attrs.remove(name);
   }
 
   /// 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) {
private:
   void updateOrderIfNecessary();
 
   /// Returns true if this operation has a valid order.
   bool hasValidOrder() { return orderIndex != kInvalidOrderIdx; }
 
 private:
   Operation(Location location, OperationName name, ArrayRef<Type> resultTypes,
             unsigned numSuccessors, unsigned numRegions,
-            const NamedAttributeList &attributes, bool hasOperandStorage);
+            const MutableDictionaryAttr &attributes, bool hasOperandStorage);
 
   // Operations are deleted through the destroy() member because they are
   // allocated with malloc.
   ~Operation();
 
   /// Returns the operand storage object.
   detail::OperandStorage &getOperandStorage() {
     assert(hasOperandStorage && "expected operation to have operand storage");
private:
   /// can use 'resultType` in an ArrayRef<Type>.
   bool hasSingleResult : 1;
   Type resultType;
 
   /// This holds the name of the operation.
   OperationName name;
 
   /// This holds general named attributes for the operation.
-  NamedAttributeList attrs;
+  MutableDictionaryAttr attrs;
 
   // allow ilist_traits access to 'block' field.
   friend struct llvm::ilist_traits<Operation>;
 
   // allow block to access the 'orderIndex' field.
   friend class Block;
 
   // allow value to access the 'ResultStorage' methods.

mlir/lib/Analysis/CallGraph.cpp

if (node->isExternal()) {
       os << "<External-Node>";
       return;
     }
 
     auto *callableRegion = node->getCallableRegion();
     auto *parentOp = callableRegion->getParentOp();
     os << "'" << callableRegion->getParentOp()->getName() << "' - Region #"
        << callableRegion->getRegionNumber();
-    if (auto attrs = parentOp->getAttrList().getDictionary())
+    if (auto attrs = parentOp->getMutableAttrDict().getDictionary())
       os << " : " << attrs;
   };
 
   for (auto &nodeIt : nodes) {
     const CallGraphNode *node = nodeIt.second.get();
 
     // Dump the header for this node.
     os << "// - Node : ";

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

Block *LLVMFuncOp::addEntryBlock() {
   for (unsigned i = 0, e = type.getFunctionNumParams(); i < e; ++i)
     entry->addArgument(type.getFunctionParamType(i));
   return entry;
 }
 
 void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
                        StringRef name, LLVMType type, LLVM::Linkage linkage,
                        ArrayRef<NamedAttribute> attrs,
-                       ArrayRef<NamedAttributeList> argAttrs) {
+                       ArrayRef<MutableDictionaryAttr> argAttrs) {
   result.addRegion();
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute("type", TypeAttr::get(type));
   result.addAttribute(getLinkageAttrName(),
                       builder.getI64IntegerAttr(static_cast<int64_t>(linkage)));
   result.attributes.append(attrs.begin(), attrs.end());
   if (argAttrs.empty())

mlir/lib/Dialect/SPIRV/SPIRVCanonicalization.cpp

LogicalResult canCanonicalizeSelection(Block *trueBlock, Block *falseBlock,
                                          Block *mergeBlock) const;
 
   bool onlyContainsBranchConditionalOp(Block *block) const {
     return std::next(block->begin()) == block->end() &&
            isa<spirv::BranchConditionalOp>(block->front());
   }
 
   bool isSameAttrList(spirv::StoreOp lhs, spirv::StoreOp rhs) const {
-    return lhs.getOperation()->getAttrList().getDictionary() ==
-           rhs.getOperation()->getAttrList().getDictionary();
+    return lhs.getOperation()->getMutableAttrDict().getDictionary() ==
+           rhs.getOperation()->getMutableAttrDict().getDictionary();
   }
 
 
   // Returns a source value for the given block.
   Value getSrcValue(Block *block) const {
     auto storeOp = cast<spirv::StoreOp>(block->front());
     return storeOp.value();
   }

mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp

private:
 
   // Mapping from result <id> to undef value of a type.
   DenseMap<uint32_t, Type> undefMap;
 
   // Result <id> to name mapping.
   DenseMap<uint32_t, StringRef> nameMap;
 
   // Result <id> to decorations mapping.
-  DenseMap<uint32_t, NamedAttributeList> decorations;
+  DenseMap<uint32_t, MutableDictionaryAttr> decorations;
 
   // Result <id> to type decorations.
   DenseMap<uint32_t, uint32_t> typeDecorations;
 
   // Result <id> to member decorations.
   // decorated-struct-type-<id> ->
   //    (struct-member-index -> (decoration -> decoration-operands))
   DenseMap<uint32_t,

mlir/lib/IR/Attributes.cpp

std::vector<ptrdiff_t> SparseElementsAttr::getFlattenedSparseIndices() const {
   size_t rank = getType().getRank();
   for (size_t i = 0, e = numSparseIndices; i != e; ++i)
     flatSparseIndices.push_back(getFlattenedIndex(
         {&*std::next(sparseIndexValues.begin(), i * rank), rank}));
   return flatSparseIndices;
 }
 
 //===----------------------------------------------------------------------===//
-// NamedAttributeList
+// MutableDictionaryAttr
 //===----------------------------------------------------------------------===//
 
-NamedAttributeList::NamedAttributeList(ArrayRef<NamedAttribute> attributes) {
+MutableDictionaryAttr::MutableDictionaryAttr(
+    ArrayRef<NamedAttribute> attributes) {
   setAttrs(attributes);
 }
 
-ArrayRef<NamedAttribute> NamedAttributeList::getAttrs() const {
+ArrayRef<NamedAttribute> MutableDictionaryAttr::getAttrs() const {
   return attrs ? attrs.getValue() : llvm::None;
 }
 
 /// Replace the held attributes with ones provided in 'newAttrs'.
-void NamedAttributeList::setAttrs(ArrayRef<NamedAttribute> attributes) {
+void MutableDictionaryAttr::setAttrs(ArrayRef<NamedAttribute> attributes) {
   // Don't create an attribute list if there are no attributes.
   if (attributes.empty())
     attrs = nullptr;
   else
     attrs = DictionaryAttr::get(attributes, attributes[0].second.getContext());
 }
 
 /// Return the specified attribute if present, null otherwise.
-Attribute NamedAttributeList::get(StringRef name) const {
+Attribute MutableDictionaryAttr::get(StringRef name) const {
   return attrs ? attrs.get(name) : nullptr;
 }
 
 /// Return the specified attribute if present, null otherwise.
-Attribute NamedAttributeList::get(Identifier name) const {
+Attribute MutableDictionaryAttr::get(Identifier name) const {
   return attrs ? attrs.get(name) : nullptr;
 }
 
 /// 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.
-void NamedAttributeList::set(Identifier name, Attribute value) {
+void MutableDictionaryAttr::set(Identifier name, Attribute value) {
   assert(value && "attributes may never be null");
 
   // Look for an existing value for the given name, and set it in-place.
   ArrayRef<NamedAttribute> values = getAttrs();
   auto it = llvm::find_if(
       values, [name](NamedAttribute attr) { return attr.first == name; });
   if (it != values.end()) {
     // Bail out early if the value is the same as what we already have.
void MutableDictionaryAttr::set(Identifier name, Attribute value) {
   newAttrs.append(values.begin(), it);
   newAttrs.push_back({name, value});
   newAttrs.append(it, values.end());
   attrs = DictionaryAttr::getWithSorted(newAttrs, value.getContext());
 }
 
 /// Remove the attribute with the specified name if it exists.  The return
 /// value indicates whether the attribute was present or not.
-auto NamedAttributeList::remove(Identifier name) -> RemoveResult {
+auto MutableDictionaryAttr::remove(Identifier name) -> RemoveResult {
   auto origAttrs = getAttrs();
   for (unsigned i = 0, e = origAttrs.size(); i != e; ++i) {
     if (origAttrs[i].first == name) {
       // Handle the simple case of removing the only attribute in the list.
       if (e == 1) {
         attrs = nullptr;
         return RemoveResult::Removed;
       }

mlir/lib/IR/Function.cpp

 }
 FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
                       iterator_range<dialect_attr_iterator> attrs) {
   SmallVector<NamedAttribute, 8> attrRef(attrs);
   return create(location, name, type, llvm::makeArrayRef(attrRef));
 }
 FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
                       ArrayRef<NamedAttribute> attrs,
-                      ArrayRef<NamedAttributeList> argAttrs) {
+                      ArrayRef<MutableDictionaryAttr> argAttrs) {
   FuncOp func = create(location, name, type, attrs);
   func.setAllArgAttrs(argAttrs);
   return func;
 }
 
 void FuncOp::build(OpBuilder &builder, OperationState &result, StringRef name,
                    FunctionType type, ArrayRef<NamedAttribute> attrs) {
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
   result.attributes.append(attrs.begin(), attrs.end());
   result.addRegion();
 }
 
 void FuncOp::build(OpBuilder &builder, OperationState &result, StringRef name,
                    FunctionType type, ArrayRef<NamedAttribute> attrs,
-                   ArrayRef<NamedAttributeList> argAttrs) {
+                   ArrayRef<MutableDictionaryAttr> argAttrs) {
   build(builder, result, name, type, attrs);
   assert(type.getNumInputs() == argAttrs.size());
   SmallString<8> argAttrName;
   for (unsigned i = 0, e = type.getNumInputs(); i != e; ++i)
     if (auto argDict = argAttrs[i].getDictionary())
       result.addAttribute(getArgAttrName(i, argAttrName), argDict);
 }
 
void FuncOp::eraseArguments(ArrayRef<unsigned> argIndices) {
 
   // There are 3 things that need to be updated:
   // - Function type.
   // - Arg attrs.
   // - Block arguments of entry block.
 
   // Update the function type and arg attrs.
   SmallVector<Type, 4> newInputTypes;
-  SmallVector<NamedAttributeList, 4> newArgAttrs;
+  SmallVector<MutableDictionaryAttr, 4> newArgAttrs;
   for (int i = 0; i < originalNumArgs; i++) {
     if (shouldEraseArg(i))
       continue;
     newInputTypes.emplace_back(oldType.getInput(i));
     newArgAttrs.emplace_back(getArgAttrDict(i));
   }
   setType(FunctionType::get(newInputTypes, oldType.getResults(), getContext()));
   setAllArgAttrs(newArgAttrs);

mlir/lib/IR/Module.cpp

LogicalResult ModuleOp::verify() {
 
   // Check that the body has no block arguments.
   auto *body = &bodyRegion.front();
   if (body->getNumArguments() != 0)
     return emitOpError("expected body to have no arguments");
 
   // Check that none of the attributes are non-dialect attributes, except for
   // the symbol related attributes.
-  for (auto attr : getOperation()->getAttrList().getAttrs()) {
+  for (auto attr : getOperation()->getMutableAttrDict().getAttrs()) {
     if (!attr.first.strref().contains('.') &&
         !llvm::is_contained(
             ArrayRef<StringRef>{mlir::SymbolTable::getSymbolAttrName(),
                                 mlir::SymbolTable::getVisibilityAttrName()},
             attr.first.strref()))
       return emitOpError(
                  "can only contain dialect-specific attributes, found: '")
              << attr.first << "'";

mlir/lib/IR/Operation.cpp

 /// Create a new Operation with the specific fields.
 Operation *Operation::create(Location location, OperationName name,
                              ArrayRef<Type> resultTypes,
                              ArrayRef<Value> operands,
                              ArrayRef<NamedAttribute> attributes,
                              ArrayRef<Block *> successors,
                              unsigned numRegions) {
   return create(location, name, resultTypes, operands,
-                NamedAttributeList(attributes), successors, numRegions);
+                MutableDictionaryAttr(attributes), successors, numRegions);
 }
 
 /// Create a new Operation from operation state.
 Operation *Operation::create(const OperationState &state) {
-  return Operation::create(state.location, state.name, state.types,
-                           state.operands, NamedAttributeList(state.attributes),
-                           state.successors, state.regions);
+  return Operation::create(
+      state.location, state.name, state.types, state.operands,
+      MutableDictionaryAttr(state.attributes), state.successors, state.regions);
 }
 
 /// Create a new Operation with the specific fields.
 Operation *Operation::create(Location location, OperationName name,
                              ArrayRef<Type> resultTypes,
                              ArrayRef<Value> operands,
-                             NamedAttributeList attributes,
+                             MutableDictionaryAttr attributes,
                              ArrayRef<Block *> successors,
                              RegionRange regions) {
   unsigned numRegions = regions.size();
   Operation *op = create(location, name, resultTypes, operands, attributes,
                          successors, numRegions);
   for (unsigned i = 0; i < numRegions; ++i)
     if (regions[i])
       op->getRegion(i).takeBody(*regions[i]);
   return op;
 }
 
-/// Overload of create that takes an existing NamedAttributeList to avoid
+/// Overload of create that takes an existing MutableDictionaryAttr to avoid
 /// unnecessarily uniquing a list of attributes.
 Operation *Operation::create(Location location, OperationName name,
                              ArrayRef<Type> resultTypes,
                              ArrayRef<Value> operands,
-                             NamedAttributeList attributes,
+                             MutableDictionaryAttr attributes,
                              ArrayRef<Block *> successors,
                              unsigned numRegions) {
   // We only need to allocate additional memory for a subset of results.
   unsigned numTrailingResults = OpResult::getNumTrailing(resultTypes.size());
   unsigned numInlineResults = OpResult::getNumInline(resultTypes.size());
   unsigned numSuccessors = successors.size();
   unsigned numOperands = operands.size();
 
Operation *Operation::create(Location location, OperationName name,
   for (unsigned i = 0; i != numSuccessors; ++i)
     new (&blockOperands[i]) BlockOperand(op, successors[i]);
 
   return op;
 }
 
 Operation::Operation(Location location, OperationName name,
                      ArrayRef<Type> resultTypes, unsigned numSuccessors,
-                     unsigned numRegions, const NamedAttributeList &attributes,
+                     unsigned numRegions,
+                     const MutableDictionaryAttr &attributes,
                      bool hasOperandStorage)
     : location(location), numSuccs(numSuccessors), numRegions(numRegions),
       hasOperandStorage(hasOperandStorage), hasSingleResult(false), name(name),
       attrs(attributes) {
   if (!resultTypes.empty()) {
     // If there is a single result it is stored in-place, otherwise use a tuple.
     hasSingleResult = resultTypes.size() == 1;
     if (hasSingleResult)

mlir/lib/IR/SymbolTable.cpp

 /// May have the following access chain:
 ///
 ///     [0, 0, 1]
 ///
 static WalkResult walkSymbolRefs(
     Operation *op,
     function_ref<WalkResult(SymbolTable::SymbolUse, ArrayRef<int>)> callback) {
   // Check to see if the operation has any attributes.
-  DictionaryAttr attrDict = op->getAttrList().getDictionary();
+  DictionaryAttr attrDict = op->getMutableAttrDict().getDictionary();
   if (!attrDict)
     return WalkResult::advance();
 
   // A worklist of a container attribute and the current index into the held
   // attribute list.
   SmallVector<Attribute, 1> attrWorklist(1, attrDict);
   SmallVector<int, 1> curAccessChain(1, /*Value=*/-1);
 
replaceAllSymbolUsesImpl(SymbolT symbol, StringRef newSymbol, IRUnitT *limit) {
 
   // The set of access chains into the attribute dictionary of the current
   // operation, as well as the replacement attribute to use.
   SmallVector<std::pair<SmallVector<int, 1>, SymbolRefAttr>, 1> accessChains;
 
   // Generate a new attribute dictionary for the current operation by replacing
   // references to the old symbol.
   auto generateNewAttrDict = [&] {
-    auto oldDict = curOp->getAttrList().getDictionary();
+    auto oldDict = curOp->getMutableAttrDict().getDictionary();
     auto newDict = rebuildAttrAfterRAUW(oldDict, accessChains, /*depth=*/0);
     return newDict.cast<DictionaryAttr>();
   };
 
   // Generate a new attribute to replace the given attribute.
   MLIRContext *ctx = limit->getContext();
   FlatSymbolRefAttr newLeafAttr = FlatSymbolRefAttr::get(newSymbol, ctx);
   for (SymbolScope &scope : collectSymbolScopes(symbol, limit)) {

mlir/lib/Parser/Parser.cpp

case Token::eof: {
       assert(!operations.empty() && "expected a valid module terminator");
 
       // Check that the first operation is a module, and it is the only
       // non-terminator operation.
       ModuleOp nested = dyn_cast<ModuleOp>(operations.front());
       if (nested && std::next(operations.begin(), 2) == operations.end()) {
         // Merge the data of the nested module operation into 'module'.
         module.setLoc(nested.getLoc());
-        module.setAttrs(nested.getOperation()->getAttrList());
+        module.setAttrs(nested.getOperation()->getMutableAttrDict());
         bodyBlocks.splice(bodyBlocks.end(), nested.getBodyRegion().getBlocks());
 
         // Erase the original module body.
         bodyBlocks.pop_front();
       }
 
       return opParser.popSSANameScope();
     }

mlir/lib/Pass/IRPrinting.cpp

public:
   OperationFingerPrint(Operation *topOp) {
     llvm::SHA1 hasher;
 
     // Hash each of the operations based upon their mutable bits:
     topOp->walk([&](Operation *op) {
       //   - Operation pointer
       addDataToHash(hasher, op);
       //   - Attributes
-      addDataToHash(hasher,
-                    op->getAttrList().getDictionary().getAsOpaquePointer());
+      addDataToHash(
+          hasher,
+          op->getMutableAttrDict().getDictionary().getAsOpaquePointer());
       //   - Blocks in Regions
       for (Region &region : op->getRegions()) {
         for (Block &block : region) {
           addDataToHash(hasher, &block);
           for (BlockArgument arg : block.getArguments())
             addDataToHash(hasher, arg);
         }
       }

mlir/lib/Transforms/CSE.cpp

struct SimpleOperationInfo : public llvm::DenseMapInfo<Operation *> {
   static unsigned getHashValue(const Operation *opC) {
     auto *op = const_cast<Operation *>(opC);
     // Hash the operations based upon their:
     //   - Operation Name
     //   - Attributes
     //   - Result Types
     //   - Operands
     return llvm::hash_combine(
-        op->getName(), op->getAttrList().getDictionary(), op->getResultTypes(),
+        op->getName(), op->getMutableAttrDict().getDictionary(),
+        op->getResultTypes(),
         llvm::hash_combine_range(op->operand_begin(), op->operand_end()));
   }
   static bool isEqual(const Operation *lhsC, const Operation *rhsC) {
     auto *lhs = const_cast<Operation *>(lhsC);
     auto *rhs = const_cast<Operation *>(rhsC);
     if (lhs == rhs)
       return true;
     if (lhs == getTombstoneKey() || lhs == getEmptyKey() ||
         rhs == getTombstoneKey() || rhs == getEmptyKey())
       return false;
 
     // Compare the operation name.
     if (lhs->getName() != rhs->getName())
       return false;
     // Check operand and result type counts.
     if (lhs->getNumOperands() != rhs->getNumOperands() ||
         lhs->getNumResults() != rhs->getNumResults())
       return false;
     // Compare attributes.
-    if (lhs->getAttrList() != rhs->getAttrList())
+    if (lhs->getMutableAttrDict() != rhs->getMutableAttrDict())
       return false;
     // Compare operands.
     if (!std::equal(lhs->operand_begin(), lhs->operand_end(),
                     rhs->operand_begin()))
       return false;
     // Compare result types.
     return std::equal(lhs->result_type_begin(), lhs->result_type_end(),
                       rhs->result_type_begin());

mlir/lib/Transforms/DialectConversion.cpp

 
 /// The state of an operation that was updated by a pattern in-place. This
 /// contains all of the necessary information to reconstruct an operation that
 /// was updated in place.
 class OperationTransactionState {
 public:
   OperationTransactionState() = default;
   OperationTransactionState(Operation *op)
-      : op(op), loc(op->getLoc()), attrs(op->getAttrList()),
+      : op(op), loc(op->getLoc()), attrs(op->getMutableAttrDict()),
         operands(op->operand_begin(), op->operand_end()),
         successors(op->successor_begin(), op->successor_end()) {}
 
   /// Discard the transaction state and reset the state of the original
   /// operation.
   void resetOperation() const {
     op->setLoc(loc);
     op->setAttrs(attrs);
     op->setOperands(operands);
     for (auto it : llvm::enumerate(successors))
       op->setSuccessor(it.value(), it.index());
   }
 
   /// Return the original operation of this state.
   Operation *getOperation() const { return op; }
 
 private:
   Operation *op;
   LocationAttr loc;
-  NamedAttributeList attrs;
+  MutableDictionaryAttr attrs;
   SmallVector<Value, 8> operands;
   SmallVector<Block *, 2> successors;
 };
 } // end anonymous namespace
 
 namespace mlir {
 namespace detail {
 struct ConversionPatternRewriterImpl {

mlir/lib/Transforms/SCCP.cpp

void SCCPSolver::visitOperation(Operation *op) {
   auto isOverdefinedFn = [&](Value value) { return isOverdefined(value); };
   if (llvm::all_of(op->getResults(), isOverdefinedFn))
     return;
 
   // Save the original operands and attributes just in case the operation folds
   // in-place. The constant passed in may not correspond to the real runtime
   // value, so in-place updates are not allowed.
   SmallVector<Value, 8> originalOperands(op->getOperands());
-  NamedAttributeList originalAttrs = op->getAttrList();
+  MutableDictionaryAttr originalAttrs = op->getMutableAttrDict();
 
   // Simulate the result of folding this operation to a constant. If folding
   // fails or was an in-place fold, mark the results as overdefined.
   SmallVector<OpFoldResult, 8> foldResults;
   foldResults.reserve(op->getNumResults());
   if (failed(op->fold(operandConstants, foldResults)))
     return markAllOverdefined(op, op->getResults());