[mlir][core] Inline Intrinsic Attributes

[Mogball]

Summary

PoC patch.

[jpienaar]

Could you expand the description to give the why's of the change?

mlir/include/mlir/IR/OperationSupport.h

532

Class comment?

533

Not sure the unsigned comment make sense. Many also consider using unsigned to represent non-negative constraint as anti-pattern (see previous discussion on list).

567

Also document what is returned when it is not found.

[Mogball]

mlir/include/mlir/IR/OperationSupport.h

533

In this case it's important to keep the size of Operation smaller. E.g. we use unsigned for the number of successors instead of size_t because it's half the size.

std::vector (by default) is 33% bigger than SmallVector because its size and capacity are 64 bit

flang/include/flang/Optimizer/Builder/FIRBuilder.h

public:
 
   /// Create a temporary. A temp is allocated using `fir.alloca` and can be read
   /// and written using `fir.load` and `fir.store`, resp.  The temporary can be
   /// given a name via a front-end `Symbol` or a `StringRef`.
   mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
                               llvm::StringRef name = {},
                               mlir::ValueRange shape = {},
                               mlir::ValueRange lenParams = {},
-                              llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
+                              mlir::AttributeRange attrs = {});
 
   /// Create an unnamed and untracked temporary on the stack.
   mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
                               mlir::ValueRange shape) {
     return createTemporary(loc, type, llvm::StringRef{}, shape);
   }
 
   mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
-                              llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+                              mlir::AttributeRange attrs) {
     return createTemporary(loc, type, llvm::StringRef{}, {}, {}, attrs);
   }
 
   mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
                               llvm::StringRef name,
-                              llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+                              mlir::AttributeRange attrs) {
     return createTemporary(loc, type, name, {}, {}, attrs);
   }
 
   /// Create a global value.
   fir::GlobalOp createGlobal(mlir::Location loc, mlir::Type type,
                              llvm::StringRef name,
                              mlir::StringAttr linkage = {},
                              mlir::Attribute value = {}, bool isConst = false);

flang/include/flang/Optimizer/Dialect/FIROps.td

class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
   let assemblyFormat = [{
     operands attr-dict `:` functional-type(operands, results)
   }];
 }
 
 def fir_OneResultOpBuilder : OpBuilder<(ins
     "mlir::Type":$resultType,
     "mlir::ValueRange":$operands,
-    CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes),
+    CArg<"mlir::AttributeRange", "{}">:$attributes),
   [{
     if (resultType)
       $_state.addTypes(resultType);
     $_state.addOperands(operands);
     $_state.addAttributes(attributes);
   }]>;
 
 // Base class of FIR operations that return 1 result
