[mlir] [VectorOps] Correctly account for rank-0 affine-map result in vector.contract

[aartbik]

Summary

Now that, thanks to ntv, we have the ability to parse and represent an affine
map with rank-0 results, viz. (i,j) -> (), we can pay off some engineering debt
in special casing the verification of such affine maps in dot-product flavored
vector.contract operations.

[nicolasvasilache]

Thanks for the cleanup Aart!

mlir/lib/Dialect/VectorOps/VectorOps.cpp

static LogicalResult verify(ContractionOp op) {
   for (auto it : llvm::enumerate(op.indexing_maps())) {
     auto index = it.index();
     auto map = it.value().cast<AffineMapAttr>().getValue();
     if (map.getNumSymbols() != 0)
       return op.emitOpError("expected indexing map ")
              << index << " to have no symbols";
     auto vectorType = op.getOperand(index).getType().dyn_cast<VectorType>();
     unsigned rank = vectorType ? vectorType.getShape().size() : 0;
-    // Since (...) -> () is parsed into an empty map, we need to add
-    // a special case for this situation: continue the verification
-    // of an empty map if the resulting rank is indeed zero, i.e. this
-    // is a reduction into a scalar.
-    if (map.getNumDims() == 0 && map.getNumResults() == 0 && rank == 0)
-      continue;
     // Verify that the map has the right number of inputs, outputs, and indices.
+    // This also correctly accounts for (..) -> () for rank-0 results.
     if (map.getNumDims() != numIterators)
       return op.emitOpError("expected indexing map ")
              << index << " to have " << numIterators << " number of inputs";
     if (map.getNumResults() != rank)
       return op.emitOpError("expected indexing map ")
              << index << " to have " << rank << " number of outputs";
     if (!map.isProjectedPermutation())
       return op.emitOpError("expected indexing map ")

mlir/lib/Dialect/VectorOps/VectorTransforms.cpp

for (auto it : llvm::enumerate(iteratorTypes)) {
       results.push_back(it.value());
     }
     return results;
   }
 
   // Helper to construct an affine map with one index removed.
   static AffineMap adjustMap(AffineMap map, int64_t index,
                              PatternRewriter &rewriter) {
+    auto *ctx = rewriter.getContext();
     SmallVector<AffineExpr, 4> results;
     for (int64_t i = 0, e = map.getNumResults(); i < e; ++i) {
       int64_t idx = map.getResult(i).cast<AffineDimExpr>().getPosition();
       if (idx == index)
         continue;
       // Re-insert remaining indices, but renamed when occurring
       // after the removed index.
-      auto targetExpr =
-          getAffineDimExpr(idx < index ? idx : idx - 1, rewriter.getContext());
+      auto targetExpr = getAffineDimExpr(idx < index ? idx : idx - 1, ctx);
       results.push_back(targetExpr);
     }
-    // Since (...) -> () cannot be represented properly,
-    // we resort to an empty map when this situation happens.
-    return results.empty() ? AffineMap::get(rewriter.getContext())
+    // The (...) -> () affine map has its own factory method.
+    return results.empty() ? AffineMap::get(map.getNumDims() - 1, 0, ctx)
                            : AffineMap::get(map.getNumDims() - 1, 0, results);
   }
 
   // Helper to drop dimension from vector type.
   static Type adjustType(VectorType tp, int64_t index) {
     int64_t rank = tp.getRank();
     Type eltType = tp.getElementType();
     if (rank == 1) {