[mlir][linalg] Cleanup LinalgOp usage in generalization.

[gysit]

Summary

Replace the uses of deprecated Structured Op Interface methods in Generalization.cpp. This patch is based on https://reviews.llvm.org/D103394.

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

 
 using namespace mlir;
 using namespace mlir::linalg;
 
 // Creates a linalg.generic op from the given `namedOp`. Returns a null op if
 // the given `namedOp` does not have a region builder.
 static GenericOp createGenericOpFromNamedOp(LinalgOp namedOp,
                                             PatternRewriter &rewriter) {
+  SmallVector<Value> inputOperands = namedOp.getInputOperands();
+  SmallVector<Value> outputOperands = namedOp.getOutputOperands();
   SmallVector<AffineMap> indexingMaps = namedOp.getIndexingMaps();
   SmallVector<StringRef> iterators = llvm::to_vector<4>(
       namedOp.iterator_types().getAsValueRange<StringAttr>());
   SmallVector<RankedTensorType> resultTypes = namedOp.getOutputTensorTypes();
   SmallVector<Type> types(resultTypes.begin(), resultTypes.end());
 
   // Inline the existing region if the named operation has a region attached.
   if (namedOp->getNumRegions() == 1) {
-    GenericOp genericOp = rewriter.create<GenericOp>(
-        namedOp.getLoc(), types, namedOp.getInputs(), namedOp.getOutputs(),
-        indexingMaps, iterators);
+    GenericOp genericOp =
+        rewriter.create<GenericOp>(namedOp.getLoc(), types, inputOperands,
+                                   outputOperands, indexingMaps, iterators);
     rewriter.inlineRegionBefore(namedOp->getRegion(0), genericOp.region(),
                                 genericOp.region().begin());
     return genericOp;
   }
 
   // Otherwise use the region builder to generate a new region.
   // TODO: Remove this path once all linag operations have a region attached.
   auto regionBuilder = namedOp.getRegionBuilder();
   if (!regionBuilder) {
     LLVM_DEBUG(llvm::dbgs() << "no region builder for op: " << namedOp << "\n");
     return nullptr;
   }
   return rewriter.create<GenericOp>(
-      namedOp.getLoc(), types, namedOp.getInputs(), namedOp.getOutputs(),
-      indexingMaps, iterators,
+      namedOp.getLoc(), types, inputOperands, outputOperands, indexingMaps,
+      iterators,
       [&regionBuilder](OpBuilder &bodyBuilder, Location loc, ValueRange) {
         ImplicitLocOpBuilder b(loc, bodyBuilder);
         regionBuilder(b, *bodyBuilder.getBlock(),
                       /*captures=*/{});
       });
 }
 
 namespace {
void LinalgGeneralizationPass::runOnFunction() {
   RewritePatternSet patterns(&getContext());
   populateLinalgConvGeneralizationPatterns(patterns);
   populateLinalgNamedOpsGeneralizationPatterns(patterns);
   (void)applyPatternsAndFoldGreedily(func.getBody(), std::move(patterns));
 }
 
 GenericOp GeneralizeConvOp::createGenericOp(ConvOp convOp,
                                             OpBuilder &builder) const {
-  SmallVector<AffineMap, 4> indexingMaps = convOp.getIndexingMaps();
+  SmallVector<AffineMap> indexingMaps = convOp.getIndexingMaps();
   auto iterators =
       llvm::to_vector<4>(convOp.iterator_types().getAsValueRange<StringAttr>());
+  SmallVector<Value> inputBuffers = convOp.getInputBufferOperands();
+  SmallVector<Value> outputBuffers = convOp.getOutputBufferOperands();
   return builder.create<GenericOp>(
-      convOp.getLoc(), /*resultTensorTypes=*/ArrayRef<Type>(),
-      convOp.getInputBuffers(), convOp.getOutputBuffers(), indexingMaps,
-      iterators,
+      convOp.getLoc(), /*resultTensorTypes=*/ArrayRef<Type>(), inputBuffers,
+      outputBuffers, indexingMaps, iterators,
       [](OpBuilder &bodyBuilder, Location bodyLoc, ValueRange bodyArgs) {
         Value mul =
             bodyBuilder.create<MulFOp>(bodyLoc, bodyArgs[0], bodyArgs[1]);
         Value add = bodyBuilder.create<AddFOp>(bodyLoc, mul, bodyArgs[2]);
         bodyBuilder.create<YieldOp>(bodyLoc, add);
       });
 }