Make linalg::ReshapeOp implement ViewLikeOpInterface

[herhut]

Summary

A reshape aliases its input memref, so it acts like a view.

[herhut]

Format tablegen.

[nicolasvasilache]

Thanks Stephan!

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

[{
       build(builder, result, rangeType, min, max, step);
     }]>];
 
   // Fully specified by traits.
   let verifier = ?;
   let assemblyFormat = "$min `:` $max `:` $step attr-dict `:` type(results)";
 }
 
-class Linalg_ReshapeLikeOp<string mnemonic> :
-    Linalg_Op<mnemonic, [NoSideEffect]> {
+class Linalg_ReshapeLikeOp<string mnemonic, list<OpTrait> traits = []> :
+    Linalg_Op<mnemonic, !listconcat(traits, [NoSideEffect])> {
   let builders = [
     // Builders for a contracting reshape whose result type is computed from
     // `src` and `reassociation`.
     OpBuilder<"OpBuilder &b, OperationState &result, Value src, "
               "ArrayRef<ReassociationExprs> reassociation, "
               "ArrayRef<NamedAttribute> attrs = {}">,
     OpBuilder<"OpBuilder &b, OperationState &result, Value src, "
               "ArrayRef<ReassociationIndices> reassociation, "
SmallVector<AffineMap, 4> getReassociationMaps() {
       ](Attribute a) { return a.cast<AffineMapAttr>().getValue(); }));
     }
   }];
   let assemblyFormat = [{
     $src $reassociation attr-dict `:` type($src) `into` type(results)
   }];
 }
 
-def Linalg_ReshapeOp : Linalg_ReshapeLikeOp<"reshape">,
+def Linalg_ReshapeOp : Linalg_ReshapeLikeOp<"reshape",
+    [DeclareOpInterfaceMethods<ViewLikeOpInterface>]>,
     Arguments<(ins AnyStridedMemRef:$src, AffineMapArrayAttr:$reassociation)>,
     Results<(outs AnyStridedMemRef:$result)> {
   let summary = "linalg.reshape produces a new view into the operand view";
   let description = [{
     The `linalg.reshape` op produces a new view whose sizes are a reassociation
     of the original `view`. Depending on whether or not the reassociated
     MemRefType is contiguous, the resulting memref may require explicit alloc
     and copies.

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

void mlir::linalg::ReshapeOp::build(OpBuilder &b, OperationState &result,
                                     ArrayRef<ReassociationExprs> reassociation,
                                     ArrayRef<NamedAttribute> attrs) {
   auto maps = getSymbolLessAffineMaps(reassociation);
   build(b, result, resultType, src, attrs);
   result.addAttribute(ReshapeOp::getReassociationAttrName(),
                       b.getAffineMapArrayAttr(maps));
 }
 
+Value mlir::linalg::ReshapeOp::getViewSource() { return src(); }
+
 // Common verifier for reshape-like types. Fills `expandedType` and
 // `collapsedType` with the proper `src` or `result` type.
 template <typename Op, typename T>
 static LogicalResult verifyReshapeLikeTypes(Op op, T &expandedType,
                                             T &collapsedType) {
   expandedType = op.getSrcType();
   collapsedType = op.getResultType();
   unsigned expandedRank = expandedType.getRank();