[mlir][NFC] Remove unnecessary attr name getters from StructuredOpsUtils.h.

[olegshyshkov]

Summary

Those methods were added long time ago. Now we get the same methods generated by tablegen, so there is no need for duplicates.

[bkramer]

looks good

[olegshyshkov]

Thank you!

mlir/include/mlir/Dialect/Utils/StructuredOpsUtils.h

 bool isColumnMajorMatmul(ArrayAttr indexingMaps);
 
 /// Tests whether the given maps describe a row major batch matmul. The test is
 /// permutation-invariant. Note that this only checks the affine maps from an
 /// operation, so does not perform any checks on the math being performed within
 /// the reduction.
 bool isRowMajorBatchMatmul(ArrayAttr indexingMaps);
 
-/// Attribute name for the AffineArrayAttr which encodes the relationship
-/// between a structured op iterators' and its operands.
-constexpr StringRef getIndexingMapsAttrName() { return "indexing_maps"; }
-
-/// Attribute name for the StrArrayAttr which encodes the type of a structured
-/// op's iterators.
-constexpr StringRef getIteratorTypesAttrName() { return "iterator_types"; }
-
-/// Attribute name for the StrArrayAttr which encodes the distribution type for
-/// `linalg.tiled_loop`.
-constexpr StringRef getDistributionTypesAttrName() {
-  return "distribution_types";
-}
-
-/// Attribute name for the StringAttr which encodes an optional documentation
-/// string of the structured op.
-constexpr StringRef getDocAttrName() { return "doc"; }
-
-/// Attribute name for the StrArrayAttr which encodes the external library
-/// function that implements the structured op.
-constexpr StringRef getLibraryCallAttrName() { return "library_call"; }
-
-/// Attribute name for the StrArrayAttr which encodes the value of strides.
-constexpr StringRef getStridesAttrName() { return "strides"; }
-
-/// Attribute name for the StrArrayAttr which encodes the value of dilations.
-constexpr StringRef getDilationsAttrName() { return "dilations"; }
-
-/// Attribute name for the StrArrayAttr which encodes the value of paddings.
-constexpr StringRef getPaddingAttrName() { return "padding"; }
-
 /// Use to encode that a particular iterator type has parallel semantics.
 constexpr StringRef getParallelIteratorTypeName() { return "parallel"; }
 
 /// Use to encode that a particular iterator type has reduction semantics.
 constexpr StringRef getReductionIteratorTypeName() { return "reduction"; }
 
 /// Use to encode that a particular iterator type has window semantics.
 constexpr StringRef getWindowIteratorTypeName() { return "window"; }

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

VectorType getLHSVectorMaskType() {
       if (llvm::size(getMasks()) != 2) return VectorType();
       return getOperand(3).getType().cast<VectorType>();
     }
     VectorType getRHSVectorMaskType() {
       if (llvm::size(getMasks()) != 2) return VectorType();
       return getOperand(4).getType().cast<VectorType>();
     }
     Type getResultType() { return getResult().getType(); }
-    ArrayRef<StringRef> getTraitAttrNames();
+    SmallVector<StringRef> getTraitAttrNames();
     static unsigned getAccOperandIndex() { return 2; }
 
     llvm::SmallVector<::mlir::AffineMap, 4> getIndexingMapsArray() {
       return llvm::to_vector<4>(getIndexingMaps().getAsValueRange<::mlir::AffineMapAttr>());
     }
 
     // Returns the bounds of each dimension in the iteration space spanned
     // by the iterator types of this operation.
     void getIterationBounds(SmallVectorImpl<int64_t> &iterationBounds);
 
     // Returns a list of index maps, where there is a list entry for each
     // op indexing map attribute (i.e. one for each input and output, with
     // the output listed last). Each index map, maps from this operations
     // iteration space, to vector dimensions of the maps input/output.
     void getIterationIndexMap(
       std::vector<DenseMap<int64_t, int64_t>> &iterationIndexMap);
 
     std::vector<std::pair<int64_t, int64_t>> getContractingDimMap();
     std::vector<std::pair<int64_t, int64_t>> getBatchDimMap();
 
