[mlir][interfaces] Allow only ranked tensors/memrefs in DestinationStyleOpInterface

[springerm]

Summary

We have currently no need for unranked tensors/memrefs.

[pifon2a]

Just wondering, do we have an example where we need unranked DPS?

[springerm]

In D136588#3878907, @pifon2a wrote:

Just wondering, do we have an example where we need unranked DPS?

There is a test case in Tensor/ops.mlir that requires this, otherwise the op interface verifier fails:

%1 = tensor.insert %arg0 into %arg3[%arg1, %arg1, %arg1] : tensor<*xf32>

[springerm]

update

[springerm]

Allowing only ranked tensors/memrefs as per offline discussion.

mlir/include/mlir/Interfaces/DestinationStyleOpInterface.td

 include "mlir/IR/OpBase.td"
 
 def DestinationStyleOpInterface : OpInterface<"DestinationStyleOpInterface"> {
   let description = [{
     Ops that are in destination style have designated output operands, which act
     as initial tensor values for the results of the operation or the output
     buffers to which the results of the op will be written.
 
-    Output operands must be tensors or memrefs. Input operands can have any
-    type. All non-output operands are inputs.
+    Output operands must be ranked tensors or ranked memrefs. Input operands can
+    have any type. All non-output operands are inputs.
 
     It is assumed that the output operands of the op are the operands at
     position [start, end). The positions are defined by getOutputsPositionRange
     method. All non-output operands are "inputs" of the DPS op.
 
     If the op has "tensor semantics", then the input operands are either scalars
-    or tensors. The output operands are tensors and every tensor output is tied
-    to a corresponding tensor OpResult in a 1-to-1 fashion. The i-th output
-    tensor is tied to the i-th OpResult. The op may not have any additional
-    OpResults. Output operands and their tied OpResults have the same type.
-
-    If the op has "buffer semantics", then the input operands are either memrefs
-    or other non-tensor types, e.g. scalar types. Furthermore, the output
-    operands are memrefs and the op has no results.
+    or ranked tensors. The output operands are ranked tensors and every tensor
+    output is tied to a corresponding tensor OpResult in a 1-to-1 fashion.
+    The i-th output tensor is tied to the i-th OpResult. The op may not have any
+    additional OpResults. Output operands and their tied OpResults have the same
+    type.
+
+    If the op has "buffer semantics", then the input operands are either ranked
+    memrefs or other non-tensor types, e.g. scalar types. Furthermore, the
+    output operands are ranked memrefs and the op has no results.
 
     Destination-passing style abstraction makes certain transformations easier.
     For example, tiling implementation can extract/insert slices from/into the
     destination of an op and use the resulting shaped value as an iter_arg in
     the surrounding loop structure. As another example, bufferization does not
     have to allocate new buffers for destinations (in case of in-place
     bufferization) and can directly reuse the existing destination buffer.
 
InterfaceMethod<
         assert(opResult.getDefiningOp() == $_op.getOperation());
         return $_op.getOutputOperand(opResult.getResultNumber());
       }]
     >,
     //===------------------------------------------------------------------===//
     // Other interface methods.
     //===------------------------------------------------------------------===//
     InterfaceMethod<
-      /*desc=*/"Return whether the op has only MemRef input and outputs.",
+      /*desc=*/"Return whether the op has only ranked MemRef inputs/outputs.",
       /*retTy=*/"bool",
       /*methodName=*/"hasBufferSemantics",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op->getNumResults() == 0 &&
           llvm::all_of($_op->getOpOperands(),
             [&](OpOperand &opOperand) {
               return isScalar(&opOperand) ||
                      opOperand.get().getType().template isa<MemRefType>();
             });
       }]
     >,
     InterfaceMethod<
-      /*desc=*/"Return whether the op has only RankedTensor input and outputs.",
+      /*desc=*/"Return whether the op has only ranked tensor inputs/outputs.",
       /*retTy=*/"bool",
       /*methodName=*/"hasTensorSemantics",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return llvm::all_of($_op->getOpOperands(),
           [&](OpOperand &opOperand) {
             return isScalar(&opOperand) ||

mlir/lib/Interfaces/DestinationStyleOpInterface.cpp

 
 LogicalResult detail::verifyDestinationStyleOpInterface(Operation *op) {
   DestinationStyleOpInterface dstStyleOp =
       cast<DestinationStyleOpInterface>(op);
 
   SmallVector<OpOperand *> outputBufferOperands, outputTensorOperands;
   for (OpOperand *operand : dstStyleOp.getOutputOperands()) {
     Type type = operand->get().getType();
-    if (type.isa<MemRefType>())
+    if (type.isa<MemRefType>()) {
       outputBufferOperands.push_back(operand);
-    if (type.isa<RankedTensorType>())
+    } else if (type.isa<RankedTensorType>()) {
       outputTensorOperands.push_back(operand);
+    } else {
+      return op->emitOpError("expected that operand #")
+             << operand->getOperandNumber()
+             << " is a ranked tensor or a ranked memref";
+    }
   }
 
   // Expect at least one output operand.
   int64_t numInputs = dstStyleOp.getNumInputs();
   int64_t numOutputs = dstStyleOp.getNumOutputs();
   if (numOutputs == 0)
     return op->emitOpError("expected at least one output operand");
   if (failed(OpTrait::impl::verifyNOperands(op, numInputs + numOutputs)))