[mlir] Move isGuaranteedCollapsible to CollapseShapeOp (NFC).

[akuegel]

Summary

It seems more natural than to have it as a static method of ExpandShapeOp.
Also fix a typo ("the the" -> "the").

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

let description = [{
     If an op can be statically proven to be invalid (e.g, an expansion from
     `memref<10xf32>` to `memref<2x6xf32>`), it is rejected by the verifier. If
     it cannot statically be proven invalid (e.g., the full example above; it is
     unclear whether the first source dimension is divisible by 5), the op is
     accepted by the verifier. However, if the op is in fact invalid at runtime,
     the behavior is undefined.
 
     The source memref can be zero-ranked. In that case, the reassociation
-    indices must be empty and the the result shape may only consist of unit
+    indices must be empty and the result shape may only consist of unit
     dimensions.
 
     For simplicity, this op may not be used to cast dynamicity of dimension
     sizes and/or strides. I.e., if and only if a source dimension is dynamic,
     there must be a dynamic result dimension in the corresponding reassociation
     group. Same for strides.
 
     Note: This op currently assumes that the inner strides are of the
[{
       build($_builder, $_state, resultType, src, reassociationMaps, attrs);
     }]>,
 
     // Builder that infers the result layout map. The result shape must be
     // specified. Otherwise, the op may be ambiguous.
     OpBuilder<(ins "ArrayRef<int64_t>":$resultShape, "Value":$src,
                "ArrayRef<ReassociationIndices>":$reassociation)>
   ];
-
-  let extraClassDeclaration = commonExtraClassDeclaration # [{
-    /// Return `true` if this source MemRef type is guaranteed to be collapsible
-    /// according to the given reassociation indices. In the presence of dynamic
-    /// strides this is usually not the case.
-    static bool isGuaranteedCollapsible(
-        MemRefType srcType, ArrayRef<ReassociationIndices> reassociation);
-  }];
-
+  let extraClassDeclaration = commonExtraClassDeclaration;
   let hasVerifier = 1;
 }
 
 def MemRef_CollapseShapeOp : MemRef_ReassociativeReshapeOp<"collapse_shape"> {
   let summary = "operation to produce a memref with a smaller rank.";
   let description = [{
     The `memref.collapse_shape` op produces a new view with a smaller rank
     whose sizes are a reassociation of the original `view`. The operation is
OpBuilder<(ins "Type":$resultType, "Value":$src,
       "ArrayRef<ReassociationExprs>":$reassociation,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
     [{
       auto reassociationMaps =
           convertReassociationMapsToIndices($_builder, reassociation);
       build($_builder, $_state, resultType, src, reassociationMaps, attrs);
     }]>
   ];
-  let extraClassDeclaration = commonExtraClassDeclaration;
+  let extraClassDeclaration = commonExtraClassDeclaration # [{
+    /// Return `true` if this source MemRef type is guaranteed to be collapsible
+    /// according to the given reassociation indices. In the presence of dynamic
+    /// strides this is usually not the case.
+    static bool isGuaranteedCollapsible(
+        MemRefType srcType, ArrayRef<ReassociationIndices> reassociation);
+  }];
+
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // StoreOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_StoreOp : MemRef_Op<"store",

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

for (int64_t idx : llvm::reverse(trailingReassocs)) {
       if (!stride.saturated && !srcStride.saturated && stride != srcStride)
         return failure();
     }
   }
   return makeStridedLinearLayoutMap(resultStrides, srcOffset,
                                     srcType.getContext());
 }
 
-bool ExpandShapeOp::isGuaranteedCollapsible(
+bool CollapseShapeOp::isGuaranteedCollapsible(
     MemRefType srcType, ArrayRef<ReassociationIndices> reassociation) {
   // MemRefs with standard layout are always collapsible.
   if (srcType.getLayout().isIdentity())
     return true;
 
   return succeeded(computeCollapsedLayoutMap(srcType, reassociation,
                                              /*strict=*/true));
 }

mlir/lib/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.cpp

if (tensorResultType.getRank() == 0) {
       replaceOpWithNewBufferizedOp<memref::CollapseShapeOp>(
           rewriter, op, resultType, buffer, collapseShapeOp.reassociation());
       return success();
     }
 
     // If the dims are not collapsible (due to an incompatible source layout
     // map), force an out-of-place bufferization, i.e., a buffer copy. This
     // newly allocated buffer will have no layout map and thus be collapsible.
-    bool canBeCollapsed = memref::ExpandShapeOp::isGuaranteedCollapsible(
+    bool canBeCollapsed = memref::CollapseShapeOp::isGuaranteedCollapsible(
         bufferType, collapseShapeOp.getReassociationIndices());
     Optional<BufferizationState::ForceInPlacability> overrideInPlace =
         canBeCollapsed
             ? None
             : Optional<BufferizationState::ForceInPlacability>(
                   BufferizationState::ForceInPlacability::FORCE_OUT_OF_PLACE);
     Value buffer = *state.getBuffer(rewriter, srcOperand, overrideInPlace);