-    static constexpr StringRef getKindAttrStrName() { return "kind"; }
-
     static CombiningKind getDefaultKind() {
       return CombiningKind::ADD;
     }
 
     // Returns iterator types in string format.
     SmallVector<StringRef> getIteratorTypeNames() {
       return llvm::to_vector(
           llvm::map_range(getIteratorTypes(), [](Attribute a) {

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

mlir::linalg::interchangeGenericOp(RewriterBase &rewriter, GenericOp genericOp,
   // 2. Compute the interchanged indexing maps.
   SmallVector<AffineMap> newIndexingMaps;
   for (OpOperand &opOperand : genericOp->getOpOperands()) {
     AffineMap m = genericOp.getMatchingIndexingMap(&opOperand);
     if (!permutationMap.isEmpty())
       m = m.compose(permutationMap);
     newIndexingMaps.push_back(m);
   }
-  genericOp->setAttr(getIndexingMapsAttrName(),
-                     rewriter.getAffineMapArrayAttr(newIndexingMaps));
+  genericOp.setIndexingMapsAttr(
 
   // 3. Compute the interchanged iterator types.
   ArrayRef<Attribute> itTypes = genericOp.getIteratorTypes().getValue();
   SmallVector<Attribute> itTypesVector;
   llvm::append_range(itTypesVector, itTypes);
   SmallVector<int64_t> permutation(interchangeVector.begin(),
                                    interchangeVector.end());
   applyPermutationToVector(itTypesVector, permutation);
-  genericOp->setAttr(getIteratorTypesAttrName(),
-                     ArrayAttr::get(context, itTypesVector));
+  genericOp.setIteratorTypesAttr(rewriter.getArrayAttr(itTypesVector));
 
   // 4. Transform the index operations by applying the permutation map.
   if (genericOp.hasIndexSemantics()) {
     OpBuilder::InsertionGuard guard(rewriter);
     for (IndexOp indexOp :
          llvm::make_early_inc_range(genericOp.getBody()->getOps<IndexOp>())) {
       rewriter.setInsertionPoint(indexOp);
       SmallVector<Value> allIndices;

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

 //===----------------------------------------------------------------------===//
 
 void vector::ContractionOp::build(OpBuilder &builder, OperationState &result,
                                   Value lhs, Value rhs, Value acc,
                                   ArrayRef<ArrayRef<AffineExpr>> indexingExprs,
                                   ArrayRef<IteratorType> iteratorTypes) {
   result.addOperands({lhs, rhs, acc});
   result.addTypes(acc.getType());
-  result.addAttribute(::mlir::getIndexingMapsAttrName(),
+  result.addAttribute(getIndexingMapsAttrName(result.name),
                       builder.getAffineMapArrayAttr(
                           AffineMap::inferFromExprList(indexingExprs)));
   result.addAttribute(
-      ::mlir::getIteratorTypesAttrName(),
+      getIteratorTypesAttrName(result.name),
       builder.getArrayAttr(llvm::to_vector(llvm::map_range(
           iteratorTypes, [&](IteratorType t) -> mlir::Attribute {
             return IteratorTypeAttr::get(builder.getContext(), t);
           }))));
 }
 
 void vector::ContractionOp::build(OpBuilder &builder, OperationState &result,
                                   Value lhs, Value rhs, Value acc,
                                   ArrayAttr indexingMaps,
                                   ArrayAttr iteratorTypes) {
   build(builder, result, lhs, rhs, acc, indexingMaps, iteratorTypes,
         ContractionOp::getDefaultKind());
 }
 
 void vector::ContractionOp::build(OpBuilder &builder, OperationState &result,
                                   Value lhs, Value rhs, Value acc,
                                   ArrayAttr indexingMaps,
                                   ArrayAttr iteratorTypes, CombiningKind kind) {
   result.addOperands({lhs, rhs, acc});
   result.addTypes(acc.getType());
-  result.addAttribute(::mlir::getIndexingMapsAttrName(), indexingMaps);
-  result.addAttribute(::mlir::getIteratorTypesAttrName(), iteratorTypes);
-  result.addAttribute(ContractionOp::getKindAttrStrName(),
+  result.addAttribute(getIndexingMapsAttrName(result.name), indexingMaps);
+  result.addAttribute(getIteratorTypesAttrName(result.name), iteratorTypes);
+  result.addAttribute(getKindAttrName(result.name),
                       CombiningKindAttr::get(builder.getContext(), kind));
 }
 
 ParseResult ContractionOp::parse(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::UnresolvedOperand lhsInfo;
   OpAsmParser::UnresolvedOperand rhsInfo;
   OpAsmParser::UnresolvedOperand accInfo;
   SmallVector<OpAsmParser::UnresolvedOperand, 2> masksInfo;
ParseResult ContractionOp::parse(OpAsmParser &parser, OperationState &result) {
   result.attributes.assign(dictAttr.getValue().begin(),
                            dictAttr.getValue().end());
 
   // Convert array of string into an array of IteratyType enums. This is needed,
   // because tests still use the old format when 'iterator_types' attribute is
   // represented as an array of strings.
   // TODO: Remove this conversion once tests are fixed.
   ArrayAttr iteratorTypes =
-      result.attributes.get("iterator_types").cast<ArrayAttr>();
+      result.attributes.get(getIteratorTypesAttrName(result.name))
+          .cast<ArrayAttr>();
 
   SmallVector<Attribute> iteratorTypeAttrs;
 
   for (StringRef s : iteratorTypes.getAsValueRange<StringAttr>()) {
     auto maybeIteratorType = symbolizeIteratorType(s);
     if (!maybeIteratorType.has_value())
       return parser.emitError(loc) << "unexpected iterator_type (" << s << ")";
 
-    iteratorTypeAttrs.push_back(IteratorTypeAttr::get(
-        parser.getContext(), maybeIteratorType.value()));
+    iteratorTypeAttrs.push_back(
+        IteratorTypeAttr::get(parser.getContext(), maybeIteratorType.value()));
   }
-  result.attributes.set("iterator_types",
+  result.attributes.set(getIteratorTypesAttrName(result.name),
                         parser.getBuilder().getArrayAttr(iteratorTypeAttrs));
 
-  if (!result.attributes.get(ContractionOp::getKindAttrStrName())) {
+  if (!result.attributes.get(getKindAttrName(result.name))) {
     result.addAttribute(
-        ContractionOp::getKindAttrStrName(),
+        getKindAttrName(result.name),
         CombiningKindAttr::get(result.getContext(),
                                ContractionOp::getDefaultKind()));
   }
   if (masksInfo.empty())
     return success();
   if (masksInfo.size() != 2)
     return parser.emitError(parser.getNameLoc(),
                             "expected zero or exactly 2 vector mask operands");
LogicalResult ContractionOp::verify() {
   auto vectorType = resType.dyn_cast<VectorType>();
   auto elementType = vectorType ? vectorType.getElementType() : resType;
   if (!isSupportedCombiningKind(getKind(), elementType))
     return emitOpError("unsupported contraction type");
 
   return success();
 }
 
-ArrayRef<StringRef> ContractionOp::getTraitAttrNames() {
-  static constexpr StringRef names[3] = {::mlir::getIndexingMapsAttrName(),
-                                         ::mlir::getIteratorTypesAttrName(),
-                                         ContractionOp::getKindAttrStrName()};
-  return llvm::makeArrayRef(names);
+SmallVector<StringRef> ContractionOp::getTraitAttrNames() {
+  return SmallVector<StringRef>{getIndexingMapsAttrName(),
+                                getIteratorTypesAttrName(), getKindAttrName()};
 }
 
 static int64_t getResultIndex(AffineMap map, AffineExpr targetExpr) {
   for (int64_t i = 0, e = map.getNumResults(); i < e; ++i)
     if (targetExpr == map.getResult(i))
       return i;
   return -1;
 }