Catch negative size earlier

This now does catch the negative size inside the interface so that an
`op.emitError` can be thrown. That works, but then continues to
return an empty result?

Instead, the interface can probably be refactored first because it's
very restrictive in its current form.

Author: rikhuijzer

mlir/include/mlir/Interfaces/ViewLikeInterface.h

@@ -19,6 +19,7 @@
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/PatternMatch.h"
+#include <_types/_uint64_t.h>
 
 namespace mlir {
 
@@ -72,6 +73,19 @@ class OpWithOffsetSizesAndStridesConstantArgumentFolder final
         failed(foldDynamicIndexList(mixedStrides)))
       return failure();
 
+    SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
+    SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
+    dispatchIndexOpFoldResults(mixedOffsets, dynamicOffsets, staticOffsets);
+    dispatchIndexOpFoldResults(mixedSizes, dynamicSizes, staticSizes);
+    dispatchIndexOpFoldResults(mixedStrides, dynamicStrides, staticStrides);
+
+    for (int64_t size : staticSizes) {
+      if (size < 0 && !ShapedType::isDynamic(size)) {
+        return op.emitError("expected non-negative size, but got ")
+               << size;;
+      }
+    }
+
     // Create the new op in canonical form.
     auto resultType =
         ResultTypeFn()(op, mixedOffsets, mixedSizes, mixedStrides);

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

@@ -2843,6 +2843,8 @@ static LogicalResult produceSubViewErrorMsg(SliceVerificationResult result,
 }
 
 LogicalResult SubViewOp::verify() {
+  llvm::outs() << "SubViewOp::verify\n";
+
   for (int64_t offset : getStaticOffsets()) {
     if (offset < 0 && !ShapedType::isDynamic(offset))
       return emitError("expected subview offsets to be non-negative, but got ")
@@ -3103,6 +3105,19 @@ struct SubViewReturnTypeCanonicalizer {
   MemRefType operator()(SubViewOp op, ArrayRef<OpFoldResult> mixedOffsets,
                         ArrayRef<OpFoldResult> mixedSizes,
                         ArrayRef<OpFoldResult> mixedStrides) {
+    SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
+    SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
+    dispatchIndexOpFoldResults(mixedOffsets, dynamicOffsets, staticOffsets);
+    dispatchIndexOpFoldResults(mixedSizes, dynamicSizes, staticSizes);
+    dispatchIndexOpFoldResults(mixedStrides, dynamicStrides, staticStrides);
+
+    for (int64_t size : staticSizes) {
+      if (size < 0 && !ShapedType::isDynamic(size)) {
+        llvm::dbgs() << "expected subview sizes to be non-negative, but got "
+                     << size << "\n";
+        return {};
+      }
+    }
 
     // Infer a memref type without taking into account any rank reductions.
     MemRefType nonReducedType = cast<MemRefType>(SubViewOp::inferResultType(

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

@@ -1163,6 +1163,8 @@ static void operandsAndShape(TensorType resultType,
 }
 
 LogicalResult GenerateOp::verify() {
+  llvm::outs() << "GenerateOp::verify()\n";
+
   // Ensure that the tensor type has as many dynamic dimensions as are
   // specified by the operands.
   RankedTensorType resultType = llvm::cast<RankedTensorType>(getType());
@@ -1173,6 +1175,7 @@ LogicalResult GenerateOp::verify() {
   SmallVector<Value> newOperands;
   SmallVector<int64_t> newShape;
   operandsAndShape(resultType, getDynamicExtents(), newOperands, newShape);
+
   for (int64_t newdim : newShape) {
     if (newdim < 0 && !ShapedType::isDynamic(newdim))
       return emitError("tensor dimensions must be non-negative");
@@ -1242,7 +1245,7 @@ struct StaticTensorGenerate : public OpRewritePattern<GenerateOp> {
 
     for (int64_t newdim : newShape) {
       // This check also occurs in the verifier, but we need it here too
-      // since intermediate passes may have some replaced dynamic dimensions
+      // since intermediate passes may have replaced some dynamic dimensions
       // by constants.
       if (newdim < 0 && !ShapedType::isDynamic(newdim))
         return failure();