[mlir][linalg] Fix crash in canonicalization pattern

[springerm]

Summary

This crash was due to incorrect usage of hasTensorSemantics, which has changed recently with DestinationStyleOpInterface. An op has tensor semantics if all of its inits and inputs are tensors. Previously, only inits needed to be tensors.

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

LogicalResult matchAndRewrite(GenericOp genericOp,
     // Check if there is any change to operands.
     if (newInputOperands.size() + newOutputOperands.size() ==
         genericOp->getNumOperands())
       return failure();
 
     // Create the new op with the body being empty.
     Location loc = genericOp.getLoc();
     SmallVector<Type> newResultTypes;
-    if (genericOp.hasTensorSemantics()) {
-      newResultTypes = llvm::to_vector(llvm::map_range(
-          newOutputOperands, [](Value v) { return v.getType(); }));
-    }
+    for (Value v : newOutputOperands)
+      if (v.getType().isa<TensorType>())
+        newResultTypes.push_back(v.getType());
     auto newOp = rewriter.create<GenericOp>(
         loc, newResultTypes, newInputOperands, newOutputOperands,
         rewriter.getAffineMapArrayAttr(newIndexingMaps),
         genericOp.getIteratorTypes(), genericOp.getDocAttr(),
         genericOp.getLibraryCallAttr(),
         [](OpBuilder & /*builder*/, Location /*loc*/, ValueRange /*args*/) {
           return;
         });

mlir/test/Dialect/Linalg/canonicalize.mlir

 // For now, check generic remained unchanged.
 // CHECK-LABEL: func @identity_mixed
 //  CHECK-SAME:     (%[[ARG1:.*]]: tensor<?xf32>, %[[ARG2:.*]]: memref<?xf32>)
 //       CHECK:     linalg.generic {
 //  CHECK-SAME:    indexing_maps = [#map, #map],
 //  CHECK-SAME:    iterator_types = ["parallel"]
 //  CHECK-SAME:  } ins(%[[ARG1]] : tensor<?xf32>)
 //  CHECK-SAME:    outs(%[[ARG2]] : memref<?xf32>) {
+
+// -----
+
+// Just make sure that we don't crash.
+
+// CHECK-LABEL: func @dedeplicate_regression_test
+func.func @dedeplicate_regression_test(%0: tensor<4xf32>, %1: memref<4xf32>) {
+  %36 = linalg.generic
+    {indexing_maps = [affine_map<(d0) -> (d0)>,
+                      affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>],
+     iterator_types = ["parallel"]}
+    ins(%1, %1 : memref<4xf32>, memref<4xf32>)
+    outs(%0 : tensor<4xf32>) {
+  ^bb0(%in: f32, %in_24: f32, %out: f32):
+    linalg.yield %in : f32
+  } -> tensor<4xf32>
+  %53 = linalg.generic {indexing_maps = [affine_map<(d0) -> (d0)>],
+                        iterator_types = ["parallel"]}
+                        outs(%36 : tensor<4xf32>) {
+  ^bb0(%out: f32):
+    linalg.yield %out : f32
+  } -> tensor<4xf32>
+  return
+}