[mlir][linalg] Check the iterator types are valid.

[gysit]

Summary

Improve the LinalgOp verification to ensure the iterator types is known. Previously, unknown iterator types have been ignored without warning, which can lead to confusing bugs.

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

if (failed(OpTrait::impl::verifyNOperands(op, numInputs + numOutputs)))
     return failure();
   // Verify the number of results matches the number of output tensors.
   if (op->getNumResults() != linalgOp.getOutputTensorOperands().size())
     return op->emitOpError("expected the number of results (")
            << op->getNumResults()
            << ") to be equal to the number of output tensors ("
            << linalgOp.getOutputTensorOperands().size() << ")";
 
+  // Check all iterator types are known.
+  auto iteratorTypesRange =
+      linalgOp.iterator_types().getAsValueRange<StringAttr>();
+  for (StringRef iteratorType : iteratorTypesRange) {
+    if (!llvm::is_contained(getAllIteratorTypeNames(), iteratorType))
+      return op->emitOpError("unexpected iterator_type (")
+             << iteratorType << ")";
+  }
+
   // Before checking indexing maps, we need to make sure the attributes
   // referenced by it are valid.
   if (linalgOp.hasDynamicIndexingMaps())
     if (failed(linalgOp.verifyIndexingMapRequiredAttributes()))
       return failure();
 
   // All input/output operands must be indexed.
   if (static_cast<int64_t>(linalgOp.indexing_maps().size()) !=

mlir/test/Dialect/Linalg/invalid.mlir

iterator_types = ["parallel"]}
       outs(%arg0 : memref<1xi32>) {
     ^bb(%i : i32):
     linalg.yield %i : i32
   }
 }
 
 // -----
 
+func @generic_wrong_iterator(%arg0: memref<1xi32>) {
+  // expected-error @+1 {{op unexpected iterator_type (random)}}
+  linalg.generic {
+    indexing_maps =  [ affine_map<(i) -> (i)> ],
+    iterator_types = ["random"]}
+      outs(%arg0 : memref<1xi32>) {
+    ^bb(%i : i32):
+    linalg.yield %i : i32
+  }
+}
+
+// -----
+
 func @generic_one_d_view(%arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>) {
   // expected-error @+1 {{expected operand rank (1) to match the result rank of indexing_map #0 (2)}}
   linalg.generic {
     indexing_maps =  [ affine_map<() -> (0, 0)> ],
     iterator_types = []}
       outs(%arg0 : memref<?xf32, affine_map<(i)[off]->(off + i)>>) {
     ^bb(%f : f32):
       linalg.yield %f: f32