def fir_AllocaOp : fir_Op<"alloca", [AttrSizedOperandSegments,
   let parser =
       "return parseAllocatableOp(wrapAllocaResultType, parser, result);";
   let printer = "printAllocatableOp(p, (*this));";
 
   let builders = [
     OpBuilder<(ins "mlir::Type":$inType, "llvm::StringRef":$uniqName,
       "llvm::StringRef":$bindcName, CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType, "llvm::StringRef":$uniqName,
       "llvm::StringRef":$bindcName, "bool":$pinned,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType, "llvm::StringRef":$uniqName,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType, "llvm::StringRef":$uniqName,
       "bool":$pinned, CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType, "bool":$pinned,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>];
 
   let verifier = "return ::verify(*this);";
 
   let extraClassDeclaration = [{
     mlir::Type getAllocatedType();
     bool hasLenParams() { return !typeparams().empty(); }
     bool hasShapeOperands() { return !shape().empty(); }
     unsigned numLenParams() { return typeparams().size(); }
def fir_AllocMemOp : fir_Op<"allocmem",
   let parser =
       "return parseAllocatableOp(wrapAllocMemResultType, parser, result);";
   let printer = "printAllocatableOp(p, (*this));";
 
   let builders = [
     OpBuilder<(ins "mlir::Type":$in_type, "llvm::StringRef":$uniq_name,
       "llvm::StringRef":$bindc_name, CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$in_type, "llvm::StringRef":$uniq_name,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$in_type,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>];
 
   let verifier = "return ::verify(*this);";
 
   let extraClassDeclaration = [{
     mlir::Type getAllocatedType();
     bool hasLenParams() { return !typeparams().empty(); }
     bool hasShapeOperands() { return !shape().empty(); }
     unsigned numLenParams() { return typeparams().size(); }

 class fir_IntegralSwitchTerminatorOp<string mnemonic,
     list<OpTrait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
 
   let skipDefaultBuilders = 1;
   let builders = [OpBuilder<(ins "mlir::Value":$selector,
     "llvm::ArrayRef<int64_t>":$compareOperands,
     "llvm::ArrayRef<mlir::Block *>":$destinations,
     CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
-    CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes),
+    CArg<"mlir::AttributeRange", "{}">:$attributes),
     [{
       $_state.addOperands(selector);
       llvm::SmallVector<mlir::Attribute> ivalues;
       for (auto iv : compareOperands)
         ivalues.push_back($_builder.getI64IntegerAttr(iv));
       ivalues.push_back($_builder.getUnitAttr());
       $_state.addAttribute(getCasesAttr(), $_builder.getArrayAttr(ivalues));
       const auto count = destinations.size();
def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "mlir::Value":$selector,
       "llvm::ArrayRef<mlir::Attribute>":$compareAttrs,
       "llvm::ArrayRef<mlir::ValueRange>":$cmpOperands,
       "llvm::ArrayRef<mlir::Block *>":$destinations,
       CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Value":$selector,
       "llvm::ArrayRef<mlir::Attribute>":$compareAttrs,
       "llvm::ArrayRef<mlir::Value>":$cmpOpList,
       "llvm::ArrayRef<mlir::Block *>":$destinations,
       CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>];
 
   let parser = "return parseSelectCase(parser, result);";
 
   let printer = "::print(p, *this);";
 
   let verifier = "return ::verify(*this);";
 
   let extraClassDeclaration = extraSwitchClassDeclaration#[{
let description = [{
     ```
   }];
 
   let skipDefaultBuilders = 1;
   let builders = [OpBuilder<(ins "mlir::Value":$selector,
     "llvm::ArrayRef<mlir::Attribute>":$typeOperands,
     "llvm::ArrayRef<mlir::Block *>":$destinations,
     CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
-    CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
+    CArg<"mlir::AttributeRange", "{}">:$attributes)>];
 
   let parser = "return parseSelectType(parser, result);";
 
   let printer = "::print(p, *this);";
 
   let verifier = "return ::verify(*this);";
 
   let extraClassDeclaration = extraSwitchClassDeclaration;
def fir_DoLoopOp : region_Op<"do_loop",
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "mlir::Value":$lowerBound, "mlir::Value":$upperBound,
       "mlir::Value":$step, CArg<"bool", "false">:$unordered,
       CArg<"bool", "false">:$finalCountValue,
       CArg<"mlir::ValueRange", "llvm::None">:$iterArgs,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>
   ];
 
   let extraClassDeclaration = [{
     mlir::Value getInductionVar() { return getBody()->getArgument(0); }
     mlir::OpBuilder getBodyBuilder() {
       return OpBuilder(getBody(), std::prev(getBody()->end()));
     }
     mlir::Block::BlockArgListType getRegionIterArgs() {
def fir_IterWhileOp : region_Op<"iterate_while",
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "mlir::Value":$lowerBound, "mlir::Value":$upperBound,
       "mlir::Value":$step, "mlir::Value":$iterate,
       CArg<"bool", "false">:$finalCountValue,
       CArg<"mlir::ValueRange", "llvm::None">:$iterArgs,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>
   ];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef getFinalValueAttrName() {
       return "finalValue";
     }
     mlir::Block *getBody() { return &region().front(); }
     mlir::Value getIterateVar() { return getBody()->getArgument(1); }
def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
 
   let parser = "return parseGlobalOp(parser, result);";
 
   let printer = "::print(p, *this);";
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
+      CArg<"mlir::AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "llvm::StringRef":$name, "bool":$isConstant,
       "mlir::Type":$type,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
+      CArg<"mlir::AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
       CArg<"mlir::StringAttr", "{}">:$linkage,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
+      CArg<"mlir::AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "llvm::StringRef":$name, "bool":$isConstant,
       "mlir::Type":$type, CArg<"mlir::StringAttr", "{}">:$linkage,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
+      CArg<"mlir::AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
       "mlir::Attribute":$initVal, CArg<"mlir::StringAttr", "{}">:$linkage,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
+      CArg<"mlir::AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "llvm::StringRef":$name, "bool":$isConstant,
       "mlir::Type":$type, "mlir::Attribute":$initVal,
       CArg<"mlir::StringAttr", "{}">:$linkage,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
+      CArg<"mlir::AttributeRange", "{}">:$attrs)>,
   ];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef symbolAttrName() { return "symref"; }
     static constexpr llvm::StringRef getConstantAttrName() {
       return "constant";
     }
     static constexpr llvm::StringRef linkageAttrName() { return "linkName"; }
def fir_DispatchTableOp : fir_Op<"dispatch_table",
 
   let verifier = "return ::verify(*this);";
 
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs),
+      CArg<"mlir::AttributeRange", "{}">:$attrs),
     [{
       $_state.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                            $_builder.getStringAttr(name));
       $_state.addAttributes(attrs);
     }]>
   ];
 
   let extraClassDeclaration = [{

flang/include/flang/Optimizer/Dialect/FIROpsSupport.h

 }
 
 /// Get or create a FuncOp in a module.
 ///
 /// If `module` already contains FuncOp `name`, it is returned. Otherwise, a new
 /// FuncOp is created, and that new FuncOp is returned.
 mlir::FuncOp createFuncOp(mlir::Location loc, mlir::ModuleOp module,
                           llvm::StringRef name, mlir::FunctionType type,
-                          llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
+                          mlir::AttributeRange attrs = {});
 
 /// Get or create a GlobalOp in a module.
 fir::GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
                              llvm::StringRef name, mlir::Type type,
-                             llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
+                             mlir::AttributeRange attrs = {});
 
 /// Attribute to mark Fortran entities with the CONTIGUOUS attribute.
 constexpr llvm::StringRef getContiguousAttrName() { return "fir.contiguous"; }
 /// Attribute to mark Fortran entities with the OPTIONAL attribute.
 constexpr llvm::StringRef getOptionalAttrName() { return "fir.optional"; }
 
 /// Attribute to mark Fortran entities with the TARGET attribute.
 static constexpr llvm::StringRef getTargetAttrName() { return "fir.target"; }

flang/lib/Optimizer/Builder/FIRBuilder.cpp

mlir::Block *fir::FirOpBuilder::getAllocaBlock() {
   // auto iface =
   //     getRegion().getParentOfType<mlir::omp::OutlineableOpenMPOpInterface>();
   // return iface ? iface.getAllocaBlock() : getEntryBlock();
   return getEntryBlock();
 }
 
 /// Create a temporary variable on the stack. Anonymous temporaries have no
 /// `name` value. Temporaries do not require a uniqued name.
-mlir::Value
-fir::FirOpBuilder::createTemporary(mlir::Location loc, mlir::Type type,
-                                   llvm::StringRef name, mlir::ValueRange shape,
+mlir::Value fir::FirOpBuilder::createTemporary(mlir::Location loc,
+                                               mlir::Type type,
+                                               llvm::StringRef name,
+                                               mlir::ValueRange shape,
                                                mlir::ValueRange lenParams,
-                                   llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+                                               mlir::AttributeRange attrs) {
   llvm::SmallVector<mlir::Value> dynamicShape =
       elideExtentsAlreadyInType(type, shape);
   llvm::SmallVector<mlir::Value> dynamicLength =
       elideLengthsAlreadyInType(type, lenParams);
   InsertPoint insPt;
   const bool hoistAlloc = dynamicShape.empty() && dynamicLength.empty();
   if (hoistAlloc) {
     insPt = saveInsertionPoint();

flang/lib/Optimizer/Dialect/FIROps.cpp

 mlir::Type fir::AllocaOp::getRefTy(mlir::Type ty) {
   return ReferenceType::get(ty);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           llvm::StringRef uniqName, mlir::ValueRange typeparams,
                           mlir::ValueRange shape,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   auto nameAttr = builder.getStringAttr(uniqName);
   build(builder, result, wrapAllocaResultType(inType), inType, nameAttr, {},
         /*pinned=*/false, typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           llvm::StringRef uniqName, bool pinned,
                           mlir::ValueRange typeparams, mlir::ValueRange shape,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   auto nameAttr = builder.getStringAttr(uniqName);
   build(builder, result, wrapAllocaResultType(inType), inType, nameAttr, {},
         pinned, typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           llvm::StringRef uniqName, llvm::StringRef bindcName,
                           mlir::ValueRange typeparams, mlir::ValueRange shape,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   auto nameAttr =
       uniqName.empty() ? mlir::StringAttr{} : builder.getStringAttr(uniqName);
   auto bindcAttr =
       bindcName.empty() ? mlir::StringAttr{} : builder.getStringAttr(bindcName);
   build(builder, result, wrapAllocaResultType(inType), inType, nameAttr,
         bindcAttr, /*pinned=*/false, typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           llvm::StringRef uniqName, llvm::StringRef bindcName,
                           bool pinned, mlir::ValueRange typeparams,
                           mlir::ValueRange shape,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   auto nameAttr =
       uniqName.empty() ? mlir::StringAttr{} : builder.getStringAttr(uniqName);
   auto bindcAttr =
       bindcName.empty() ? mlir::StringAttr{} : builder.getStringAttr(bindcName);
   build(builder, result, wrapAllocaResultType(inType), inType, nameAttr,
         bindcAttr, pinned, typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           mlir::ValueRange typeparams, mlir::ValueRange shape,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   build(builder, result, wrapAllocaResultType(inType), inType, {}, {},
         /*pinned=*/false, typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           bool pinned, mlir::ValueRange typeparams,
                           mlir::ValueRange shape,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   build(builder, result, wrapAllocaResultType(inType), inType, {}, {}, pinned,
         typeparams, shape);
   result.addAttributes(attributes);
 }
 
 static mlir::LogicalResult verify(fir::AllocaOp &op) {
   llvm::SmallVector<llvm::StringRef> visited;
   if (verifyInType(op.getInType(), visited, op.numShapeOperands()))

 mlir::Type fir::AllocMemOp::getRefTy(mlir::Type ty) {
   return HeapType::get(ty);
 }
 
 void fir::AllocMemOp::build(mlir::OpBuilder &builder,
                             mlir::OperationState &result, mlir::Type inType,
                             llvm::StringRef uniqName,
                             mlir::ValueRange typeparams, mlir::ValueRange shape,
-                            llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                            mlir::AttributeRange attributes) {
   auto nameAttr = builder.getStringAttr(uniqName);
   build(builder, result, wrapAllocMemResultType(inType), inType, nameAttr, {},
         typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocMemOp::build(mlir::OpBuilder &builder,
                             mlir::OperationState &result, mlir::Type inType,
                             llvm::StringRef uniqName, llvm::StringRef bindcName,
                             mlir::ValueRange typeparams, mlir::ValueRange shape,
-                            llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                            mlir::AttributeRange attributes) {
   auto nameAttr = builder.getStringAttr(uniqName);
   auto bindcAttr = builder.getStringAttr(bindcName);
   build(builder, result, wrapAllocMemResultType(inType), inType, nameAttr,
         bindcAttr, typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocMemOp::build(mlir::OpBuilder &builder,
                             mlir::OperationState &result, mlir::Type inType,
                             mlir::ValueRange typeparams, mlir::ValueRange shape,
-                            llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                            mlir::AttributeRange attributes) {
   build(builder, result, wrapAllocMemResultType(inType), inType, {}, {},
         typeparams, shape);
   result.addAttributes(attributes);
 }
 
 static mlir::LogicalResult verify(fir::AllocMemOp op) {
   llvm::SmallVector<llvm::StringRef> visited;
   if (verifyInType(op.getInType(), visited, op.numShapeOperands()))

 
 void fir::GlobalOp::appendInitialValue(mlir::Operation *op) {
   getBlock().getOperations().push_back(op);
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, bool isConstant, Type type,
                           Attribute initialVal, StringAttr linkage,
-                          ArrayRef<NamedAttribute> attrs) {
+                          AttributeRange attrs) {
   result.addRegion();
   result.addAttribute(typeAttrName(result.name), mlir::TypeAttr::get(type));
   result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute(symbolAttrName(),
                       SymbolRefAttr::get(builder.getContext(), name));
   if (isConstant)
     result.addAttribute(constantAttrName(result.name), builder.getUnitAttr());
   if (initialVal)
     result.addAttribute(initValAttrName(result.name), initialVal);
   if (linkage)
     result.addAttribute(linkageAttrName(), linkage);
   result.attributes.append(attrs.begin(), attrs.end());
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, Type type, Attribute initialVal,
-                          StringAttr linkage, ArrayRef<NamedAttribute> attrs) {
+                          StringAttr linkage, AttributeRange attrs) {
   build(builder, result, name, /*isConstant=*/false, type, {}, linkage, attrs);
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, bool isConstant, Type type,
-                          StringAttr linkage, ArrayRef<NamedAttribute> attrs) {
+                          StringAttr linkage, AttributeRange attrs) {
   build(builder, result, name, isConstant, type, {}, linkage, attrs);
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, Type type, StringAttr linkage,
-                          ArrayRef<NamedAttribute> attrs) {
+                          AttributeRange attrs) {
   build(builder, result, name, /*isConstant=*/false, type, {}, linkage, attrs);
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, bool isConstant, Type type,
-                          ArrayRef<NamedAttribute> attrs) {
+                          AttributeRange attrs) {
   build(builder, result, name, isConstant, type, StringAttr{}, attrs);
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
-                          StringRef name, Type type,
-                          ArrayRef<NamedAttribute> attrs) {
+                          StringRef name, Type type, AttributeRange attrs) {
   build(builder, result, name, /*isConstant=*/false, type, attrs);
 }
 
 mlir::ParseResult fir::GlobalOp::verifyValidLinkage(StringRef linkage) {
   // Supporting only a subset of the LLVM linkage types for now
   static const char *validNames[] = {"common", "internal", "linkonce", "weak"};
   return mlir::success(llvm::is_contained(validNames, linkage));
 }

 // IterWhileOp
 //===----------------------------------------------------------------------===//
 
 void fir::IterWhileOp::build(mlir::OpBuilder &builder,
                              mlir::OperationState &result, mlir::Value lb,
                              mlir::Value ub, mlir::Value step,
                              mlir::Value iterate, bool finalCountValue,
                              mlir::ValueRange iterArgs,
-                             llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                             mlir::AttributeRange attributes) {
   result.addOperands({lb, ub, step, iterate});
   if (finalCountValue) {
     result.addTypes(builder.getIndexType());
     result.addAttribute(getFinalValueAttrName(), builder.getUnitAttr());
   }
   result.addTypes(iterate.getType());
   result.addOperands(iterArgs);
   for (auto v : iterArgs)

 //===----------------------------------------------------------------------===//
 // DoLoopOp
 //===----------------------------------------------------------------------===//
 
 void fir::DoLoopOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Value lb,
                           mlir::Value ub, mlir::Value step, bool unordered,
                           bool finalCountValue, mlir::ValueRange iterArgs,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   result.addOperands({lb, ub, step});
   result.addOperands(iterArgs);
   if (finalCountValue) {
     result.addTypes(builder.getIndexType());
     result.addAttribute(finalValueAttrName(result.name), builder.getUnitAttr());
   }
   for (auto v : iterArgs)
     result.addTypes(v.getType());
static A getSubOperands(unsigned pos, A allArgs,
   return allArgs.slice(start, (*(ranges.begin() + pos)).getZExtValue(),
                        std::forward<AdditionalArgs>(additionalArgs)...);
 }
 
 static mlir::MutableOperandRange
 getMutableSuccessorOperands(unsigned pos, mlir::MutableOperandRange operands,
                             StringRef offsetAttr) {
   Operation *owner = operands.getOwner();
-  NamedAttribute targetOffsetAttr =
-      *owner->getAttrDictionary().getNamed(offsetAttr);
+  NamedAttribute targetOffsetAttr = *owner->getNamedAttr(offsetAttr);
   return getSubOperands(
       pos, operands, targetOffsetAttr.second.cast<DenseIntElementsAttr>(),
       mlir::MutableOperandRange::OperandSegment(pos, targetOffsetAttr));
 }
 
 static unsigned denseElementsSize(mlir::DenseIntElementsAttr attr) {
   return attr.getNumElements();
 }

 
 void fir::SelectCaseOp::build(mlir::OpBuilder &builder,
                               mlir::OperationState &result,
                               mlir::Value selector,
                               llvm::ArrayRef<mlir::Attribute> compareAttrs,
                               llvm::ArrayRef<mlir::ValueRange> cmpOperands,
                               llvm::ArrayRef<mlir::Block *> destinations,
                               llvm::ArrayRef<mlir::ValueRange> destOperands,
-                              llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                              mlir::AttributeRange attributes) {
   result.addOperands(selector);
   result.addAttribute(getCasesAttr(), builder.getArrayAttr(compareAttrs));
   llvm::SmallVector<int32_t> operOffs;
   int32_t operSize = 0;
   for (auto attr : compareAttrs) {
     if (attr.isa<fir::ClosedIntervalAttr>()) {
       operOffs.push_back(2);
       operSize += 2;

 /// partitioning is unchecked, so can go awry on bad input.
 void fir::SelectCaseOp::build(mlir::OpBuilder &builder,
                               mlir::OperationState &result,
                               mlir::Value selector,
                               llvm::ArrayRef<mlir::Attribute> compareAttrs,
                               llvm::ArrayRef<mlir::Value> cmpOpList,
                               llvm::ArrayRef<mlir::Block *> destinations,
                               llvm::ArrayRef<mlir::ValueRange> destOperands,
-                              llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                              mlir::AttributeRange attributes) {
   llvm::SmallVector<mlir::ValueRange> cmpOpers;
   auto iter = cmpOpList.begin();
   for (auto &attr : compareAttrs) {
     if (attr.isa<fir::ClosedIntervalAttr>()) {
       cmpOpers.push_back(mlir::ValueRange({iter, iter + 2}));
       iter += 2;
     } else if (attr.isa<UnitAttr>()) {
       cmpOpers.push_back(mlir::ValueRange{});

 }
 
 void fir::SelectTypeOp::build(mlir::OpBuilder &builder,
                               mlir::OperationState &result,
                               mlir::Value selector,
                               llvm::ArrayRef<mlir::Attribute> typeOperands,
                               llvm::ArrayRef<mlir::Block *> destinations,
                               llvm::ArrayRef<mlir::ValueRange> destOperands,
-                              llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                              mlir::AttributeRange attributes) {
   result.addOperands(selector);
   result.addAttribute(getCasesAttr(), builder.getArrayAttr(typeOperands));
   const auto count = destinations.size();
   for (mlir::Block *dest : destinations)
     result.addSuccessors(dest);
   const auto opCount = destOperands.size();
   llvm::SmallVector<int32_t> argOffs;
   int32_t sumArgs = 0;

 
 bool fir::isReferenceLike(mlir::Type type) {
   return type.isa<fir::ReferenceType>() || type.isa<fir::HeapType>() ||
          type.isa<fir::PointerType>();
 }
 
 mlir::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
                                StringRef name, mlir::FunctionType type,
-                               llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+                               mlir::AttributeRange attrs) {
   if (auto f = module.lookupSymbol<mlir::FuncOp>(name))
     return f;
   mlir::OpBuilder modBuilder(module.getBodyRegion());
   modBuilder.setInsertionPointToEnd(module.getBody());
   auto result = modBuilder.create<mlir::FuncOp>(loc, name, type, attrs);
   result.setVisibility(mlir::SymbolTable::Visibility::Private);
   return result;
 }
 
 fir::GlobalOp fir::createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
                                   StringRef name, mlir::Type type,
-                                  llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+                                  mlir::AttributeRange attrs) {
   if (auto g = module.lookupSymbol<fir::GlobalOp>(name))
     return g;
   mlir::OpBuilder modBuilder(module.getBodyRegion());
   auto result = modBuilder.create<fir::GlobalOp>(loc, name, type, attrs);
   result.setVisibility(mlir::SymbolTable::Visibility::Private);
   return result;
 }
 

llvm/include/llvm/ADT/STLExtras.h

public:
   /// See `detail::indexed_accessor_range_base` for details.
   static ReferenceT
   dereference_iterator(const std::pair<BaseT, ptrdiff_t> &base,
                        ptrdiff_t index) {
     return DerivedT::dereference(base.first, base.second + index);
   }
 };
 
+namespace detail {
+/// A first or second range over a range of references should return references
+/// to member. But a first or second range over a range of temporaries should
+/// return a temporary.
+template <typename EltTy, typename FirstTy> struct first_range {
+  using type =
+      typename std::conditional_t<std::is_reference<EltTy>::value, FirstTy,
+                                  std::remove_reference_t<FirstTy>>;
+};
+} // end namespace detail
+
 /// Given a container of pairs, return a range over the first elements.
 template <typename ContainerTy> auto make_first_range(ContainerTy &&c) {
+  using EltTy = decltype((*std::begin(c)));
   return llvm::map_range(
       std::forward<ContainerTy>(c),
-      [](decltype((*std::begin(c))) elt) -> decltype((elt.first)) {
+      [](EltTy elt) ->
+      typename detail::first_range<EltTy, decltype((elt.first))>::type {
         return elt.first;
       });
 }
 
 /// Given a container of pairs, return a range over the second elements.
 template <typename ContainerTy> auto make_second_range(ContainerTy &&c) {
+  using EltTy = decltype((*std::begin(c)));
   return llvm::map_range(
       std::forward<ContainerTy>(c),
-      [](decltype((*std::begin(c))) elt) -> decltype((elt.second)) {
+      [](EltTy elt) ->
+      typename detail::first_range<EltTy, decltype((elt.second))>::type {
         return elt.second;
       });
 }
 
 //===----------------------------------------------------------------------===//
 //     Extra additions to <utility>
 //===----------------------------------------------------------------------===//
 

mlir/docs/DeclarativeRewrites.md

 In the above, we are using `BOp`'s result for building `COp`.
 
 #### Building operations
 
 Given that `COp` was specified with table-driven op definition, there will be
 several `build()` methods generated for it. One of them has aggregated
 parameters for result types, operands, and attributes in the signature: `void
 COp::build(..., ArrayRef<Type> resultTypes, Array<Value> operands,
-ArrayRef<NamedAttribute> attr)`. The pattern in the above calls this `build()`
-method for constructing the `COp`.
+AttributeRange attr)`. The pattern in the above calls this `build()` method for
+constructing the `COp`.
 
 In general, arguments in the result pattern will be passed directly to the
 `build()` method to leverage the auto-generated `build()` method, list them in
 the pattern by following the exact same order as the ODS `arguments` definition.
 Otherwise, a custom `build()` method that matches the argument list is required.
 
 Right now all ODS-generated `build()` methods require specifying the result
 type(s), unless the op has known traits like `SameOperandsAndResultType` that we

mlir/docs/OpDefinitions.md

 
 ### Operation traits and constraints
 
 Traits are operation properties that affect syntax or semantics. MLIR C++ models
 various traits in the `mlir::OpTrait` namespace.
 
 Both operation traits, [interfaces](Interfaces.md/#utilizing-the-ods-framework),
 and constraints involving multiple operands/attributes/results are provided as
-the third template parameter to the `Op` class. They should be deriving from
-the `OpTrait` class. See [Constraints](#constraints) for more information.
+the third template parameter to the `Op` class. They should be deriving from the
+`OpTrait` class. See [Constraints](#constraints) for more information.
 
 ### Builder methods
 
 For each operation, there are a few builders automatically generated based on
 the arguments and returns types. For example, given the following op definition:
 
 ```tablegen
 def MyOp : ... {

 
 The following builders are generated:
 
 ```c++
 // All result-types/operands/attributes have one aggregate parameter.
 static void build(OpBuilder &odsBuilder, OperationState &odsState,
                   ArrayRef<Type> resultTypes,
                   ValueRange operands,
-                  ArrayRef<NamedAttribute> attributes);
+                  AttributeRange attributes);
 
 // Each result-type/operand/attribute has a separate parameter. The parameters
 // for attributes are of mlir::Attribute types.
 static void build(OpBuilder &odsBuilder, OperationState &odsState,
                   Type i32_result, Type f32_result, ...,
                   Value i32_operand, Value f32_operand, ...,
                   IntegerAttr i32_attr, FloatAttr f32_attr, ...);
 

 static void build(OpBuilder &odsBuilder, OperationState &odsState,
                   ArrayRef<Type> resultTypes,
                   Value i32_operand, Value f32_operand, ...,
                   IntegerAttr i32_attr, FloatAttr f32_attr, ...);
 
 // All operands/attributes have aggregate parameters.
 // Generated if return type can be inferred.
 static void build(OpBuilder &odsBuilder, OperationState &odsState,
-                  ValueRange operands, ArrayRef<NamedAttribute> attributes);
+                  ValueRange operands, AttributeRange attributes);
 
 // (And manually specified builders depending on the specific op.)
 ```
 
 The first form provides basic uniformity so that we can create ops using the
 same form regardless of the exact op. This is particularly useful for
 implementing declarative pattern rewrites.
 

 ### Custom parser and printer methods
 
 Functions to parse and print the operation's custom assembly form.
 
 ### Custom verifier code
 
 Verification code will be automatically generated for
 [constraints](#constraints) specified on various entities of the op. To perform
-_additional_ verification, you can use
+*additional* verification, you can use
 
 ```tablegen
 let verifier = [{
   ...
 }];
 ```
 
 Code placed in `verifier` will be called after the auto-generated verification
def ReturnOp : ... {
   // We only print the operands and types if there are a non-zero number
   // of operands.
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 ```
 
 ##### Unit Attributes
 
-In MLIR, the [`unit` Attribute](Dialects/Builtin.md/#unitattr) is special in that it
-only has one possible value, i.e. it derives meaning from its existence. When a
-unit attribute is used to anchor an optional group and is not the first element
-of the group, the presence of the unit attribute can be directly correlated with
-the presence of the optional group itself. As such, in these situations the unit
-attribute will not be printed or present in the output and will be automatically
-inferred when parsing by the presence of the optional group itself.
+In MLIR, the [`unit` Attribute](Dialects/Builtin.md/#unitattr) is special in
+that it only has one possible value, i.e. it derives meaning from its existence.
+When a unit attribute is used to anchor an optional group and is not the first
+element of the group, the presence of the unit attribute can be directly
+correlated with the presence of the optional group itself. As such, in these
+situations the unit attribute will not be printed or present in the output and
+will be automatically inferred when parsing by the presence of the optional
+group itself.
 
 For example, the following operation:
 
 ```tablegen
 def FooOp : ... {
   let arguments = (ins UnitAttr:$is_read_only);
 
   let assemblyFormat = "attr-dict (`is_read_only` $is_read_only^)?";

 
 This means the qualified name of the generated C++ class does not necessarily
 match exactly with the operation name as explained in
 [Operation name](#operation-name). This is to allow flexible naming to satisfy
 coding style requirements.
 
 #### Operand adaptors
 
-For each operation, we automatically generate an _operand adaptor_. This class
+For each operation, we automatically generate an *operand adaptor*. This class
 solves the problem of accessing operands provided as a list of `Value`s without
 using "magic" constants. The operand adaptor takes a reference to an array of
 `Value` and provides methods with the same names as those in the operation class
 to access them. For example, for a binary arithmetic operation, it may provide
 `.lhs()` to access the first operand and `.rhs()` to access the second operand.
 
 The operand adaptor class lives in the same namespace as the operation class,
 and has the name of the operation followed by `Adaptor` as well as an alias

 `$_builder`, `$_op`, and `$_self`:
 
 *   `$_builder` will be replaced by a `mlir::Builder` instance so that you can
     access common build methods.
 *   `$_op` will be replaced by the current operation so that you can access
     information of the current operation.
 *   `$_self` will be replaced with the entity this predicate is attached to.
     E.g., `BoolAttr` is an attribute constraint that wraps a
-    `CPred<"$_self.isa<BoolAttr>()">`. Then for `BoolAttr:$attr`,`$_self` will be
-    replaced by `$attr`. For type constraints, it's a little bit special since
-    we want the constraints on each type definition reads naturally and we want
-    to attach type constraints directly to an operand/result, `$_self` will be
-    replaced by the operand/result's type. E.g., for `F32` in `F32:$operand`,
+    `CPred<"$_self.isa<BoolAttr>()">`. Then for `BoolAttr:$attr`,`$_self` will
+    be replaced by `$attr`. For type constraints, it's a little bit special
+    since we want the constraints on each type definition reads naturally and we
+    want to attach type constraints directly to an operand/result, `$_self` will
+    be replaced by the operand/result's type. E.g., for `F32` in `F32:$operand`,
     its `$_self` will be expanded as `operand(...).getType()`.
 
 TODO: Reconsider the leading symbol for special placeholders. Eventually we want
 to allow referencing operand/result `$-name`s; such `$-name`s can start with
 underscore.
 
 For example, to write an attribute `attr` is an `IntegerAttr`, in C++ you can
 just call `attr.isa<IntegerAttr>()`. The code can be wrapped in a `CPred` as

 common C++ [attribute classes][AttrClasses] defined in MLIR's core IR library
 and one is free to define dialect-specific attribute classes. ODS allows one to
 use these attributes in TableGen to define operations, potentially with more
 fine-grained constraints. For example, `StrAttr` directly maps to `StringAttr`;
 `F32Attr`/`F64Attr` requires the `FloatAttr` to additionally be of a certain
 bitwidth.
 
 ODS attributes are defined as having a storage type (corresponding to a backing
-`mlir::Attribute` that _stores_ the attribute), a return type (corresponding to
-the C++ _return_ type of the generated helper getters) as well as a method
-to convert between the internal storage and the helper method.
+`mlir::Attribute` that *stores* the attribute), a return type (corresponding to
+the C++ *return* type of the generated helper getters) as well as a method to
+convert between the internal storage and the helper method.
 
 ### Attribute decorators
 
 There are a few important attribute adapters/decorators/modifiers that can be
 applied to ODS attributes to specify common additional properties like
 optionality, default values, etc.:
 
 *   `DefaultValuedAttr`: specifies the
llvm::Optional<MyBitEnum> symbolizeMyBitEnum(uint32_t value) {
 
   if (value & ~(1u | 2u | 4u)) return llvm::None;
   return static_cast<MyBitEnum>(value);
 }
 ```
 
 ## Type Definitions
 
-MLIR defines the `TypeDef` class hierarchy to enable generation of data types from
-their specifications. A type is defined by specializing the `TypeDef` class with
-concrete contents for all the fields it requires. For example, an integer type
-could be defined as:
+MLIR defines the `TypeDef` class hierarchy to enable generation of data types
+from their specifications. A type is defined by specializing the `TypeDef` class
+with concrete contents for all the fields it requires. For example, an integer
+type could be defined as:
 
 ```tablegen
 // All of the types will extend this class.
 class Test_Type<string name> : TypeDef<Test_Dialect, name> { }
 
 // An alternate int type.
 def IntegerType : Test_Type<"TestInteger"> {
   let mnemonic = "int";

 class MyType : /*...*/ {
   /*...*/
   static MyType get(::mlir::MLIRContext *context, int intParam);
 };
 ```
 
 This builder is identical to the one that will be automatically generated for
 `MyType`. The `context` parameter is implicitly added by the generator, and is
-used when building the Type instance (with `Base::get`). The distinction
-here is that we can provide the implementation of this `get` method. With this
-style of builder definition only the declaration is generated, the implementor
-of `MyType` will need to provide a definition of `MyType::get`.
+used when building the Type instance (with `Base::get`). The distinction here is
+that we can provide the implementation of this `get` method. With this style of
+builder definition only the declaration is generated, the implementor of
+`MyType` will need to provide a definition of `MyType::get`.
 
 The second builder will generate the declaration of a builder method that looks
 like:
 
 ```tablegen
   let builders = [
     TypeBuilder<(ins CArg<"int", "0">:$intParam)>,
   ];

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp

matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     auto loc = op->getLoc();
     lowerOpToLoops(
         op, operands, rewriter,
         [loc](OpBuilder &builder, ValueRange memRefOperands,
               ValueRange loopIvs) {
           // Generate an adaptor for the remapped operands of the BinaryOp. This
           // allows for using the nice named accessors that are generated by the
           // ODS.
-          typename BinaryOp::Adaptor binaryAdaptor(memRefOperands);
+          typename BinaryOp::Adaptor binaryAdaptor(builder.getContext(),
+                                                   memRefOperands);
 
           // Generate loads for the element of 'lhs' and 'rhs' at the inner
           // loop.
           auto loadedLhs =
               builder.create<AffineLoadOp>(loc, binaryAdaptor.lhs(), loopIvs);
           auto loadedRhs =
               builder.create<AffineLoadOp>(loc, binaryAdaptor.rhs(), loopIvs);
 
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     auto loc = op->getLoc();
     lowerOpToLoops(op, operands, rewriter,
                    [loc](OpBuilder &builder, ValueRange memRefOperands,
                          ValueRange loopIvs) {
                      // Generate an adaptor for the remapped operands of the
                      // TransposeOp. This allows for using the nice named
                      // accessors that are generated by the ODS.
-                     toy::TransposeOpAdaptor transposeAdaptor(memRefOperands);
+                     toy::TransposeOpAdaptor transposeAdaptor(
+                         builder.getContext(), memRefOperands);
                      Value input = transposeAdaptor.input();
 
                      // Transpose the elements by generating a load from the
                      // reverse indices.
                      SmallVector<Value, 2> reverseIvs(llvm::reverse(loopIvs));
                      return builder.create<AffineLoadOp>(loc, input,
                                                          reverseIvs);
                    });

mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp

matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     auto loc = op->getLoc();
     lowerOpToLoops(
         op, operands, rewriter,
         [loc](OpBuilder &builder, ValueRange memRefOperands,
               ValueRange loopIvs) {
           // Generate an adaptor for the remapped operands of the BinaryOp. This
           // allows for using the nice named accessors that are generated by the
           // ODS.
-          typename BinaryOp::Adaptor binaryAdaptor(memRefOperands);
+          typename BinaryOp::Adaptor binaryAdaptor(builder.getContext(),
+                                                   memRefOperands);
 
           // Generate loads for the element of 'lhs' and 'rhs' at the inner
           // loop.
           auto loadedLhs =
               builder.create<AffineLoadOp>(loc, binaryAdaptor.lhs(), loopIvs);
           auto loadedRhs =
               builder.create<AffineLoadOp>(loc, binaryAdaptor.rhs(), loopIvs);
 
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     auto loc = op->getLoc();
     lowerOpToLoops(op, operands, rewriter,
                    [loc](OpBuilder &builder, ValueRange memRefOperands,
                          ValueRange loopIvs) {
                      // Generate an adaptor for the remapped operands of the
                      // TransposeOp. This allows for using the nice named
                      // accessors that are generated by the ODS.
-                     toy::TransposeOpAdaptor transposeAdaptor(memRefOperands);
+                     toy::TransposeOpAdaptor transposeAdaptor(
+                         builder.getContext(), memRefOperands);
                      Value input = transposeAdaptor.input();
 
                      // Transpose the elements by generating a load from the
                      // reverse indices.
                      SmallVector<Value, 2> reverseIvs(llvm::reverse(loopIvs));
                      return builder.create<AffineLoadOp>(loc, input,
                                                          reverseIvs);
                    });

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     auto loc = op->getLoc();
     lowerOpToLoops(
         op, operands, rewriter,
         [loc](OpBuilder &builder, ValueRange memRefOperands,
               ValueRange loopIvs) {
           // Generate an adaptor for the remapped operands of the BinaryOp. This
           // allows for using the nice named accessors that are generated by the
           // ODS.
-          typename BinaryOp::Adaptor binaryAdaptor(memRefOperands);
+          typename BinaryOp::Adaptor binaryAdaptor(builder.getContext(),
+                                                   memRefOperands);
 
           // Generate loads for the element of 'lhs' and 'rhs' at the inner
           // loop.
           auto loadedLhs =
               builder.create<AffineLoadOp>(loc, binaryAdaptor.lhs(), loopIvs);
           auto loadedRhs =
               builder.create<AffineLoadOp>(loc, binaryAdaptor.rhs(), loopIvs);
 
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     auto loc = op->getLoc();
     lowerOpToLoops(op, operands, rewriter,
                    [loc](OpBuilder &builder, ValueRange memRefOperands,
                          ValueRange loopIvs) {
                      // Generate an adaptor for the remapped operands of the
                      // TransposeOp. This allows for using the nice named
                      // accessors that are generated by the ODS.
-                     toy::TransposeOpAdaptor transposeAdaptor(memRefOperands);
+                     toy::TransposeOpAdaptor transposeAdaptor(
+                         builder.getContext(), memRefOperands);
                      Value input = transposeAdaptor.input();
 
                      // Transpose the elements by generating a load from the
                      // reverse indices.
                      SmallVector<Value, 2> reverseIvs(llvm::reverse(loopIvs));
                      return builder.create<AffineLoadOp>(loc, input,
                                                          reverseIvs);
                    });

mlir/include/mlir/Conversion/LLVMCommon/Pattern.h

explicit ConvertOpToLLVMPattern(LLVMTypeConverter &typeConverter,
                                   PatternBenefit benefit = 1)
       : ConvertToLLVMPattern(SourceOp::getOperationName(),
                              &typeConverter.getContext(), typeConverter,
                              benefit) {}
 
   /// Wrappers around the RewritePattern methods that pass the derived op type.
   void rewrite(Operation *op, ArrayRef<Value> operands,
                ConversionPatternRewriter &rewriter) const final {
-    rewrite(cast<SourceOp>(op), OpAdaptor(operands, op->getAttrDictionary()),
-            rewriter);
+    rewrite(cast<SourceOp>(op),
+            OpAdaptor(getContext(), operands, op->getAttrs()), rewriter);
   }
   LogicalResult match(Operation *op) const final {
     return match(cast<SourceOp>(op));
   }
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     return matchAndRewrite(cast<SourceOp>(op),
-                           OpAdaptor(operands, op->getAttrDictionary()),
+                           OpAdaptor(getContext(), operands, op->getAttrs()),
                            rewriter);
   }
 
   /// Rewrite and Match methods that operate on the SourceOp type. These must be
   /// overridden by the derived pattern class.
   /// NOTICE: These methods are deprecated and will be removed. All new code
   /// should use the adaptor methods below instead.
   virtual void rewrite(SourceOp op, ArrayRef<Value> operands,
                        ConversionPatternRewriter &rewriter) const {
     llvm_unreachable("must override rewrite or matchAndRewrite");
   }
   virtual LogicalResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const {
     if (succeeded(match(op))) {
-      rewrite(op, OpAdaptor(operands, op->getAttrDictionary()), rewriter);
+      rewrite(op, OpAdaptor(getContext(), operands, op->getAttrs()), rewriter);
       return success();
     }
     return failure();
   }
 
   /// Rewrite and Match methods that operate on the SourceOp type. These must be
   /// overridden by the derived pattern class.
   virtual LogicalResult match(SourceOp op) const {

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

def Async_AwaitOp : Async_Op<"await"> {
 
   let arguments = (ins Async_AnyValueOrTokenType:$operand);
   let results = (outs Optional<AnyType>:$result);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<(ins "Value":$operand,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
   ];
 
   let extraClassDeclaration = [{
     Optional<Type> getResultType() {
       if (getResultTypes().empty()) return None;
       return getResultTypes()[0];
     }
   }];

mlir/include/mlir/Dialect/GPU/GPUOps.td

def GPU_GPUFuncOp : GPU_Op<"func", [HasParent<"GPUModuleOp">,
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<(ins "StringRef":$name, "FunctionType":$type,
       CArg<"TypeRange", "{}">:$workgroupAttributions,
       CArg<"TypeRange", "{}">:$privateAttributions,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = [{
     /// Returns `true` if the GPU function defined by this Op is a kernel, i.e.
     /// it is intended to be launched from host.
     bool isKernel() {
       return (*this)->getAttrOfType<UnitAttr>(
           GPUDialect::getKernelFuncAttrName()) != nullptr;

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

 }
 
 class LLVM_Builder<string builder> {
   string llvmBuilder = builder;
 }
 
 def LLVM_OneResultOpBuilder :
   OpBuilder<(ins "Type":$resultType, "ValueRange":$operands,
-    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
+    CArg<"AttributeRange", "{}">:$attributes),
   [{
     if (resultType) $_state.addTypes(resultType);
     $_state.addOperands(operands);
     for (auto namedAttr : attributes) {
       $_state.addAttribute(namedAttr.first, namedAttr.second);
     }
   }]>;
 
 def LLVM_ZeroResultOpBuilder :
   OpBuilder<(ins "ValueRange":$operands,
-    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
+    CArg<"AttributeRange", "{}">:$attributes),
   [{
     $_state.addOperands(operands);
     for (auto namedAttr : attributes) {
       $_state.addAttribute(namedAttr.first, namedAttr.second);
     }
   }]>;
 
 // 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),
+    CArg<"AttributeRange", "{}">:$attributes),
   [{
     assert(isCompatibleType(resultType) && "result must be an LLVM type");
     assert(resultType.isa<LLVMVoidType>() &&
            "for zero-result operands, only 'void' is accepted as result type");
     build($_builder, $_state, operands, attributes);
   }]>;
 
 
 // Opaque builder used for terminator operations that contain successors.
 def LLVM_TerminatorPassthroughOpBuilder :
   OpBuilder<(ins "ValueRange":$operands, "SuccessorRange":$destinations,
-    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
+    CArg<"AttributeRange", "{}">:$attributes),
   [{
     $_state.addOperands(operands);
     $_state.addSuccessors(destinations);
     $_state.addAttributes(attributes);
   }]>;
 
 // Base class for LLVM terminator operations.  All terminator operations have
 // zero results and an optional list of successors.
let description = [{
     ```
   }];
   let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$callee,
                    Variadic<LLVM_Type>,
                    DefaultValuedAttr<LLVM_FMFAttr, "{}">:$fastmathFlags);
   let results = (outs Variadic<LLVM_Type>);
   let builders = [
     OpBuilder<(ins "LLVMFuncOp":$func, "ValueRange":$operands,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes), [{
+      CArg<"AttributeRange", "{}">:$attributes), [{
       Type resultType = func.getType().getReturnType();
       if (!resultType.isa<LLVM::LLVMVoidType>())
         $_state.addTypes(resultType);
       $_state.addAttribute("callee", SymbolRefAttr::get(func));
       $_state.addAttributes(attributes);
       $_state.addOperands(operands);
     }]>,
     OpBuilder<(ins "TypeRange":$results, "StringAttr":$callee,

 def LLVM_ExtractElementOp : LLVM_Op<"extractelement", [NoSideEffect]> {
   let arguments = (ins LLVM_AnyVector:$vector, AnyInteger:$position);
   let results = (outs LLVM_Type:$res);
   string llvmBuilder = [{
     $res = builder.CreateExtractElement($vector, $position);
   }];
   let builders = [
     OpBuilder<(ins "Value":$vector, "Value":$position,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
+      CArg<"AttributeRange", "{}">:$attrs)>];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return parseExtractElementOp(parser, result); }];
   let printer = [{ printExtractElementOp(p, *this); }];
 }
 def LLVM_ExtractValueOp : LLVM_Op<"extractvalue", [NoSideEffect]> {
   let arguments = (ins LLVM_AnyAggregate:$container, ArrayAttr:$position);
   let results = (outs LLVM_Type:$res);
   string llvmBuilder = [{
def LLVM_ShuffleVectorOp : LLVM_Op<"shufflevector", [NoSideEffect]> {
   let results = (outs LLVM_AnyVector:$res);
   string llvmBuilder = [{
       SmallVector<unsigned, 4> position = extractPosition($mask);
       SmallVector<int, 4> mask(position.begin(), position.end());
       $res = builder.CreateShuffleVector($v1, $v2, mask);
   }];
   let builders = [
     OpBuilder<(ins "Value":$v1, "Value":$v2, "ArrayAttr":$mask,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
+      CArg<"AttributeRange", "{}">:$attrs)>];
   let verifier = [{
     auto type1 = v1().getType();
     auto type2 = v2().getType();
     if (::mlir::LLVM::getVectorElementType(type1) !=
             ::mlir::LLVM::getVectorElementType(type2))
       return emitOpError("expected matching LLVM IR Dialect element types");
     return success();
   }];
let description = [{
 
     // Define the global.
     llvm.mlir.global @const(42 : i32) : i32
     ```
   }];
 
   let builders = [
     OpBuilder<(ins "GlobalOp":$global,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       build($_builder, $_state,
             LLVM::LLVMPointerType::get(global.getType(), global.addr_space()),
             global.sym_name());
       $_state.addAttributes(attrs);
     }]>,
     OpBuilder<(ins "LLVMFuncOp":$func,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       build($_builder, $_state,
             LLVM::LLVMPointerType::get(func.getType()), func.getName());
       $_state.addAttributes(attrs);
     }]>
   ];
 
   let extraClassDeclaration = [{
def LLVM_GlobalOp : LLVM_Op<"mlir.global",
   let regions = (region AnyRegion:$initializer);
 
   let builders = [
     OpBuilder<(ins "Type":$type, "bool":$isConstant, "Linkage":$linkage,
       "StringRef":$name, "Attribute":$value,
       CArg<"uint64_t", "0">:$alignment,
       CArg<"unsigned", "0">:$addrSpace,
       CArg<"bool", "false">:$dsoLocal,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = [{
     /// Return the LLVM type of the global.
     Type getType() {
       return getGlobalType();
     }
     /// Return the initializer attribute if it exists, or a null attribute.
def LLVM_LLVMFuncOp : LLVM_Op<"func",
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<(ins "StringRef":$name, "Type":$type,
       CArg<"Linkage", "Linkage::External">:$linkage,
       CArg<"bool", "false">:$dsoLocal,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
+      CArg<"AttributeRange", "{}">:$attrs,
       CArg<"ArrayRef<DictionaryAttr>", "{}">:$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();
 

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

[{
         shape.size(), ShapedType::kDynamicSize);
       build($_builder, $_state, shape, staticShape, elementType);
     }]>,
     OpBuilder<(ins "ArrayRef<int64_t>":$staticShape, "Type":$elementType),
     [{
       build($_builder, $_state, ValueRange{}, staticShape, elementType);
     }]>,
     OpBuilder<(ins "ArrayRef<OpFoldResult>":$sizes, "Type":$elementType,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let hasCanonicalizer = 1;
 }
 
 def Linalg_PadTensorOp : Linalg_Op<"pad_tensor",
     [AttrSizedOperandSegments, NoSideEffect,
      DeclareOpInterfaceMethods<ReifyRankedShapedTypeOpInterface>,
let extraClassDeclaration = [{
     }
   }];
 
   let builders = [
     // Build a PadTensorOp with mixed static and dynamic entries.
     OpBuilder<(ins "Value":$source, "ArrayRef<int64_t>":$staticLow,
       "ArrayRef<int64_t>":$staticHigh, "ValueRange":$low, "ValueRange":$high,
       CArg<"bool", "false">:$nofold,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a PadTensorOp with all dynamic entries.
     OpBuilder<(ins "Value":$source, "ValueRange":$low, "ValueRange":$high,
       CArg<"bool", "false">:$nofold,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a PadTensorOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
     OpBuilder<(ins "Type":$resultType, "Value":$source,
       "ArrayRef<OpFoldResult>":$low, "ArrayRef<OpFoldResult>":$high,
       CArg<"bool", "false">:$nofold,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
   ];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 
 def Linalg_RangeOp :
     Linalg_Op<"range", [NoSideEffect]>,

 
 class Linalg_ReshapeLikeOp<string mnemonic, list<OpTrait> traits = []> :
     Linalg_Op<mnemonic, !listconcat(traits, [NoSideEffect])> {
   let builders = [
     // Builders for a contracting reshape whose result type is computed from
     // `src` and `reassociation`.
     OpBuilder<(ins "Value":$src,
       "ArrayRef<ReassociationIndices>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "Value":$src,
       "ArrayRef<ReassociationExprs>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       auto reassociationMaps =
           convertReassociationMapsToIndices($_builder, reassociation);
       build($_builder, $_state, src, reassociationMaps, attrs);
     }]>,
 
     // Builders for a reshape whose result type is passed explicitly. This may
     // be either a contracting or expanding reshape.
     OpBuilder<(ins "Type":$resultType, "Value":$src,
       "ArrayRef<ReassociationIndices>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       build($_builder, $_state, resultType, src, attrs);
       $_state.addAttribute("reassociation",
                           getReassociationIndicesAttribute($_builder, reassociation));
     }]>,
     OpBuilder<(ins "Type":$resultType, "Value":$src,
       "ArrayRef<ReassociationExprs>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       auto reassociationMaps =
           convertReassociationMapsToIndices($_builder, reassociation);
       build($_builder, $_state, resultType, src, reassociationMaps, attrs);
     }]>
   ];
 
   code commonExtraClassDeclaration = [{

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

let arguments = (ins
     OptionalAttr<AffineMapAttr>:$inputPermutation,
     OptionalAttr<AffineMapAttr>:$outputPermutation);
   let regions = (region AnyRegion:$region);
 
   let builders = [
     OpBuilder<(ins "Value":$input, "Value":$output,
       CArg<"AffineMap", "AffineMap()">:$inputPermutation,
       CArg<"AffineMap", "AffineMap()">:$outputPermutation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
+      CArg<"AttributeRange", "{}">:$attrs)>];
 
   let extraClassDeclaration = structuredOpsDecls # [{
     ValueRange inputs() { return getOperands().take_front(); }
     ValueRange outputs() { return getOperands().take_back(); }
 
     // Rank-polymorphic.
     //   filling_value -> O(ivs) with parallel iterators.
     ArrayAttr iterator_types() {
def GenericOp : LinalgStructuredBase_Op<"generic", [AttrSizedOperandSegments]> {
   let regions = (region AnyRegion:$region);
 
   let builders = [
     OpBuilder<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
       "ValueRange":$outputs, "ArrayRef<AffineMap>":$indexingMaps,
       "ArrayRef<StringRef>":$iteratorTypes, "StringRef":$doc,
       "StringRef":$libraryCall,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
+      CArg<"AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
       "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
       "StringRef":$doc, "StringRef":$libraryCall,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
+      CArg<"AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
       "ValueRange":$outputs, "ArrayRef<AffineMap>":$indexingMaps,
       "ArrayRef<StringRef>":$iteratorTypes,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
+      CArg<"AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
       "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
+      CArg<"AttributeRange", "{}">:$attributes)>
   ];
 
   let extraClassDeclaration = structuredOpsBaseDecls # [{
     SmallVector<StringRef, 8> linalgTraitAttrNames() {
       return SmallVector<StringRef, 8>{
         getDocAttrName(),
         getIndexingMapsAttrName(), getLibraryCallAttrName(),
         getIteratorTypesAttrName(),

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

def MemRef_ReinterpretCastOp:
   let parser = ?;
   let printer = ?;
 
   let builders = [
     // Build a ReinterpretCastOp with mixed static and dynamic entries.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "OpFoldResult":$offset, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a ReinterpretCastOp with static entries.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "int64_t":$offset, "ArrayRef<int64_t>":$sizes,
       "ArrayRef<int64_t>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a ReinterpretCastOp with dynamic entries.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "Value":$offset, "ValueRange":$sizes,
       "ValueRange":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     // The result of the op is always a ranked memref.
     MemRefType getType() { return getResult().getType().cast<MemRefType>(); }
     Value getViewSource() { return source(); }
 
     /// Return the rank of the source ShapedType.
MemRef_Op<mnemonic, !listconcat(traits,
       [NoSideEffect, ViewLikeOpInterface])>,
     Arguments<(ins AnyStridedMemRef:$src, IndexListArrayAttr:$reassociation)>,
     Results<(outs AnyStridedMemRef:$result)>{
   let builders = [
     // Builders for a contracting reshape whose result type is computed from
     // `src` and `reassociation`.
     OpBuilder<(ins "Value":$src,
       "ArrayRef<ReassociationIndices>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "Value":$src,
       "ArrayRef<ReassociationExprs>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       auto reassociationMaps =
           convertReassociationMapsToIndices($_builder, reassociation);
       build($_builder, $_state, src, reassociationMaps, attrs);
     }]>,
 
     // Builders for a reshape whose result type is passed explicitly. This may
     // be either a contracting or expanding reshape.
     OpBuilder<(ins "Type":$resultType, "Value":$src,
       "ArrayRef<ReassociationIndices>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       build($_builder, $_state, resultType, src, attrs);
       $_state.addAttribute("reassociation",
                           getReassociationIndicesAttribute($_builder, reassociation));
     }]>,
     OpBuilder<(ins "Type":$resultType, "Value":$src,
       "ArrayRef<ReassociationExprs>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       auto reassociationMaps =
           convertReassociationMapsToIndices($_builder, reassociation);
       build($_builder, $_state, resultType, src, reassociationMaps, attrs);
     }]>
   ];
 
   code commonExtraClassDeclaration = [{
let assemblyFormat = [{
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let builders = [
     // Build a SubViewOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
     OpBuilder<(ins "Value":$source, "ArrayRef<OpFoldResult>":$offsets,
       "ArrayRef<OpFoldResult>":$sizes, "ArrayRef<OpFoldResult>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a SubViewOp with mixed static and dynamic entries and inferred
     // result type.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a SubViewOp with static entries and custom result type. If the
     // type passed is nullptr, it is inferred.
     OpBuilder<(ins "Value":$source, "ArrayRef<int64_t>":$offsets,
       "ArrayRef<int64_t>":$sizes, "ArrayRef<int64_t>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a SubViewOp with static entries and inferred result type.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "ArrayRef<int64_t>":$offsets, "ArrayRef<int64_t>":$sizes,
       "ArrayRef<int64_t>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a SubViewOp with dynamic entries and custom result type. If the
     // type passed is nullptr, it is inferred.
     OpBuilder<(ins "Value":$source, "ValueRange":$offsets,
       "ValueRange":$sizes, "ValueRange":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a SubViewOp with dynamic entries and inferred result type.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "ValueRange":$offsets, "ValueRange":$sizes, "ValueRange":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// Returns the type of the base memref operand.
     MemRefType getSourceType() {
       return source().getType().cast<MemRefType>();
     }
 
let description = [{
 
     ```mlir
     %1 = memref.transpose %0 (i, j) -> (j, i) : memref<?x?xf32> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d1 * s0 + d0)>>
     ```
   }];
 
   let builders = [
     OpBuilder<(ins "Value":$in, "AffineMapAttr":$permutation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
+      CArg<"AttributeRange", "{}">:$attrs)>];
 
   let extraClassDeclaration = [{
     static StringRef getPermutationAttrName() { return "permutation"; }
     ShapedType getShapedType() { return in().getType().cast<ShapedType>(); }
   }];
 
   let hasFolder = 1;
 }

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

let arguments = (ins Optional<AnyType>:$if_expr_var,
              Variadic<AnyType>:$copyin_vars,
              Variadic<AnyType>:$allocate_vars,
              Variadic<AnyType>:$allocators_vars,
              OptionalAttr<ProcBindKind>:$proc_bind_val);
 
   let regions = (region AnyRegion:$region);
 
   let builders = [
-    OpBuilder<(ins CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
+    OpBuilder<(ins CArg<"AttributeRange", "{}">:$attributes)>
   ];
   let parser = [{ return parseParallelOp(parser, result); }];
   let printer = [{ return printParallelOp(p, *this); }];
   let verifier = [{ return ::verifyParallelOp(*this); }];
 }
 
 def TerminatorOp : OpenMP_Op<"terminator", [Terminator]> {
   let summary = "terminator for OpenMP regions";
let arguments = (ins Variadic<IntLikeType>:$lowerBound,
              OptionalAttr<OrderKind>:$order_val,
              UnitAttr:$inclusive);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<(ins "ValueRange":$lowerBound, "ValueRange":$upperBound,
                "ValueRange":$step,
-               CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
+               CArg<"AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "TypeRange":$resultTypes, "ValueRange":$lowerBound,
                "ValueRange":$upperBound, "ValueRange":$step,
                "ValueRange":$privateVars, "ValueRange":$firstprivateVars,
                "ValueRange":$lastprivate_vars, "ValueRange":$linear_vars,
                "ValueRange":$linear_step_vars, "ValueRange":$reduction_vars,
                "StringAttr":$schedule_val, "Value":$schedule_chunk_var,
                "IntegerAttr":$collapse_val, "UnitAttr":$nowait,
                "IntegerAttr":$ordered_val, "StringAttr":$order_val,
                "UnitAttr":$inclusive, CArg<"bool", "true">:$buildBody)>,
     OpBuilder<(ins "TypeRange":$resultTypes, "ValueRange":$operands,
-               CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
+               CArg<"AttributeRange", "{}">:$attributes)>
   ];
 
   let regions = (region AnyRegion:$region);
 
   let extraClassDeclaration = [{
     /// Returns the number of loops in the workshape loop nest.
     unsigned getNumLoops() { return lowerBound().size(); }
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVMemoryOps.td

let arguments = (ins
     OptionalAttr<SPV_MemoryAccessAttr>:$memory_access,
     OptionalAttr<I32Attr>:$alignment
   );
 
   let results = (outs);
 
   let builders = [
     OpBuilder<(ins "Value":$ptr, "Value":$value,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$namedAttrs),
+      CArg<"AttributeRange", "{}">:$namedAttrs),
     [{
       $_state.addOperands(ptr);
       $_state.addOperands(value);
       $_state.addAttributes(namedAttrs);
     }]>
   ];
 }
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td

def SPV_FuncOp : SPV_Op<"func", [
 
   let regions = (region AnyRegion:$body);
 
   let verifier = [{ return success(); }];
 
   let builders = [
     OpBuilder<(ins "StringRef":$name, "FunctionType":$type,
       CArg<"spirv::FunctionControl", "spirv::FunctionControl::None">:$control,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
+      CArg<"AttributeRange", "{}">:$attrs)>];
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let extraClassDeclaration = [{
   private:
     // This trait needs access to the hooks defined below.
OpBuilder<(ins "TypeAttr":$type,
                    "StringAttr":$sym_name,
                    CArg<"FlatSymbolRefAttr", "nullptr">:$initializer),
     [{
       $_state.addAttribute("type", type);
       $_state.addAttribute(sym_nameAttrName($_state.name), sym_name);
       if (initializer)
         $_state.addAttribute(initializerAttrName($_state.name), initializer);
     }]>,
-    OpBuilder<(ins "TypeAttr":$type, "ArrayRef<NamedAttribute>":$namedAttrs),
+    OpBuilder<(ins "TypeAttr":$type, "AttributeRange":$namedAttrs),
     [{
       $_state.addAttribute("type", type);
       $_state.addAttributes(namedAttrs);
     }]>,
     OpBuilder<(ins "Type":$type, "StringRef":$name,
       "unsigned":$descriptorSet, "unsigned":$binding)>,
     OpBuilder<(ins "Type":$type, "StringRef":$name,
       "spirv::BuiltIn":$builtin)>,

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

def Shape_ShapeEqOp : Shape_Op<"shape_eq",
   let builders = [
   OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
     [{ build($_builder, $_state, ::llvm::makeArrayRef({lhs, rhs})); }]>,
   ];
   let extraClassDeclaration = [{
     // TODO: This should really be automatic. Figure out how to not need this defined.
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
     ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
-    ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+    ::mlir::AttributeRange attributes, ::mlir::RegionRange regions,
     ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {
       inferredReturnTypes.push_back(::mlir::IntegerType::get(context,
                                                              /*width=*/1));
       return success();
     };
   }];
 
   let assemblyFormat = "$shapes attr-dict `:` type($shapes)";
def Shape_IsBroadcastableOp : Shape_Op<"is_broadcastable",
   let builders = [
   OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
     [{ build($_builder, $_state, ::llvm::makeArrayRef({lhs, rhs})); }]>,
   ];
   let extraClassDeclaration = [{
     // TODO: This should really be automatic. Figure out how to not need this defined.
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
     ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
-    ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+    ::mlir::AttributeRange attributes, ::mlir::RegionRange regions,
     ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {
       inferredReturnTypes.push_back(::mlir::IntegerType::get(context,
                                                              /*width=*/1));
       return success();
     };
   }];
 
   let hasFolder = 1;
def Shape_CstrBroadcastableOp : Shape_Op<"cstr_broadcastable",
   OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
     [{ build($_builder, $_state, ::llvm::makeArrayRef({lhs, rhs})); }]>,
   ];
 
   let extraClassDeclaration = [{
     // TODO: This should really be automatic. Figure out how to not need this defined.
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
     ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
-    ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+    ::mlir::AttributeRange attributes, ::mlir::RegionRange regions,
     ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {
       inferredReturnTypes.push_back(::mlir::shape::WitnessType::get(context));
       return success();
     };
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
def Shape_CstrEqOp : Shape_Op<"cstr_eq", [Commutative, InferTypeOpInterface]> {
   let results = (outs Shape_WitnessType:$result);
 
   let assemblyFormat = "$shapes attr-dict `:` type($shapes)";
 
   let extraClassDeclaration = [{
     // TODO: This should really be automatic. Figure out how to not need this defined.
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
     ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
-    ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+    ::mlir::AttributeRange attributes, ::mlir::RegionRange regions,
     ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {
       inferredReturnTypes.push_back(::mlir::shape::WitnessType::get(context));
       return success();
     };
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;

mlir/include/mlir/Dialect/Tensor/IR/TensorOps.td

let assemblyFormat = [{
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let builders = [
     // Build an ExtractSliceOp with mixed static and dynamic entries and
     // inferred result type.
     OpBuilder<(ins "Value":$source, "ArrayRef<OpFoldResult>":$offsets,
       "ArrayRef<OpFoldResult>":$sizes, "ArrayRef<OpFoldResult>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build an ExtractSliceOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
     OpBuilder<(ins "RankedTensorType":$resultType, "Value":$source,
       "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build an ExtractSliceOp with dynamic entries and custom result type. If
     // the type passed is nullptr, it is inferred.
     OpBuilder<(ins "Value":$source, "ValueRange":$offsets,
       "ValueRange":$sizes, "ValueRange":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build an ExtractSliceOp with dynamic entries and inferred result type.
     OpBuilder<(ins "RankedTensorType":$resultType, "Value":$source,
       "ValueRange":$offsets, "ValueRange":$sizes, "ValueRange":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// Returns the type of the base tensor operand.
     RankedTensorType getSourceType() {
       return source().getType().cast<RankedTensorType>();
     }
 
def Tensor_InsertSliceOp : BaseOpWithOffsetSizesAndStrides<
 
   let verifier = ?;
 
   let builders = [
     // Build a InsertSliceOp with mixed static and dynamic entries.
     OpBuilder<(ins "Value":$source, "Value":$dest,
       "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a InsertSliceOp with dynamic entries.
     OpBuilder<(ins "Value":$source, "Value":$dest,
       "ValueRange":$offsets, "ValueRange":$sizes, "ValueRange":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// Returns the type of the base tensor operand.
     RankedTensorType getSourceType() {
       return source().getType().cast<RankedTensorType>();
     }
 

mlir/include/mlir/IR/AttributeRange.h

+#ifndef MLIR_IR_ATTRIBUTERANGE_H_
+#define MLIR_IR_ATTRIBUTERANGE_H_
+
+#include "mlir/IR/Attributes.h"
+#include "mlir/IR/Identifier.h"
+#include "llvm/ADT/STLExtras.h"
+
+namespace mlir {
+class DictionaryAttr;
+class NamedAttrList;
+class Operation;
+namespace detail {
+class OpAttributeList;
+} // end namespace detail
+
+/// Named attribute flat map implementation.
+///
+/// Base lookup functions for implementing a named attribute flat map. These
+/// functions implement attribute lookups for strings and identifiers on both
+/// lists sorted and unsorted (by string).
+///
+/// These functions return whether the exact name was found and, if so, an
+/// iterator to the element. Otherwise, an identifier lookup will return
+/// pass-the-end whereas a string lookup will return the insertion location.
+namespace impl {
+template <typename IteratorT, typename ToStringRef>
+std::pair<IteratorT, bool> lookupAttributeSorted(IteratorT first,
+                                                 IteratorT last, StringRef name,
+                                                 ToStringRef &&asStringRef) {
+  auto length = std::distance(first, last);
+  using diff_t = decltype(length);
+
+  while (length > 0) {
+    diff_t half = length / 2;
+    IteratorT mid = first + half;
+    auto c = asStringRef(*mid).compare(name);
+    if (c < 0) {
+      first = mid;
+      ++first;
+      length = length - half - 1;
+    } else if (c > 0) {
+      length = half;
+    } else {
+      return {mid, true};
+    }
+  }
+  return {first, false};
+}
+
+template <typename IteratorT>
+std::pair<IteratorT, bool>
+lookupAttributeSorted(IteratorT first, IteratorT last, StringRef name) {
+  return lookupAttributeSorted(
+      first, last, name,
+      [](const NamedAttribute &attr) { return attr.first.strref(); });
+}
+
+template <typename IteratorT>
+std::pair<IteratorT, bool>
+lookupAttributeSorted(IteratorT first, IteratorT last, Identifier name) {
+  auto it = std::find_if(first, last, [name](const NamedAttribute &attr) {
+    return attr.first == name;
+  });
+  return {it, it != last};
+}
+
+template <typename IteratorT>
+std::pair<IteratorT, bool>
+lookupAttributeUnsorted(IteratorT first, IteratorT last, StringRef name) {
+  auto it = std::find_if(first, last, [name](const NamedAttribute &attr) {
+    return attr.first == name;
+  });
+  return {it, it != last};
+}
+
+template <typename IteratorT>
+std::pair<IteratorT, bool>
+lookupAttributeUnsorted(IteratorT first, IteratorT last, Identifier name) {
+  return lookupAttributeSorted(first, last, name);
+}
+
+/// String and identifier attribute lookup functions when the names and
+/// attributes are stored in separate, associated lists.
+///
+/// The returned iterators follow the same semantics as the above functions,
+/// except that separate name and attribute iterators are returned.
+
+template <typename NameIt, typename AttrIt>
+std::tuple<NameIt, AttrIt, bool>
+findInlineAttribute(NameIt nameFirst, NameIt nameLast, AttrIt attrFirst,
+                    StringRef name) {
+  auto nameIt = lookupAttributeSorted(
+      nameFirst, nameLast, name, [](Identifier name) { return name.strref(); });
+  auto attrIt = std::next(attrFirst, std::distance(nameFirst, nameIt.first));
+  return {nameIt.first, attrIt, nameIt.second};
+}
+
+template <typename NameIt, typename AttrIt>
+std::tuple<NameIt, AttrIt, bool>
+findInlineAttribute(NameIt nameFirst, NameIt nameLast, AttrIt attrFirst,
+                    Identifier name) {
+  auto nameIt = std::find(nameFirst, nameLast, name);
+  auto attrIt = std::next(attrFirst, std::distance(nameFirst, nameIt));
+  return {nameIt, attrIt, nameIt != nameLast};
+}
+} // end namespace impl
+
+class AttributeRange final {
+  /// TODO: llvm::PointerUnion cannot be used with pointers to incomplete types
+  /// because it queries the alignment of the types. The dependency of Operation
+  /// on AttributeRange is difficult to break because it depends on
+  /// AttributeRange::iterator and defines several iterator and range types that
+  /// depend on it as well.
+  union Owner {
+    const NamedAttribute *attrs; // array-like colleciton of named attributes
+    Operation *op;               // operation as a collection of attributes
+
+    Owner(const NamedAttribute *attributes) : attrs(attributes) {}
+    Owner(Operation *operation) : op(operation) {}
+  };
+
+  /// Discriminator for the union.
+  enum Kind { NAMED_ATTR_ARRAY, OPERATION };
+
+public:
+  /// Base type constructors.
+  AttributeRange(const NamedAttribute *attrs, unsigned numAttrs, bool isSorted)
+      : first(attrs, 0, NAMED_ATTR_ARRAY),
+        last(attrs, numAttrs, NAMED_ATTR_ARRAY), sorted(isSorted) {}
+  AttributeRange(Operation *op);
+
+  /// Conversions from containers of attributes.
+  AttributeRange(ArrayRef<NamedAttribute> attrs = {}, bool isSorted = false)
+      : AttributeRange(attrs.data(), attrs.size(), isSorted) {}
+  AttributeRange(const NamedAttribute &attr)
+      : AttributeRange(&attr, /*numAttrs=*/1, /*isSorted=*/true) {}
+  AttributeRange(std::initializer_list<NamedAttribute> attrs)
+      : AttributeRange(ArrayRef<NamedAttribute>(attrs), /*isSorted=*/false) {}
+  template <typename Arg,
+            typename = typename std::enable_if_t<
+                std::is_constructible<ArrayRef<NamedAttribute>, Arg>::value &&
+                !std::is_convertible<Arg, NamedAttribute>::value>>
+  AttributeRange(Arg &&arg, bool isSorted = false)
+      : AttributeRange(ArrayRef<NamedAttribute>(std::forward<Arg>(arg)),
+                       isSorted) {}
+  AttributeRange(DictionaryAttr dictAttr);
+  AttributeRange(const NamedAttrList &list);
+  AttributeRange(const detail::OpAttributeList &opAttrs);
+
+  /// Check whether the attribute range is sorted.
+  bool isSorted() const { return sorted; }
+
+  /// An iterator for the attribute range.
+  class iterator
+      : public llvm::iterator_facade_base<
+            iterator, std::random_access_iterator_tag, NamedAttribute,
+            ptrdiff_t, const NamedAttribute *, NamedAttribute> {
+
+    iterator(Owner owner, ptrdiff_t index, Kind kind);
+
+  public:
+    NamedAttribute operator*() const;
+    iterator &operator+=(ptrdiff_t diff);
+    iterator &operator-=(ptrdiff_t diff);
+
+    bool operator==(const iterator &it) const { return index == it.index; }
+    bool operator<(const iterator &it) const { return index < it.index; }
+    ptrdiff_t operator-(const iterator &it) const;
+
+  private:
+    /// Pointer to the underlying collection.
+    Owner owner;
+    /// Index of this iterator into the range.
+    ptrdiff_t index : 31;
+    /// Discriminator for the collection union.
+    Kind kind : 1;
+
+    /// Give access to constructor.
+    friend class AttributeRange;
+  };
+
+  /// Iterators.
+  iterator begin() const { return first; }
+  iterator end() const { return last; }
+
+  /// Direct accessors.
+  NamedAttribute front() const {
+    assert(size() >= 1 && "expected to have attributes");
+    return *begin();
+  }
+  NamedAttribute back() const {
+    assert(size() >= 1 && "expected to have attributes");
+    return *std::prev(end(), 1);
+  }
+  NamedAttribute operator[](ptrdiff_t index) const { return begin()[index]; }
+
+  /// Query number of elements.
+  unsigned size() const { return std::distance(begin(), end()); }
+  bool empty() const { return size() == 0; }
+
+  /// Implicit conversion to vector.
+  operator SmallVector<NamedAttribute>() const {
+    return llvm::to_vector<llvm::CalculateSmallVectorDefaultInlinedElements<
+        NamedAttribute>::value>(*this);
+  }
+
+  /// Element-wise comparison to another range.
+  bool operator==(const AttributeRange &other) const {
+    return size() == other.size() && llvm::equal(*this, other);
+  }
+  bool operator!=(const AttributeRange &other) const {
+    return !operator==(other);
+  }
+
+private:
+  template <typename NameT>
+  std::pair<iterator, bool> findAttribute(NameT name) const {
+    assert(first.kind == NAMED_ATTR_ARRAY);
+    return isSorted() ? impl::lookupAttributeSorted(begin(), end(), name)
+                      : impl::lookupAttributeUnsorted(begin(), end(), name);
+  }
+  std::pair<iterator, bool> lookupAttribute(Identifier name) const {
+    return impl::lookupAttributeUnsorted(begin(), end(), name);
+  }
+
+  Optional<NamedAttribute> opGetNamed(StringRef name) const;
+  Optional<NamedAttribute> opGetNamed(Identifier name) const;
+
+public:
+  /// Read-only dictionary-like operations.
+  template <typename NameT>
+  Attribute get(NameT name) const {
+    if (first.kind == NAMED_ATTR_ARRAY) {
+      auto result = findAttribute(name);
+      return result.second ? result.first->second : Attribute();
+    }
+    auto result = opGetNamed(name);
+    return result.hasValue() ? result->second : Attribute();
+  }
+  template <typename NameT>
+  Optional<NamedAttribute> getNamed(NameT name) const {
+    if (first.kind == NAMED_ATTR_ARRAY) {
+      auto result = findAttribute(name);
+      return result.second ? *result.first : Optional<NamedAttribute>();
+    }
+    return opGetNamed(name);
+  }
+  template <typename AttributeT, typename NameT>
+  AttributeT getAs(NameT name) const {
+    return get(name).template dyn_cast_or_null<AttributeT>();
+  }
+
+  /// Apply a function to elements in sorted order.
+  void applySorted(llvm::function_ref<void(NamedAttribute)> eachFn) const;
+
+  class sorted_iterator
+      : public llvm::iterator_facade_base<
+            sorted_iterator, std::forward_iterator_tag, NamedAttribute,
+            ptrdiff_t, const NamedAttribute *, NamedAttribute> {
+
+    sorted_iterator(const AttributeRange *attrs);
+    sorted_iterator(const AttributeRange *attrs, int);
+
+  public:
+    NamedAttribute operator*() const;
+    sorted_iterator &operator++();
+    bool operator==(const sorted_iterator &it) const;
+
+  private:
+    const Identifier *nameIt;
+    const Identifier *nameEnd;
+    const Attribute *inAttrIt;
+    const NamedAttribute *attrIt;
+    const NamedAttribute *attrEnd;
+    bool curIsIntrinsic;
+
+    friend class AttributeRange;
+  };
+
+  sorted_iterator sorted_begin() const { return sorted_iterator(this); }
+  sorted_iterator sorted_end() const { return sorted_iterator(this, int()); }
+  using sorted_range = llvm::iterator_range<sorted_iterator>;
+  sorted_range getMaybeSorted() const { return {sorted_begin(), sorted_end()}; }
+
+private:
+  /// Iterator to the first element in the range.
+  iterator first;
+  /// Pass-the-end iterator.
+  iterator last;
+  /// Whether the range of attributes *can* be traversed in sorted order. NOTE:
+  /// this does not mean that [first, last) is sorted.
+  bool sorted;
+};
+
+inline llvm::hash_code hash_value(AttributeRange attrs) {
+  return llvm::hash_combine_range(attrs.begin(), attrs.end());
+}
+
+namespace impl {
+/// Separate intrinsic and extrinsic attributes from a maybe sorted range.
+void separateIntrinsicAttrs(AttributeRange attrs,
+                            ArrayRef<Identifier> intrinsicNames,
+                            MutableArrayRef<Attribute> intrinsicAttrs,
+                            SmallVectorImpl<NamedAttribute> &extraAttrs);
+void forEachSorted(ArrayRef<Identifier> intrinsicNames,
+                   ArrayRef<Attribute> intrinsicAttrs,
+                   const detail::OpAttributeList &extraAttrs,
+                   llvm::function_ref<void(NamedAttribute)> eachFn);
+} // end namespace impl
+
+} // end namespace mlir
+
+#endif // MLIR_IR_ATTRIBUTERANGE_H_

mlir/include/mlir/IR/Builders.h

Ty getType(Args... args) {
     return Ty::get(context, args...);
   }
 
   // Attributes.
   NamedAttribute getNamedAttr(StringRef name, Attribute val);
 
   UnitAttr getUnitAttr();
   BoolAttr getBoolAttr(bool value);
-  DictionaryAttr getDictionaryAttr(ArrayRef<NamedAttribute> value);
+  DictionaryAttr getDictionaryAttr(AttributeRange value);
   IntegerAttr getIntegerAttr(Type type, int64_t value);
   IntegerAttr getIntegerAttr(Type type, const APInt &value);
   FloatAttr getFloatAttr(Type type, double value);
   FloatAttr getFloatAttr(Type type, const APFloat &value);
   StringAttr getStringAttr(const Twine &bytes);
   ArrayAttr getArrayAttr(ArrayRef<Attribute> value);
 
   // Returns a 0-valued attribute of the given `type`. This function only

mlir/include/mlir/IR/BuiltinAttributes.h

 //===- BuiltinAttributes.h - MLIR Builtin Attribute Classes -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_BUILTINATTRIBUTES_H
 #define MLIR_IR_BUILTINATTRIBUTES_H
 
+#include "mlir/IR/AttributeRange.h"
 #include "mlir/IR/BuiltinAttributeInterfaces.h"
 #include "mlir/IR/SubElementInterfaces.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/Sequence.h"
 #include <complex>
 
 namespace mlir {
 class AffineMap;

mlir/include/mlir/IR/BuiltinAttributes.td

def Builtin_DenseStringElementsAttr : Builtin_Attr<
   let genStorageClass = 0;
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // DictionaryAttr
 //===----------------------------------------------------------------------===//
 
+def AttrRangeParameter : AttrOrTypeParameter<"::mlir::AttributeRange", ""> {
+  let allocator = [{
+    $_dst = AttributeRange($_allocator.copyInto($_self), true);
+  }];
+}
+
 def Builtin_DictionaryAttr : Builtin_Attr<"Dictionary", [
     DeclareAttrInterfaceMethods<SubElementAttrInterface>
   ]> {
   let summary = "An dictionary of named Attribute values";
   let description = [{
     Syntax:
 
     ```
     dictionary-attribute ::= `{` (attribute-entry (`,` attribute-entry)*)? `}`
     ```
 
     A dictionary attribute is an attribute that represents a sorted collection of
     named attribute values. The elements are sorted by name, and each name must be
     unique within the collection.
 
     Examples:
 
     ```mlir
     {}
     {attr_name = "string attribute"}
     {int_attr = 10, "string attr name" = "string attribute"}
     ```
   }];
-  let parameters = (ins ArrayRefParameter<"NamedAttribute", "">:$value);
+  // TODO: DictionaryAttr should exist as an ArrayRef<NamedAttribute> and only
+  // be converted to AttributeRange as needed, but this cannot be done with ODS
+  // attributes.
+  let parameters = (ins AttrRangeParameter:$value);
   let builders = [
-    AttrBuilder<(ins CArg<"ArrayRef<NamedAttribute>", "llvm::None">:$value)>
+    AttrBuilder<(ins CArg<"AttributeRange", "llvm::None">:$value)>
   ];
   let extraClassDeclaration = [{
-    using ValueType = ArrayRef<NamedAttribute>;
+    using ValueType = AttributeRange;
 
     /// Construct a dictionary with an array of values that is known to already
     /// be sorted by name and uniqued.
     static DictionaryAttr getWithSorted(MLIRContext *context,
-                                        ArrayRef<NamedAttribute> value);
+                                        AttributeRange value);
 
     /// Return the specified attribute if present, null otherwise.
     Attribute get(StringRef name) const;
     Attribute get(Identifier name) const;
 
     /// Return the specified named attribute if present, None otherwise.
     Optional<NamedAttribute> getNamed(StringRef name) const;
     Optional<NamedAttribute> getNamed(Identifier name) const;
 
     /// Support range iteration.
-    using iterator = llvm::ArrayRef<NamedAttribute>::iterator;
+    using iterator = AttributeRange::iterator;
     iterator begin() const;
     iterator end() const;
     bool empty() const { return size() == 0; }
     size_t size() const;
 
     /// Sorts the NamedAttributes in the array ordered by name as expected by
     /// getWithSorted and returns whether the values were sorted.
     /// Requires: uniquely named attributes.
-    static bool sort(ArrayRef<NamedAttribute> values,
+    static bool sort(AttributeRange values,
                      SmallVectorImpl<NamedAttribute> &storage);
 
     /// Sorts the NamedAttributes in the array ordered by name as expected by
     /// getWithSorted in place on an array and returns whether the values needed
     /// to be sorted.
     /// Requires: uniquely named attributes.
     static bool sortInPlace(SmallVectorImpl<NamedAttribute> &array);
 

mlir/include/mlir/IR/BuiltinOps.td

]> {
 
   let arguments = (ins SymbolNameAttr:$sym_name,
                        TypeAttr:$type,
                        OptionalAttr<StrAttr>:$sym_visibility);
   let regions = (region AnyRegion:$body);
 
   let builders = [OpBuilder<(ins
     "StringRef":$name, "FunctionType":$type,
-    CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
+    CArg<"AttributeRange", "{}">:$attrs,
     CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs)
   >];
   let extraClassDeclaration = [{
     static FuncOp create(Location location, StringRef name, FunctionType type,
-                         ArrayRef<NamedAttribute> attrs = {});
+                         AttributeRange attrs = {});
     static FuncOp create(Location location, StringRef name, FunctionType type,
                          Operation::dialect_attr_range attrs);
     static FuncOp create(Location location, StringRef name, FunctionType type,
-                         ArrayRef<NamedAttribute> attrs,
+                         AttributeRange attrs,
                          ArrayRef<DictionaryAttr> argAttrs);
 
     /// 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). If the mapper
     /// contains entries for function arguments, these arguments are not
     /// included in the new function. Replaces references to cloned sub-values
     /// with the corresponding value that is copied, and adds those mappings to

mlir/include/mlir/IR/FunctionSupport.h

 /// size of `attrs` is expected to match the number of arguments/results of the
 /// given `op`.
 void setAllArgAttrDicts(Operation *op, ArrayRef<DictionaryAttr> attrs);
 void setAllArgAttrDicts(Operation *op, ArrayRef<Attribute> attrs);
 void setAllResultAttrDicts(Operation *op, ArrayRef<DictionaryAttr> attrs);
 void setAllResultAttrDicts(Operation *op, ArrayRef<Attribute> attrs);
 
 /// Return all of the attributes for the argument at 'index'.
-inline ArrayRef<NamedAttribute> getArgAttrs(Operation *op, unsigned index) {
+inline AttributeRange getArgAttrs(Operation *op, unsigned index) {
   auto argDict = getArgAttrDict(op, index);
   return argDict ? argDict.getValue() : llvm::None;
 }
 
 /// Return all of the attributes for the result at 'index'.
-inline ArrayRef<NamedAttribute> getResultAttrs(Operation *op, unsigned index) {
+inline AttributeRange getResultAttrs(Operation *op, unsigned index) {
   auto resultDict = getResultAttrDict(op, index);
   return resultDict ? resultDict.getValue() : llvm::None;
 }
 
 /// Insert the specified arguments and update the function type attribute.
 void insertFunctionArguments(Operation *op, ArrayRef<unsigned> argIndices,
                              TypeRange argTypes,
                              ArrayRef<DictionaryAttr> argAttrs,
public:
   /// FunctionLike operations allow for attaching attributes to each of the
   /// respective function arguments. These argument attributes are stored as
   /// DictionaryAttrs in the main operation attribute dictionary. The name of
   /// these entries is `arg` followed by the index of the argument. These
   /// argument attribute dictionaries are optional, and will generally only
   /// exist if they are non-empty.
 
   /// Return all of the attributes for the argument at 'index'.
-  ArrayRef<NamedAttribute> getArgAttrs(unsigned index) {
+  AttributeRange getArgAttrs(unsigned index) {
     return function_like_impl::getArgAttrs(this->getOperation(), index);
   }
 
   /// Return an ArrayAttr containing all argument attribute dictionaries of this
   /// function, or nullptr if no arguments have attributes.
   ArrayAttr getAllArgAttrs() {
     return this->getOperation()->template getAttrOfType<ArrayAttr>(
         function_like_impl::getArgDictAttrName());
AttrClass getArgAttrOfType(unsigned index, Identifier name) {
     return getArgAttr(index, name).template dyn_cast_or_null<AttrClass>();
   }
   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, AttributeRange attributes);
 
   /// Set the attributes held by the argument at 'index'. `attributes` may be
   /// null, in which case any existing argument attributes are removed.
   void setArgAttrs(unsigned index, DictionaryAttr attributes);
   void setAllArgAttrs(ArrayRef<DictionaryAttr> attributes) {
     assert(attributes.size() == getNumArguments());
     function_like_impl::setAllArgAttrDicts(this->getOperation(), attributes);
   }
public:
   /// 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) {
+  AttributeRange getResultAttrs(unsigned index) {
     return function_like_impl::getResultAttrs(this->getOperation(), index);
   }
 
   /// Return an ArrayAttr containing all result attribute dictionaries of this
   /// function, or nullptr if no result have attributes.
   ArrayAttr getAllResultAttrs() {
     return this->getOperation()->template getAttrOfType<ArrayAttr>(
         function_like_impl::getResultDictAttrName());
AttrClass getResultAttrOfType(unsigned index, Identifier name) {
     return getResultAttr(index, name).template dyn_cast_or_null<AttrClass>();
   }
   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, AttributeRange attributes);
 
   /// Set the attributes held by the result at 'index'. `attributes` may be
   /// null, in which case any existing argument attributes are removed.
   void setResultAttrs(unsigned index, DictionaryAttr attributes);
   void setAllResultAttrs(ArrayRef<DictionaryAttr> attributes) {
     assert(attributes.size() == getNumResults());
     function_like_impl::setAllResultAttrDicts(this->getOperation(), attributes);
   }

 }
 
 //===----------------------------------------------------------------------===//
 // Function Argument Attribute.
 //===----------------------------------------------------------------------===//
 
 /// Set the attributes held by the argument at 'index'.
 template <typename ConcreteType>
-void FunctionLike<ConcreteType>::setArgAttrs(
-    unsigned index, ArrayRef<NamedAttribute> attributes) {
+void FunctionLike<ConcreteType>::setArgAttrs(unsigned index,
+                                             AttributeRange attributes) {
   assert(index < getNumArguments() && "invalid argument number");
   Operation *op = this->getOperation();
   return function_like_impl::detail::setArgResAttrDict(
       op, function_like_impl::getArgDictAttrName(), getNumArguments(), index,
       DictionaryAttr::get(op->getContext(), attributes));
 }
 
 template <typename ConcreteType>

 }
 
 //===----------------------------------------------------------------------===//
 // Function Result Attribute.
 //===----------------------------------------------------------------------===//
 
 /// Set the attributes held by the result at 'index'.
 template <typename ConcreteType>
-void FunctionLike<ConcreteType>::setResultAttrs(
-    unsigned index, ArrayRef<NamedAttribute> attributes) {
+void FunctionLike<ConcreteType>::setResultAttrs(unsigned index,
+                                                AttributeRange attributes) {
   assert(index < getNumResults() && "invalid result number");
   Operation *op = this->getOperation();
   return function_like_impl::detail::setArgResAttrDict(
       op, function_like_impl::getResultDictAttrName(), getNumResults(), index,
       DictionaryAttr::get(op->getContext(), attributes));
 }
 
 template <typename ConcreteType>

mlir/include/mlir/IR/OpBase.td

class Op<Dialect dialect, string mnemonic, list<OpTrait> props = []> {
   //                   Attribute <attr0-name>, Attribute <attr1-name>, ...);
   // ```
   // * where the attributes follow the same declaration order as in the op.
   //
   // ```c++
   // static void build(OpBuilder &, OperationState &odsState,
   //                   TypeRange resultTypes,
   //                   ValueRange operands,
-  //                   ArrayRef<NamedAttribute> attributes);
+  //                   AttributeRange attributes);
   // ```
   list<OpBuilder> builders = ?;
 
   // Avoid generating default build functions.  Custom builders must be
   // provided.
   bit skipDefaultBuilders = 0;
 
   // Custom parser.

mlir/include/mlir/IR/OpImplementation.h

public:
   virtual void printNewline() = 0;
 
   /// Print a block argument in the usual format of:
   ///   %ssaName : type {attr1=42} loc("here")
   /// where location printing is controlled by the standard internal option.
   /// You may pass omitType=true to not print a type, and pass an empty
   /// attribute list if you don't care for attributes.
   virtual void printRegionArgument(BlockArgument arg,
-                                   ArrayRef<NamedAttribute> argAttrs = {},
+                                   AttributeRange argAttrs = {},
                                    bool omitType = false) = 0;
 
   /// Print implementations for various things an operation contains.
   virtual void printOperand(Value value) = 0;
   virtual void printOperand(Value value, raw_ostream &os) = 0;
 
   /// Print a comma separated list of operands.
   template <typename ContainerType>
public:
   /// Print the successor and its operands.
   virtual void printSuccessorAndUseList(Block *successor,
                                         ValueRange succOperands) = 0;
 
   /// If the specified operation has attributes, print out an attribute
   /// dictionary with their values.  elidedAttrs allows the client to ignore
   /// specific well known attributes, commonly used if the attribute value is
   /// printed some other way (like as a fixed operand).
-  virtual void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
+  virtual void printOptionalAttrDict(AttributeRange attrs,
                                      ArrayRef<StringRef> elidedAttrs = {}) = 0;
 
   /// If the specified operation has attributes, print out an attribute
   /// dictionary prefixed with 'attributes'.
   virtual void
-  printOptionalAttrDictWithKeyword(ArrayRef<NamedAttribute> attrs,
+  printOptionalAttrDictWithKeyword(AttributeRange attrs,
                                    ArrayRef<StringRef> elidedAttrs = {}) = 0;
 
   /// Print the entire operation with the default generic assembly form.
   /// If `printOpName` is true, then the operation name is printed (the default)
   /// otherwise it is omitted and the print will start with the operand list.
   virtual void printGenericOp(Operation *op, bool printOpName = true) = 0;
 
   /// Prints a region.
public:
   // Attribute/Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Invoke the `getChecked` method of the given Attribute or Type class, using
   /// the provided location to emit errors in the case of failure. Note that
   /// unlike `OpBuilder::getType`, this method does not implicitly insert a
   /// context parameter.
   template <typename T, typename... ParamsT>
-  T getChecked(llvm::SMLoc loc, ParamsT &&... params) {
+  T getChecked(llvm::SMLoc loc, ParamsT &&...params) {
     return T::getChecked([&] { return emitError(loc); },
                          std::forward<ParamsT>(params)...);
   }
   /// A variant of `getChecked` that uses the result of `getNameLoc` to emit
   /// errors.
   template <typename T, typename... ParamsT>
-  T getChecked(ParamsT &&... params) {
+  T getChecked(ParamsT &&...params) {
     return T::getChecked([&] { return emitError(getNameLoc()); },
                          std::forward<ParamsT>(params)...);
   }
 
   //===--------------------------------------------------------------------===//
   // Attribute Parsing
   //===--------------------------------------------------------------------===//
 

mlir/include/mlir/IR/Operation.h

 
 namespace mlir {
 /// Operation is a basic unit of execution within MLIR. Operations can
 /// be nested within `Region`s held by other operations effectively forming a
 /// tree. Child operations are organized into operation blocks represented by a
 /// 'Block' class.
 class alignas(8) Operation final
     : public llvm::ilist_node_with_parent<Operation, Block>,
-      private llvm::TrailingObjects<Operation, BlockOperand, Region,
+      private llvm::TrailingObjects<Operation, Attribute, BlockOperand, Region,
                                     detail::OperandStorage> {
 public:
   /// Create a new Operation with the specific fields.
   static Operation *create(Location location, OperationName name,
                            TypeRange resultTypes, ValueRange operands,
-                           ArrayRef<NamedAttribute> attributes,
-                           BlockRange successors, unsigned numRegions);
-
-  /// Overload of create that takes an existing DictionaryAttr to avoid
-  /// unnecessarily uniquing a list of attributes.
-  static Operation *create(Location location, OperationName name,
-                           TypeRange resultTypes, ValueRange operands,
-                           DictionaryAttr attributes, BlockRange successors,
+                           AttributeRange attributes, BlockRange 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,
                            TypeRange resultTypes, ValueRange operands,
-                           DictionaryAttr attributes,
+                           AttributeRange attributes,
                            BlockRange 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:
   result_type_iterator result_type_begin() { return getResultTypes().begin(); }
   result_type_iterator result_type_end() { return getResultTypes().end(); }
   result_type_range getResultTypes() { return getResults().getTypes(); }
 
   //===--------------------------------------------------------------------===//
   // Attributes
   //===--------------------------------------------------------------------===//
 
+private:
+  template <typename NameT>
+  std::tuple<ArrayRef<Identifier>::iterator,
+             MutableArrayRef<Attribute>::iterator, bool>
+  findIntrinsicAttr(NameT name) {
+    ArrayRef<Identifier> names = getIntrinsicAttributeNames();
+    MutableArrayRef<Attribute> attrs = getIntrinsicAttributes();
+    return impl::findInlineAttribute(names.begin(), names.end(), attrs.begin(),
+                                     name);
+  }
+
+  template <typename NameT>
+  void setAttrImpl(NameT name, Attribute value) {
+    auto it = findIntrinsicAttr(name);
+    if (std::get<2>(it)) {
+      *std::get<1>(it) = value;
+      return;
+    }
+    extraAttrs.set(name, value);
+  }
+
+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.getValue(); }
+  AttributeRange getAttrs() { return this; }
+  AttributeRange::iterator attr_begin() { return getAttrs().begin(); }
+  AttributeRange::iterator attr_end() { return getAttrs().end(); }
 
   /// Return all of the attributes on this operation as a DictionaryAttr.
-  DictionaryAttr getAttrDictionary() { return attrs; }
+  DictionaryAttr getAttrDictionary() {
+    if (numIntrinsicAttrs == 0)
+      return extraAttrs.convertToDictionary(getContext());
+    return DictionaryAttr::get(getContext(), getAttrs());
+  }
 
   /// Set the attribute dictionary on this operation.
-  void setAttrs(DictionaryAttr newAttrs) {
-    assert(newAttrs && "expected valid attribute dictionary");
-    attrs = newAttrs;
-  }
-  void setAttrs(ArrayRef<NamedAttribute> newAttrs) {
-    setAttrs(DictionaryAttr::get(getContext(), newAttrs));
-  }
+  void setAttrs(AttributeRange 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>();
+  template <typename NameT>
+  Attribute getAttr(NameT name) {
+    auto attr = extraAttrs.get(name);
+    if (attr)
+      return attr;
+    auto it = findIntrinsicAttr(name);
+    if (std::get<2>(it))
+      return *std::get<1>(it);
+    return Attribute();
+  }
+
+  template <typename NameT>
+  Optional<NamedAttribute> getNamedAttr(NameT name) {
+    auto it = findIntrinsicAttr(name);
+    if (std::get<2>(it))
+      return NamedAttribute(*std::get<0>(it), *std::get<1>(it));
+    return extraAttrs.getNamed(name);
+  }
+
+  template <typename AttributeT, typename NameT>
+  AttributeT getAttrOfType(NameT name) {
+    return getAttr(name).template dyn_cast_or_null<AttributeT>();
   }
 
   /// Return true if the operation has an attribute with the provided name,
   /// false otherwise.
-  bool hasAttr(Identifier name) { return static_cast<bool>(getAttr(name)); }
-  bool hasAttr(StringRef name) { return static_cast<bool>(getAttr(name)); }
+  template <typename NameT>
+  bool hasAttr(NameT name) {
+    auto it = findIntrinsicAttr(name);
+    if (std::get<2>(it))
+      return static_cast<bool>(*std::get<1>(it));
+    return extraAttrs.has(name);
+  }
   template <typename AttrClass, typename NameT>
   bool hasAttrOfType(NameT &&name) {
     return static_cast<bool>(
         getAttrOfType<AttrClass>(std::forward<NameT>(name)));
   }
 
   /// 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) {
-    NamedAttrList attributes(attrs);
-    if (attributes.set(name, value) != value)
-      attrs = attributes.getDictionary(getContext());
-  }
   void setAttr(StringRef name, Attribute value) {
-    setAttr(Identifier::get(name, getContext()), value);
+    return setAttrImpl(name, value);
+  }
+  void setAttr(Identifier name, Attribute value) {
+    return setAttrImpl(name, value);
   }
 
   /// Remove the attribute with the specified name if it exists. Return the
   /// attribute that was erased, or nullptr if there was no attribute with such
   /// name.
-  Attribute removeAttr(Identifier name) {
-    NamedAttrList attributes(attrs);
-    Attribute removedAttr = attributes.erase(name);
-    if (removedAttr)
-      attrs = attributes.getDictionary(getContext());
-    return removedAttr;
+  template <typename NameT>
+  Attribute removeAttr(NameT name) {
+    auto it = findIntrinsicAttr(name);
+    if (std::get<2>(it)) {
+      Attribute prev = *std::get<1>(it);
+      *std::get<1>(it) = Attribute();
+      return prev;
     }
-  Attribute removeAttr(StringRef name) {
-    return removeAttr(Identifier::get(name, getContext()));
+    return extraAttrs.erase(name);
   }
 
   /// A utility iterator that filters out non-dialect attributes.
   class dialect_attr_iterator
-      : public llvm::filter_iterator<ArrayRef<NamedAttribute>::iterator,
+      : public llvm::filter_iterator<AttributeRange::iterator,
                                      bool (*)(NamedAttribute)> {
     static bool filter(NamedAttribute attr) {
       // Dialect attributes are prefixed by the dialect name, like operations.
       return attr.first.strref().count('.');
     }
 
-    explicit dialect_attr_iterator(ArrayRef<NamedAttribute>::iterator it,
-                                   ArrayRef<NamedAttribute>::iterator end)
-        : llvm::filter_iterator<ArrayRef<NamedAttribute>::iterator,
+    explicit dialect_attr_iterator(AttributeRange::iterator it,
+                                   AttributeRange::iterator end)
+        : llvm::filter_iterator<AttributeRange::iterator,
                                 bool (*)(NamedAttribute)>(it, end, &filter) {}
 
     // Allow access to the constructor.
     friend Operation;
   };
   using dialect_attr_range = iterator_range<dialect_attr_iterator>;
 
   /// Return a range corresponding to the dialect attributes for this operation.
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('.'))
         attrs.push_back(attr);
-    setAttrs(attrs.getDictionary(getContext()));
+    setAttrs(attrs);
+  }
+
+  /// Get a reference to the underlying attribute storage.
+  detail::OpAttributeList &getOpAttributes() { return extraAttrs; }
+  /// Get a reference to the intrinsic attribute list.
+  MutableArrayRef<Attribute> getIntrinsicAttributes() {
+    return {getTrailingObjects<Attribute>(), numIntrinsicAttrs};
+  }
+  Attribute &getIntrinsicAttribute(unsigned index) {
+    return getIntrinsicAttributes()[index];
+  }
+  void setIntrinsicAttribute(unsigned index, Attribute value) {
+    getIntrinsicAttributes()[index] = value;
+  }
+  Attribute removeIntrinsicAttribute(unsigned index) {
+    auto value = getIntrinsicAttribute(index);
+    setIntrinsicAttribute(index, Attribute());
+    return value;
+  }
+  ArrayRef<Identifier> getIntrinsicAttributeNames() {
+    return {intrinsicAttrNames, numIntrinsicAttrs};
+  }
+  NamedAttribute getIntrinsicNamedAttribute(unsigned index) {
+    return {getIntrinsicAttributeName(index), getIntrinsicAttribute(index)};
+  }
+  Identifier getIntrinsicAttributeName(unsigned index) {
+    return getIntrinsicAttributeNames()[index];
   }
 
   //===--------------------------------------------------------------------===//
   // Blocks
   //===--------------------------------------------------------------------===//
 
   /// Returns the number of regions held by this operation.
   unsigned getNumRegions() { return numRegions; }
private:
   /// potentially recomputing the order of the parent block.
   void updateOrderIfNecessary();
 
   /// Returns true if this operation has a valid order.
   bool hasValidOrder() { return orderIndex != kInvalidOrderIdx; }
 
 private:
   Operation(Location location, OperationName name, unsigned numResults,
+            ArrayRef<Identifier> intrinsicAttributeNames,
             unsigned numSuccessors, unsigned numRegions,
-            DictionaryAttr attributes, bool hasOperandStorage);
+            AttributeRange attributes, bool hasOperandStorage);
 
   // Operations are deleted through the destroy() member because they are
   // allocated with malloc.
   ~Operation();
 
   /// Returns the additional size necessary for allocating the given objects
   /// before an Operation in-memory.
   static size_t prefixAllocSize(unsigned numOutOfLineResults,
private:
   /// or derived from.
   Location location;
 
   /// Relative order of this operation in its parent block. Used for
   /// O(1) local dominance checks between operations.
   mutable unsigned orderIndex = 0;
 
   const unsigned numResults;
-  const unsigned numSuccs;
-  const unsigned numRegions : 31;
+  const unsigned numIntrinsicAttrs;
+  const unsigned numSuccs : 16;
+  const unsigned numRegions : 15;
 
   /// This bit signals whether this operation has an operand storage or not. The
   /// operand storage may be elided for operations that are known to never have
   /// operands.
   bool hasOperandStorage : 1;
 
+  const Identifier *const intrinsicAttrNames;
+
   /// This holds the name of the operation.
   OperationName name;
 
   /// This holds general named attributes for the operation.
-  DictionaryAttr attrs;
+  detail::OpAttributeList extraAttrs;
 
   // 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.
   friend class Value;
 
   // allow ilist_node_with_parent to access the 'getParent' method.
   friend class llvm::ilist_node_with_parent<Operation, Block>;
 
   // This stuff is used by the TrailingObjects template.
-  friend llvm::TrailingObjects<Operation, BlockOperand, Region,
+  friend llvm::TrailingObjects<Operation, Attribute, BlockOperand, Region,
                                detail::OperandStorage>;
+  size_t numTrailingObjects(OverloadToken<Attribute>) const {
+    return numIntrinsicAttrs;
+  }
   size_t numTrailingObjects(OverloadToken<BlockOperand>) const {
     return numSuccs;
   }
   size_t numTrailingObjects(OverloadToken<Region>) const { return numRegions; }
 };
 
 inline raw_ostream &operator<<(raw_ostream &os, const Operation &op) {
   const_cast<Operation &>(op).print(os, OpPrintingFlags().useLocalScope());

mlir/include/mlir/IR/OperationSupport.h

 //===- OperationSupport.h ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a number of support types that Operation and related
 // classes build on top of.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_OPERATION_SUPPORT_H
 #define MLIR_IR_OPERATION_SUPPORT_H
 
+#include "mlir/IR/AttributeRange.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BlockSupport.h"
 #include "mlir/IR/Identifier.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/TypeRange.h"
 #include "mlir/IR/Types.h"
 #include "mlir/IR/Value.h"
 #include "mlir/Support/InterfaceSupport.h"

 class NamedAttrList {
 public:
   using const_iterator = SmallVectorImpl<NamedAttribute>::const_iterator;
   using const_reference = const NamedAttribute &;
   using reference = NamedAttribute &;
   using size_type = size_t;
 
   NamedAttrList() : dictionarySorted({}, true) {}
-  NamedAttrList(ArrayRef<NamedAttribute> attributes);
+  NamedAttrList(AttributeRange attributes);
   NamedAttrList(DictionaryAttr attributes);
   NamedAttrList(const_iterator in_start, const_iterator in_end);
+  template <typename IteratorT>
+  NamedAttrList(IteratorT in_start, IteratorT in_end) {
+    assign(in_start, in_end);
+  }
 
   bool operator!=(const NamedAttrList &other) const {
     return !(*this == other);
   }
   bool operator==(const NamedAttrList &other) const {
     return attrs == other.attrs;
   }
 
void append(IteratorT in_start, IteratorT in_end) {
     // end of current list.
     dictionarySorted.setPointerAndInt(nullptr, false);
     attrs.append(in_start, in_end);
   }
 
   /// Replaces the attributes with new list of attributes.
   void assign(const_iterator in_start, const_iterator in_end);
 
-  /// Replaces the attributes with new list of attributes.
-  void assign(ArrayRef<NamedAttribute> range) {
-    assign(range.begin(), range.end());
+  template <typename IteratorT>
+  void assign(IteratorT in_start, IteratorT in_end) {
+    dictionarySorted.setPointerAndInt(nullptr, false);
+    attrs.assign(in_start, in_end);
   }
 
+  /// Replaces the attributes with new list of attributes.
+  void assign(AttributeRange range) { assign(range.begin(), range.end()); }
+
   bool empty() const { return attrs.empty(); }
 
   void reserve(size_type N) { attrs.reserve(N); }
 
   /// Add an attribute with the specified name.
   void push_back(NamedAttribute newAttribute);
 
   /// Pop last element from list.
   void pop_back() { attrs.pop_back(); }
 
   /// Returns an entry with a duplicate name the list, if it exists, else
   /// returns llvm::None.
   Optional<NamedAttribute> findDuplicate() const;
 
   /// Return a dictionary attribute for the underlying dictionary. This will
   /// return an empty dictionary attribute if empty rather than null.
   DictionaryAttr getDictionary(MLIRContext *context) const;
 
   /// Return all of the attributes on this operation.
-  ArrayRef<NamedAttribute> getAttrs() const;
+  AttributeRange getAttrs() const;
 
   /// Return the specified attribute if present, null otherwise.
   Attribute get(Identifier name) const;
   Attribute get(StringRef name) const;
 
   /// Return the specified named attribute if present, None otherwise.
   Optional<NamedAttribute> getNamed(StringRef name) const;
   Optional<NamedAttribute> getNamed(Identifier name) const;
public:
   Attribute erase(StringRef name);
 
   const_iterator begin() const { return attrs.begin(); }
   const_iterator end() const { return attrs.end(); }
 
   NamedAttrList &operator=(const SmallVectorImpl<NamedAttribute> &rhs);
   operator ArrayRef<NamedAttribute>() const;
 
-private:
   /// Return whether the attributes are sorted.
   bool isSorted() const { return dictionarySorted.getInt(); }
 
+private:
   /// Erase the attribute at the given iterator position.
   Attribute eraseImpl(SmallVectorImpl<NamedAttribute>::iterator it);
 
   // These are marked mutable as they may be modified (e.g., sorted)
   mutable SmallVector<NamedAttribute, 4> attrs;
   // Pair with cached DictionaryAttr and status of whether attrs is sorted.
   // Note: just because sorted does not mean a DictionaryAttr has been created
   // but the case where there is a DictionaryAttr but attrs isn't sorted should
struct OperationState {
   SmallVector<std::unique_ptr<Region>, 1> regions;
 
 public:
   OperationState(Location location, StringRef name);
 
   OperationState(Location location, OperationName name);
 
   OperationState(Location location, StringRef name, ValueRange operands,
-                 TypeRange types, ArrayRef<NamedAttribute> attributes,
+                 TypeRange types, AttributeRange attributes,
                  BlockRange successors = {},
                  MutableArrayRef<std::unique_ptr<Region>> regions = {});
 
   void addOperands(ValueRange newOperands);
 
   void addTypes(ArrayRef<Type> newTypes) {
     types.append(newTypes.begin(), newTypes.end());
   }
public:
   }
 
   /// Add an attribute with the specified name.
   void addAttribute(Identifier name, Attribute attr) {
     attributes.append(name, attr);
   }
 
   /// Add an array of named attributes.
-  void addAttributes(ArrayRef<NamedAttribute> newAttributes) {
+  void addAttributes(AttributeRange newAttributes) {
     attributes.append(newAttributes);
   }
 
   void addSuccessors(Block *successor) { successors.push_back(successor); }
   void addSuccessors(BlockRange newSuccessors);
 
   /// Create a region that should be attached to the operation.  These regions
   /// can be filled in immediately without waiting for Operation to be
public:
   /// Operation.
   void addRegions(MutableArrayRef<std::unique_ptr<Region>> regions);
 
   /// Get the context held by this operation state.
   MLIRContext *getContext() const { return location->getContext(); }
 };
 
 //===----------------------------------------------------------------------===//
+// OpAttributeList
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class OpAttributeList {
+  /// Use SmallVector with zero inlined elements. SmallVector should use
+  /// `unsigned` as its size type.
+  /// TODO: SmallVector doubles its capacity when growing, which may be
+  /// excessive when `set` only adds one attribute.
+  using Storage = SmallVector<NamedAttribute, 0>;
+
+public:
+  using iterator = Storage::iterator;
+  using const_iterator = Storage::const_iterator;
+  using reference = Storage::reference;
+  using const_reference = Storage::const_reference;
+
+  OpAttributeList(AttributeRange attributes);
+
+  /// Attribute lookups.
+  template <typename NameT>
+  Attribute get(NameT name) const {
+    auto it = lookupAttribute(name);
+    return it.second ? it.first->second : Attribute();
+  }
+  template <typename NameT>
+  Optional<NamedAttribute> getNamed(NameT name) const {
+    auto it = lookupAttribute(name);
+    return it.second ? *it.first : Optional<NamedAttribute>();
+  }
+  template <typename AttributeT, typename NameT>
+  AttributeT getAs(NameT name) const {
+    return get(name).template dyn_cast_or_null<AttributeT>();
+  }
+  template <typename NameT>
+  bool has(NameT name) const {
+    return lookupAttribute(name).second;
+  }
+
+  /// Delete an attribute, if one was found. Returns the erased value.
+  template <typename NameT>
+  Attribute erase(NameT name) {
+    auto it = lookupAttribute(name);
+    if (!it.second)
+      return Attribute();
+    auto value = it.first->second;
+    attrs.erase(it.first);
+    return value;
+  }
+
+  /// Set the value of an attribute.
+  void set(StringRef name, Attribute value);
+  void set(Identifier name, Attribute value);
+
+  /// Add an attribute when it is known that the attribute is more likely to not
+  /// already be in the list. This method goes straight to string lookup, which
+  /// is faster than set(Identifier, Attribute) when adding a new attribute.
+  void addOrSet(Identifier name, Attribute value);
+  /// Set an attribute when it is known that the attribute is more like to
+  /// already be in the list. This method skips the string lookup, which *may*
+  /// be faster than set(StringRef, Attribute) when overwriting an attribute.
+  void setOrAdd(StringRef name, Attribute value);
+
+  /// Overwrite the entire list with a new range of attributes.
+  void assign(AttributeRange attributes);
+
+  /// Query the number of elements.
+  unsigned size() const { return attrs.size(); }
+  bool empty() const { return attrs.empty(); }
+
+  /// Direct indexed access.
+  NamedAttribute operator[](ptrdiff_t index) const { return attrs[index]; }
+
+  /// Iterators over the attributes.
+  iterator begin() { return attrs.begin(); }
+  iterator end() { return attrs.end(); }
+  const_iterator begin() const { return attrs.begin(); }
+  const_iterator end() const { return attrs.end(); }
+
+  /// Conversions to other attribute ranges and containers.
+  operator ArrayRef<NamedAttribute>() const { return attrs; }
+  DictionaryAttr convertToDictionary(MLIRContext *context) const;
+
+private:
+  template <typename NameT>
+  std::pair<iterator, bool> lookupAttribute(NameT name) {
+    return impl::lookupAttributeSorted(attrs.begin(), attrs.end(), name);
+  }
+  template <typename NameT>
+  std::pair<const_iterator, bool> lookupAttribute(NameT name) const {
+    return impl::lookupAttributeSorted(attrs.begin(), attrs.end(), name);
+  }
+
+  /// Give Operation access to private methods and members.
+  friend class ::mlir::Operation;
+
+  /// The internal storage of attributes inside an operation.
+  Storage attrs;
+};
+} // end namespace detail
+
+//===----------------------------------------------------------------------===//
 // OperandStorage
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 /// This class contains the information for a trailing operand storage.
 struct TrailingOperandStorage final
     : public llvm::TrailingObjects<TrailingOperandStorage, OpOperand> {
 #if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && (BYTE_ORDER == BIG_ENDIAN)

mlir/include/mlir/Interfaces/InferTypeOpInterface.h

 // Helper function to infer return tensor returns types given element and
 // shape inference function.
 //
 // TODO: Consider generating typedefs for trait member functions if this usage
 // becomes more common.
 LogicalResult inferReturnTensorTypes(
     function_ref<LogicalResult(
         MLIRContext *, Optional<Location> location, ValueShapeRange operands,
-        DictionaryAttr attributes, RegionRange regions,
+        AttributeRange attributes, RegionRange regions,
         SmallVectorImpl<ShapedTypeComponents> &retComponents)>
         componentTypeFn,
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes);
 
 /// Verifies that the inferred result types match the actual result types for
 /// the op. Precondition: op implements InferTypeOpInterface.
 LogicalResult verifyInferredResultTypes(Operation *op);
 } // namespace detail
 
 namespace OpTrait {

 ///   these always populates all element types and shapes or fails, but this\
 ///   trait is currently only used where the interfaces are, so keep it
 ///   restricted for now).
 template <typename ConcreteType>
 class InferTensorType : public TraitBase<ConcreteType, InferTensorType> {
 public:
   static LogicalResult
   inferReturnTypes(MLIRContext *context, Optional<Location> location,
-                   ValueRange operands, DictionaryAttr attributes,
+                   ValueRange operands, AttributeRange attributes,
                    RegionRange regions,
                    SmallVectorImpl<Type> &inferredReturnTypes) {
     static_assert(
         ConcreteType::template hasTrait<InferShapedTypeOpInterface::Trait>(),
         "requires InferShapedTypeOpInterface to ensure succesful invocation");
     static_assert(
         ConcreteType::template hasTrait<InferTypeOpInterface::Trait>(),
         "requires InferTypeOpInterface to ensure succesful invocation");

mlir/include/mlir/Interfaces/InferTypeOpInterface.td

StaticInterfaceMethod<
       called with valid arguments, e.g., operands are verified, or it may result
       in an undefined behavior.
       }],
       /*retTy=*/"::mlir::LogicalResult",
       /*methodName=*/"inferReturnTypes",
       /*args=*/(ins "::mlir::MLIRContext *":$context,
                     "::llvm::Optional<::mlir::Location>":$location,
                     "::mlir::ValueRange":$operands,
-                    "::mlir::DictionaryAttr":$attributes,
+                    "::mlir::AttributeRange":$attributes,
                     "::mlir::RegionRange":$regions,
                     "::llvm::SmallVectorImpl<::mlir::Type>&":$inferredReturnTypes)
     >,
     StaticInterfaceMethod<
       /*desc=*/"Returns whether two array of types are compatible result types"
                " for an op.",
       /*retTy=*/"bool",
       /*methodName=*/"isCompatibleReturnTypes",
StaticInterfaceMethod<
       may be returned by this function while returning success. E.g., partial
       population of components is not error condition.
       }],
       /*retTy=*/"::mlir::LogicalResult",
       /*methodName=*/"inferReturnTypeComponents",
       /*args=*/(ins "::mlir::MLIRContext*":$context,
                     "::mlir::Optional<::mlir::Location>":$location,
                     "::mlir::ValueShapeRange":$operands,
-                    "::mlir::DictionaryAttr":$attributes,
+                    "::mlir::AttributeRange":$attributes,
                     "::mlir::RegionRange":$regions,
                     "::mlir::SmallVectorImpl<::mlir::ShapedTypeComponents>&":
                       $inferredReturnShapes),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{ return ::mlir::failure(); }]
     >,
     InterfaceMethod<
       /*desc=*/[{Reify the shape computation for the operation.

mlir/include/mlir/Support/StorageUniquer.h

public:
   };
 
   /// This is a utility allocator used to allocate memory for instances of
   /// derived types.
   class StorageAllocator {
   public:
     /// Copy the specified array of elements into memory managed by our bump
     /// pointer allocator.  This assumes the elements are all PODs.
-    template <typename T> ArrayRef<T> copyInto(ArrayRef<T> elements) {
-      if (elements.empty())
+    template <typename RangeT,
+              typename T = std::remove_const_t<std::remove_reference_t<
+                  decltype(*std::begin(std::declval<RangeT>()))>>>
+    ArrayRef<T> copyInto(RangeT elements) {
+      return copyInto(std::begin(elements), std::end(elements));
+    }
+
+    template <typename IteratorT,
+              typename T = std::remove_const_t<std::remove_reference_t<
+                  decltype(*std::declval<IteratorT>())>>>
+    ArrayRef<T> copyInto(IteratorT first, IteratorT last) {
+      if (first == last)
         return llvm::None;
-      auto result = allocator.Allocate<T>(elements.size());
-      std::uninitialized_copy(elements.begin(), elements.end(), result);
-      return ArrayRef<T>(result, elements.size());
+      auto *result = allocator.Allocate<T>(std::distance(first, last));
+      std::uninitialized_copy(first, last, result);
+      return ArrayRef<T>(result, std::distance(first, last));
     }
 
     /// Copy the provided string into memory managed by our bump pointer
     /// allocator.
     StringRef copyInto(StringRef str) {
       auto result = copyInto(ArrayRef<char>(str.data(), str.size()));
       return StringRef(result.data(), str.size());
     }

mlir/include/mlir/Transforms/DialectConversion.h

 
 protected:
   /// See `RewritePattern::RewritePattern` for information on the other
   /// available constructors.
   using RewritePattern::RewritePattern;
   /// Construct a conversion pattern with the given converter, and forward the
   /// remaining arguments to RewritePattern.
   template <typename... Args>
-  ConversionPattern(TypeConverter &typeConverter, Args &&... args)
+  ConversionPattern(TypeConverter &typeConverter, Args &&...args)
       : RewritePattern(std::forward<Args>(args)...),
         typeConverter(&typeConverter) {}
 
 protected:
   /// An optional type converter for use by this pattern.
   TypeConverter *typeConverter = nullptr;
 
 private:
OpConversionPattern(TypeConverter &typeConverter, MLIRContext *context,
                       PatternBenefit benefit = 1)
       : ConversionPattern(typeConverter, SourceOp::getOperationName(), benefit,
                           context) {}
 
   /// Wrappers around the ConversionPattern methods that pass the derived op
   /// type.
   void rewrite(Operation *op, ArrayRef<Value> operands,
                ConversionPatternRewriter &rewriter) const final {
-    rewrite(cast<SourceOp>(op), OpAdaptor(operands, op->getAttrDictionary()),
-            rewriter);
+    rewrite(cast<SourceOp>(op),
+            OpAdaptor(getContext(), operands, op->getAttrs()), rewriter);
   }
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     return matchAndRewrite(cast<SourceOp>(op),
-                           OpAdaptor(operands, op->getAttrDictionary()),
+                           OpAdaptor(getContext(), operands, op->getAttrs()),
                            rewriter);
   }
 
   /// Rewrite and Match methods that operate on the SourceOp type and accept the
   /// raw operand values.
   /// NOTICE: These methods are deprecated and will be removed. All new code
   /// should use the adaptor methods below instead.
   virtual void rewrite(SourceOp op, ArrayRef<Value> operands,
                        ConversionPatternRewriter &rewriter) const {
     llvm_unreachable("must override matchAndRewrite or a rewrite method");
   }
   virtual LogicalResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const {
     if (failed(match(op)))
       return failure();
-    rewrite(op, OpAdaptor(operands, op->getAttrDictionary()), rewriter);
+    rewrite(op, OpAdaptor(getContext(), operands, op->getAttrs()), rewriter);
     return success();
   }
 
   /// Rewrite and Match methods that operate on the SourceOp type. These must be
   /// overridden by the derived pattern class.
   virtual void rewrite(SourceOp op, OpAdaptor adaptor,
                        ConversionPatternRewriter &rewriter) const {
     ValueRange operands = adaptor.getOperands();

mlir/lib/CAPI/IR/IR.cpp

if (!inferInterface) {
     emitError(state.location)
         << "type inference was requested for the operation " << state.name
         << ", but the operation does not support type inference. Result "
            "types must be specified explicitly.";
     return failure();
   }
 
   if (succeeded(inferInterface->inferReturnTypes(
-          context, state.location, state.operands,
-          state.attributes.getDictionary(context), state.regions, state.types)))
+          context, state.location, state.operands, state.attributes,
+          state.regions, state.types)))
     return success();
 
   // Diagnostic emitted by interface.
   return failure();
 }
 
 MlirOperation mlirOperationCreate(MlirOperationState *state) {
   assert(state);

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

CmpIOpLowering::matchAndRewrite(arith::CmpIOp op, OpAdaptor adaptor,
 
   auto vectorType = resultType.dyn_cast<VectorType>();
   if (!vectorType)
     return rewriter.notifyMatchFailure(op, "expected vector result type");
 
   return LLVM::detail::handleMultidimensionalVectors(
       op.getOperation(), adaptor.getOperands(), *getTypeConverter(),
       [&](Type llvm1DVectorTy, ValueRange operands) {
-        OpAdaptor adaptor(operands);
+        OpAdaptor adaptor(getContext(), operands);
         return rewriter.create<LLVM::ICmpOp>(
             op.getLoc(), llvm1DVectorTy,
             convertCmpPredicate<LLVM::ICmpPredicate>(op.getPredicate()),
             adaptor.getLhs(), adaptor.getRhs());
       },
       rewriter);
 
   return success();
CmpFOpLowering::matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
 
   auto vectorType = resultType.dyn_cast<VectorType>();
   if (!vectorType)
     return rewriter.notifyMatchFailure(op, "expected vector result type");
 
   return LLVM::detail::handleMultidimensionalVectors(
       op.getOperation(), adaptor.getOperands(), *getTypeConverter(),
       [&](Type llvm1DVectorTy, ValueRange operands) {
-        OpAdaptor adaptor(operands);
+        OpAdaptor adaptor(getContext(), operands);
         return rewriter.create<LLVM::FCmpOp>(
             op.getLoc(), llvm1DVectorTy,
             convertCmpPredicate<LLVM::FCmpPredicate>(op.getPredicate()),
             adaptor.getLhs(), adaptor.getRhs());
       },
       rewriter);
 }
 

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

auto coroSize =
         rewriter.create<LLVM::CoroSizeOp>(loc, rewriter.getI64Type());
 
     // Allocate memory for the coroutine frame.
     auto coroAlloc = rewriter.create<LLVM::CallOp>(
         loc, i8Ptr, SymbolRefAttr::get(rewriter.getContext(), kMalloc),
         ValueRange(coroSize.getResult()));
 
     // Begin a coroutine: @llvm.coro.begin.
-    auto coroId = CoroBeginOpAdaptor(adaptor.getOperands()).id();
+    auto coroId = CoroBeginOpAdaptor(getContext(), adaptor.getOperands()).id();
     rewriter.replaceOpWithNewOp<LLVM::CoroBeginOp>(
         op, i8Ptr, ValueRange({coroId, coroAlloc.getResult(0)}));
 
     return success();
   }
 };
 } // namespace
 

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

 struct DimOpLowering : public ConvertOpToLLVMPattern<memref::DimOp> {
   using ConvertOpToLLVMPattern<memref::DimOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(memref::DimOp dimOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Type operandType = dimOp.source().getType();
     if (operandType.isa<UnrankedMemRefType>()) {
-      rewriter.replaceOp(
-          dimOp, {extractSizeOfUnrankedMemRef(
-                     operandType, dimOp, adaptor.getOperands(), rewriter)});
+      rewriter.replaceOp(dimOp, {extractSizeOfUnrankedMemRef(
+                                    operandType, dimOp, adaptor, rewriter)});
 
       return success();
     }
     if (operandType.isa<MemRefType>()) {
-      rewriter.replaceOp(
-          dimOp, {extractSizeOfRankedMemRef(operandType, dimOp,
-                                            adaptor.getOperands(), rewriter)});
+      rewriter.replaceOp(dimOp, {extractSizeOfRankedMemRef(operandType, dimOp,
+                                                           adaptor, rewriter)});
       return success();
     }
     llvm_unreachable("expected MemRefType or UnrankedMemRefType");
   }
 
 private:
   Value extractSizeOfUnrankedMemRef(Type operandType, memref::DimOp dimOp,
                                     OpAdaptor adaptor,

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

static LogicalResult replaceWithLoadOrStore(Operation *op, ValueRange operands,
                                             LLVMTypeConverter &typeConverter,
                                             unsigned alignment, bool isVolatile,
                                             bool isNonTemporal) {
   if (auto loadOp = dyn_cast<spirv::LoadOp>(op)) {
     auto dstType = typeConverter.convertType(loadOp.getType());
     if (!dstType)
       return failure();
     rewriter.replaceOpWithNewOp<LLVM::LoadOp>(
-        loadOp, dstType, spirv::LoadOpAdaptor(operands).ptr(), alignment,
-        isVolatile, isNonTemporal);
+        loadOp, dstType, spirv::LoadOpAdaptor(op->getContext(), operands).ptr(),
+        alignment, isVolatile, isNonTemporal);
     return success();
   }
   auto storeOp = cast<spirv::StoreOp>(op);
-  spirv::StoreOpAdaptor adaptor(operands);
+  spirv::StoreOpAdaptor adaptor(op->getContext(), operands);
   rewriter.replaceOpWithNewOp<LLVM::StoreOp>(storeOp, adaptor.value(),
                                              adaptor.ptr(), alignment,
                                              isVolatile, isNonTemporal);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Type conversion

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 
 using namespace mlir;
 
 #define PASS_NAME "convert-std-to-llvm"
 
 /// 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,
+static void filterFuncAttributes(AttributeRange 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" ||
         (filterArgAttrs &&
          attr.first == function_like_impl::getArgDictAttrName()))
       continue;

mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp

static LogicalResult replaceTransferOpWithMubuf(
   return success();
 }
 
 static LogicalResult replaceTransferOpWithMubuf(
     ConversionPatternRewriter &rewriter, ValueRange operands,
     LLVMTypeConverter &typeConverter, Location loc, TransferWriteOp xferOp,
     Type &vecTy, Value &dwordConfig, Value &vindex, Value &offsetSizeInBytes,
     Value &glc, Value &slc) {
-  auto adaptor = TransferWriteOpAdaptor(operands, xferOp->getAttrDictionary());
+  auto adaptor = TransferWriteOpAdaptor(rewriter.getContext(), operands,
+                                        xferOp->getAttrs());
   rewriter.replaceOpWithNewOp<ROCDL::MubufStoreOp>(xferOp, adaptor.vector(),
                                                    dwordConfig, vindex,
                                                    offsetSizeInBytes, glc, slc);
   return success();
 }
 
 namespace {
 /// Conversion pattern that converts a 1-D vector transfer read/write.

mlir/lib/Dialect/Async/IR/Async.cpp

LogicalResult CreateGroupOp::canonicalize(CreateGroupOp op,
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 /// AwaitOp
 //===----------------------------------------------------------------------===//
 
 void AwaitOp::build(OpBuilder &builder, OperationState &result, Value operand,
-                    ArrayRef<NamedAttribute> attrs) {
+                    AttributeRange attrs) {
   result.addOperands({operand});
   result.attributes.append(attrs.begin(), attrs.end());
 
   // Add unwrapped async.value type to the returned values types.
   if (auto valueType = operand.getType().dyn_cast<ValueType>())
     result.addTypes(valueType.getValueType());
 }
 

mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp

outlineExecuteOp(SymbolTable &symbolTable, ExecuteOp execute) {
 
   // Collect types for the outlined function inputs and outputs.
   auto typesRange = llvm::map_range(
       functionInputs, [](Value value) { return value.getType(); });
   SmallVector<Type, 4> inputTypes(typesRange.begin(), typesRange.end());
   auto outputTypes = execute.getResultTypes();
 
   auto funcType = FunctionType::get(ctx, inputTypes, outputTypes);
-  auto funcAttrs = ArrayRef<NamedAttribute>();
+  auto funcAttrs = AttributeRange();
 
   // TODO: Derive outlined function name from the parent FuncOp (support
   // multiple nested async.execute operations).
   FuncOp func = FuncOp::create(loc, kAsyncFnPrefix, funcType, funcAttrs);
   symbolTable.insert(func);
 
   SymbolTable::setSymbolVisibility(func, SymbolTable::Visibility::Private);
   auto builder = ImplicitLocOpBuilder::atBlockBegin(loc, func.addEntryBlock());

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

BlockArgument GPUFuncOp::addPrivateAttribution(Type type) {
   // Buffers on the private memory always come after buffers on the workgroup
   // memory.
   return getBody().addArgument(type);
 }
 
 void GPUFuncOp::build(OpBuilder &builder, OperationState &result,
                       StringRef name, FunctionType type,
                       TypeRange workgroupAttributions,
-                      TypeRange privateAttributions,
-                      ArrayRef<NamedAttribute> attrs) {
+                      TypeRange privateAttributions, AttributeRange attrs) {
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
   result.addAttribute(getNumWorkgroupAttributionsAttrName(),
                       builder.getI64IntegerAttr(workgroupAttributions.size()));
   result.addAttributes(attrs);
   Region *body = result.addRegion();
   Block *entryBlock = new Block;

mlir/lib/Dialect/GPU/Transforms/AsyncRegionRewriter.cpp

if (currentToken)
       return success();
 
     // Clone the op to return a token in addition to the other results.
     SmallVector<Type, 1> resultTypes;
     resultTypes.reserve(1 + op->getNumResults());
     copy(op->getResultTypes(), std::back_inserter(resultTypes));
     resultTypes.push_back(tokenType);
     auto *newOp = Operation::create(op->getLoc(), op->getName(), resultTypes,
-                                    op->getOperands(), op->getAttrDictionary(),
+                                    op->getOperands(), op->getAttrs(),
                                     op->getSuccessors(), op->getNumRegions());
 
     // Clone regions into new op.
     BlockAndValueMapping mapping;
     for (auto pair : llvm::zip_first(op->getRegions(), newOp->getRegions()))
       std::get<0>(pair).cloneInto(&std::get<1>(pair), mapping);
 
     // Replace the op with the async clone.

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

 static constexpr const char kVolatileAttrName[] = "volatile_";
 static constexpr const char kNonTemporalAttrName[] = "nontemporal";
 
 #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) {
+static auto processFMFAttr(AttributeRange 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;
         }
         return true;
       }));
   return filteredAttrs;
 }
 
 static ParseResult parseLLVMOpAttrs(OpAsmParser &parser,
                                     NamedAttrList &result) {
   return parser.parseOptionalAttrDict(result);
 }
 
 static void printLLVMOpAttrs(OpAsmPrinter &printer, Operation *op,
-                             DictionaryAttr attrs) {
-  printer.printOptionalAttrDict(processFMFAttr(attrs.getValue()));
+                             AttributeRange attrs) {
+  printer.printOptionalAttrDict(processFMFAttr(attrs));
 }
 
 /// Verifies `symbol`'s use in `op` to ensure the symbol is a valid and
 /// fully defined llvm.func.
 static LogicalResult verifySymbolAttrUse(FlatSymbolRefAttr symbol,
                                          Operation *op,
                                          SymbolTableCollection &symbolTable) {
   StringRef name = symbol.getValue();

 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::ExtractElementOp.
 //===----------------------------------------------------------------------===//
 // Expects vector to be of wrapped LLVM vector type and position to be of
 // wrapped LLVM i32 type.
 void LLVM::ExtractElementOp::build(OpBuilder &b, OperationState &result,
                                    Value vector, Value position,
-                                   ArrayRef<NamedAttribute> attrs) {
+                                   AttributeRange attrs) {
   auto vectorType = vector.getType();
   auto llvmType = LLVM::getVectorElementType(vectorType);
   build(b, result, llvmType, vector, position);
   result.addAttributes(attrs);
 }
 
 static void printExtractElementOp(OpAsmPrinter &p, ExtractElementOp &op) {
   p << ' ' << op.getVector() << "[" << op.getPosition() << " : "

 
 /// Returns the name used for the unnamed_addr attribute. This *must* correspond
 /// to the name of the attribute in ODS.
 static StringRef getUnnamedAddrAttrName() { return "unnamed_addr"; }
 
 void GlobalOp::build(OpBuilder &builder, OperationState &result, Type type,
                      bool isConstant, Linkage linkage, StringRef name,
                      Attribute value, uint64_t alignment, unsigned addrSpace,
-                     bool dsoLocal, ArrayRef<NamedAttribute> attrs) {
+                     bool dsoLocal, AttributeRange attrs) {
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute("global_type", TypeAttr::get(type));
   if (isConstant)
     result.addAttribute("constant", builder.getUnitAttr());
   if (value)
     result.addAttribute("value", value);
   if (dsoLocal)

 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::ShuffleVectorOp.
 //===----------------------------------------------------------------------===//
 // Expects vector to be of wrapped LLVM vector type and position to be of
 // wrapped LLVM i32 type.
 void LLVM::ShuffleVectorOp::build(OpBuilder &b, OperationState &result,
                                   Value v1, Value v2, ArrayAttr mask,
-                                  ArrayRef<NamedAttribute> attrs) {
+                                  AttributeRange attrs) {
   auto containerType = v1.getType();
   auto vType = LLVM::getFixedVectorType(
       LLVM::getVectorElementType(containerType), mask.size());
   build(b, result, vType, v1, v2, mask);
   result.addAttributes(attrs);
 }
 
 static void printShuffleVectorOp(OpAsmPrinter &p, ShuffleVectorOp &op) {
Block *LLVMFuncOp::addEntryBlock() {
   LLVMFunctionType type = getType();
   for (unsigned i = 0, e = type.getNumParams(); i < e; ++i)
     entry->addArgument(type.getParamType(i));
   return entry;
 }
 
 void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
                        StringRef name, Type type, LLVM::Linkage linkage,
-                       bool dsoLocal, ArrayRef<NamedAttribute> attrs,
+                       bool dsoLocal, AttributeRange attrs,
                        ArrayRef<DictionaryAttr> argAttrs) {
   result.addRegion();
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute("type", TypeAttr::get(type));
   result.addAttribute(::getLinkageAttrName(),
                       LinkageAttr::get(builder.getContext(), linkage));
   result.attributes.append(attrs.begin(), attrs.end());

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

 //===----------------------------------------------------------------------===//
 void CopyOp::regionBuilder(ImplicitLocOpBuilder &b, Block &block) {
   assert(block.getNumArguments() == 2 && "CopyOp regionBuilder expects 2 args");
   b.create<linalg::YieldOp>(block.getArgument(0));
 }
 
 void CopyOp::build(OpBuilder &builder, OperationState &result, Value input,
                    Value output, AffineMap inputPermutation,
-                   AffineMap outputPermutation,
-                   ArrayRef<NamedAttribute> namedAttrs) {
+                   AffineMap outputPermutation, AttributeRange namedAttrs) {
   result.addOperands({input, output});
   result.addAttributes(namedAttrs);
   if (inputPermutation)
     result.addAttribute("inputPermutation",
                         AffineMapAttr::get(inputPermutation));
   if (outputPermutation)
     result.addAttribute("outputPermutation",
                         AffineMapAttr::get(outputPermutation));

 //===----------------------------------------------------------------------===//
 // GenericOps
 //===----------------------------------------------------------------------===//
 void GenericOp::build(
     OpBuilder &builder, OperationState &result, TypeRange resultTensorTypes,
     ValueRange inputs, ValueRange outputs, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes, StringRef doc, StringRef libraryCall,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild,
-    ArrayRef<NamedAttribute> attributes) {
+    AttributeRange attributes) {
   build(builder, result, resultTensorTypes, inputs, outputs,
         builder.getAffineMapArrayAttr(indexingMaps),
         builder.getStrArrayAttr(iteratorTypes),
         doc.empty() ? StringAttr() : builder.getStringAttr(doc),
         libraryCall.empty() ? StringAttr()
                             : builder.getStringAttr(libraryCall));
   result.addAttributes(attributes);
   if (!bodyBuild)
void GenericOp::build(
   bodyBuild(builder, result.location, bodyBlock->getArguments());
 }
 
 void GenericOp::build(
     OpBuilder &builder, OperationState &result, ValueRange inputs,
     ValueRange outputs, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes, StringRef doc, StringRef libraryCall,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild,
-    ArrayRef<NamedAttribute> attributes) {
+    AttributeRange attributes) {
   build(builder, result, TypeRange{}, inputs, outputs, indexingMaps,
         iteratorTypes, doc, libraryCall, bodyBuild, attributes);
 }
 
 void GenericOp::build(
     OpBuilder &builder, OperationState &result, ValueRange inputs,
     ValueRange outputs, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild,
-    ArrayRef<NamedAttribute> attributes) {
+    AttributeRange attributes) {
   build(builder, result, inputs, outputs, indexingMaps, iteratorTypes,
         /*doc=*/"",
         /*libraryCall=*/"", bodyBuild, attributes);
 }
 
 void GenericOp::build(
     OpBuilder &builder, OperationState &result, TypeRange resultTensorTypes,
     ValueRange inputs, ValueRange outputs, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild,
-    ArrayRef<NamedAttribute> attributes) {
+    AttributeRange attributes) {
   build(builder, result, resultTensorTypes, inputs, outputs, indexingMaps,
         iteratorTypes,
         /*doc=*/"",
         /*libraryCall=*/"", bodyBuild, attributes);
 }
 
 static void print(OpAsmPrinter &p, GenericOp op) {
   p << " ";
void GenericOp::getCanonicalizationPatterns(RewritePatternSet &results,
   results.add<DeduplicateGenericOpInputs, EraseIdentityGenericOp>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // InitTensorOp
 //===----------------------------------------------------------------------===//
 void InitTensorOp::build(OpBuilder &b, OperationState &result,
                          ArrayRef<OpFoldResult> sizes, Type elementType,
-                         ArrayRef<NamedAttribute> attrs) {
+                         AttributeRange attrs) {
   unsigned rank = sizes.size();
   SmallVector<Value, 4> dynamicSizes;
   SmallVector<int64_t, 4> staticSizes;
   for (unsigned i = 0; i < rank; ++i) {
     dispatchIndexOpFoldResult(sizes[i], dynamicSizes, staticSizes,
                               ShapedType::kDynamicSize);
   }
   auto resultType = RankedTensorType ::get(staticSizes, elementType);
RankedTensorType PadTensorOp::inferResultType(RankedTensorType sourceType,
   }
 
   return RankedTensorType::get(inferredShape, sourceType.getElementType());
 }
 
 void PadTensorOp::build(OpBuilder &b, OperationState &result, Value source,
                         ArrayRef<int64_t> staticLow,
                         ArrayRef<int64_t> staticHigh, ValueRange low,
-                        ValueRange high, bool nofold,
-                        ArrayRef<NamedAttribute> attrs) {
+                        ValueRange high, bool nofold, AttributeRange attrs) {
   auto sourceType = source.getType().cast<RankedTensorType>();
   auto resultType = inferResultType(sourceType, staticLow, staticHigh);
   build(b, result, resultType, source, low, high, b.getI64ArrayAttr(staticLow),
         b.getI64ArrayAttr(staticHigh), nofold ? b.getUnitAttr() : UnitAttr());
   result.addAttributes(attrs);
 }
 
 void PadTensorOp::build(OpBuilder &b, OperationState &result, Value source,
                         ValueRange low, ValueRange high, bool nofold,
-                        ArrayRef<NamedAttribute> attrs) {
+                        AttributeRange attrs) {
   auto sourceType = source.getType().cast<RankedTensorType>();
   unsigned rank = sourceType.getRank();
   SmallVector<int64_t, 4> staticVector(rank, ShapedType::kDynamicSize);
   build(b, result, source, staticVector, staticVector, low, high, nofold,
         attrs);
 }
 
 void PadTensorOp::build(OpBuilder &b, OperationState &result, Type resultType,
                         Value source, ArrayRef<OpFoldResult> low,
                         ArrayRef<OpFoldResult> high, bool nofold,
-                        ArrayRef<NamedAttribute> attrs) {
+                        AttributeRange attrs) {
   assert(resultType.isa<RankedTensorType>());
   auto sourceType = source.getType().cast<RankedTensorType>();
   unsigned rank = sourceType.getRank();
   SmallVector<Value, 4> dynamicLow, dynamicHigh;
   SmallVector<int64_t, 4> staticLow, staticHigh;
   for (unsigned i = 0; i < rank; ++i) {
     // staticLow and staticHigh have full information of the padding config.
     // This will grow staticLow and staticHigh with 1 value. If the config is
for (AffineMap m : reassociation) {
     currentDim += dim;
   }
 
   return RankedTensorType::get(newShape, type.getElementType());
 }
 
 void mlir::linalg::TensorCollapseShapeOp::build(
     OpBuilder &b, OperationState &result, Value src,
-    ArrayRef<ReassociationIndices> reassociation,
-    ArrayRef<NamedAttribute> attrs) {
+    ArrayRef<ReassociationIndices> reassociation, AttributeRange attrs) {
   auto resultType = computeTensorReshapeCollapsedType(
       src.getType().cast<RankedTensorType>(),
       getSymbolLessAffineMaps(
           convertReassociationIndicesToExprs(b.getContext(), reassociation)));
   build(b, result, resultType, src, attrs);
   result.addAttribute(getReassociationAttrName(),
                       getReassociationIndicesAttribute(b, reassociation));
 }
 
 void mlir::linalg::TensorExpandShapeOp::build(
     OpBuilder &b, OperationState &result, Value src,
-    ArrayRef<ReassociationIndices> reassociation,
-    ArrayRef<NamedAttribute> attrs) {
+    ArrayRef<ReassociationIndices> reassociation, AttributeRange attrs) {
   auto resultType = computeTensorReshapeCollapsedType(
       src.getType().cast<RankedTensorType>(),
       getSymbolLessAffineMaps(
           convertReassociationIndicesToExprs(b.getContext(), reassociation)));
   build(b, result, resultType, src, attrs);
   result.addAttribute(getReassociationAttrName(),
                       getReassociationIndicesAttribute(b, reassociation));
 }

mlir/lib/Dialect/Linalg/Transforms/Bufferize.cpp

matchAndRewrite(LinalgOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     // GenericOpAdaptor below expects an `operand_segment_sizes` attribute.
     if (!op->hasAttr("operand_segment_sizes"))
       return failure();
 
     // We abuse the GenericOpAdaptor here.
     // TODO: Manually create an Adaptor that captures inputs and outputs for all
     // linalg::LinalgOp interface ops.
-    linalg::GenericOpAdaptor adaptor(operands, op->getAttrDictionary());
+    linalg::GenericOpAdaptor adaptor(getContext(), operands, op->getAttrs());
 
     Location loc = op.getLoc();
     SmallVector<Value, 2> newOutputBuffers;
 
     if (failed(allocateBuffersForResults(loc, op, adaptor.outputs(),
                                          newOutputBuffers, rewriter))) {
       return op.emitOpError()
              << "Failed to allocate buffers for tensor results.";

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

 
 /// Build a ReinterpretCastOp with all dynamic entries: `staticOffsets`,
 /// `staticSizes` and `staticStrides` are automatically filled with
 /// source-memref-rank sentinel values that encode dynamic entries.
 void ReinterpretCastOp::build(OpBuilder &b, OperationState &result,
                               MemRefType resultType, Value source,
                               OpFoldResult offset, ArrayRef<OpFoldResult> sizes,
                               ArrayRef<OpFoldResult> strides,
-                              ArrayRef<NamedAttribute> attrs) {
+                              AttributeRange attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offset, dynamicOffsets, staticOffsets,
                              ShapedType::kDynamicStrideOrOffset);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
                              ShapedType::kDynamicSize);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
                              ShapedType::kDynamicStrideOrOffset);
   build(b, result, resultType, source, dynamicOffsets, dynamicSizes,
         dynamicStrides, b.getI64ArrayAttr(staticOffsets),
         b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 void ReinterpretCastOp::build(OpBuilder &b, OperationState &result,
                               MemRefType resultType, Value source,
                               int64_t offset, ArrayRef<int64_t> sizes,
-                              ArrayRef<int64_t> strides,
-                              ArrayRef<NamedAttribute> attrs) {
+                              ArrayRef<int64_t> strides, AttributeRange attrs) {
   SmallVector<OpFoldResult> sizeValues =
       llvm::to_vector<4>(llvm::map_range(sizes, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   build(b, result, resultType, source, b.getI64IntegerAttr(offset), sizeValues,
         strideValues, attrs);
 }
 
 void ReinterpretCastOp::build(OpBuilder &b, OperationState &result,
                               MemRefType resultType, Value source, Value offset,
                               ValueRange sizes, ValueRange strides,
-                              ArrayRef<NamedAttribute> attrs) {
+                              AttributeRange attrs) {
   SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, resultType, source, offset, sizeValues, strideValues, attrs);
 }
 
 // TODO: ponder whether we want to allow missing trailing sizes/strides that are
auto layout =
       makeStridedLinearLayoutMap(intStrides, intOffset, type.getContext());
   return canonicalizeStridedLayout(
       MemRefType::Builder(type).setShape(newSizes).setLayout(
           AffineMapAttr::get(layout)));
 }
 
 void ExpandShapeOp::build(OpBuilder &b, OperationState &result, Value src,
                           ArrayRef<ReassociationIndices> reassociation,
-                          ArrayRef<NamedAttribute> attrs) {
+                          AttributeRange attrs) {
   auto memRefType = src.getType().cast<MemRefType>();
   auto resultType = computeReshapeCollapsedType(
       memRefType, getSymbolLessAffineMaps(convertReassociationIndicesToExprs(
                       b.getContext(), reassociation)));
   build(b, result, resultType, src, attrs);
   result.addAttribute(getReassociationAttrName(),
                       getReassociationIndicesAttribute(b, reassociation));
 }
 
 void CollapseShapeOp::build(OpBuilder &b, OperationState &result, Value src,
                             ArrayRef<ReassociationIndices> reassociation,
-                            ArrayRef<NamedAttribute> attrs) {
+                            AttributeRange attrs) {
   auto memRefType = src.getType().cast<MemRefType>();
   auto resultType = computeReshapeCollapsedType(
       memRefType, getSymbolLessAffineMaps(convertReassociationIndicesToExprs(
                       b.getContext(), reassociation)));
   build(b, result, resultType, src, attrs);
   result.addAttribute(getReassociationAttrName(),
                       getReassociationIndicesAttribute(b, reassociation));
 }
return SubViewOp::inferRankReducedResultType(
       staticStrides);
 }
 // Build a SubViewOp with mixed static and dynamic entries and custom result
 // type. If the type passed is nullptr, it is inferred.
 void SubViewOp::build(OpBuilder &b, OperationState &result,
                       MemRefType resultType, Value source,
                       ArrayRef<OpFoldResult> offsets,
                       ArrayRef<OpFoldResult> sizes,
-                      ArrayRef<OpFoldResult> strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      ArrayRef<OpFoldResult> strides, AttributeRange attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets,
                              ShapedType::kDynamicStrideOrOffset);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
                              ShapedType::kDynamicSize);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
                              ShapedType::kDynamicStrideOrOffset);
void SubViewOp::build(OpBuilder &b, OperationState &result,
   result.addAttributes(attrs);
 }
 
 // Build a SubViewOp with mixed static and dynamic entries and inferred result
 // type.
 void SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
                       ArrayRef<OpFoldResult> offsets,
                       ArrayRef<OpFoldResult> sizes,
-                      ArrayRef<OpFoldResult> strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      ArrayRef<OpFoldResult> strides, AttributeRange attrs) {
   build(b, result, MemRefType(), source, offsets, sizes, strides, attrs);
 }
 
 // Build a SubViewOp with static entries and inferred result type.
 void SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
                       ArrayRef<int64_t> offsets, ArrayRef<int64_t> sizes,
-                      ArrayRef<int64_t> strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      ArrayRef<int64_t> strides, AttributeRange attrs) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   SmallVector<OpFoldResult> sizeValues =
       llvm::to_vector<4>(llvm::map_range(sizes, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   build(b, result, source, offsetValues, sizeValues, strideValues, attrs);
 }
 
 // Build a SubViewOp with dynamic entries and custom result type. If the
 // type passed is nullptr, it is inferred.
 void SubViewOp::build(OpBuilder &b, OperationState &result,
                       MemRefType resultType, Value source,
                       ArrayRef<int64_t> offsets, ArrayRef<int64_t> sizes,
-                      ArrayRef<int64_t> strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      ArrayRef<int64_t> strides, AttributeRange attrs) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   SmallVector<OpFoldResult> sizeValues =
       llvm::to_vector<4>(llvm::map_range(sizes, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   build(b, result, resultType, source, offsetValues, sizeValues, strideValues,
         attrs);
 }
 
 // Build a SubViewOp with dynamic entries and custom result type. If the type
 // passed is nullptr, it is inferred.
 void SubViewOp::build(OpBuilder &b, OperationState &result,
                       MemRefType resultType, Value source, ValueRange offsets,
                       ValueRange sizes, ValueRange strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      AttributeRange attrs) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, resultType, source, offsetValues, sizeValues, strideValues);
 }
 
 // Build a SubViewOp with dynamic entries and inferred result type.
 void SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
                       ValueRange offsets, ValueRange sizes, ValueRange strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      AttributeRange attrs) {
   build(b, result, MemRefType(), source, offsets, sizes, strides, attrs);
 }
 
 /// For ViewLikeOpInterface.
 Value SubViewOp::getViewSource() { return source(); }
 
 enum SubViewVerificationResult {
   Success,
auto map =
       makeStridedLinearLayoutMap(strides, offset, memRefType.getContext());
   map = permutationMap ? map.compose(permutationMap) : map;
   return MemRefType::Builder(memRefType)
       .setShape(sizes)
       .setLayout(AffineMapAttr::get(map));
 }
 
 void TransposeOp::build(OpBuilder &b, OperationState &result, Value in,
-                        AffineMapAttr permutation,
-                        ArrayRef<NamedAttribute> attrs) {
+                        AffineMapAttr permutation, AttributeRange attrs) {
   auto permutationMap = permutation.getValue();
   assert(permutationMap);
 
   auto memRefType = in.getType().cast<MemRefType>();
   // Compute result type.
   MemRefType resultType = inferTransposeResultType(memRefType, permutationMap);
 
   build(b, result, resultType, in, attrs);

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

#include "mlir/Dialect/OpenMP/OpenMPOps.cpp.inc"
   MemRefType::attachInterface<PointerLikeModel<MemRefType>>(*getContext());
 }
 
 //===----------------------------------------------------------------------===//
 // ParallelOp
 //===----------------------------------------------------------------------===//
 
 void ParallelOp::build(OpBuilder &builder, OperationState &state,
-                       ArrayRef<NamedAttribute> attributes) {
+                       AttributeRange attributes) {
   ParallelOp::build(
       builder, state, /*if_expr_var=*/nullptr, /*num_threads_var=*/nullptr,
       /*default_val=*/nullptr, /*private_vars=*/ValueRange(),
       /*firstprivate_vars=*/ValueRange(), /*shared_vars=*/ValueRange(),
       /*copyin_vars=*/ValueRange(), /*allocate_vars=*/ValueRange(),
       /*allocators_vars=*/ValueRange(), /*proc_bind_val=*/nullptr);
   state.addAttributes(attributes);
 }

 }
 
 //===----------------------------------------------------------------------===//
 // WsLoopOp
 //===----------------------------------------------------------------------===//
 
 void WsLoopOp::build(OpBuilder &builder, OperationState &state,
                      ValueRange lowerBound, ValueRange upperBound,
-                     ValueRange step, ArrayRef<NamedAttribute> attributes) {
+                     ValueRange step, AttributeRange attributes) {
   build(builder, state, TypeRange(), lowerBound, upperBound, step,
         /*private_vars=*/ValueRange(),
         /*firstprivate_vars=*/ValueRange(), /*lastprivate_vars=*/ValueRange(),
         /*linear_vars=*/ValueRange(), /*linear_step_vars=*/ValueRange(),
         /*reduction_vars=*/ValueRange(), /*schedule_val=*/nullptr,
         /*schedule_chunk_var=*/nullptr, /*collapse_val=*/nullptr,
         /*nowait=*/nullptr, /*ordered_val=*/nullptr, /*order_val=*/nullptr,
         /*inclusive=*/nullptr, /*buildBody=*/false);
   state.addAttributes(attributes);
 }
 
 void WsLoopOp::build(OpBuilder &, OperationState &state, TypeRange resultTypes,
-                     ValueRange operands, ArrayRef<NamedAttribute> attributes) {
+                     ValueRange operands, AttributeRange attributes) {
   state.addOperands(operands);
   state.addAttributes(attributes);
   (void)state.addRegion();
   assert(resultTypes.empty() && "mismatched number of return types");
   state.addTypes(resultTypes);
 }
 
 void WsLoopOp::build(OpBuilder &builder, OperationState &result,

mlir/lib/Dialect/SPIRV/IR/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->getAttrDictionary() == rhs->getAttrDictionary();
+    return lhs->getAttrs() == rhs->getAttrs();
   }
 
   // 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/IR/SPIRVOps.cpp

LogicalResult spirv::FuncOp::verifyBody() {
   // TODO: verify other bits like linkage type.
 
   return failure(walkResult.wasInterrupted());
 }
 
 void spirv::FuncOp::build(OpBuilder &builder, OperationState &state,
                           StringRef name, FunctionType type,
                           spirv::FunctionControl control,
-                          ArrayRef<NamedAttribute> attrs) {
+                          AttributeRange attrs) {
   state.addAttribute(SymbolTable::getSymbolAttrName(),
                      builder.getStringAttr(name));
   state.addAttribute(getTypeAttrName(), TypeAttr::get(type));
   state.addAttribute(spirv::attributeName<spirv::FunctionControl>(),
                      builder.getI32IntegerAttr(static_cast<uint32_t>(control)));
   state.attributes.append(attrs.begin(), attrs.end());
   state.addRegion();
 }

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

 }
 
 //===----------------------------------------------------------------------===//
 // AddOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult mlir::shape::AddOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<SizeType>() ||
       operands[1].getType().isa<SizeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }

 
 void ConstShapeOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                MLIRContext *context) {
   patterns.add<TensorCastConstShape>(context);
 }
 
 LogicalResult mlir::shape::ConstShapeOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   Builder b(context);
   auto shape = attributes.getAs<DenseIntElementsAttr>("shape");
   if (!shape)
     return emitOptionalError(location, "missing shape attribute");
   inferredReturnTypes.assign({RankedTensorType::get(
       {static_cast<int64_t>(shape.size())}, b.getIndexType())});
   return success();
OpFoldResult DivOp::fold(ArrayRef<Attribute> operands) {
   }
 
   Type indexTy = IndexType::get(getContext());
   return IntegerAttr::get(indexTy, quotient);
 }
 
 LogicalResult mlir::shape::DivOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<SizeType>() ||
       operands[1].getType().isa<SizeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
if (shape.getType().isa<ShapeType>()) {
     Value dim =
         builder.create<arith::ConstantOp>(loc, builder.getIndexType(), dimAttr);
     build(builder, result, builder.getIndexType(), shape, dim);
   }
 }
 
 LogicalResult mlir::shape::GetExtentOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::GetExtentOp::isCompatibleReturnTypes(TypeRange l,
                                                        TypeRange r) {
   // SizeType is compatible with IndexType.

 }
 
 //===----------------------------------------------------------------------===//
 // MeetOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult mlir::shape::MeetOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   inferredReturnTypes.assign({operands[0].getType()});
   return success();
 }
 
 bool mlir::shape::MeetOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   if (l.size() != 1 || r.size() != 1)
     return false;

 
 void shape::RankOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                 MLIRContext *context) {
   patterns.add<RankShapeOfCanonicalizationPattern>(context);
 }
 
 LogicalResult mlir::shape::RankOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<ShapeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
OpFoldResult NumElementsOp::fold(ArrayRef<Attribute> operands) {
   for (auto value : shape.cast<DenseIntElementsAttr>())
     product *= value;
   Builder builder(getContext());
   return builder.getIndexAttr(product.getLimitedValue());
 }
 
 LogicalResult mlir::shape::NumElementsOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<ShapeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
OpFoldResult MaxOp::fold(llvm::ArrayRef<mlir::Attribute> operands) {
   // If operands are equal, just propagate one.
   if (getLhs() == getRhs())
     return getLhs();
   return nullptr;
 }
 
 LogicalResult mlir::shape::MaxOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType() == operands[1].getType())
     inferredReturnTypes.assign({operands[0].getType()});
   else
     inferredReturnTypes.assign({SizeType::get(context)});
   return success();
 }
 
OpFoldResult MinOp::fold(llvm::ArrayRef<mlir::Attribute> operands) {
   // If operands are equal, just propagate one.
   if (getLhs() == getRhs())
     return getLhs();
   return nullptr;
 }
 
 LogicalResult mlir::shape::MinOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType() == operands[1].getType())
     inferredReturnTypes.assign({operands[0].getType()});
   else
     inferredReturnTypes.assign({SizeType::get(context)});
   return success();
 }
 
if (!rhs)
     return nullptr;
   APInt folded = lhs.getValue() * rhs.getValue();
   Type indexTy = IndexType::get(getContext());
   return IntegerAttr::get(indexTy, folded);
 }
 
 LogicalResult mlir::shape::MulOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<SizeType>() ||
       operands[1].getType().isa<SizeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }

 void ShapeOfOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                             MLIRContext *context) {
   patterns.add<ShapeOfCastExtentTensor, ShapeOfWithTensor,
                ExtractFromShapeOfExtentTensor>(context);
 }
 
 LogicalResult mlir::shape::ShapeOfOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<ValueShapeType>())
     inferredReturnTypes.assign({ShapeType::get(context)});
   else {
     auto shapedTy = operands[0].getType().cast<ShapedType>();
     int64_t rank =
         shapedTy.hasRank() ? shapedTy.getRank() : ShapedType::kDynamicSize;
     Type indexTy = IndexType::get(context);

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

 
 /// Build an ExtractSliceOp with mixed static and dynamic entries and custom
 /// result type. If the type passed is nullptr, it is inferred.
 void ExtractSliceOp::build(OpBuilder &b, OperationState &result,
                            RankedTensorType resultType, Value source,
                            ArrayRef<OpFoldResult> offsets,
                            ArrayRef<OpFoldResult> sizes,
                            ArrayRef<OpFoldResult> strides,
-                           ArrayRef<NamedAttribute> attrs) {
+                           AttributeRange attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets,
                              ShapedType::kDynamicStrideOrOffset);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
                              ShapedType::kDynamicSize);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
                              ShapedType::kDynamicStrideOrOffset);

 }
 
 /// Build an ExtractSliceOp with mixed static and dynamic entries and inferred
 /// result type.
 void ExtractSliceOp::build(OpBuilder &b, OperationState &result, Value source,
                            ArrayRef<OpFoldResult> offsets,
                            ArrayRef<OpFoldResult> sizes,
                            ArrayRef<OpFoldResult> strides,
-                           ArrayRef<NamedAttribute> attrs) {
+                           AttributeRange attrs) {
   build(b, result, RankedTensorType(), source, offsets, sizes, strides, attrs);
 }
 
 /// Build an ExtractSliceOp with dynamic entries and custom result type. If the
 /// type passed is nullptr, it is inferred.
 void ExtractSliceOp::build(OpBuilder &b, OperationState &result,
                            RankedTensorType resultType, Value source,
                            ValueRange offsets, ValueRange sizes,
-                           ValueRange strides, ArrayRef<NamedAttribute> attrs) {
+                           ValueRange strides, AttributeRange attrs) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, resultType, source, offsetValues, sizeValues, strideValues);
 }
 
 /// Build an ExtractSliceOp with dynamic entries and inferred result type.
 void ExtractSliceOp::build(OpBuilder &b, OperationState &result, Value source,
                            ValueRange offsets, ValueRange sizes,
-                           ValueRange strides, ArrayRef<NamedAttribute> attrs) {
+                           ValueRange strides, AttributeRange attrs) {
   build(b, result, RankedTensorType(), source, offsets, sizes, strides, attrs);
 }
 
 enum SliceVerificationResult {
   Success,
   RankTooLarge,
   SizeMismatch,
   ElemTypeMismatch,

 // InsertSliceOp
 //===----------------------------------------------------------------------===//
 
 // Build a InsertSliceOp with mixed static and dynamic entries.
 void InsertSliceOp::build(OpBuilder &b, OperationState &result, Value source,
                           Value dest, ArrayRef<OpFoldResult> offsets,
                           ArrayRef<OpFoldResult> sizes,
                           ArrayRef<OpFoldResult> strides,
-                          ArrayRef<NamedAttribute> attrs) {
+                          AttributeRange attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets,
                              ShapedType::kDynamicStrideOrOffset);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
                              ShapedType::kDynamicSize);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
                              ShapedType::kDynamicStrideOrOffset);
   build(b, result, dest.getType(), source, dest, dynamicOffsets, dynamicSizes,
         dynamicStrides, b.getI64ArrayAttr(staticOffsets),
         b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 // Build a InsertSliceOp with dynamic entries.
 void InsertSliceOp::build(OpBuilder &b, OperationState &result, Value source,
                           Value dest, ValueRange offsets, ValueRange sizes,
-                          ValueRange strides, ArrayRef<NamedAttribute> attrs) {
+                          ValueRange strides, AttributeRange attrs) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, source, dest, offsetValues, sizeValues, strideValues);
 }

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

 static void getF64Values(ArrayAttr arrayAttr, SmallVector<double> &values) {
   for (auto it : arrayAttr) {
     values.push_back(it.cast<FloatAttr>().getValueAsDouble());
   }
 }
 
 LogicalResult tosa::ArgMaxOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   IntegerAttr axis = attributes.get("axis").cast<IntegerAttr>();
   int32_t axisVal = axis.getValue().getSExtValue();
 
   if (!inputShape.hasRank()) {
     inferredReturnShapes.push_back(ShapedTypeComponents());
     return success();
   }
 
   SmallVector<int64_t> outShape;
   outShape.reserve(inputShape.getRank() - 1);
   for (int i = 0, s = inputShape.getRank(); i < s; i++) {
     if (i == axisVal)
       continue;
     outShape.push_back(inputShape.getDimSize(i));
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   return success();
 }
 
 LogicalResult tosa::ConcatOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   // Infer all dimension sizes by reducing based on inputs.
   int32_t axis =
       attributes.get("axis").cast<IntegerAttr>().getValue().getSExtValue();
   llvm::SmallVector<int64_t> outputShape;
   bool hasRankedInput = false;
   for (auto operand : operands) {
     ShapeAdaptor operandShape = operands.getShape(operand);
LogicalResult tosa::ConcatOp::inferReturnTypeComponents(
   outputShape[axis] = concatDimSize;
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::FullyConnectedOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   ShapeAdaptor weightShape = operands.getShape(1);
   ShapeAdaptor biasShape = operands.getShape(2);
 
   // All shapes are dynamic.
   SmallVector<int64_t> outShape;
   outShape.resize(2, ShapedType::kDynamicSize);
LogicalResult tosa::FullyConnectedOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   return success();
 }
 
 LogicalResult tosa::MatMulOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor lhsShape = operands.getShape(0);
   ShapeAdaptor rhsShape = operands.getShape(1);
 
   // All shapes are dynamic.
   SmallVector<int64_t> outShape;
   outShape.resize(3, ShapedType::kDynamicSize);
 
LogicalResult tosa::MatMulOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   return success();
 }
 
 LogicalResult tosa::PadOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   ShapeAdaptor paddingShape = operands.getShape(1);
   SmallVector<int64_t> outputShape;
 
   // If both inputs have unknown shape, we cannot determine the shape of the
   // output.
   if (!inputShape.hasRank() && !paddingShape.hasRank()) {
LogicalResult tosa::PadOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::SliceOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  ArrayAttr sizes = SliceOpAdaptor(operands, attributes).size();
+  ArrayAttr sizes = SliceOpAdaptor(context, operands, attributes).size();
   SmallVector<int64_t> outputShape;
   outputShape.reserve(sizes.size());
   for (auto val : sizes) {
     outputShape.push_back(val.cast<IntegerAttr>().getValue().getSExtValue());
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::TableOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
 
   if (!inputShape.hasRank()) {
     inferredReturnShapes.push_back(ShapedTypeComponents());
     return success();
   }
 
   inferredReturnShapes.resize(1);
   inputShape.getDims(inferredReturnShapes[0]);
   return success();
 }
 
 LogicalResult tosa::TileOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  TileOpAdaptor adaptor(operands, attributes);
+  TileOpAdaptor adaptor(context, operands, attributes);
   ArrayAttr multiples = adaptor.multiples();
   ShapeAdaptor inputShape = operands.getShape(0);
   SmallVector<int64_t> outputShape;
   if (!inputShape.hasRank()) {
     outputShape.resize(multiples.size(), ShapedType::kDynamicSize);
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
     return success();
   }
LogicalResult tosa::TileOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::ReshapeOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  ReshapeOpAdaptor adaptor(operands, attributes);
+  ReshapeOpAdaptor adaptor(context, operands, attributes);
   ShapeAdaptor inputShape = operands.getShape(0);
 
   ArrayAttr newShape = adaptor.new_shape();
   llvm::SmallVector<int64_t> newShapeValue;
   getI64Values(newShape, newShapeValue);
 
   // We cannot infer from the total number of elements so we must take the
   // shape attribute as exact.
LogicalResult tosa::ReshapeOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(newShapeValue));
   return success();
 }
 
 LogicalResult tosa::TransposeOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   ShapeAdaptor permsShape = operands.getShape(1);
 
   // If input rank and permutation length is unknown, the output rank is
   // unknown.
   if (!inputShape.hasRank() || !permsShape.hasRank() ||
       permsShape.isDynamicDim(0)) {
LogicalResult tosa::TransposeOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::GatherOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape;
   outputShape.resize(3, ShapedType::kDynamicSize);
 
   ShapeAdaptor valuesShape = operands.getShape(0);
   if (valuesShape.hasRank()) {
     outputShape[0] = valuesShape.getDimSize(0);
     outputShape[2] = valuesShape.getDimSize(2);
   }
 
   ShapeAdaptor indicesShape = operands.getShape(1);
   if (indicesShape.hasRank()) {
     if (outputShape[0] == ShapedType::kDynamicSize)
       outputShape[0] = indicesShape.getDimSize(0);
     if (outputShape[1] == ShapedType::kDynamicSize)
       outputShape[1] = indicesShape.getDimSize(1);
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::ResizeOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  ResizeOpAdaptor adaptor(operands, attributes);
+  ResizeOpAdaptor adaptor(context, operands, attributes);
   llvm::SmallVector<int64_t, 4> outputShape;
   outputShape.resize(4, ShapedType::kDynamicSize);
 
   int32_t inHeight = ShapedType::kDynamicSize;
   int32_t inWidth = ShapedType::kDynamicSize;
 
   ShapeAdaptor inputShape = operands.getShape(adaptor.input());
   if (inputShape.hasRank()) {
LogicalResult tosa::ResizeOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::ScatterOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape;
   outputShape.resize(3, ShapedType::kDynamicSize);
 
   ShapeAdaptor valuesInShape = operands.getShape(0);
   if (valuesInShape.hasRank()) {
     outputShape[0] = valuesInShape.getDimSize(0);
     outputShape[1] = valuesInShape.getDimSize(1);
static LogicalResult ReduceInferReturnTypes(
   outputShape[axisVal] = 1;
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 #define REDUCE_SHAPE_INFER(OP)                                                 \
   LogicalResult OP::inferReturnTypeComponents(                                 \
       MLIRContext *context, ::llvm::Optional<Location> location,               \
-      ValueShapeRange operands, DictionaryAttr attributes,                     \
+      ValueShapeRange operands, AttributeRange attributes,                     \
       RegionRange regions,                                                     \
       SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {           \
     return ReduceInferReturnTypes(operands.getShape(0),                        \
                                   attributes.get("axis").cast<IntegerAttr>(),  \
                                   inferredReturnShapes);                       \
   }
 
 REDUCE_SHAPE_INFER(tosa::ReduceAllOp)
if (resolveBroadcastShape(operands, outShape).failed()) {
     inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   }
   return success();
 }
 
 #define NARY_SHAPE_INFER(OP)                                                   \
   LogicalResult OP::inferReturnTypeComponents(                                 \
       MLIRContext *context, ::llvm::Optional<Location> location,               \
-      ValueShapeRange operands, DictionaryAttr attributes,                     \
+      ValueShapeRange operands, AttributeRange attributes,                     \
       RegionRange regions,                                                     \
       SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {           \
     return NAryInferReturnTypes(operands, inferredReturnShapes);               \
   }
 
 NARY_SHAPE_INFER(tosa::AbsOp)
 NARY_SHAPE_INFER(tosa::AddOp)
 NARY_SHAPE_INFER(tosa::ArithmeticRightShiftOp)

 NARY_SHAPE_INFER(tosa::RsqrtOp)
 NARY_SHAPE_INFER(tosa::SelectOp)
 NARY_SHAPE_INFER(tosa::SubOp)
 NARY_SHAPE_INFER(tosa::TanhOp)
 NARY_SHAPE_INFER(tosa::SigmoidOp)
 #undef PRED_SHAPE_INFER
 
 static LogicalResult poolingInferReturnTypes(
-    const ValueShapeRange &operands, DictionaryAttr attributes,
+    const ValueShapeRange &operands, AttributeRange attributes,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   llvm::SmallVector<int64_t> outputShape;
   outputShape.resize(4, -1);
 
   // We only know the rank if the input type is unranked.
   if (!inputShape) {
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
static LogicalResult poolingInferReturnTypes(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult Conv2DOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape(4, ShapedType::kDynamicSize);
-  Conv2DOp::Adaptor adaptor(operands.getValues(), attributes);
+  Conv2DOp::Adaptor adaptor(context, operands.getValues(), attributes);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
   int32_t inputHeight = ShapedType::kDynamicSize;
   int32_t weightWidth = ShapedType::kDynamicSize;
   int32_t weightHeight = ShapedType::kDynamicSize;
 
   // Input shape describes input width/height and batch.
 
LogicalResult Conv2DOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult Conv3DOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape(5, ShapedType::kDynamicSize);
-  Conv2DOp::Adaptor adaptor(operands.getValues(), attributes);
+  Conv2DOp::Adaptor adaptor(context, operands.getValues(), attributes);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
   int32_t inputHeight = ShapedType::kDynamicSize;
   int32_t inputDepth = ShapedType::kDynamicSize;
 
   int32_t weightWidth = ShapedType::kDynamicSize;
   int32_t weightHeight = ShapedType::kDynamicSize;
   int32_t weightDepth = ShapedType::kDynamicSize;
LogicalResult Conv3DOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult AvgPool2dOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   return poolingInferReturnTypes(operands, attributes, inferredReturnShapes);
 }
 
 LogicalResult MaxPool2dOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   return poolingInferReturnTypes(operands, attributes, inferredReturnShapes);
 }
 
 LogicalResult DepthwiseConv2DOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape(4, ShapedType::kDynamicSize);
-  DepthwiseConv2DOp::Adaptor adaptor(operands.getValues(), attributes);
+  DepthwiseConv2DOp::Adaptor adaptor(context, operands.getValues(), attributes);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
   int32_t inputHeight = ShapedType::kDynamicSize;
   int32_t inputChannels = ShapedType::kDynamicSize;
 
   int32_t weightWidth = ShapedType::kDynamicSize;
   int32_t weightHeight = ShapedType::kDynamicSize;
   int32_t depthChannels = ShapedType::kDynamicSize;
LogicalResult DepthwiseConv2DOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult TransposeConv2DOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  TransposeConv2DOp::Adaptor adaptor(operands.getValues(), attributes);
+  TransposeConv2DOp::Adaptor adaptor(context, operands.getValues(), attributes);
   llvm::SmallVector<int64_t> outputShape;
   getI64Values(adaptor.out_shape(), outputShape);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
   int32_t inputHeight = ShapedType::kDynamicSize;
   int32_t weightWidth = ShapedType::kDynamicSize;
   int32_t weightHeight = ShapedType::kDynamicSize;
 
LogicalResult TransposeConv2DOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult IfOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<tosa::YieldOp> yieldOps;
   for (Region *region : regions) {
     for (auto &block : *region)
       if (auto returnOp = dyn_cast<tosa::YieldOp>(block.getTerminator()))
         yieldOps.push_back(returnOp);
   }
 
for (const ValueKnowledge &result : resultKnowledge) {
     inferredReturnShapes.push_back(result.getShapedTypeComponents());
   }
 
   return success();
 }
 
 LogicalResult WhileOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<tosa::YieldOp> yieldOps;
   for (auto &block : *regions[1])
     if (auto returnOp = dyn_cast<tosa::YieldOp>(block.getTerminator()))
       yieldOps.push_back(returnOp);
 
   // TOSA's while must have a tosa.yield as its terminator. If not found this
   // tosa.while is invalid.

mlir/lib/Dialect/Tosa/Transforms/TosaInferShapes.cpp

for (Operation &op : block) {
       if (!shapeInterface)
         continue;
 
       SmallVector<ShapedTypeComponents> returnedShapes;
 
       ValueShapeRange range(op.getOperands(), operandShape);
       if (shapeInterface
               .inferReturnTypeComponents(op.getContext(), op.getLoc(), range,
-                                         op.getAttrDictionary(),
-                                         op.getRegions(), returnedShapes)
+                                         op.getAttrs(), op.getRegions(),
+                                         returnedShapes)
               .succeeded()) {
         for (auto it : llvm::zip(op.getResults(), returnedShapes)) {
           Value result = std::get<0>(it);
           ShapedTypeComponents predictedShape = std::get<1>(it);
 
           // Check whether this use case is replaceable. We define an op as
           // being replaceable if it is used by a ReturnOp or a TosaOp.
           bool replaceable = true;

mlir/lib/IR/AsmPrinter.cpp

if (region.empty())
       return;
 
     auto *entryBlock = &region.front();
     print(entryBlock, printEntryBlockArgs, printBlockTerminators);
     for (Block &b : llvm::drop_begin(region, 1))
       print(&b);
   }
 
-  void printRegionArgument(BlockArgument arg, ArrayRef<NamedAttribute> argAttrs,
+  void printRegionArgument(BlockArgument arg, AttributeRange argAttrs,
                            bool omitType) override {
     printType(arg.getType());
     // Visit the argument location.
     if (printerFlags.shouldPrintDebugInfo())
       // TODO: Allow deferring argument locations.
       initializer.visit(arg.getLoc(), /*canBeDeferred=*/false);
   }
 
   /// Consider the given type to be printed for an alias.
   void printType(Type type) override { initializer.visit(type); }
 
   /// Consider the given attribute to be printed for an alias.
   void printAttribute(Attribute attr) override { initializer.visit(attr); }
   void printAttributeWithoutType(Attribute attr) override {
     printAttribute(attr);
   }
 
   /// Print the given set of attributes with names not included within
   /// 'elidedAttrs'.
-  void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
+  void printOptionalAttrDict(AttributeRange attrs,
                              ArrayRef<StringRef> elidedAttrs = {}) override {
     if (attrs.empty())
       return;
     if (elidedAttrs.empty()) {
       for (const NamedAttribute &attr : attrs)
         printAttribute(attr.second);
       return;
     }
     llvm::SmallDenseSet<StringRef> elidedAttrsSet(elidedAttrs.begin(),
                                                   elidedAttrs.end());
     for (const NamedAttribute &attr : attrs)
       if (!elidedAttrsSet.contains(attr.first.strref()))
         printAttribute(attr.second);
   }
   void printOptionalAttrDictWithKeyword(
-      ArrayRef<NamedAttribute> attrs,
-      ArrayRef<StringRef> elidedAttrs = {}) override {
+      AttributeRange attrs, ArrayRef<StringRef> elidedAttrs = {}) override {
     printOptionalAttrDict(attrs, elidedAttrs);
   }
 
   /// Return a null stream as the output stream, this will ignore any data fed
   /// to it.
   raw_ostream &getStream() const override { return os; }
 
   /// The following are hooks of `OpAsmPrinter` that are not necessary for
public:
   void printAffineMap(AffineMap map);
   void
   printAffineExpr(AffineExpr expr,
                   function_ref<void(unsigned, bool)> printValueName = nullptr);
   void printAffineConstraint(AffineExpr expr, bool isEq);
   void printIntegerSet(IntegerSet set);
 
 protected:
-  void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
+  void printOptionalAttrDict(AttributeRange attrs,
                              ArrayRef<StringRef> elidedAttrs = {},
                              bool withKeyword = false);
   void printNamedAttribute(NamedAttribute attr);
   void printTrailingLocation(Location loc, bool allowAlias = true);
   void printLocationInternal(LocationAttr loc, bool pretty = false);
 
   /// Print a dense elements attribute. If 'allowHex' is true, a hex string is
   /// used instead of individual elements when the elements attr is large.
TypeSwitch<Type>(type)
         interleaveComma(tupleTy.getTypes(),
                         [&](Type type) { printType(type); });
         os << '>';
       })
       .Case<NoneType>([&](Type) { os << "none"; })
       .Default([&](Type type) { return printDialectType(type); });
 }
 
-void AsmPrinter::Impl::printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
+void AsmPrinter::Impl::printOptionalAttrDict(AttributeRange attrs,
                                              ArrayRef<StringRef> elidedAttrs,
                                              bool withKeyword) {
   // If there are no attributes, then there is nothing to be done.
   if (attrs.empty())
     return;
 
   // Functor used to print a filtered attribute list.
   auto printFilteredAttributesFn = [&](auto filteredAttrs) {
     // Print the 'attributes' keyword if necessary.
     if (withKeyword)
       os << " attributes";
 
     // Otherwise, print them all out in braces.
     os << " {";
     interleaveComma(filteredAttrs,
                     [&](NamedAttribute attr) { printNamedAttribute(attr); });
     os << '}';
   };
 
   // If no attributes are elided, we can directly print with no filtering.
   if (elidedAttrs.empty())
-    return printFilteredAttributesFn(attrs);
+    return printFilteredAttributesFn(attrs.getMaybeSorted());
 
   // 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) {
+  auto filteredAttrs =
+      llvm::make_filter_range(attrs.getMaybeSorted(), [&](NamedAttribute attr) {
         return !elidedAttrsSet.contains(attr.first.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.
void printNewline() override {
     os.indent(currentIndent);
   }
 
   /// Print a block argument in the usual format of:
   ///   %ssaName : type {attr1=42} loc("here")
   /// where location printing is controlled by the standard internal option.
   /// You may pass omitType=true to not print a type, and pass an empty
   /// attribute list if you don't care for attributes.
-  void printRegionArgument(BlockArgument arg,
-                           ArrayRef<NamedAttribute> argAttrs = {},
+  void printRegionArgument(BlockArgument arg, AttributeRange argAttrs = {},
                            bool omitType = false) override;
 
   /// Print the ID for the given value.
   void printOperand(Value value) override { printValueID(value); }
   void printOperand(Value value, raw_ostream &os) override {
     printValueID(value, /*printResultNo=*/true, &os);
   }
 
   /// Print an optional attribute dictionary with a given set of elided values.
-  void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
+  void printOptionalAttrDict(AttributeRange attrs,
                              ArrayRef<StringRef> elidedAttrs = {}) override {
     Impl::printOptionalAttrDict(attrs, elidedAttrs);
   }
   void printOptionalAttrDictWithKeyword(
-      ArrayRef<NamedAttribute> attrs,
-      ArrayRef<StringRef> elidedAttrs = {}) override {
+      AttributeRange attrs, ArrayRef<StringRef> elidedAttrs = {}) override {
     Impl::printOptionalAttrDict(attrs, elidedAttrs,
                                 /*withKeyword=*/true);
   }
 
   /// Print the given successor.
   void printSuccessor(Block *successor) override;
 
   /// Print an operation successor with the operands used for the block

 }
 
 /// Print a block argument in the usual format of:
 ///   %ssaName : type {attr1=42} loc("here")
 /// where location printing is controlled by the standard internal option.
 /// You may pass omitType=true to not print a type, and pass an empty
 /// attribute list if you don't care for attributes.
 void OperationPrinter::printRegionArgument(BlockArgument arg,
-                                           ArrayRef<NamedAttribute> argAttrs,
+                                           AttributeRange argAttrs,
                                            bool omitType) {
   printOperand(arg);
   if (!omitType) {
     os << ": ";
     printType(arg.getType());
   }
   printOptionalAttrDict(argAttrs);
   // TODO: We should allow location aliases on block arguments.

mlir/lib/IR/AttributeRange.cpp

+#include "mlir/IR/AttributeRange.h"
+#include "mlir/IR/BuiltinAttributes.h"
+#include "mlir/IR/Operation.h"
+#include "mlir/IR/OperationSupport.h"
+
+using namespace mlir;
+
+AttributeRange::AttributeRange(Operation *op)
+    : first(op, 0, OPERATION),
+      last(op,
+           op->getIntrinsicAttributes().size() + op->getOpAttributes().size(),
+           OPERATION),
+      sorted(true) {}
+
+AttributeRange::AttributeRange(DictionaryAttr dictAttr)
+    : AttributeRange(dictAttr ? dictAttr.getValue() : AttributeRange()) {
+  assert(!dictAttr || dictAttr.getValue().isSorted() &&
+                          "expected dictionary attributes to be marked sorted");
+}
+
+AttributeRange::AttributeRange(const NamedAttrList &list)
+    : AttributeRange(ArrayRef<NamedAttribute>(list), list.isSorted()) {}
+
+AttributeRange::AttributeRange(const detail::OpAttributeList &opAttrs)
+    : AttributeRange(ArrayRef<NamedAttribute>(opAttrs), true) {}
+
+AttributeRange::iterator::iterator(Owner owner, ptrdiff_t index, Kind kind)
+    : owner(owner), index(index), kind(kind) {
+  // Skip over null attributes.
+  if (kind == OPERATION) {
+    this->operator+=(0);
+    this->operator-=(0);
+  }
+}
+
+NamedAttribute AttributeRange::iterator::operator*() const {
+  if (kind == NAMED_ATTR_ARRAY)
+    return owner.attrs[index];
+
+  // Index into the correct segment.
+  MutableArrayRef<Attribute> attrs = owner.op->getIntrinsicAttributes();
+  if (index < attrs.size())
+    return {owner.op->getIntrinsicAttributeName(index), attrs[index]};
+  return owner.op->getOpAttributes()[index - attrs.size()];
+}
+
+AttributeRange::iterator &AttributeRange::iterator::operator+=(ptrdiff_t diff) {
+  index += diff;
+  if (kind == OPERATION) {
+    // Skip over null attributes.
+    MutableArrayRef<Attribute> attrs = owner.op->getIntrinsicAttributes();
+    while (index < attrs.size() && !attrs[index])
+      ++index;
+  }
+  return *this;
+}
+
+AttributeRange::iterator &AttributeRange::iterator::operator-=(ptrdiff_t diff) {
+  index -= diff;
+  if (kind == OPERATION) {
+    // Skip over null attributes.
+    MutableArrayRef<Attribute> attrs = owner.op->getIntrinsicAttributes();
+    while (index < attrs.size() && index > 0 && !attrs[index])
+      --index;
+  }
+  return *this;
+}
+
+ptrdiff_t AttributeRange::iterator::operator-(const iterator &it) const {
+  if (kind == NAMED_ATTR_ARRAY)
+    return index - it.index;
+  // We need to count the distance in the number of non-null attributes.
+  if (it.index < index)
+    return std::count_if(it, *this, [](NamedAttribute) { return true; });
+  return -std::count_if(*this, it, [](NamedAttribute) { return true; });
+}
+
+Optional<NamedAttribute> AttributeRange::opGetNamed(StringRef name) const {
+  assert(first.kind == OPERATION);
+  return first.owner.op->getNamedAttr(name);
+}
+Optional<NamedAttribute> AttributeRange::opGetNamed(Identifier name) const {
+  assert(first.kind == OPERATION);
+  return first.owner.op->getNamedAttr(name);
+}
+
+void AttributeRange::applySorted(
+    llvm::function_ref<void(NamedAttribute)> eachFn) const {
+  assert(isSorted() && "cannot traverse unsorted attribute range");
+  if (first.kind == NAMED_ATTR_ARRAY) {
+    llvm::for_each(*this, std::move(eachFn));
+    return;
+  }
+  // Parallel iteration over the operation's attributes.
+  auto *op = first.owner.op;
+  impl::forEachSorted(op->getIntrinsicAttributeNames(),
+                      op->getIntrinsicAttributes(), op->getOpAttributes(),
+                      std::move(eachFn));
+}
+
+// TODO: improve these constructors.
+AttributeRange::sorted_iterator::sorted_iterator(const AttributeRange *attrs)
+    : curIsIntrinsic(false) {
+  if (attrs->first.kind == NAMED_ATTR_ARRAY) {
+    // Make the intrinsic arrays null.
+    nameIt = nameEnd = nullptr;
+    inAttrIt = nullptr;
+    attrIt = attrs->first.owner.attrs;
+    attrEnd = attrIt + attrs->last.index;
+  } else {
+    auto *op = attrs->first.owner.op;
+    nameIt = op->getIntrinsicAttributeNames().begin();
+    nameEnd = op->getIntrinsicAttributeNames().end();
+    inAttrIt = op->getIntrinsicAttributes().begin();
+    attrIt = op->getOpAttributes().begin();
+    attrEnd = op->getOpAttributes().end();
+    // Skip null attributes.
+    for (; nameIt != nameEnd && !*inAttrIt; ++nameIt, ++inAttrIt) {
+    }
+    // Check whether the next accessed attribute should be intrinsic.
+    curIsIntrinsic =
+        (nameIt != nameEnd &&
+         (attrIt == attrEnd || nameIt->strref() < attrIt->first.strref()));
+  }
+}
+
+AttributeRange::sorted_iterator::sorted_iterator(const AttributeRange *attrs,
+                                                 int)
+    : curIsIntrinsic(false) {
+  // Set all iterators equal to the end.
+  if (attrs->first.kind == NAMED_ATTR_ARRAY) {
+    nameIt = nameEnd = nullptr;
+    inAttrIt = nullptr;
+    attrIt = attrEnd = attrs->first.owner.attrs + attrs->last.index;
+  } else {
+    auto *op = attrs->first.owner.op;
+    nameIt = nameEnd = op->getIntrinsicAttributeNames().end();
+    inAttrIt = op->getIntrinsicAttributes().end();
+    attrIt = attrEnd = op->getOpAttributes().end();
+  }
+}
+
+NamedAttribute AttributeRange::sorted_iterator::operator*() const {
+  if (curIsIntrinsic) {
+    assert(nameIt < nameEnd && "advanced intrinsic iterator past the end");
+    assert(inAttrIt && "cannot dereference null iterator");
+    assert(*inAttrIt && "dereferenced attribute cannot be null");
+    return {*nameIt, *inAttrIt};
+  }
+  assert(attrIt < attrEnd && "advanced attribute iterator past the end");
+  return *attrIt;
+}
+
+AttributeRange::sorted_iterator &AttributeRange::sorted_iterator::operator++() {
+  /// If the range [attrIt, attrEnd) isn't sorted, then it must be that the
+  /// intrinsic name and attribute ranges are empty, so the named attribute
+  /// range will be traversed regardless of whether it's sorted.
+  if (curIsIntrinsic) {
+    // Current intrinsic attribute was consumed. Advance and skip null
+    // attributes.
+    ++nameIt;
+    ++inAttrIt;
+    for (; nameIt != nameEnd && !*inAttrIt; ++nameIt, ++inAttrIt) {
+    }
+  } else if (attrIt != attrEnd) {
+    // Otherwise, advance the extra attributes iterator.
+    ++attrIt;
+  }
+  // Check whether the next value to be dereferenced should be intrinsic.
+  curIsIntrinsic =
+      (nameIt != nameEnd &&
+       (attrIt == attrEnd || nameIt->strref() < attrIt->first.strref()));
+  return *this;
+}
+
+bool AttributeRange::sorted_iterator::operator==(
+    const sorted_iterator &it) const {
+  return nameIt == it.nameIt && attrIt == it.attrIt;
+}
+
+void impl::separateIntrinsicAttrs(AttributeRange attrs,
+                                  ArrayRef<Identifier> intrinsicNames,
+                                  MutableArrayRef<Attribute> intrinsicAttrs,
+                                  SmallVectorImpl<NamedAttribute> &extraAttrs) {
+  // Sort the attribute range if it is not.
+  SmallVector<NamedAttribute> sortedAttrsStorage;
+  if (!attrs.isSorted()) {
+    sortedAttrsStorage = attrs;
+    std::sort(sortedAttrsStorage.begin(), sortedAttrsStorage.end());
+    attrs = sortedAttrsStorage;
+  }
+  // TODO: reserve_exact
+  assert(intrinsicNames.size() == intrinsicAttrs.size() &&
+         "mismatched number of intrinsic attribute names and values");
+  extraAttrs.reserve(attrs.size());
+
+  auto *nameIt = intrinsicNames.begin();
+  auto *inAttrIt = intrinsicAttrs.begin();
+  auto attrIt = attrs.begin();
+  // Iterate over the two attribute lists in parallel. Advance both iterators
+  // when an intrisic attribute is found. Otherwise, advance one at a time.
+  while (nameIt != intrinsicNames.end() && attrIt != attrs.end()) {
+    auto compare = attrIt->first.strref().compare(nameIt->strref());
+    if (compare < 0) {
+      extraAttrs.push_back(*attrIt++);
+    } else {
+      ::new (inAttrIt++)
+          Attribute(compare == 0 ? attrIt++->second : Attribute());
+      ++nameIt;
+    }
+  }
+  // Handle remaining attributes.
+  while (inAttrIt != intrinsicAttrs.end())
+    ::new (inAttrIt++) Attribute();
+  while (attrIt != attrs.end())
+    extraAttrs.push_back(*attrIt++);
+}
+
+void impl::forEachSorted(ArrayRef<Identifier> intrinsicNames,
+                         ArrayRef<Attribute> intrinsicAttrs,
+                         const detail::OpAttributeList &extraAttrs,
+                         llvm::function_ref<void(NamedAttribute)> eachFn) {
+  assert(intrinsicNames.size() == intrinsicAttrs.size() &&
+         "mismatched number of intrinsic attribute names and values");
+  auto *nameIt = intrinsicNames.begin();
+  auto *inAttrIt = intrinsicAttrs.begin();
+  auto *attrIt = extraAttrs.begin();
+
+  /// Iterate over the two attribute lists in parallel. Advance whichever
+  /// iterator(s) correspond to the lesser element.
+  while (nameIt != intrinsicNames.end() && attrIt != extraAttrs.end()) {
+    assert(*nameIt != attrIt->first && "duplicate intrinsic attribute");
+    if (nameIt->strref() < attrIt->first.strref())
+      eachFn({*nameIt++, *inAttrIt++});
+    else
+      eachFn(*attrIt++);
+  }
+  /// Handle remaining attributes.
+  while (attrIt != extraAttrs.end())
+    eachFn(*attrIt++);
+  while (inAttrIt != intrinsicAttrs.end())
+    eachFn({*nameIt++, *inAttrIt++});
+}
+
+// llvm::make_second_range must return an iterator range whose reference_type
+// is Attribute, not Attribute &.
+static_assert(
+    std::is_same<Attribute, decltype(*llvm::make_second_range(
+                                          std::declval<AttributeRange>())
+                                          .begin())>::value,
+    "make_second_range(AttributeRange) return type must be Attribute");

mlir/lib/IR/Builders.cpp

 }
 
 UnitAttr Builder::getUnitAttr() { return UnitAttr::get(context); }
 
 BoolAttr Builder::getBoolAttr(bool value) {
   return BoolAttr::get(context, value);
 }
 
-DictionaryAttr Builder::getDictionaryAttr(ArrayRef<NamedAttribute> value) {
+DictionaryAttr Builder::getDictionaryAttr(AttributeRange value) {
   return DictionaryAttr::get(context, value);
 }
 
 IntegerAttr Builder::getIndexAttr(int64_t value) {
   return IntegerAttr::get(getIndexType(), APInt(64, value));
 }
 
 IntegerAttr Builder::getI64IntegerAttr(int64_t value) {

mlir/lib/IR/BuiltinAttributes.cpp

 // DictionaryAttr
 //===----------------------------------------------------------------------===//
 
 /// Helper function that does either an in place sort or sorts from source array
 /// into destination. If inPlace then storage is both the source and the
 /// destination, else value is the source and storage destination. Returns
 /// whether source was sorted.
 template <bool inPlace>
-static bool dictionaryAttrSort(ArrayRef<NamedAttribute> value,
+static bool dictionaryAttrSort(AttributeRange value,
                                SmallVectorImpl<NamedAttribute> &storage) {
   // Specialize for the common case.
   switch (value.size()) {
   case 0:
     // Zero already sorted.
     if (!inPlace)
       storage.clear();
     break;
if (!isSorted)
       llvm::array_pod_sort(storage.begin(), storage.end());
     return !isSorted;
   }
   return false;
 }
 
 /// Returns an entry with a duplicate name from the given sorted array of named
 /// attributes. Returns llvm::None if all elements have unique names.
-static Optional<NamedAttribute>
-findDuplicateElement(ArrayRef<NamedAttribute> value) {
+static Optional<NamedAttribute> findDuplicateElement(AttributeRange 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;
 
   auto it = std::adjacent_find(
       value.begin(), value.end(),
       [](NamedAttribute l, NamedAttribute r) { return l.first == r.first; });
   return it != value.end() ? *it : none;
 }
 
-bool DictionaryAttr::sort(ArrayRef<NamedAttribute> value,
+bool DictionaryAttr::sort(AttributeRange value,
                           SmallVectorImpl<NamedAttribute> &storage) {
   bool isSorted = dictionaryAttrSort</*inPlace=*/false>(value, storage);
   assert(!findDuplicateElement(storage) &&
          "DictionaryAttr element names must be unique");
   return isSorted;
 }
 
 bool DictionaryAttr::sortInPlace(SmallVectorImpl<NamedAttribute> &array) {
   bool isSorted = dictionaryAttrSort</*inPlace=*/true>(array, array);
   assert(!findDuplicateElement(array) &&
          "DictionaryAttr element names must be unique");
   return isSorted;
 }
 
 Optional<NamedAttribute>
 DictionaryAttr::findDuplicate(SmallVectorImpl<NamedAttribute> &array,
                               bool isSorted) {
   if (!isSorted)
     dictionaryAttrSort</*inPlace=*/true>(array, array);
   return findDuplicateElement(array);
 }
 
-DictionaryAttr DictionaryAttr::get(MLIRContext *context,
-                                   ArrayRef<NamedAttribute> value) {
+DictionaryAttr DictionaryAttr::get(MLIRContext *context, AttributeRange value) {
+  if (value.isSorted())
+    return getWithSorted(context, 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) {
+                                             AttributeRange 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();
                          }) &&
          "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 {
-  Optional<NamedAttribute> attr = getNamed(name);
-  return attr ? attr->second : nullptr;
+  return getValue().get(name);
 }
 Attribute DictionaryAttr::get(Identifier name) const {
-  Optional<NamedAttribute> attr = getNamed(name);
-  return attr ? attr->second : nullptr;
+  return getValue().get(name);
 }
 
 /// Return the specified named attribute if present, None otherwise.
 Optional<NamedAttribute> DictionaryAttr::getNamed(StringRef name) const {
-  ArrayRef<NamedAttribute> values = getValue();
-  const auto *it = llvm::lower_bound(values, name);
-  return it != values.end() && it->first == name ? *it
-                                                 : Optional<NamedAttribute>();
+  return getValue().getNamed(name);
 }
 Optional<NamedAttribute> DictionaryAttr::getNamed(Identifier name) const {
-  for (auto elt : getValue())
-    if (elt.first == name)
-      return elt;
-  return llvm::None;
+  return getValue().getNamed(name);
 }
 
 DictionaryAttr::iterator DictionaryAttr::begin() const {
   return getValue().begin();
 }
 DictionaryAttr::iterator DictionaryAttr::end() const {
   return getValue().end();
 }
 size_t DictionaryAttr::size() const { return getValue().size(); }
 
 DictionaryAttr DictionaryAttr::getEmptyUnchecked(MLIRContext *context) {
-  return Base::get(context, ArrayRef<NamedAttribute>());
+  return Base::get(context, AttributeRange());
 }
 
 void DictionaryAttr::walkImmediateSubElements(
     function_ref<void(Attribute)> walkAttrsFn,
     function_ref<void(Type)> walkTypesFn) const {
   for (Attribute attr : llvm::make_second_range(getValue()))
     walkAttrsFn(attr);
 }

mlir/lib/IR/BuiltinDialect.cpp

#include "mlir/IR/BuiltinOps.cpp.inc"
   addInterfaces<BuiltinOpAsmDialectInterface>();
 }
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
-                      ArrayRef<NamedAttribute> attrs) {
+                      AttributeRange attrs) {
   OpBuilder builder(location->getContext());
   OperationState state(location, getOperationName());
   FuncOp::build(builder, state, name, type, attrs);
   return cast<FuncOp>(Operation::create(state));
 }
 FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
                       Operation::dialect_attr_range attrs) {
   SmallVector<NamedAttribute, 8> attrRef(attrs);
-  return create(location, name, type, llvm::makeArrayRef(attrRef));
+  return create(location, name, type, AttributeRange(attrRef));
 }
 FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
-                      ArrayRef<NamedAttribute> attrs,
-                      ArrayRef<DictionaryAttr> argAttrs) {
+                      AttributeRange attrs, ArrayRef<DictionaryAttr> argAttrs) {
   FuncOp func = create(location, name, type, attrs);
   func.setAllArgAttrs(argAttrs);
   return func;
 }
 
 void FuncOp::build(OpBuilder &builder, OperationState &state, StringRef name,
-                   FunctionType type, ArrayRef<NamedAttribute> attrs,
+                   FunctionType type, AttributeRange attrs,
                    ArrayRef<DictionaryAttr> argAttrs) {
   state.addAttribute(SymbolTable::getSymbolAttrName(),
                      builder.getStringAttr(name));
   state.addAttribute(getTypeAttrName(), TypeAttr::get(type));
   state.attributes.append(attrs.begin(), attrs.end());
   state.addRegion();
 
   if (argAttrs.empty())

mlir/lib/IR/CMakeLists.txt

 add_mlir_library(MLIRIR
   AffineExpr.cpp
   AffineMap.cpp
   AsmPrinter.cpp
+  AttributeRange.cpp
   Attributes.cpp
   Block.cpp
   Builders.cpp
   BuiltinAttributeInterfaces.cpp
   BuiltinAttributes.cpp
   BuiltinDialect.cpp
   BuiltinTypes.cpp
   Diagnostics.cpp

mlir/lib/IR/FunctionImplementation.cpp

void mlir::function_like_impl::printFunctionSignature(
 
   p << '(';
   ArrayAttr argAttrs = op->getAttrOfType<ArrayAttr>(getArgDictAttrName());
   for (unsigned i = 0, e = argTypes.size(); i < e; ++i) {
     if (i > 0)
       p << ", ";
 
     if (!isExternal) {
-      ArrayRef<NamedAttribute> attrs;
+      AttributeRange attrs;
       if (argAttrs)
         attrs = argAttrs[i].cast<DictionaryAttr>().getValue();
       p.printRegionArgument(body.getArgument(i), attrs);
     } else {
       p.printType(argTypes[i]);
       if (argAttrs)
         p.printOptionalAttrDict(argAttrs[i].cast<DictionaryAttr>().getValue());
     }

mlir/lib/IR/MLIRContext.cpp

void AbstractOperation::insert(
   auto &impl = ctx->getImpl();
   assert(impl.multiThreadedExecutionContext == 0 &&
          "Registering a new operation kind while in a multi-threaded execution "
          "context");
 
   // Register the attribute names of this operation.
   MutableArrayRef<Identifier> cachedAttrNames;
   if (!attrNames.empty()) {
+    assert(llvm::is_sorted(attrNames) &&
+           "expected intrinsic attribute names to be sorted alphabetically");
     cachedAttrNames = MutableArrayRef<Identifier>(
         impl.identifierAllocator.Allocate<Identifier>(attrNames.size()),
         attrNames.size());
     for (unsigned i : llvm::seq<unsigned>(0, attrNames.size()))
       new (&cachedAttrNames[i]) Identifier(Identifier::get(attrNames[i], ctx));
   }
 
   // Register the information for this operation.

mlir/lib/IR/Operation.cpp

OperationName OperationName::getFromOpaquePointer(const void *pointer) {
   return OperationName(
       RepresentationUnion::getFromOpaqueValue(const_cast<void *>(pointer)));
 }
 
 //===----------------------------------------------------------------------===//
 // Operation
 //===----------------------------------------------------------------------===//
 
-/// Create a new Operation with the specific fields.
-Operation *Operation::create(Location location, OperationName name,
-                             TypeRange resultTypes, ValueRange operands,
-                             ArrayRef<NamedAttribute> attributes,
-                             BlockRange successors, unsigned numRegions) {
-  return create(location, name, resultTypes, operands,
-                DictionaryAttr::get(location.getContext(), attributes),
-                successors, numRegions);
-}
-
 /// Create a new Operation from operation state.
 Operation *Operation::create(const OperationState &state) {
   return create(state.location, state.name, state.types, state.operands,
-                state.attributes.getDictionary(state.getContext()),
-                state.successors, state.regions);
+                state.attributes, state.successors, state.regions);
 }
 
 /// Create a new Operation with the specific fields.
 Operation *Operation::create(Location location, OperationName name,
                              TypeRange resultTypes, ValueRange operands,
-                             DictionaryAttr attributes, BlockRange successors,
+                             AttributeRange attributes, BlockRange 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 DictionaryAttr to avoid
-/// unnecessarily uniquing a list of attributes.
+/// Create a new Operation with the specific fields.
 Operation *Operation::create(Location location, OperationName name,
                              TypeRange resultTypes, ValueRange operands,
-                             DictionaryAttr attributes, BlockRange successors,
+                             AttributeRange attributes, BlockRange successors,
                              unsigned numRegions) {
   assert(llvm::all_of(resultTypes, [](Type t) { return t; }) &&
          "unexpected null result type");
 
   // 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();
   unsigned numResults = resultTypes.size();
 
   // If the operation is known to have no operands, don't allocate an operand
   // storage.
   bool needsOperandStorage = true;
   if (operands.empty()) {
     if (const AbstractOperation *abstractOp = name.getAbstractOperation())
       needsOperandStorage = !abstractOp->hasTrait<OpTrait::ZeroOperands>();
   }
 
+  ArrayRef<Identifier> intrinsicNames = {};
+  if (const AbstractOperation *abstractOp = name.getAbstractOperation())
+    intrinsicNames = abstractOp->getAttributeNames();
+
   // Compute the byte size for the operation and the operand storage. This takes
   // into account the size of the operation, its trailing objects, and its
   // prefixed objects.
   size_t byteSize =
-      totalSizeToAlloc<BlockOperand, Region, detail::OperandStorage>(
-          numSuccessors, numRegions, needsOperandStorage ? 1 : 0) +
+      totalSizeToAlloc<Attribute, BlockOperand, Region, detail::OperandStorage>(
+          intrinsicNames.size(), numSuccessors, numRegions,
+          needsOperandStorage ? 1 : 0) +
       detail::OperandStorage::additionalAllocSize(numOperands);
   size_t prefixByteSize = llvm::alignTo(
       Operation::prefixAllocSize(numTrailingResults, numInlineResults),
       alignof(Operation));
   char *mallocMem = reinterpret_cast<char *>(malloc(byteSize + prefixByteSize));
   void *rawMem = mallocMem + prefixByteSize;
 
+  // Separate the intrinsic attributes, if there are any.
+  SmallVector<NamedAttribute> extraAttrs;
+  if (!intrinsicNames.empty()) {
+    MutableArrayRef<Attribute> intrinsicAttrs(
+        reinterpret_cast<Attribute *>(reinterpret_cast<char *>(rawMem) +
+                                      sizeof(Operation)),
+        intrinsicNames.size());
+    impl::separateIntrinsicAttrs(attributes, intrinsicNames, intrinsicAttrs,
+                                 extraAttrs);
+    attributes = extraAttrs;
+  }
+
   // Create the new Operation.
-  Operation *op =
-      ::new (rawMem) Operation(location, name, numResults, numSuccessors,
-                               numRegions, attributes, needsOperandStorage);
+  Operation *op = ::new (rawMem)
+      Operation(location, name, numResults, intrinsicNames, numSuccessors,
 
   assert((numSuccessors == 0 || op->mightHaveTrait<OpTrait::IsTerminator>()) &&
          "unexpected successors in a non-terminator operation");
 
   // Initialize the results.
   auto resultTypeIt = resultTypes.begin();
   for (unsigned i = 0; i < numInlineResults; ++i, ++resultTypeIt)
     new (op->getInlineOpResult(i)) detail::InlineOpResult(*resultTypeIt, i);
Operation *Operation::create(Location location, OperationName name,
   auto blockOperands = op->getBlockOperands();
   for (unsigned i = 0; i != numSuccessors; ++i)
     new (&blockOperands[i]) BlockOperand(op, successors[i]);
 
   return op;
 }
 
 Operation::Operation(Location location, OperationName name, unsigned numResults,
+                     ArrayRef<Identifier> intrinsicAttributeNames,
                      unsigned numSuccessors, unsigned numRegions,
-                     DictionaryAttr attributes, bool hasOperandStorage)
-    : location(location), numResults(numResults), numSuccs(numSuccessors),
-      numRegions(numRegions), hasOperandStorage(hasOperandStorage), name(name),
-      attrs(attributes) {
-  assert(attributes && "unexpected null attribute dictionary");
+                     AttributeRange attributes, bool hasOperandStorage)
+    : location(location), numResults(numResults),
+      numIntrinsicAttrs(intrinsicAttributeNames.size()),
+      numSuccs(numSuccessors), numRegions(numRegions),
+      hasOperandStorage(hasOperandStorage),
+      intrinsicAttrNames(intrinsicAttributeNames.data()), name(name),
+      extraAttrs(attributes) {
 #ifndef NDEBUG
   if (!getDialect() && !getContext()->allowsUnregisteredDialects())
     llvm::report_fatal_error(
         name.getStringRef() +
         " created with unregistered dialect. If this is intended, please call "
         "allowUnregisteredDialects() on the MLIRContext, or use "
         "-allow-unregistered-dialect with the MLIR tool used.");
 #endif

 
 /// Insert the given operands into the operand list at the given 'index'.
 void Operation::insertOperands(unsigned index, ValueRange operands) {
   if (LLVM_LIKELY(hasOperandStorage))
     return setOperands(index, /*length=*/0, operands);
   assert(operands.empty() && "inserting operands without an operand storage");
 }
 
+void Operation::setAttrs(AttributeRange newAttrs) {
+  if (numIntrinsicAttrs == 0)
+    return extraAttrs.assign(newAttrs);
+
+  extraAttrs.attrs.clear();
+  impl::separateIntrinsicAttrs(newAttrs, getIntrinsicAttributeNames(),
+                               getIntrinsicAttributes(), extraAttrs.attrs);
+}
+
 //===----------------------------------------------------------------------===//
 // Diagnostics
 //===----------------------------------------------------------------------===//
 
 /// Emit an error about fatal conditions with this operation, reporting up to
 /// any diagnostic handlers that may be listening.
 InFlightDiagnostic Operation::emitError(const Twine &message) {
   InFlightDiagnostic diag = mlir::emitError(getLoc(), message);
for (auto opValue : getOperands())
     operands.push_back(mapper.lookupOrDefault(opValue));
 
   // Remap the successors.
   successors.reserve(getNumSuccessors());
   for (Block *successor : getSuccessors())
     successors.push_back(mapper.lookupOrDefault(successor));
 
   // Create the new operation.
-  auto *newOp = create(getLoc(), getName(), getResultTypes(), operands, attrs,
-                       successors, getNumRegions());
+  auto *newOp = create(getLoc(), getName(), getResultTypes(), operands,
+                       getAttrs(), successors, getNumRegions());
 
   // Remember the mapping of any results.
   for (unsigned i = 0, e = getNumResults(); i != e; ++i)
     mapper.map(getResult(i), newOp->getResult(i));
 
   return newOp;
 }
 

mlir/lib/IR/OperationSupport.cpp

 #include <numeric>
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // NamedAttrList
 //===----------------------------------------------------------------------===//
 
-NamedAttrList::NamedAttrList(ArrayRef<NamedAttribute> attributes) {
-  assign(attributes.begin(), attributes.end());
-}
+NamedAttrList::NamedAttrList(AttributeRange attributes) { assign(attributes); }
 
 NamedAttrList::NamedAttrList(DictionaryAttr attributes)
-    : NamedAttrList(attributes ? attributes.getValue()
-                               : ArrayRef<NamedAttribute>()) {
+    : NamedAttrList(attributes ? attributes.getValue() : AttributeRange()) {
   dictionarySorted.setPointerAndInt(attributes, true);
 }
 
 NamedAttrList::NamedAttrList(const_iterator in_start, const_iterator in_end) {
   assign(in_start, in_end);
 }
 
-ArrayRef<NamedAttribute> NamedAttrList::getAttrs() const { return attrs; }
+AttributeRange NamedAttrList::getAttrs() const { return attrs; }
 
 Optional<NamedAttribute> NamedAttrList::findDuplicate() const {
   Optional<NamedAttribute> duplicate =
       DictionaryAttr::findDuplicate(attrs, isSorted());
   // DictionaryAttr::findDuplicate will sort the list, so reset the sorted
   // state.
   if (!isSorted())
     dictionarySorted.setPointerAndInt(nullptr, true);

 NamedAttrList::operator=(const SmallVectorImpl<NamedAttribute> &rhs) {
   assign(rhs.begin(), rhs.end());
   return *this;
 }
 
 NamedAttrList::operator ArrayRef<NamedAttribute>() const { return attrs; }
 
 //===----------------------------------------------------------------------===//
+// OpAttributeList
+//===----------------------------------------------------------------------===//
+
+detail::OpAttributeList::OpAttributeList(AttributeRange attributes)
+    : attrs(attributes.begin(), attributes.end()) {
+  assert(llvm::none_of(attributes,
+                       [](NamedAttribute attr) { return !attr.second; }) &&
+         "cannot have null attributes");
+  if (!attributes.isSorted())
+    // TODO: llvm::array_pod_sort calls `qsort` which is somehow making heap
+    // allocations.
+    std::sort(attrs.begin(), attrs.end());
+}
+
+void detail::OpAttributeList::set(StringRef name, Attribute value) {
+  assert(value && "attribute cannot be null");
+  auto it = lookupAttribute(name);
+  if (it.second) {
+    it.first->second = value;
+  } else {
+    attrs.insert(it.first, {Identifier::get(name, value.getContext()), value});
+  }
+}
+
+void detail::OpAttributeList::set(Identifier name, Attribute value) {
+  assert(value && "attribute cannot be null");
+  auto it = lookupAttribute(name);
+  if (it.second) {
+    it.first->second = value;
+  } else {
+    // Need to perform a string lookup to do a sorted insert.
+    auto insertIt = lookupAttribute(name.strref());
+    assert(!insertIt.second);
+    attrs.insert(insertIt.first, {name, value});
+  }
+}
+
+void detail::OpAttributeList::addOrSet(Identifier name, Attribute value) {
+  assert(value && "attribute cannot be null");
+  // Go straight to string lookup.
+  auto it = lookupAttribute(name.strref());
+  if (LLVM_UNLIKELY(it.second)) {
+    it.first->second = value;
+  } else {
+    attrs.insert(it.first, {name, value});
+  }
+}
+
+void detail::OpAttributeList::setOrAdd(StringRef name, Attribute value) {
+  assert(value && "attribute cannot be null");
+  // Go straight to identifier lookup.
+  auto nameId = Identifier::get(name, value.getContext());
+  auto it = lookupAttribute(nameId);
+  if (LLVM_LIKELY(it.second)) {
+    it.first->second = value;
+  } else {
+    // Need to perform a string lookup to do a sorted insert.
+    auto insertIt = lookupAttribute(name);
+    assert(!insertIt.second);
+    attrs.insert(insertIt.first, {nameId, value});
+  }
+}
+
+void detail::OpAttributeList::assign(AttributeRange attributes) {
+  assert(llvm::none_of(attributes,
+                       [](NamedAttribute attr) { return !attr.second; }) &&
+         "cannot have null attributes");
+  // Re-using the existing storage may prevent a re-allocation.
+  attrs.assign(attributes.begin(), attributes.end());
+  if (!attributes.isSorted())
+    std::sort(attrs.begin(), attrs.end());
+}
+
+DictionaryAttr
+detail::OpAttributeList::convertToDictionary(MLIRContext *context) const {
+  return DictionaryAttr::getWithSorted(context, attrs);
+}
+
+//===----------------------------------------------------------------------===//
 // OperationState
 //===----------------------------------------------------------------------===//
 
 OperationState::OperationState(Location location, StringRef name)
     : location(location), name(name, location->getContext()) {}
 
 OperationState::OperationState(Location location, OperationName name)
     : location(location), name(name) {}
 
 OperationState::OperationState(Location location, StringRef name,
                                ValueRange operands, TypeRange types,
-                               ArrayRef<NamedAttribute> attributes,
-                               BlockRange successors,
+                               AttributeRange attributes, BlockRange successors,
                                MutableArrayRef<std::unique_ptr<Region>> regions)
     : location(location), name(name, location->getContext()),
       operands(operands.begin(), operands.end()),
       types(types.begin(), types.end()),
       attributes(attributes.begin(), attributes.end()),
       successors(successors.begin(), successors.end()) {
   for (std::unique_ptr<Region> &r : regions)
     this->regions.push_back(std::move(r));

 
 llvm::hash_code OperationEquivalence::computeHash(
     Operation *op, function_ref<llvm::hash_code(Value)> hashOperands,
     function_ref<llvm::hash_code(Value)> hashResults, Flags flags) {
   // Hash operations based upon their:
   //   - Operation Name
   //   - Attributes
   //   - Result Types
-  llvm::hash_code hash = llvm::hash_combine(
-      op->getName(), op->getAttrDictionary(), op->getResultTypes());
+  llvm::hash_code hash =
+      llvm::hash_combine(op->getName(), op->getAttrs(), op->getResultTypes());
 
   //   - Operands
   for (Value operand : op->getOperands())
     hash = llvm::hash_combine(hash, hashOperands(operand));
   //   - Operands
   for (Value result : op->getResults())
     hash = llvm::hash_combine(hash, hashResults(result));
   return hash;

 bool OperationEquivalence::isEquivalentTo(
     Operation *lhs, Operation *rhs,
     function_ref<LogicalResult(Value, Value)> mapOperands,
     function_ref<LogicalResult(Value, Value)> mapResults, Flags flags) {
   if (lhs == rhs)
     return true;
 
   // Compare the operation properties.
-  if (lhs->getName() != rhs->getName() ||
-      lhs->getAttrDictionary() != rhs->getAttrDictionary() ||
+  if (lhs->getName() != rhs->getName() || lhs->getAttrs() != rhs->getAttrs() ||
       lhs->getNumRegions() != rhs->getNumRegions() ||
       lhs->getNumSuccessors() != rhs->getNumSuccessors() ||
       lhs->getNumOperands() != rhs->getNumOperands() ||
       lhs->getNumResults() != rhs->getNumResults())
     return false;
   if (!(flags & IgnoreLocations) && lhs->getLoc() != rhs->getLoc())
     return false;
 

mlir/lib/IR/SymbolTable.cpp

LogicalResult detail::verifySymbol(Operation *op) {
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Symbol Use Lists
 //===----------------------------------------------------------------------===//
 
+/// Abstraction of an attribute container. An attribute container can be the
+/// operation itself, a dictionary attribute, or an array attribute.
+using AttrContainer = llvm::PointerUnion<Operation *, Attribute>;
+
 /// Walk all of the symbol references within the given operation, invoking the
 /// provided callback for each found use. The callbacks takes as arguments: the
 /// use of the symbol, and the nested access chain to the attribute within the
 /// operation dictionary. An access chain is a set of indices into nested
 /// container attributes. For example, a symbol use in an attribute dictionary
 /// that looks like the following:
 ///
 ///    {use = [{other_attr, @symbol}]}
 ///
 /// 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->getAttrDictionary();
-  if (attrDict.empty())
+  AttributeRange attrs = op->getAttrs();
+  if (attrs.empty())
     return WalkResult::advance();
 
   // A worklist of a container attribute and the current index into the held
-  // attribute list.
-  SmallVector<Attribute, 1> attrWorklist(1, attrDict);
+  // attribute list. The first container of attributes is always the operation
+  // itself.
+  SmallVector<AttrContainer, 1> attrWorklist(1, op);
   SmallVector<int, 1> curAccessChain(1, /*Value=*/-1);
 
   // Process the symbol references within the given nested attribute range.
   auto processAttrs = [&](int &index, auto attrRange) -> WalkResult {
     for (Attribute attr : llvm::drop_begin(attrRange, index)) {
       /// Check for a nested container attribute, these will also need to be
       /// walked.
       if (attr.isa<ArrayAttr, DictionaryAttr>()) {
auto processAttrs = [&](int &index, auto attrRange) -> WalkResult {
     // Pop this container attribute from the worklist.
     attrWorklist.pop_back();
     curAccessChain.pop_back();
     return WalkResult::advance();
   };
 
   WalkResult result = WalkResult::advance();
   do {
-    Attribute attr = attrWorklist.back();
+    AttrContainer container = attrWorklist.back();
     int &index = curAccessChain.back();
     ++index;
 
     // Process the given attribute, which is guaranteed to be a container.
-    if (auto dict = attr.dyn_cast<DictionaryAttr>())
-      result = processAttrs(index, make_second_range(dict.getValue()));
-    else
+    if (auto attr = container.dyn_cast<Attribute>()) {
+      if (auto dictAttr = attr.dyn_cast<DictionaryAttr>()) {
+        result =
+            processAttrs(index, llvm::make_second_range(dictAttr.getValue()));
+      } else {
         result = processAttrs(index, attr.cast<ArrayAttr>().getValue());
+      }
+    } else {
+      result = processAttrs(
+          index,
+          llvm::make_second_range(container.get<Operation *>()->getAttrs()));
+    }
   } while (!attrWorklist.empty() && !result.wasInterrupted());
   return result;
 }
 
 /// Walk all of the uses, for any symbol, that are nested within the given
 /// regions, invoking the provided callback for each. This does not traverse
 /// into any nested symbol tables.
 static Optional<WalkResult> walkSymbolUses(
bool SymbolTable::symbolKnownUseEmpty(Operation *symbol, Region *from) {
   return symbolKnownUseEmptyImpl(symbol, from);
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolTable::replaceAllSymbolUses
 
 /// Rebuild the given attribute container after replacing all references to a
 /// symbol with the updated attribute in 'accesses'.
-static Attribute rebuildAttrAfterRAUW(
-    Attribute container,
+static AttrContainer rebuildAttrAfterRAUW(
+    AttrContainer container,
     ArrayRef<std::pair<SmallVector<int, 1>, SymbolRefAttr>> accesses,
     unsigned depth) {
   // Given a range of Attributes, update the ones referred to by the given
   // access chains to point to the new symbol attribute.
   auto updateAttrs = [&](auto &&attrRange) {
     auto attrBegin = std::begin(attrRange);
     for (unsigned i = 0, e = accesses.size(); i != e;) {
       ArrayRef<int> access = accesses[i].first;
for (unsigned i = 0, e = accesses.size(); i != e;) {
       // Otherwise, this is a container. Collect all of the accesses for this
       // index and recurse. The recursion here is bounded by the size of the
       // largest access array.
       auto nestedAccesses = accesses.drop_front(i).take_while([&](auto &it) {
         ArrayRef<int> nextAccess = it.first;
         return nextAccess.size() > depth + 1 &&
                nextAccess[depth] == access[depth];
       });
-      attr = rebuildAttrAfterRAUW(attr, nestedAccesses, depth + 1);
+      AttrContainer result =
+          rebuildAttrAfterRAUW(attr, nestedAccesses, depth + 1);
+      assert(result.is<Attribute>() &&
+             "expected nested container to be an attribute");
+      attr = result.get<Attribute>();
 
       // Skip over all of the accesses that refer to the nested container.
       i += nestedAccesses.size();
     }
   };
 
-  if (auto dictAttr = container.dyn_cast<DictionaryAttr>()) {
+  if (auto attr = container.dyn_cast<Attribute>()) {
+    if (auto dictAttr = attr.dyn_cast<DictionaryAttr>()) {
       auto newAttrs = llvm::to_vector<4>(dictAttr.getValue());
       updateAttrs(make_second_range(newAttrs));
       return DictionaryAttr::get(dictAttr.getContext(), newAttrs);
     }
-  auto newAttrs = llvm::to_vector<4>(container.cast<ArrayAttr>().getValue());
+    auto newAttrs = llvm::to_vector<4>(attr.cast<ArrayAttr>().getValue());
     updateAttrs(newAttrs);
-  return ArrayAttr::get(container.getContext(), newAttrs);
+    return ArrayAttr::get(attr.getContext(), newAttrs);
+  }
+  auto *op = container.get<Operation *>();
+  auto opAttrs = llvm::to_vector<4>(op->getAttrs());
+  updateAttrs(make_second_range(opAttrs));
+  op->setAttrs(AttributeRange(opAttrs, /*sorted=*/true));
+  return op;
 }
 
 /// Generates a new symbol reference attribute with a new leaf reference.
 static SymbolRefAttr generateNewRefAttr(SymbolRefAttr oldAttr,
                                         FlatSymbolRefAttr newLeafAttr) {
   if (oldAttr.isa<FlatSymbolRefAttr>())
     return newLeafAttr;
   auto nestedRefs = llvm::to_vector<2>(oldAttr.getNestedReferences());
   nestedRefs.back() = newLeafAttr;
   return SymbolRefAttr::get(oldAttr.getRootReference(), nestedRefs);
 }
 
 /// The implementation of SymbolTable::replaceAllSymbolUses below.
 template <typename SymbolT, typename IRUnitT>
 static LogicalResult
 replaceAllSymbolUsesImpl(SymbolT symbol, StringAttr newSymbol, IRUnitT *limit) {
-  // A collection of operations along with their new attribute dictionary.
-  std::vector<std::pair<Operation *, DictionaryAttr>> updatedAttrDicts;
-
   // The current operation being processed.
   Operation *curOp = nullptr;
 
   // 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->getAttrDictionary();
-    auto newDict = rebuildAttrAfterRAUW(oldDict, accessChains, /*depth=*/0);
-    return newDict.cast<DictionaryAttr>();
+  auto updateOpAttrs = [&](Operation *op) {
+    rebuildAttrAfterRAUW(op, accessChains, /*depth=*/0);
   };
 
   // Generate a new attribute to replace the given attribute.
   FlatSymbolRefAttr newLeafAttr = FlatSymbolRefAttr::get(newSymbol);
   for (SymbolScope &scope : collectSymbolScopes(symbol, limit)) {
     SymbolRefAttr newAttr = generateNewRefAttr(scope.symbol, newLeafAttr);
     auto walkFn = [&](SymbolTable::SymbolUse symbolUse,
                       ArrayRef<int> accessChain) {
auto walkFn = [&](SymbolTable::SymbolUse symbolUse,
               SymbolRefAttr::get(useRef.getRootReference(), nestedRefs);
         }
       }
 
       // If there was a previous operation, generate a new attribute dict
       // for it. This means that we've finished processing the current
       // operation, so generate a new dictionary for it.
       if (curOp && symbolUse.getUser() != curOp) {
-        updatedAttrDicts.push_back({curOp, generateNewAttrDict()});
+        updateOpAttrs(curOp);
         accessChains.clear();
       }
 
       // Record this access.
       curOp = symbolUse.getUser();
       accessChains.push_back({llvm::to_vector<1>(accessChain), replacementRef});
       return WalkResult::advance();
     };
     if (!scope.walk(walkFn))
       return failure();
 
     // Check to see if we have a dangling op that needs to be processed.
     if (curOp) {
-      updatedAttrDicts.push_back({curOp, generateNewAttrDict()});
+      updateOpAttrs(curOp);
       curOp = nullptr;
     }
   }
 
-  // Update the attribute dictionaries as necessary.
-  for (auto &it : updatedAttrDicts)
-    it.first->setAttrs(it.second);
   return success();
 }
 
 /// Attempt to replace all uses of the given symbol 'oldSymbol' with the
 /// provided symbol 'newSymbol' that are nested within the given operation
 /// 'from'. This does not traverse into any nested symbol tables. If there are
 /// any unknown operations that may potentially be symbol tables, no uses are
 /// replaced and failure is returned.

mlir/lib/Interfaces/InferTypeOpInterface.cpp

ShapeAdaptor ValueShapeRange::getShape(int index) const {
   if (index < 0 || static_cast<size_t>(index) >= size())
     return nullptr;
   return getShape(operator[](index));
 }
 
 LogicalResult mlir::detail::inferReturnTensorTypes(
     function_ref<LogicalResult(
         MLIRContext *, Optional<Location> location, ValueShapeRange operands,
-        DictionaryAttr attributes, RegionRange regions,
+        AttributeRange attributes, RegionRange regions,
         SmallVectorImpl<ShapedTypeComponents> &retComponents)>
         componentTypeFn,
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   SmallVector<ShapedTypeComponents, 2> retComponents;
   if (failed(componentTypeFn(context, location, operands, attributes, regions,
                              retComponents)))
     return failure();
   for (auto shapeAndType : retComponents) {
     assert(shapeAndType.getAttribute() == nullptr && "attribute not supported");
     if (shapeAndType.hasRank())
       inferredReturnTypes.push_back(RankedTensorType::get(
           shapeAndType.getDims(), shapeAndType.getElementType()));
     else
       inferredReturnTypes.push_back(
           UnrankedTensorType::get(shapeAndType.getElementType()));
   }
   return success();
 }
 
 LogicalResult mlir::detail::verifyInferredResultTypes(Operation *op) {
   SmallVector<Type, 4> inferredReturnTypes;
   auto retTypeFn = cast<InferTypeOpInterface>(op);
-  if (failed(retTypeFn.inferReturnTypes(
-          op->getContext(), op->getLoc(), op->getOperands(),
-          op->getAttrDictionary(), op->getRegions(), inferredReturnTypes)))
+  if (failed(retTypeFn.inferReturnTypes(op->getContext(), op->getLoc(),
+                                        op->getOperands(), op->getAttrs(),
+                                        op->getRegions(), inferredReturnTypes)))
     return failure();
   if (!retTypeFn.isCompatibleReturnTypes(inferredReturnTypes,
                                          op->getResultTypes()))
     return op->emitOpError("inferred type(s) ")
            << inferredReturnTypes
            << " are incompatible with return type(s) of operation "
            << op->getResultTypes();
   return success();
 }

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->getAttrDictionary());
+      for (NamedAttribute attr : op->getAttrs()) {
+        addDataToHash(hasher, attr.first);
+        addDataToHash(hasher, attr.second);
+      }
       //   - 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/Rewrite/ByteCode.cpp

for (unsigned i = 0, e = read(); i != e; ++i) {
     }
 
     // Handle the case where the operation has inferred types.
     InferTypeOpInterface::Concept *concept =
         state.name.getAbstractOperation()->getInterface<InferTypeOpInterface>();
 
     // TODO: Handle failure.
     state.types.clear();
-    if (failed(concept->inferReturnTypes(
-            state.getContext(), state.location, state.operands,
-            state.attributes.getDictionary(state.getContext()), state.regions,
-            state.types)))
+    if (failed(concept->inferReturnTypes(state.getContext(), state.location,
+                                         state.operands, state.attributes,
+                                         state.regions, state.types)))
       return;
     break;
   }
 
   Operation *resultOp = rewriter.createOperation(state);
   memory[memIndex] = resultOp;
 
   LLVM_DEBUG({

mlir/lib/Transforms/SCCP.cpp

SmallVector<Attribute> constantOperands(
         llvm::map_range(operands, [](LatticeElement<SCCPLatticeValue> *value) {
           return value->getValue().constant;
         }));
 
     // 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());
-    DictionaryAttr originalAttrs = op->getAttrDictionary();
+    SmallVector<NamedAttribute> originalAttrs = op->getAttrs();
 
     // 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(constantOperands, foldResults)))
       return markAllPessimisticFixpoint(op->getResults());
 

mlir/lib/Transforms/Utils/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->getAttrDictionary()),
+      : op(op), loc(op->getLoc()), attrs(op->getAttrs()),
         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;
-  DictionaryAttr attrs;
+  SmallVector<NamedAttribute> attrs;
   SmallVector<Value, 8> operands;
   SmallVector<Block *, 2> successors;
 };
 
 //===----------------------------------------------------------------------===//
 // OpReplacement
 
 /// This class represents one requested operation replacement via 'replaceOp' or

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

static void printCustomDirectiveAttributes(OpAsmPrinter &printer, Operation *,
                                            Attribute attribute,
                                            Attribute optAttribute) {
   printer << attribute;
   if (optAttribute)
     printer << ", " << optAttribute;
 }
 
 static void printCustomDirectiveAttrDict(OpAsmPrinter &printer, Operation *op,
-                                         DictionaryAttr attrs) {
-  printer.printOptionalAttrDict(attrs.getValue());
+                                         AttributeRange attrs) {
+  printer.printOptionalAttrDict(attrs);
 }
 
 static void printCustomDirectiveOptionalOperandRef(OpAsmPrinter &printer,
                                                    Operation *op,
                                                    Value optOperand) {
   printer << (optOperand ? "1" : "0");
 }
 

 }
 
 OpFoldResult TestPassthroughFold::fold(ArrayRef<Attribute> operands) {
   return getOperand();
 }
 
 LogicalResult OpWithInferTypeInterfaceOp::inferReturnTypes(
     MLIRContext *, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType() != operands[1].getType()) {
     return emitOptionalError(location, "operand type mismatch ",
                              operands[0].getType(), " vs ",
                              operands[1].getType());
   }
   inferredReturnTypes.assign({operands[0].getType()});
   return success();
 }
 
 LogicalResult OpWithShapedTypeInferTypeInterfaceOp::inferReturnTypeComponents(
     MLIRContext *context, Optional<Location> location, ValueShapeRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   // Create return type consisting of the last element of the first operand.
   auto operandType = operands.front().getType();
   auto sval = operandType.dyn_cast<ShapedType>();
   if (!sval) {
     return emitOptionalError(location, "only shaped type operands allowed");
   }
   int64_t dim =

mlir/test/lib/Dialect/Test/TestOps.td

 
 def FormatInferTypeOp : TEST_Op<"format_infer_type", [InferTypeOpInterface]> {
   let results = (outs AnyType);
   let assemblyFormat = "attr-dict";
 
   let extraClassDeclaration = [{
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
           ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
-          ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+          ::mlir::AttributeRange attributes, ::mlir::RegionRange regions,
           ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
       inferredReturnTypes.assign({::mlir::IntegerType::get(context, 16)});
       return ::mlir::success();
     }
    }];
 }
 
 //===----------------------------------------------------------------------===//

 def TableGenBuildOp5 : TEST_Op<"tblgen_build_5",
       [SameOperandsAndResultType, InferTypeOpInterface]> {
   let arguments = (ins Variadic<AnyType>:$inputs);
   let results = (outs AnyType:$result);
 
   let extraClassDeclaration = [{
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *,
           ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
-          ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+          ::mlir::AttributeRange attributes, ::mlir::RegionRange regions,
           ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
       inferredReturnTypes.assign({operands[0].getType()});
       return ::mlir::success();
     }
    }];
 }
 
 //===----------------------------------------------------------------------===//

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

static void invokeCreateWithInferredReturnType(Operation *op) {
   b.setInsertionPointAfter(op);
 
   // Use permutations of 2 args as operands.
   assert(fop.getNumArguments() >= 2);
   for (int i = 0, e = fop.getNumArguments(); i < e; ++i) {
     for (int j = 0; j < e; ++j) {
       std::array<Value, 2> values = {{fop.getArgument(i), fop.getArgument(j)}};
       SmallVector<Type, 2> inferredReturnTypes;
-      if (succeeded(OpTy::inferReturnTypes(
-              context, llvm::None, values, op->getAttrDictionary(),
-              op->getRegions(), inferredReturnTypes))) {
+      if (succeeded(OpTy::inferReturnTypes(context, llvm::None, values,
+                                           op->getAttrs(), op->getRegions(),
+                                           inferredReturnTypes))) {
         OperationState state(location, OpTy::getOperationName());
         // TODO: Expand to regions.
         OpTy::build(b, state, values, op->getAttrs());
         (void)b.createOperation(state);
       }
     }
   }
 }

mlir/test/mlir-linalg-ods-gen/test-linalg-ods-yaml-gen.yaml

 
 #       ODS:  let arguments =
 #  ODS-NEXT:    Variadic<AnyType>:$inputs,
 #  ODS-NEXT:    Variadic<AnyShaped>:$outputs
 
 #       ODS:  let builders =
 #       ODS:  (ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
 #  ODS-NEXT:       "ValueRange":$outputs,
-#  ODS-NEXT:       CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
+#  ODS-NEXT:       CArg<"AttributeRange", "{}">:$attributes),
 
 #       ODS:    $_state.addOperands(inputs);
 #  ODS-NEXT:    $_state.addOperands(outputs);
 #  ODS-NEXT:    $_state.addTypes(resultTensorTypes);
 #  ODS-NEXT:    $_state.addAttributes(attributes);
 #  ODS-NEXT:    $_state.addAttribute(
 #  ODS-NEXT:      "operand_segment_sizes",
 #  ODS-NEXT:      $_builder.getI32VectorAttr({

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

let arguments = (ins
       SomeAttr:$aAttr,
       DefaultValuedAttr<SomeAttr, "4.2">:$bAttr,
       OptionalAttr<SomeAttr>:$cAttr
   );
 }
 
 // DECL-LABEL: AOp declarations
 
-// Test attribute name methods
+// Test attribute name and index methods
 // ---
 
 // DECL:      static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames()
 // DECL-NEXT:   static ::llvm::StringRef attrNames[] =
 // DECL-SAME:     {::llvm::StringRef("aAttr"), ::llvm::StringRef("bAttr"), ::llvm::StringRef("cAttr")};
 // DECL-NEXT:   return ::llvm::makeArrayRef(attrNames);
 
+// DECL:      unsigned aAttrAttrIndex()
+// DECL-NEXT:      return 0;
 // DECL:      ::mlir::Identifier aAttrAttrName()
-// DECL-NEXT:      return getAttributeNameForIndex(0);
+// DECL-NEXT:      return getAttributeNameForIndex(aAttrAttrIndex());
 // DECL:      ::mlir::Identifier aAttrAttrName(::mlir::OperationName name)
-// DECL-NEXT:      return getAttributeNameForIndex(name, 0);
+// DECL-NEXT:      return getAttributeNameForIndex(name, aAttrAttrIndex());
 
+// DECL:      unsigned bAttrAttrIndex()
+// DECL-NEXT:      return 1;
 // DECL:      ::mlir::Identifier bAttrAttrName()
-// DECL-NEXT:      return getAttributeNameForIndex(1);
+// DECL-NEXT:      return getAttributeNameForIndex(bAttrAttrIndex());
 // DECL:      ::mlir::Identifier bAttrAttrName(::mlir::OperationName name)
-// DECL-NEXT:      return getAttributeNameForIndex(name, 1);
+// DECL-NEXT:      return getAttributeNameForIndex(name, bAttrAttrIndex());
 
+// DECL:      unsigned cAttrAttrIndex()
+// DECL-NEXT:      return 2;
 // DECL:      ::mlir::Identifier cAttrAttrName()
-// DECL-NEXT:      return getAttributeNameForIndex(2);
+// DECL-NEXT:      return getAttributeNameForIndex(cAttrAttrIndex());
 // DECL:      ::mlir::Identifier cAttrAttrName(::mlir::OperationName name)
-// DECL-NEXT:      return getAttributeNameForIndex(name, 2);
+// DECL-NEXT:      return getAttributeNameForIndex(name, cAttrAttrIndex());
 
 // DEF-LABEL: AOp definitions
 
 // Test verify method
 // ---
 
 // DEF:      ::mlir::LogicalResult AOpAdaptor::verify
 // DEF:      auto tblgen_aAttr = odsAttrs.get("aAttr");
 // DEF-NEXT: if (!tblgen_aAttr) return emitError(loc, "'test.a_op' op ""requires attribute 'aAttr'");
 // DEF:        if (!((some-condition))) return emitError(loc, "'test.a_op' op ""attribute 'aAttr' failed to satisfy constraint: some attribute kind");
 // DEF:      auto tblgen_bAttr = odsAttrs.get("bAttr");
 // DEF-NEXT: if (tblgen_bAttr) {
 // DEF-NEXT:   if (!((some-condition))) return emitError(loc, "'test.a_op' op ""attribute 'bAttr' failed to satisfy constraint: some attribute kind");
 // DEF:      auto tblgen_cAttr = odsAttrs.get("cAttr");
 // DEF-NEXT: if (tblgen_cAttr) {
 // DEF-NEXT:   if (!((some-condition))) return emitError(loc, "'test.a_op' op ""attribute 'cAttr' failed to satisfy constraint: some attribute kind");
 
 // Test getter methods
 // ---
 
 // DEF:      some-attr-kind AOp::aAttrAttr()
-// DEF-NEXT:   (*this)->getAttr(aAttrAttrName()).template cast<some-attr-kind>()
+// DEF-NEXT:   (*this)->getIntrinsicAttribute(aAttrAttrIndex()).template cast<some-attr-kind>()
 // DEF:      some-return-type AOp::aAttr() {
 // DEF-NEXT:   auto attr = aAttrAttr()
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // DEF:      some-attr-kind AOp::bAttrAttr()
-// DEF-NEXT:   return (*this)->getAttr(bAttrAttrName()).template dyn_cast_or_null<some-attr-kind>()
+// DEF-NEXT:   return (*this)->getIntrinsicAttribute(bAttrAttrIndex()).template dyn_cast_or_null<some-attr-kind>()
 // DEF:      some-return-type AOp::bAttr() {
 // DEF-NEXT:   auto attr = bAttrAttr();
 // DEF-NEXT:   if (!attr)
 // DEF-NEXT:       return some-const-builder-call(::mlir::Builder((*this)->getContext()), 4.2).some-convert-from-storage();
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // DEF:      some-attr-kind AOp::cAttrAttr()
-// DEF-NEXT:   return (*this)->getAttr(cAttrAttrName()).template dyn_cast_or_null<some-attr-kind>()
+// DEF-NEXT:   return (*this)->getIntrinsicAttribute(cAttrAttrIndex()).template dyn_cast_or_null<some-attr-kind>()
 // DEF:      ::llvm::Optional<some-return-type> AOp::cAttr() {
 // DEF-NEXT:   auto attr = cAttrAttr()
 // DEF-NEXT:   return attr ? ::llvm::Optional<some-return-type>(attr.some-convert-from-storage()) : (::llvm::None);
 
 // Test setter methods
 // ---
 
 // DEF:      void AOp::aAttrAttr(some-attr-kind attr) {
-// DEF-NEXT:   (*this)->setAttr(aAttrAttrName(), attr);
+// DEF-NEXT:   (*this)->setIntrinsicAttribute(aAttrAttrIndex(), attr);
 // DEF:      void AOp::bAttrAttr(some-attr-kind attr) {
-// DEF-NEXT:   (*this)->setAttr(bAttrAttrName(), attr);
+// DEF-NEXT:   (*this)->setIntrinsicAttribute(bAttrAttrIndex(), attr);
 // DEF:      void AOp::cAttrAttr(some-attr-kind attr) {
-// DEF-NEXT:   (*this)->setAttr(cAttrAttrName(), attr);
+// DEF-NEXT:   (*this)->setIntrinsicAttribute(cAttrAttrIndex(), attr);
 
 // Test remove methods
 // ---
 
 // DEF: ::mlir::Attribute AOp::removeCAttrAttr() {
-// DEF-NEXT: return (*this)->removeAttr(cAttrAttrName());
+// DEF-NEXT: return (*this)->removeIntrinsicAttribute(cAttrAttrIndex());
 
 // Test build methods
 // ---
 
 // DEF:      void AOp::build(
 // DEF:        odsState.addAttribute(aAttrAttrName(odsState.name), aAttr);
 // DEF:        odsState.addAttribute(bAttrAttrName(odsState.name), bAttr);
 // DEF:        if (cAttr) {
 // DEF-NEXT:     odsState.addAttribute(cAttrAttrName(odsState.name), cAttr);
 
 // DEF:      void AOp::build(
 // DEF:        some-return-type aAttr, some-return-type bAttr, /*optional*/some-attr-kind cAttr
 // DEF:        odsState.addAttribute(aAttrAttrName(odsState.name), some-const-builder-call(odsBuilder, aAttr));
 
 // DEF:      void AOp::build(
-// DEF:        ::llvm::ArrayRef<::mlir::NamedAttribute> attributes
+// DEF:        ::mlir::AttributeRange attributes
 // DEF:      odsState.addAttributes(attributes);
 
 // Test the above but with prefix.
 
 def Test2_Dialect : Dialect {
   let name = "test2";
   let cppNamespace = "foobar2";
   let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;

 // Test attribute name methods
 // ---
 
 // DECL:      static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames()
 // DECL-NEXT:   static ::llvm::StringRef attrNames[] =
 // DECL-SAME:     {::llvm::StringRef("aAttr"), ::llvm::StringRef("bAttr"), ::llvm::StringRef("cAttr")};
 // DECL-NEXT:   return ::llvm::makeArrayRef(attrNames);
 
+// DECL:      unsigned getAAttrAttrIndex()
+// DECL-NEXT:      return 0;
 // DECL:      ::mlir::Identifier getAAttrAttrName()
-// DECL-NEXT:      return getAttributeNameForIndex(0);
+// DECL-NEXT:      return getAttributeNameForIndex(getAAttrAttrIndex());
 // DECL:      ::mlir::Identifier getAAttrAttrName(::mlir::OperationName name)
-// DECL-NEXT:      return getAttributeNameForIndex(name, 0);
+// DECL-NEXT:      return getAttributeNameForIndex(name, getAAttrAttrIndex());
 
+// DECL:      unsigned getBAttrAttrIndex()
+// DECL-NEXT:      return 1;
 // DECL:      ::mlir::Identifier getBAttrAttrName()
-// DECL-NEXT:      return getAttributeNameForIndex(1);
+// DECL-NEXT:      return getAttributeNameForIndex(getBAttrAttrIndex());
 // DECL:      ::mlir::Identifier getBAttrAttrName(::mlir::OperationName name)
-// DECL-NEXT:      return getAttributeNameForIndex(name, 1);
+// DECL-NEXT:      return getAttributeNameForIndex(name, getBAttrAttrIndex());
 
+// DECL:      unsigned getCAttrAttrIndex()
+// DECL-NEXT:      return 2;
 // DECL:      ::mlir::Identifier getCAttrAttrName()
-// DECL-NEXT:      return getAttributeNameForIndex(2);
+// DECL-NEXT:      return getAttributeNameForIndex(getCAttrAttrIndex());
 // DECL:      ::mlir::Identifier getCAttrAttrName(::mlir::OperationName name)
-// DECL-NEXT:      return getAttributeNameForIndex(name, 2);
+// DECL-NEXT:      return getAttributeNameForIndex(name, getCAttrAttrIndex());
 
 // DEF-LABEL: AgetOp definitions
 
 // Test verify method
 // ---
 
 // DEF:      ::mlir::LogicalResult AgetOpAdaptor::verify
 // DEF:      auto tblgen_aAttr = odsAttrs.get("aAttr");
 // DEF-NEXT: if (!tblgen_aAttr) return emitError(loc, "'test2.a_get_op' op ""requires attribute 'aAttr'");
 // DEF:        if (!((some-condition))) return emitError(loc, "'test2.a_get_op' op ""attribute 'aAttr' failed to satisfy constraint: some attribute kind");
 // DEF:      auto tblgen_bAttr = odsAttrs.get("bAttr");
 // DEF-NEXT: if (tblgen_bAttr) {
 // DEF-NEXT:   if (!((some-condition))) return emitError(loc, "'test2.a_get_op' op ""attribute 'bAttr' failed to satisfy constraint: some attribute kind");
 // DEF:      auto tblgen_cAttr = odsAttrs.get("cAttr");
 // DEF-NEXT: if (tblgen_cAttr) {
 // DEF-NEXT:   if (!((some-condition))) return emitError(loc, "'test2.a_get_op' op ""attribute 'cAttr' failed to satisfy constraint: some attribute kind");
 
 // Test getter methods
 // ---
 
 // DEF:      some-attr-kind AgetOp::getAAttrAttr()
-// DEF-NEXT:   (*this)->getAttr(getAAttrAttrName()).template cast<some-attr-kind>()
+// DEF-NEXT:   (*this)->getIntrinsicAttribute(getAAttrAttrIndex()).template cast<some-attr-kind>()
 // DEF:      some-return-type AgetOp::getAAttr() {
 // DEF-NEXT:   auto attr = getAAttrAttr()
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // DEF:      some-attr-kind AgetOp::getBAttrAttr()
-// DEF-NEXT:   return (*this)->getAttr(getBAttrAttrName()).template dyn_cast_or_null<some-attr-kind>()
+// DEF-NEXT:   return (*this)->getIntrinsicAttribute(getBAttrAttrIndex()).template dyn_cast_or_null<some-attr-kind>()
 // DEF:      some-return-type AgetOp::getBAttr() {
 // DEF-NEXT:   auto attr = getBAttrAttr();
 // DEF-NEXT:   if (!attr)
 // DEF-NEXT:       return some-const-builder-call(::mlir::Builder((*this)->getContext()), 4.2).some-convert-from-storage();
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // DEF:      some-attr-kind AgetOp::getCAttrAttr()
-// DEF-NEXT:   return (*this)->getAttr(getCAttrAttrName()).template dyn_cast_or_null<some-attr-kind>()
+// DEF-NEXT:   return (*this)->getIntrinsicAttribute(getCAttrAttrIndex()).template dyn_cast_or_null<some-attr-kind>()
 // DEF:      ::llvm::Optional<some-return-type> AgetOp::getCAttr() {
 // DEF-NEXT:   auto attr = getCAttrAttr()
 // DEF-NEXT:   return attr ? ::llvm::Optional<some-return-type>(attr.some-convert-from-storage()) : (::llvm::None);
 
 // Test setter methods
 // ---
 
 // DEF:      void AgetOp::setAAttrAttr(some-attr-kind attr) {
-// DEF-NEXT:   (*this)->setAttr(getAAttrAttrName(), attr);
+// DEF-NEXT:   (*this)->setIntrinsicAttribute(getAAttrAttrIndex(), attr);
 // DEF:      void AgetOp::setBAttrAttr(some-attr-kind attr) {
-// DEF-NEXT:   (*this)->setAttr(getBAttrAttrName(), attr);
+// DEF-NEXT:   (*this)->setIntrinsicAttribute(getBAttrAttrIndex(), attr);
 // DEF:      void AgetOp::setCAttrAttr(some-attr-kind attr) {
-// DEF-NEXT:   (*this)->setAttr(getCAttrAttrName(), attr);
+// DEF-NEXT:   (*this)->setIntrinsicAttribute(getCAttrAttrIndex(), attr);
 
 // Test remove methods
 // ---
 
 // DEF: ::mlir::Attribute AgetOp::removeCAttrAttr() {
-// DEF-NEXT: return (*this)->removeAttr(getCAttrAttrName());
+// DEF-NEXT: return (*this)->removeIntrinsicAttribute(getCAttrAttrIndex());
 
 // Test build methods
 // ---
 
 // DEF:      void AgetOp::build(
 // DEF:        odsState.addAttribute(getAAttrAttrName(odsState.name), aAttr);
 // DEF:        odsState.addAttribute(getBAttrAttrName(odsState.name), bAttr);
 // DEF:        if (cAttr) {
 // DEF-NEXT:     odsState.addAttribute(getCAttrAttrName(odsState.name), cAttr);
 
 // DEF:      void AgetOp::build(
 // DEF:        some-return-type aAttr, some-return-type bAttr, /*optional*/some-attr-kind cAttr
 // DEF:        odsState.addAttribute(getAAttrAttrName(odsState.name), some-const-builder-call(odsBuilder, aAttr));
 
 // DEF:      void AgetOp::build(
-// DEF:        ::llvm::ArrayRef<::mlir::NamedAttribute> attributes
+// DEF:        ::mlir::AttributeRange attributes
 // DEF:      odsState.addAttributes(attributes);
 
 def SomeTypeAttr : TypeAttrBase<"SomeType", "some type attribute">;
 
 def BOp : NS_Op<"b_op", []> {
   let arguments = (ins
     AnyAttr:$any_attr,
     BoolAttr:$bool_attr,
def UnitAttrOp : NS_Op<"unit_attr_op", []> {
   let arguments = (ins UnitAttr:$attr);
 }
 
 // DEF-LABEL: UnitAttrOp definitions
 // DEF: bool UnitAttrOp::attr() {
 // DEF:   return {{.*}} != nullptr
 
 // DEF: ::mlir::Attribute UnitAttrOp::removeAttrAttr() {
-// DEF-NEXT:   (*this)->removeAttr(attrAttrName());
+// DEF-NEXT:   (*this)->removeIntrinsicAttribute(attrAttrIndex());
 
 // DEF: build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::UnitAttr attr)
 
 
 // Test elementAttr field of TypedArrayAttr.
 // ---
 
 def SomeTypedArrayAttr : TypedArrayAttrBase<SomeAttr, "SomeAttr array">;

mlir/test/mlir-tblgen/op-decl-and-defs.td

let extraClassDeclaration = [{
     void displayGraph();
   }];
 }
 
 // CHECK-LABEL: NS::AOp declarations
 
 // CHECK: class AOpAdaptor {
 // CHECK: public:
-// CHECK:   AOpAdaptor(::mlir::ValueRange values
+// CHECK:   AOpAdaptor(::mlir::MLIRContext *mlirContext
 // CHECK:   ::mlir::ValueRange getODSOperands(unsigned index);
 // CHECK:   ::mlir::Value getA();
 // CHECK:   ::mlir::ValueRange getB();
 // CHECK:   ::mlir::IntegerAttr getAttr1();
 // CHECK:   ::mlir::FloatAttr getAttr2();
 // CHECK:   ::mlir::Region &getSomeRegion();
 // CHECK:   ::mlir::RegionRange getSomeRegions();
 // CHECK: private:

 // CHECK:   uint32_t getAttr1();
 // CHECK:   ::mlir::FloatAttr getAttr2Attr()
 // CHECK:   ::llvm::Optional< ::llvm::APFloat > getAttr2();
 // CHECK:   ::mlir::Attribute removeAttr2Attr();
 // CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value val);
 // CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, int integer = 0);
 // CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::TypeRange s, ::mlir::Value a, ::mlir::ValueRange b, ::mlir::IntegerAttr attr1, /*optional*/::mlir::FloatAttr attr2, unsigned someRegionsCount)
 // CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::TypeRange s, ::mlir::Value a, ::mlir::ValueRange b, uint32_t attr1, /*optional*/::mlir::FloatAttr attr2, unsigned someRegionsCount)
-// CHECK:   static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes, unsigned numRegions)
+// CHECK:   static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes, unsigned numRegions)
 // CHECK:   static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
 // CHECK:   void print(::mlir::OpAsmPrinter &p);
 // CHECK:   ::mlir::LogicalResult verify();
 // CHECK:   static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
 // CHECK:   ::mlir::LogicalResult fold(::llvm::ArrayRef<::mlir::Attribute> operands, ::llvm::SmallVectorImpl<::mlir::OpFoldResult> &results);
 // CHECK:   // Display a graph for debugging purposes.
 // CHECK:   void displayGraph();
 // CHECK: };
 
 // DEFS-LABEL: NS::AOp definitions
 
-// DEFS: AOpAdaptor::AOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions)
+// DEFS: AOpAdaptor::AOpAdaptor(::mlir::MLIRContext *mlirContext, ::mlir::ValueRange values, ::mlir::AttributeRange attrs, ::mlir::RegionRange regions) : odsContext(mlirContext), odsOperands(values), odsAttrs(attrs), odsRegions(regions)
 // DEFS: ::mlir::RegionRange AOpAdaptor::getRegions()
 // DEFS: ::mlir::RegionRange AOpAdaptor::getSomeRegions()
 // DEFS-NEXT: return odsRegions.drop_front(1);
 
 // Check AttrSizedOperandSegments
 // ---
 
 def NS_AttrSizedOperandOp : NS_Op<"attr_sized_operands",
                                  [AttrSizedOperandSegments]> {
   let arguments = (ins
     Variadic<I32>:$a,
     Variadic<I32>:$b,
     I32:$c,
     Variadic<I32>:$d,
     I32ElementsAttr:$operand_segment_sizes
   );
 }
 
 // CHECK-LABEL: AttrSizedOperandOpAdaptor(
+// CHECK-SAME:    ::mlir::MLIRContext *mlirContext
 // CHECK-SAME:    ::mlir::ValueRange values
-// CHECK-SAME:    ::mlir::DictionaryAttr attrs
+// CHECK-SAME:    ::mlir::AttributeRange attrs
 // CHECK:  ::mlir::ValueRange getA();
 // CHECK:  ::mlir::ValueRange getB();
 // CHECK:  ::mlir::Value getC();
 // CHECK:  ::mlir::ValueRange getD();
 // CHECK:  ::mlir::DenseIntElementsAttr getOperandSegmentSizes();
 
 // Check op trait for different number of operands
 // ---

 def NS_HCollectiveParamsOp : NS_Op<"op_collective_params", []> {
   let arguments = (ins AnyType:$a);
   let results = (outs AnyType:$b);
 }
 
 // CHECK_LABEL: class NS_HCollectiveParamsOp :
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type b, ::mlir::Value a);
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {})
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {})
 
 // Check suppression of "separate arg, separate result" build method for an op
 // with single variadic arg and single variadic result (since it will be
 // ambiguous with the collective params build method).
 def NS_HCollectiveParamsSuppress0Op : NS_Op<"op_collective_suppress0", []> {
   let arguments = (ins Variadic<I32>:$a);
   let results = (outs Variadic<I32>:$b);
 }
 
 // CHECK_LABEL: class NS_HCollectiveParamsSuppress0Op :
 // CHECK-NOT: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange b, ::mlir::ValueRange a);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
 
 // Check suppression of "separate arg, collective result" build method for an op
 // with single variadic arg and non variadic result (since it will be
 // ambiguous with the collective params build method).
 def NS_HCollectiveParamsSuppress1Op : NS_Op<"op_collective_suppress1", []> {
   let arguments = (ins Variadic<I32>:$a);
   let results = (outs I32:$b);
 }
 
 // CHECK_LABEL: class NS_HCollectiveParamsSuppress1Op :
 // CHECK-NOT: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange b, ::mlir::ValueRange a);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
 
 // Check suppression of "separate arg, collective result" build method for an op
 // with single variadic arg and > 1 variadic result (since it will be
 // ambiguous with the collective params build method). Note that "separate arg,
 // separate result" build method should be generated in this case as its not
 // ambiguous with the collective params build method.
 def NS_HCollectiveParamsSuppress2Op : NS_Op<"op_collective_suppress2", [SameVariadicResultSize]> {
   let arguments = (ins Variadic<I32>:$a);
   let results = (outs Variadic<I32>:$b, Variadic<F32>:$c);
 }
 // CHECK_LABEL: class NS_HCollectiveParamsSuppress2Op :
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange b, ::mlir::TypeRange c, ::mlir::ValueRange a);
 // CHECK-NOT: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange b, ::mlir::ValueRange a);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
 
 // Check default value of `attributes` for the `genUseOperandAsResultTypeCollectiveParamBuilder` builder
 def NS_IOp : NS_Op<"op_with_same_operands_and_result_types_trait", [SameOperandsAndResultType]> {
   let arguments = (ins AnyType:$a, AnyType:$b);
   let results = (outs AnyType:$r);
 }
 // CHECK_LABEL: class NS_IOp :
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::Value a, ::mlir::Value b);
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
-// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
 
 // Check default value of `attributes` for the `genInferredTypeCollectiveParamBuilder` builder
 def NS_JOp : NS_Op<"op_with_InferTypeOpInterface_interface", [DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let arguments = (ins AnyType:$a, AnyType:$b);
   let results = (outs AnyType:$r);
 }
 // CHECK_LABEL: class NS_JOp :
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::Value a, ::mlir::Value b);
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
-// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
 
 // Test usage of OpTraitList getting flattened during emission.
 def NS_KOp : NS_Op<"k_op", [IsolatedFromAbove,
     OpTraitList<[DeclareOpInterfaceMethods<InferTypeOpInterface>]>]> {
   let arguments = (ins AnyType:$a, AnyType:$b);
 }
 
 // CHECK: class KOp : public ::mlir::Op<KOp,

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: void OpD::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes)
 // CHECK: odsState.addTypes({attr.second.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: void OpE::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes)
 // CHECK: odsState.addTypes({attr.second.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

 // Test that if the only operand is variadic, we access the first value in the
 // pack to set result type
 // ---
 def OpK : NS_Op<"only_input_is_variadic_with_same_value_type_op", [SameOperandsAndResultType]> {
   let arguments = (ins Variadic<AnyTensor>:$input);
   let results = (outs AnyTensor:$result);
 }
 
-// CHECK-LABEL: OpK::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes)
+// CHECK-LABEL: OpK::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes)
 // CHECK: odsState.addTypes({operands[0].getType()});
 
 // Test with inferred shapes and interleaved with operands/attributes.
 //
 def OpL1 : NS_Op<"op_with_all_types_constraint",
     [AllTypesMatch<["a", "b"]>]> {
   let arguments = (ins I32Attr:$attr1, AnyType:$a);
   let results = (outs Res<AnyType, "output b", []>:$b);

mlir/test/python/python_test_ops.td

 
 def InferResultsOp : TestOp<"infer_results_op", [InferTypeOpInterface]> {
   let arguments = (ins);
   let results = (outs AnyInteger:$single, AnyInteger:$doubled);
 
   let extraClassDeclaration = [{
     static ::mlir::LogicalResult inferReturnTypes(
       ::mlir::MLIRContext *context, ::llvm::Optional<::mlir::Location> location,
-      ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes,
+      ::mlir::ValueRange operands, ::mlir::AttributeRange attributes,
       ::mlir::RegionRange regions,
       ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
       ::mlir::Builder b(context);
       inferredReturnTypes.push_back(b.getI32Type());
       inferredReturnTypes.push_back(b.getI64Type());
       return ::mlir::success();
     }
   }];

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp

/*extraInterfaces=*/[{2}])> {
     );
     let results = (outs Variadic<AnyRankedTensor>:$result_tensors);
     let regions = (region AnyRegion:$region);
 
     let skipDefaultBuilders = 1;
     let builders = [
       OpBuilder<
       (ins "ValueRange":$inputs, "ValueRange":$outputs,
-            CArg<"ArrayRef<NamedAttribute>", "{{}">:$attributes),
+            CArg<"AttributeRange", "{{}">:$attributes),
       [{{
         $_state.addOperands(inputs);
         $_state.addOperands(outputs);
         SmallVector<Type> resultTensorTypes;
         copy_if(outputs.getTypes(),
                 std::back_inserter(resultTensorTypes),
                 [](Type type) {{ return type.isa<RankedTensorType>(); });
         $_state.addTypes(resultTensorTypes);
         $_state.addAttribute(
           "operand_segment_sizes",
           $_builder.getI32VectorAttr({{
             static_cast<int32_t>(inputs.size()),
             static_cast<int32_t>(outputs.size())}));
         $_state.addAttributes(attributes);
         createAndFillStructuredOpRegion<{0}>(
           $_builder,
           $_state,
           TypeRange(inputs),
           TypeRange(outputs));
       }]>,
       OpBuilder<
       (ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
             "ValueRange":$outputs,
-            CArg<"ArrayRef<NamedAttribute>", "{{}">:$attributes),
+            CArg<"AttributeRange", "{{}">:$attributes),
       [{{
         $_state.addOperands(inputs);
         $_state.addOperands(outputs);
         $_state.addTypes(resultTensorTypes);
         $_state.addAttributes(attributes);
         $_state.addAttribute(
           "operand_segment_sizes",
           $_builder.getI32VectorAttr({{
             static_cast<int32_t>(inputs.size()),
             static_cast<int32_t>(outputs.size())}));
         createAndFillStructuredOpRegion<{0}>(
           $_builder,
           $_state,
           TypeRange(inputs),
           TypeRange(outputs));
       }]>,
       OpBuilder<
       (ins "TypeRange":$resultTensorTypes, "ValueRange":$operands,
-            CArg<"ArrayRef<NamedAttribute>", "{{}">:$attributes),
+            CArg<"AttributeRange", "{{}">:$attributes),
       [{{
         $_state.addOperands(operands);
         $_state.addAttributes(attributes);
         $_state.addTypes(resultTensorTypes);
         (void)$_state.addRegion();
       }]>
       {5}
     ];

 // Builder method taking attribute parameters. Parameters:
 // {0}: Class name
 // {1}: Comma interleaved attribute parameters
 // {2}: Attribute initialization
 static const char structuredOpBuilderFormat[] = R"FMT(
   , OpBuilder<
   (ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
        "ValueRange":$outputs, {1},
-       CArg<"ArrayRef<NamedAttribute>", "{{}">:$attributes),
+       CArg<"AttributeRange", "{{}">:$attributes),
   [{{
     $_state.addOperands(inputs);
     $_state.addOperands(outputs);
     $_state.addTypes(resultTensorTypes);
     $_state.addAttribute(
       "operand_segment_sizes",
       $_builder.getI32VectorAttr({{
         static_cast<int32_t>(inputs.size()),

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 
 // The logic to calculate the actual value range for a declared operand/result
 // of an op with variadic operands/results. Note that this logic is assumes
 // the op has an attribute specifying the size of each operand/result segment
 // (variadic or not).
 //
 // {0}: The name of the attribute specifying the segment sizes.
 const char *adapterSegmentSizeAttrInitCode = R"(
-  assert(odsAttrs && "missing segment size attribute for op");
+  assert(!odsAttrs.empty() && "missing segment size attribute for op");
   auto sizeAttr = odsAttrs.get("{0}").cast<::mlir::DenseIntElementsAttr>();
 )";
 const char *opSegmentSizeAttrInitCode = R"(
-  auto sizeAttr = (*this)->getAttr({0}).cast<::mlir::DenseIntElementsAttr>();
+  auto sizeAttr = (*this)->getIntrinsicAttribute({0}).cast<::mlir::DenseIntElementsAttr>();
 )";
 const char *attrSizedSegmentValueRangeCalcCode = R"(
   const uint32_t *sizeAttrValueIt = &*sizeAttr.value_begin<uint32_t>();
   if (sizeAttr.isSplat())
     return {*sizeAttrValueIt * index, *sizeAttrValueIt};
 
   unsigned start = 0;
   for (unsigned i = 0; i < index; ++i)
PrintFatalError(op.getLoc(), "Unexpected overlap when generating `" +
                                    op.getOperationName() + " (from line " +
                                    Twine(line) + ")");
 }
 #define ERROR_IF_PRUNED(M, N, O) errorIfPruned(__LINE__, M, N, O)
 
 void OpEmitter::genAttrNameGetters() {
   // A map of attribute names (including implicit attributes) registered to the
   // current operation, to the relative order in which they were registered.
-  llvm::MapVector<StringRef, unsigned> attributeNames;
+  llvm::StringSet<> attrNameSet;
 
   // Enumerate the attribute names of this op, assigning each a relative
   // ordering.
-  auto addAttrName = [&](StringRef name) {
-    unsigned index = attributeNames.size();
-    attributeNames.insert({name, index});
-  };
   for (const NamedAttribute &namedAttr : op.getAttributes())
-    addAttrName(namedAttr.name);
+    attrNameSet.insert(namedAttr.name);
   // Include key attributes from several traits as implicitly registered.
   std::string operandSizes = "operand_segment_sizes";
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments"))
-    addAttrName(operandSizes);
+    attrNameSet.insert(operandSizes);
   std::string attrSizes = "result_segment_sizes";
   if (op.getTrait("::mlir::OpTrait::AttrSizedResultSegments"))
-    addAttrName(attrSizes);
+    attrNameSet.insert(attrSizes);
+
+  /// Sort intrinsic attribute names alphabetically.
+  SmallVector<StringRef> attributeNames;
+  for (auto &it : attrNameSet)
+    attributeNames.push_back(it.first());
+  llvm::array_pod_sort(attributeNames.begin(), attributeNames.end());
 
   // Emit the getAttributeNames method.
   {
     auto *method = opClass.addMethodAndPrune(
         "::llvm::ArrayRef<::llvm::StringRef>", "getAttributeNames",
         OpMethod::Property(OpMethod::MP_Static | OpMethod::MP_Inline));
     ERROR_IF_PRUNED(method, "getAttributeNames", op);
     auto &body = method->body();
     if (attributeNames.empty()) {
       body << "  return {};";
     } else {
       body << "  static ::llvm::StringRef attrNames[] = {";
-      llvm::interleaveComma(llvm::make_first_range(attributeNames), body,
-                            [&](StringRef attrName) {
-                              body << "::llvm::StringRef(\"" << attrName
-                                   << "\")";
-                            });
+      llvm::interleaveComma(attributeNames, body, [&](StringRef attrName) {
+        body << "::llvm::StringRef(\"" << attrName << "\")";
       body << "};\n  return ::llvm::makeArrayRef(attrNames);";
     }
   }
   if (attributeNames.empty())
     return;
 
   // Emit the getAttributeNameForIndex methods.
   {
// Emit the getAttributeNameForIndex methods.
     ERROR_IF_PRUNED(method, "getAttributeNameForIndex", op);
     method->body() << "assert(index < " << attributeNames.size()
                    << " && \"invalid attribute index\");\n"
                       "  return name.getAbstractOperation()"
                       "->getAttributeNames()[index];";
   }
 
   // Generate the <attr>AttrName methods, that expose the attribute names to
-  // users.
-  const char *attrNameMethodBody = "  return getAttributeNameForIndex({0});";
-  for (const std::pair<StringRef, unsigned> &attrIt : attributeNames) {
-    for (StringRef name : op.getGetterNames(attrIt.first)) {
-      std::string methodName = (name + "AttrName").str();
+  // users, and the <attr>AttrIndex methods, that return the index of the
+  // attribute in the op's intrinsic attributes list.
+  const char *attrNameMethodBody = "  return getAttributeNameForIndex({0}());";
+  for (auto it : llvm::enumerate(attributeNames)) {
+    for (StringRef name : op.getGetterNames(it.value())) {
+      std::string nameGetter = (name + "AttrName").str();
+      std::string indexGetter = (name + "AttrIndex").str();
+
+      // Generate the index getter.
+      {
+        auto *method = opClass.addMethodAndPrune(
+            "unsigned", indexGetter,
+            OpMethod::Property(OpMethod::MP_Static | OpMethod::MP_Inline));
+        ERROR_IF_PRUNED(method, indexGetter, op);
+        method->body() << llvm::formatv(" return {0};", it.index());
+      }
 
-      // Generate the non-static variant.
+      // Generate the non-static name getter.
       {
         auto *method =
-            opClass.addMethodAndPrune("::mlir::Identifier", methodName,
+            opClass.addMethodAndPrune("::mlir::Identifier", nameGetter,
                                       OpMethod::Property(OpMethod::MP_Inline));
-        ERROR_IF_PRUNED(method, methodName, op);
-        method->body()
-            << llvm::formatv(attrNameMethodBody, attrIt.second).str();
+        ERROR_IF_PRUNED(method, nameGetter, op);
+        method->body() << llvm::formatv(attrNameMethodBody, indexGetter).str();
       }
 
-      // Generate the static variant.
+      // Generate the static name getter.
       {
         auto *method = opClass.addMethodAndPrune(
-            "::mlir::Identifier", methodName,
+            "::mlir::Identifier", nameGetter,
             OpMethod::Property(OpMethod::MP_Inline | OpMethod::MP_Static),
             "::mlir::OperationName", "name");
-        ERROR_IF_PRUNED(method, methodName, op);
-        method->body() << llvm::formatv(attrNameMethodBody,
-                                        "name, " + Twine(attrIt.second))
-                              .str();
-      }
-    }
-  }
+        ERROR_IF_PRUNED(method, nameGetter, op);
+        method->body()
+            << llvm::formatv(attrNameMethodBody, "name, " + indexGetter).str();
+      }
+
+/// Code to set the value of a materialized default-valued attribute.
+///
+/// {0}: Code snippet that constructs the attribute's default value.
+/// {1}: Attribute name.
+static const char *const getAttrDefaultValue = R"(
+  if (!attr) {
+    attr = {0};
+    (*this)->setIntrinsicAttribute({1}AttrIndex(), attr);
   }
+)";
 
 void OpEmitter::genAttrGetters() {
   FmtContext fctx;
   fctx.withBuilder("::mlir::Builder((*this)->getContext())");
 
   // Emit the derived attribute body.
   auto emitDerivedAttr = [&](StringRef name, Attribute attr) {
     if (auto *method = opClass.addMethodAndPrune(attr.getReturnType(), name))
       method->body() << "  " << attr.getDerivedCodeBody() << "\n";
   };
 
   // Emit with return type specified.
   auto emitAttrWithReturnType = [&](StringRef name, Attribute attr) {
     auto *method = opClass.addMethodAndPrune(attr.getReturnType(), name);
     ERROR_IF_PRUNED(method, name, op);
     auto &body = method->body();
     body << "  auto attr = " << name << "Attr();\n";
     if (attr.hasDefaultValue()) {
-      // Returns the default value if not set.
-      // TODO: this is inefficient, we are recreating the attribute for every
-      // call. This should be set instead.
-      std::string defaultValue = std::string(
-          tgfmt(attr.getConstBuilderTemplate(), &fctx, attr.getDefaultValue()));
-      body << "    if (!attr)\n      return "
-           << tgfmt(attr.getConvertFromStorageCall(),
-                    &fctx.withSelf(defaultValue))
-           << ";\n";
+      // Construct the default value, and store it in the op.
+      body << formatv(
+          getAttrDefaultValue,
+          tgfmt(attr.getConstBuilderTemplate(), &fctx, attr.getDefaultValue()),
+          name);
     }
     body << "  return "
          << tgfmt(attr.getConvertFromStorageCall(), &fctx.withSelf("attr"))
          << ";\n";
   };
 
   // Generate named accessor with Attribute return type. This is a wrapper class
   // that allows referring to the attributes via accessors instead of having to
   // use the string interface for better compile time verification.
   auto emitAttrWithStorageType = [&](StringRef name, Attribute attr) {
     auto *method =
         opClass.addMethodAndPrune(attr.getStorageType(), (name + "Attr").str());
     if (!method)
       return;
     auto &body = method->body();
-    body << "  return (*this)->getAttr(" << name << "AttrName()).template ";
+    body << "  return (*this)->getIntrinsicAttribute(" << name
+         << "AttrIndex()).template ";
     if (attr.isOptional() || attr.hasDefaultValue())
       body << "dyn_cast_or_null<";
     else
       body << "cast<";
     body << attr.getStorageType() << ">();";
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes()) {
void OpEmitter::genAttrSetters() {
   // Generate raw named setter type. This is a wrapper class that allows setting
   // to the attributes via setters instead of having to use the string interface
   // for better compile time verification.
   auto emitAttrWithStorageType = [&](StringRef setterName, StringRef getterName,
                                      Attribute attr) {
     auto *method = opClass.addMethodAndPrune(
         "void", (setterName + "Attr").str(), attr.getStorageType(), "attr");
     if (method)
-      method->body() << "  (*this)->setAttr(" << getterName
-                     << "AttrName(), attr);";
+      method->body() << "  (*this)->setIntrinsicAttribute(" << getterName
+                     << "AttrIndex(), attr);";
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes()) {
     if (!namedAttr.attr.isDerivedAttr())
       for (auto names : llvm::zip(op.getSetterNames(namedAttr.name),
                                   op.getGetterNames(namedAttr.name)))
         emitAttrWithStorageType(std::get<0>(names), std::get<1>(names),
                                 namedAttr.attr);
   }
 }
 
 void OpEmitter::genOptionalAttrRemovers() {
   // Generate methods for removing optional attributes, instead of having to
   // use the string interface. Enables better compile time verification.
   auto emitRemoveAttr = [&](StringRef name) {
     auto upperInitial = name.take_front().upper();
     auto suffix = name.drop_front();
     auto *method = opClass.addMethodAndPrune(
         "::mlir::Attribute", ("remove" + upperInitial + suffix + "Attr").str());
     if (!method)
       return;
-    method->body() << "  return (*this)->removeAttr(" << op.getGetterName(name)
-                   << "AttrName());";
+    method->body() << "  return (*this)->removeIntrinsicAttribute("
+                   << op.getGetterName(name) << "AttrIndex());";
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes())
     if (namedAttr.attr.isOptional())
       emitRemoveAttr(namedAttr.name);
 }
 
 // Generates the code to compute the start and end index of an operand or result
static void generateNamedOperandGetters(const Operator &op, Class &opClass,
   }
 }
 
 void OpEmitter::genNamedOperandGetters() {
   // Build the code snippet used for initializing the operand_segment_size)s
   // array.
   std::string attrSizeInitCode;
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
-    std::string attr = op.getGetterName("operand_segment_sizes") + "AttrName()";
+    std::string attr =
+        op.getGetterName("operand_segment_sizes") + "AttrIndex()";
     attrSizeInitCode = formatv(opSegmentSizeAttrInitCode, attr).str();
   }
 
   generateNamedOperandGetters(
       op, opClass,
       /*isAdaptor=*/false,
       /*sizeAttrInit=*/attrSizeInitCode,
       /*rangeType=*/"::mlir::Operation::operand_range",
for (StringRef name : op.getGetterNames(operand.name)) {
       ERROR_IF_PRUNED(m, name, op);
       auto &body = m->body();
       body << "  auto range = getODSOperandIndexAndLength(" << i << ");\n"
            << "  auto mutableRange = "
               "::mlir::MutableOperandRange(getOperation(), "
               "range.first, range.second";
       if (attrSizedOperands)
         body << ", ::mlir::MutableOperandRange::OperandSegment(" << i
-             << "u, *getOperation()->getAttrDictionary().getNamed("
-             << op.getGetterName("operand_segment_sizes") << "AttrName()))";
+             << "u, getOperation()->getIntrinsicNamedAttribute("
+             << op.getGetterName("operand_segment_sizes") << "AttrIndex()))";
       body << ");\n";
 
       // If this operand is a nested variadic, we split the range into a
       // MutableOperandRangeRange that provides a range over all of the
       // sub-ranges.
       if (operand.isVariadicOfVariadic()) {
         //
         body << "  return "
-                "mutableRange.split(*(*this)->getAttrDictionary().getNamed("
+                "mutableRange.split((*this)->getIntrinsicNamedAttribute("
              << op.getGetterName(
                     operand.constraint.getVariadicOfVariadicSegmentSizeAttr())
-             << "AttrName()));\n";
+             << "AttrIndex()));\n";
       } else {
         // Otherwise, we use the full range directly.
         body << "  return mutableRange;\n";
       }
     }
   }
 }
 
if (attrSizedResults && sameVariadicSize) {
     PrintFatalError(op.getLoc(),
                     "op cannot have both 'AttrSizedResultSegments' and "
                     "'SameVariadicResultSize' traits");
   }
 
   // Build the initializer string for the result segment size attribute.
   std::string attrSizeInitCode;
   if (attrSizedResults) {
-    std::string attr = op.getGetterName("result_segment_sizes") + "AttrName()";
+    std::string attr = op.getGetterName("result_segment_sizes") + "AttrIndex()";
     attrSizeInitCode = formatv(opSegmentSizeAttrInitCode, attr).str();
   }
 
   generateValueRangeStartAndEnd(
       opClass, "getODSResultIndexAndLength", numVariadicResults,
       numNormalResults, "getOperation()->getNumResults()", attrSizedResults,
       attrSizeInitCode, op.getResults());
 
if (inferType) {
       // Generate builder that infers type too.
       // TODO: Subsume this with general checking if type can be
       // inferred automatically.
       // TODO: Expand to handle regions.
       body << formatv(R"(
         ::llvm::SmallVector<::mlir::Type, 2> inferredReturnTypes;
         if (::mlir::succeeded({0}::inferReturnTypes(odsBuilder.getContext(),
                       {1}.location, {1}.operands,
-                      {1}.attributes.getDictionary({1}.getContext()),
-                      /*regions=*/{{}, inferredReturnTypes)))
+                      {1}.attributes, /*regions=*/{{}, inferredReturnTypes)))
           {1}.addTypes(inferredReturnTypes);
         else
           ::llvm::report_fatal_error("Failed to infer result type(s).");)",
                       opClass.getClassName(), builderOpState);
       return;
     }
 
     switch (paramKind) {
void OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {
 
   // Signature
   llvm::SmallVector<OpMethodParameter, 4> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "odsBuilder");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::ValueRange", "operands");
   // Provide default value for `attributes` when its the last parameter
   StringRef attributesDefaultValue = op.getNumVariadicRegions() ? "" : "{}";
-  paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
-                         "attributes", attributesDefaultValue);
+  paramList.emplace_back("::mlir::AttributeRange", "attributes",
+                         attributesDefaultValue);
   if (op.getNumVariadicRegions())
     paramList.emplace_back("unsigned", "numRegions");
 
   auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
                                       std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;

 }
 
 void OpEmitter::genInferredTypeCollectiveParamBuilder() {
   // TODO: Expand to support regions.
   SmallVector<OpMethodParameter, 4> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "odsBuilder");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::ValueRange", "operands");
-  paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
-                         "attributes", "{}");
+  paramList.emplace_back("::mlir::AttributeRange", "attributes", "{}");
   auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
                                       std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;
   auto &body = m->body();
 
   int numResults = op.getNumResults();
if (int numRegions = op.getNumRegions()) {
     body << "    (void)" << builderOpState << ".addRegion();\n";
   }
 
   // Result types
   body << formatv(R"(
     ::mlir::SmallVector<::mlir::Type, 2> inferredReturnTypes;
     if (::mlir::succeeded({0}::inferReturnTypes(odsBuilder.getContext(),
                   {1}.location, operands,
-                  {1}.attributes.getDictionary({1}.getContext()),
-                  /*regions=*/{{}, inferredReturnTypes))) {{)",
+                  {1}.attributes, /*regions=*/{{}, inferredReturnTypes))) {{)",
                   opClass.getClassName(), builderOpState);
   if (numVariadicResults == 0 || numNonVariadicResults != 0)
     body << "  assert(inferredReturnTypes.size()"
          << (numVariadicResults != 0 ? " >= " : " == ") << numNonVariadicResults
          << "u && \"mismatched number of return types\");\n";
   body << "      " << builderOpState << ".addTypes(inferredReturnTypes);";
 
   body << formatv(R"(
void OpEmitter::genUseOperandAsResultTypeSeparateParamBuilder() {
   body << "});\n\n";
 }
 
 void OpEmitter::genUseAttrAsResultTypeBuilder() {
   SmallVector<OpMethodParameter, 4> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "odsBuilder");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::ValueRange", "operands");
-  paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
-                         "attributes", "{}");
+  paramList.emplace_back("::mlir::AttributeRange", "attributes", "{}");
   auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
                                       std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;
 
   auto &body = m->body();
 
void OpEmitter::genCollectiveParamBuilder() {
 
   SmallVector<OpMethodParameter, 4> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::TypeRange", "resultTypes");
   paramList.emplace_back("::mlir::ValueRange", "operands");
   // Provide default value for `attributes` when its the last parameter
   StringRef attributesDefaultValue = op.getNumVariadicRegions() ? "" : "{}";
-  paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
-                         "attributes", attributesDefaultValue);
+  paramList.emplace_back("::mlir::AttributeRange", "attributes",
+                         attributesDefaultValue);
   if (op.getNumVariadicRegions())
     paramList.emplace_back("unsigned", "numRegions");
 
   auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
                                       std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;
private:
   // which verifies all the op-independent attribute constraints.
   void addVerification();
 
   const Operator &op;
   Class adaptor;
 };
 } // end namespace
 
+/// Code template to get an attribute in an OpAdaptor.
+///
+/// {0}: Attribute storage type.
+/// {1}: Attribute name.
+/// {2}: `cast` for required attributes, `dyn_cast_or_null` for optional or
+///      default-valued attributes.
+static const char *const opAdaptorGetAttr = R"(
+  {0} attr = odsAttrs.get("{1}").{2}<{0}>();
+)";
+
+/// Code template to materialize an attribute's default value in an OpAdaptor,
+/// if a value for the attribute was not found.
+///
+/// TODO: This is inefficient because default values are materialized each call.
+///       However, OpAdaptor is an immutable view on an Operation-like.
+///
+/// {0}: Code snippet to construct the attribute's default value;
+static const char *const opAdaptorConstructDefaultAttr = R"(
+  if (!attr)
+    attr = {0};
+)";
+
 OpOperandAdaptorEmitter::OpOperandAdaptorEmitter(const Operator &op)
     : op(op), adaptor(op.getAdaptorName()) {
+  adaptor.newField("::mlir::MLIRContext *", "odsContext");
   adaptor.newField("::mlir::ValueRange", "odsOperands");
-  adaptor.newField("::mlir::DictionaryAttr", "odsAttrs");
+  adaptor.newField("::mlir::AttributeRange", "odsAttrs");
   adaptor.newField("::mlir::RegionRange", "odsRegions");
   const auto *attrSizedOperands =
       op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
   {
     SmallVector<OpMethodParameter, 2> paramList;
+    paramList.emplace_back("::mlir::MLIRContext *", "mlirContext");
     paramList.emplace_back("::mlir::ValueRange", "values");
-    paramList.emplace_back("::mlir::DictionaryAttr", "attrs",
-                           attrSizedOperands ? "" : "nullptr");
+    paramList.emplace_back("::mlir::AttributeRange", "attrs",
+                           attrSizedOperands ? "" : "{}");
     paramList.emplace_back("::mlir::RegionRange", "regions", "{}");
     auto *constructor = adaptor.addConstructorAndPrune(std::move(paramList));
 
+    constructor->addMemberInitializer("odsContext", "mlirContext");
     constructor->addMemberInitializer("odsOperands", "values");
     constructor->addMemberInitializer("odsAttrs", "attrs");
     constructor->addMemberInitializer("odsRegions", "regions");
   }
 
   {
     auto *constructor = adaptor.addConstructorAndPrune(
         llvm::formatv("{0}&", op.getCppClassName()).str(), "op");
+    constructor->addMemberInitializer("odsContext", "op->getContext()");
     constructor->addMemberInitializer("odsOperands", "op->getOperands()");
-    constructor->addMemberInitializer("odsAttrs", "op->getAttrDictionary()");
+    constructor->addMemberInitializer("odsAttrs", "op->getAttrs()");
     constructor->addMemberInitializer("odsRegions", "op->getRegions()");
   }
 
   {
     auto *m = adaptor.addMethodAndPrune("::mlir::ValueRange", "getOperands");
     ERROR_IF_PRUNED(m, "getOperands", op);
     m->body() << "  return odsOperands;";
   }
   std::string attr = "operand_segment_sizes";
   std::string sizeAttrInit = formatv(adapterSegmentSizeAttrInitCode, attr);
   generateNamedOperandGetters(op, adaptor,
                               /*isAdaptor=*/true, sizeAttrInit,
                               /*rangeType=*/"::mlir::ValueRange",
                               /*rangeBeginCall=*/"odsOperands.begin()",
                               /*rangeSizeCall=*/"odsOperands.size()",
                               /*getOperandCallPattern=*/"odsOperands[{0}]");
 
   FmtContext fctx;
-  fctx.withBuilder("::mlir::Builder(odsAttrs.getContext())");
+  fctx.withBuilder("::mlir::Builder(odsContext)");
 
   auto emitAttr = [&](StringRef name, Attribute attr) {
     auto *method = adaptor.addMethodAndPrune(attr.getStorageType(), name);
     ERROR_IF_PRUNED(method, "Adaptor::" + name, op);
     auto &body = method->body();
-    body << "  assert(odsAttrs && \"no attributes when constructing adapter\");"
-         << "\n  " << attr.getStorageType() << " attr = "
-         << "odsAttrs.get(\"" << name << "\").";
-    if (attr.hasDefaultValue() || attr.isOptional())
-      body << "dyn_cast_or_null<";
-    else
-      body << "cast<";
-    body << attr.getStorageType() << ">();\n";
+    body << formatv(opAdaptorGetAttr, attr.getStorageType(), name,
+                    attr.hasDefaultValue() || attr.isOptional()
+                        ? "dyn_cast_or_null"
+                        : "cast");
 
     if (attr.hasDefaultValue()) {
-      // Use the default value if attribute is not set.
-      // TODO: this is inefficient, we are recreating the attribute for every
-      // call. This should be set instead.
-      std::string defaultValue = std::string(
+      body << formatv(
+          opAdaptorConstructDefaultAttr,
           tgfmt(attr.getConstBuilderTemplate(), &fctx, attr.getDefaultValue()));
-      body << "  if (!attr)\n    attr = " << defaultValue << ";\n";
     }
     body << "  return attr;\n";
   };
 
   {
     auto *m =
-        adaptor.addMethodAndPrune("::mlir::DictionaryAttr", "getAttributes");
+        adaptor.addMethodAndPrune("::mlir::AttributeRange", "getAttributes");
     ERROR_IF_PRUNED(m, "Adaptor::getAttributes", op);
     m->body() << "  return odsAttrs;";
   }
   for (auto &namedAttr : op.getAttributes()) {
     const auto &name = namedAttr.name;
     const auto &attr = namedAttr.attr;
     if (!attr.isDerivedAttr()) {
       for (auto emitName : op.getGetterNames(name))

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 
 /// The code snippet used to generate a parser call to infer return types.
 ///
 /// {0}: The operation class name
 const char *const inferReturnTypesParserCode = R"(
   ::llvm::SmallVector<::mlir::Type> inferredReturnTypes;
   if (::mlir::failed({0}::inferReturnTypes(parser.getContext(),
       result.location, result.operands,
-      result.attributes.getDictionary(parser.getContext()),
-      result.regions, inferredReturnTypes)))
+      result.attributes, result.regions, inferredReturnTypes)))
     return ::mlir::failure();
   result.addTypes(inferredReturnTypes);
 )";
 
 /// The code snippet used to generate a parser call for a region list.
 ///
 /// {0}: The name for the region list.
 const char *regionListParserCode = R"(

 /// The code snippet used to generate a printer call for a region of an
 // operation that has the SingleBlockImplicitTerminator trait.
 ///
 /// {0}: The name of the region.
 const char *regionSingleBlockImplicitTerminatorPrinterCode = R"(
   {
     bool printTerminator = true;
     if (auto *term = {0}.empty() ? nullptr : {0}.begin()->getTerminator()) {{
-      printTerminator = !term->getAttrDictionary().empty() ||
+      printTerminator = !term->getAttrs().empty() ||
                         term->getNumOperands() != 0 ||
                         term->getNumResults() != 0;
     }
     p.printRegion({0}, /*printEntryBlockArgs=*/true,
                   /*printBlockTerminators=*/printTerminator);
   }
 )";
 

 /// Generate the printer for a custom directive parameter.
 static void genCustomDirectiveParameterPrinter(Element *element,
                                                const Operator &op,
                                                OpMethodBody &body) {
   if (auto *attr = dyn_cast<AttributeVariable>(element)) {
     body << op.getGetterName(attr->getVar()->name) << "Attr()";
 
   } else if (isa<AttrDictDirective>(element)) {
-    body << "getOperation()->getAttrDictionary()";
+    body << "getOperation()->getAttrs()";
 
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
     body << op.getGetterName(operand->getVar()->name) << "()";
 
   } else if (auto *region = dyn_cast<RegionVariable>(element)) {
     body << op.getGetterName(region->getVar()->name) << "()";
 
   } else if (auto *successor = dyn_cast<SuccessorVariable>(element)) {

mlir/unittests/TableGen/StructsGenTest.cpp

 /// 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);
+  llvm::SmallVector<mlir::NamedAttribute, 4> newValues(expectedValues.begin(),
+                                                       --expectedValues.end());
 
   // 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;
   auto wrongAttr = mlir::NamedAttribute(id, elementsAttr);