[mlir] Mark OpState::removeAttr() deprecated.

[csigg]

Summary

Fix call sites.

The method will be removed 2 weeks later.

[csigg]

Fix GPUDialect.cpp.

mlir/include/mlir/IR/OpDefinition.h

public:
   template <typename DialectAttrs>
   void setDialectAttrs(DialectAttrs &&attrs) {
     state->setDialectAttrs(std::forward<DialectAttrs>(attrs));
   }
 
   /// 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) { return state->removeAttr(name); }
-  Attribute removeAttr(StringRef name) {
+  LLVM_ATTRIBUTE_DEPRECATED(
+      Attribute removeAttr(Identifier name),
+      "Use Operation::removeAttr() instead (replace '.' with '->').") {
+    return state->removeAttr(name);
+  }
+  LLVM_ATTRIBUTE_DEPRECATED(
+      Attribute removeAttr(StringRef name),
+      "Use Operation::removeAttr() instead (replace '.' with '->').") {
     return state->removeAttr(Identifier::get(name, getContext()));
   }
 
   /// Return true if there are no users of any results of this operation.
   bool use_empty() { return state->use_empty(); }
 
   /// Remove this operation from its parent block and delete it.
   void erase() { state->erase(); }

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

spvModule.walk([&](spirv::GlobalVariableOp op) {
                           std::to_string(descriptorSet.getInt()),
                           std::to_string(binding.getInt()));
 
         // Replace all symbol uses and set the new symbol name. Finally, remove
         // descriptor set and binding attributes.
         if (failed(SymbolTable::replaceAllSymbolUses(op, name, spvModule)))
           op.emitError("unable to replace all symbol uses for ") << name;
         SymbolTable::setSymbolName(op, name);
-        op.removeAttr(kDescriptorSet);
-        op.removeAttr(kBinding);
+        op->removeAttr(kDescriptorSet);
+        op->removeAttr(kBinding);
       }
     });
   }
 }

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

 
 void GPUFuncOp::setType(FunctionType newType) {
   auto oldType = getType();
   assert(newType.getNumResults() == oldType.getNumResults() &&
          "unimplemented: changes to the number of results");
 
   SmallVector<char, 16> nameBuf;
   for (int i = newType.getNumInputs(), e = oldType.getNumInputs(); i < e; i++)
-    removeAttr(getArgAttrName(i, nameBuf));
+    removeAttr->removeAttr(getArgAttrName(i, nameBuf));
 
   (*this)->setAttr(getTypeAttrName(), TypeAttr::get(newType));
 }
 
 /// Hook for FunctionLike verifier.
 LogicalResult GPUFuncOp::verifyType() {
   Type type = getTypeAttr().getValue();
   if (!type.isa<FunctionType>())

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

if (lateCodegenStrategyOptions.enableVectorToSCFConversion) {
     OwningRewritePatternList vectorToLoopsPatterns;
     populateVectorToSCFConversionPatterns(vectorToLoopsPatterns, context,
                                           vectorToSCFOptions);
     (void)applyPatternsAndFoldGreedily(func, std::move(vectorToLoopsPatterns));
   }
 
   // Ensure we drop the marker in the end.
   func.walk([](LinalgOp op) {
-    op.removeAttr(LinalgTransforms::kLinalgTransformMarker);
+    op->removeAttr(LinalgTransforms::kLinalgTransformMarker);
   });
 }

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

