[mlir][standard] Fix parsing of scalar subview and canonicalize

[herhut]

Summary

Parsing of a scalar subview did not create the required static_offsets attribute.
This also adds support for folding scalar subviews away.

[nicolasvasilache]

Thanks @herhut !

[nicolasvasilache]

Bonus points for similar fix for subtensor / subtensor_insert, esp. since tensor<0xf32> has different semantics.
But this can go standalone.

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// encode the dynamic case.
     static Type inferResultType(MemRefType sourceMemRefType,
                                 ArrayRef<int64_t> staticOffsets,
                                 ArrayRef<int64_t> staticSizes,
                                 ArrayRef<int64_t> staticStrides);
   }];
 
   let hasCanonicalizer = 1;
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SubTensorOp
 //===----------------------------------------------------------------------===//
 
 def SubTensorOp : BaseOpWithOffsetSizesAndStrides<"subtensor"> {
   let summary = "subtensor operation";

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

 ///   2. `ssa` is filled with "[%arg0, %arg1]".
 static ParseResult
 parseListOfOperandsOrIntegers(OpAsmParser &parser, OperationState &result,
                               StringRef attrName, int64_t dynVal,
                               SmallVectorImpl<OpAsmParser::OperandType> &ssa) {
   if (failed(parser.parseLSquare()))
     return failure();
   // 0-D.
-  if (succeeded(parser.parseOptionalRSquare()))
+  if (succeeded(parser.parseOptionalRSquare())) {
+    result.addAttribute(attrName, parser.getBuilder().getArrayAttr({}));
     return success();
+  }
 
   SmallVector<int64_t, 4> attrVals;
   while (true) {
     OpAsmParser::OperandType operand;
     auto res = parser.parseOptionalOperand(operand);
     if (res.hasValue() && succeeded(res.getValue())) {
       ssa.push_back(operand);
       attrVals.push_back(dynVal);

 } // namespace
 
 void SubViewOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                             MLIRContext *context) {
   results.insert<OpWithOffsetSizesAndStridesConstantArgumentFolder<SubViewOp>,
                  SubViewOpMemRefCastFolder>(context);
 }
 
+OpFoldResult SubViewOp::fold(ArrayRef<Attribute> operands) {
+  if (getResultRank() == 0 && getSourceRank() == 0)
+    return getViewSource();
+
+  return {};
+}
+
 //===----------------------------------------------------------------------===//
 // SubTensorOp
 //===----------------------------------------------------------------------===//
 
 static void print(OpAsmPrinter &p, SubTensorOp op) {
   return printOpWithOffsetsSizesAndStrides<SubTensorOp>(p, op);
 }
 

mlir/test/IR/core-ops.mlir

func @memref_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
   // CHECK: subview %18[0, 0] [1, 8] [1, 1]  : memref<1x8xf32> to memref<8xf32>
   %19 = subview %18[0, 0][1, 8][1, 1] : memref<1x8xf32> to memref<8xf32>
 
   %20 = alloc() : memref<8x16x4xf32>
   // CHECK: subview %20[0, 0, 0] [1, 16, 4] [1, 1, 1]  : memref<8x16x4xf32> to memref<16x4xf32>
   %21 = subview %20[0, 0, 0][1, 16, 4][1, 1, 1] : memref<8x16x4xf32> to memref<16x4xf32>
 
   %22 = subview %20[3, 4, 2][1, 6, 3][1, 1, 1] : memref<8x16x4xf32> to memref<6x3xf32, offset: 210, strides: [4, 1]>
+
+  %23 = alloc() : memref<f32>
+  %78 = subview %23[] [] []  : memref<f32> to memref<f32>
   return
 }
 
 // CHECK-LABEL: func @test_dimop
 // CHECK-SAME: %[[ARG:.*]]: tensor<4x4x?xf32>
 func @test_dimop(%arg0: tensor<4x4x?xf32>) {
   // CHECK: %[[C2:.*]] = constant 2 : index
   // CHECK: %{{.*}} = dim %[[ARG]], %[[C2]] : tensor<4x4x?xf32>

mlir/test/Transforms/constant-fold.mlir

func @splat_fold() -> (vector<4xf32>, tensor<4xf32>) {
   %v = splat %c : vector<4xf32>
   %t = splat %c : tensor<4xf32>
   return %v, %t : vector<4xf32>, tensor<4xf32>
 
   // CHECK-NEXT: [[V:%.*]] = constant dense<1.000000e+00> : vector<4xf32>
   // CHECK-NEXT: [[T:%.*]] = constant dense<1.000000e+00> : tensor<4xf32>
   // CHECK-NEXT: return [[V]], [[T]] : vector<4xf32>, tensor<4xf32>
 }
+
+// -----
+
+// CHECK-LABEL: func @subview_scalar_fold
+func @subview_scalar_fold(%arg0: memref<f32>) -> memref<f32> {
+  // CHECK-NOT: subview
+  %c = subview %arg0[] [] [] : memref<f32> to memref<f32>
+  return %c : memref<f32>
+}