static void applyTilingToLoopPatterns(LinalgTilingLoopType loopType,
   MLIRContext *ctx = funcOp.getContext();
   OwningRewritePatternList patterns;
   insertTilingPatterns(patterns, options, ctx);
   (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
   (void)applyPatternsAndFoldGreedily(
       funcOp, getLinalgTilingCanonicalizationPatterns(ctx));
   // Drop the marker.
   funcOp.walk([](LinalgOp op) {
-    op.removeAttr(LinalgTransforms::kLinalgTransformMarker);
+    op->removeAttr(LinalgTransforms::kLinalgTransformMarker);
   });
 }
 
 namespace {
 struct LinalgTilingPass : public LinalgTilingBase<LinalgTilingPass> {
   LinalgTilingPass() = default;
   LinalgTilingPass(ArrayRef<int64_t> sizes) { tileSizes = sizes; }
 

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

static LogicalResult lowerEntryPointABIAttr(spirv::FuncOp funcOp,
   builder.create<spirv::EntryPointOp>(
       funcOp.getLoc(), executionModel.getValue(), funcOp, interfaceVars);
 
   // Specifies the spv.ExecutionModeOp.
   auto localSizeAttr = entryPointAttr.local_size();
   SmallVector<int32_t, 3> localSize(localSizeAttr.getValues<int32_t>());
   builder.create<spirv::ExecutionModeOp>(
       funcOp.getLoc(), funcOp, spirv::ExecutionMode::LocalSize, localSize);
-  funcOp.removeAttr(entryPointAttrName);
+  funcOp->removeAttr(entryPointAttrName);
   return success();
 }
 
 namespace {
 /// A pattern to convert function signature according to interface variable ABI
 /// attributes.
 ///
 /// Specifically, this pattern creates global variables according to interface

mlir/test/lib/Transforms/TestConvVectorization.cpp

void TestConvVectorization::runOnOperation() {
   // Programmatic controlled lowering of vector.transfer only.
   OwningRewritePatternList vectorToLoopsPatterns;
   populateVectorToSCFConversionPatterns(vectorToLoopsPatterns, context,
                                         VectorTransferToSCFOptions());
   (void)applyPatternsAndFoldGreedily(module, std::move(vectorToLoopsPatterns));
 
   // Ensure we drop the marker in the end.
   module.walk([](linalg::LinalgOp op) {
-    op.removeAttr(linalg::LinalgTransforms::kLinalgTransformMarker);
+    op->removeAttr(linalg::LinalgTransforms::kLinalgTransformMarker);
   });
 }
 
 namespace mlir {
 namespace test {
 void registerTestConvVectorization() {
   PassRegistration<TestConvVectorization> testTransformPatternsPass(
       "test-conv-vectorization", "Test vectorization of convolutions");
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLinalgTransforms.cpp

patterns.insert<LinalgPromotionPattern<FillOp>>(
       LinalgTransformationFilter(
           Identifier::get("_promote_views_aligned_", ctx),
           Identifier::get("_views_aligned_promoted_", ctx)));
 
   (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
 
   // Drop the marker.
   funcOp.walk([](LinalgOp op) {
-    op.removeAttr(LinalgTransforms::kLinalgTransformMarker);
+    op->removeAttr(LinalgTransforms::kLinalgTransformMarker);
   });
 }
 
 static void fillL1TilingAndMatmulToVectorPatterns(
     FuncOp funcOp, StringRef startMarker,
     SmallVectorImpl<OwningRewritePatternList> &patternsVector) {
   MLIRContext *ctx = funcOp.getContext();
   patternsVector.emplace_back(std::make_unique<LinalgTilingPattern<MatmulOp>>(
tilingPattern.insert<linalg::LinalgTilingPattern<linalg::MatmulI8I8I32Op>>(
           Identifier::get("tile-and-pad", context)));
   (void)applyPatternsAndFoldGreedily(funcOp, std::move(tilingPattern));
 }
 
 /// Apply transformations specified as patterns.
 void TestLinalgTransforms::runOnFunction() {
   auto lambda = [&](void *) {
     getFunction().walk([](LinalgOp op) {
-      op.removeAttr(LinalgTransforms::kLinalgTransformMarker);
+      op->removeAttr(LinalgTransforms::kLinalgTransformMarker);
     });
   };
   std::unique_ptr<void, decltype(lambda)> cleanupGuard{(void *)1, lambda};
 
   if (testPromotionOptions) {
     OwningRewritePatternList patterns;
     fillPromotionCallBackPatterns(&getContext(), patterns);
     (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));