[mlir][Linalg] NFC - Make consistent use of op.emitOpError

[nicolasvasilache]

Summary

This is part of an ongoing cleanup and uniformization work.

[merge_guards_bot]

Unit tests: pass. 61127 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

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

 
 template <typename GenericOpType>
 LogicalResult verifyBlockArgs(GenericOpType op, Block &block);
 
 template <> LogicalResult verifyBlockArgs(GenericOp op, Block &block) {
   auto nViews = op.getNumInputsAndOutputs();
   auto nInputViews = op.getNumInputs();
   if (block.getNumArguments() != nViews)
-    return op.emitError(
-        "op expected number of block arguments to match number of views");
+    return op.emitOpError(
+        "expected number of block arguments to match number of views");
 
   for (unsigned i = 0; i < nViews; ++i) {
     auto viewType = op.getViewType(i);
     if (viewType.getElementType() != block.getArgument(i)->getType())
-      return op.emitError("op expected block argument ")
+      return op.emitOpError("expected block argument ")
              << i << " of the same type as elemental type of "
              << ((i < nInputViews) ? "input " : "output ")
              << "view: " << viewType;
   }
   return success();
 }
 
 template <> LogicalResult verifyBlockArgs(IndexedGenericOp op, Block &block) {
   auto nInputViews = op.getNumInputs();
   auto nLoops = op.getNumLoops();
   auto nViews = op.getNumInputsAndOutputs();
   if (block.getNumArguments() != nViews + nLoops)
-    return op.emitError(
-        "op expected number of block arguments to match number of views + "
+    return op.emitOpError(
+        "expected number of block arguments to match number of views + "
         "number of loops");
 
   for (unsigned i = 0; i < nLoops; ++i) {
     if (!block.getArgument(i)->getType().isIndex())
-      return op.emitError("op expected block argument ")
+      return op.emitOpError("expected block argument ")
              << i << " to be of IndexType";
   }
 
   for (unsigned i = 0; i < nViews; ++i) {
     unsigned memrefArgIndex = i + nLoops;
     auto viewType = op.getViewType(i);
     if (viewType.getElementType() !=
         block.getArgument(memrefArgIndex)->getType())
-      return op.emitError("op expected block argument ")
+      return op.emitOpError("expected block argument ")
              << memrefArgIndex << " of the same type as elemental type of "
              << ((i < nInputViews) ? "input " : "output ")
              << "view: " << viewType;
   }
   return success();
 }
 
 template <typename GenericOpType>
 LogicalResult verifyFuncArgs(GenericOpType op, FunctionType funType);
 
 template <> LogicalResult verifyFuncArgs(GenericOp op, FunctionType funType) {
   auto nViews = op.getNumInputsAndOutputs();
   auto nInputViews = op.getNumInputs();
   if (funType.getNumInputs() != nViews)
-    return op.emitError("op expected fun arguments to match number of views");
+    return op.emitOpError("expected fun arguments to match number of views");
   if (funType.getNumResults() != op.getNumOutputs())
-    return op.emitError(
-        "op expected fun results to match number of output views");
+    return op.emitOpError(
+        "expected fun results to match number of output views");
 
   for (auto en : llvm::enumerate(op.indexing_maps())) {
     auto idx = en.index();
     auto view = (idx < nInputViews) ? op.getInputViewType(idx)
                                     : op.getOutputViewType(idx - nInputViews);
     if (funType.getInput(idx) != view.getElementType())
-      return op.emitError("op expected fun argument ")
+      return op.emitOpError("expected fun argument ")
              << idx << " of the same type as elemental type "
              << view.getElementType() << " of view " << idx;
 
     if (idx >= nInputViews) {
       auto resultIdx = idx - nInputViews;
       if (funType.getResult(resultIdx) != view.getElementType())
-        return op.emitError("op expected fun result ")
+        return op.emitOpError("expected fun result ")
                << resultIdx << " of the same type as elemental type "
                << view.getElementType() << " of view " << idx;
     }
   }
   return success();
 }
 
 template <>
 LogicalResult verifyFuncArgs(IndexedGenericOp op, FunctionType funType) {
   auto nLoops = op.getNumLoops();
   auto nInputViews = op.getNumInputs();
   auto nOutputs = op.getNumOutputs();
   auto nViews = op.getNumInputsAndOutputs();
   if (funType.getNumInputs() != nViews + nLoops)
-    return op.emitError(
-        "op expected fun arguments to match number of views + number of loops");
+    return op.emitOpError(
+        "expected fun arguments to match number of views + number of loops");
   if (funType.getNumResults() != nOutputs)
-    return op.emitError(
-        "op expected fun results to match number of output views");
+    return op.emitOpError(
+        "expected fun results to match number of output views");
   for (unsigned i = 0; i < nLoops; ++i) {
     if (!funType.getInput(i).isIndex())
-      return op.emitError("op expected fun argument ")
+      return op.emitOpError("expected fun argument ")
              << i << " to be of IndexType";
   }
   for (auto en : llvm::enumerate(op.indexing_maps())) {
     auto idx = en.index();
     auto funIdx = nLoops + idx;
     auto view = (idx < nInputViews) ? op.getInputViewType(idx)
                                     : op.getOutputViewType(idx - nInputViews);
     if (funType.getInput(funIdx) != view.getElementType())
-      return op.emitError("op expected fun argument ")
+      return op.emitOpError("expected fun argument ")
              << funIdx << " of the same type as elemental type "
              << view.getElementType() << " of view " << idx;
 
     if (idx >= nInputViews) {
       auto resultIdx = idx - nInputViews;
       if (funType.getResult(resultIdx) != view.getElementType())
-        return op.emitError("op expected fun result ")
+        return op.emitOpError("expected fun result ")
                << resultIdx << " of the same type as elemental type "
                << view.getElementType() << " of view " << idx;
     }
   }
   return success();
 }
 
 template <typename GenericOpType>
 LogicalResult verifyGenericOp(GenericOpType op) {
   auto nInputViews = op.getNumInputs();
   auto nLoops = op.getNumLoops();
   auto nViews = op.getNumInputsAndOutputs();
   if (nViews != llvm::size(op.views()))
-    return op.emitError("op expected exactly ") << nViews << " view operands";
+    return op.emitOpError("expected exactly ") << nViews << " view operands";
 
   auto &region = op.region();
   auto funOp = op.getFunction();
   auto funType = funOp ? funOp.getType() : FunctionType();
   if (!region.empty()) {
     if (region.getBlocks().size() != 1)
-      return op.emitError("op expected region with 1 block");
+      return op.emitOpError("expected region with 1 block");
     if (failed(verifyBlockArgs(op, region.getBlocks().front())))
       return failure();
   } else {
     if (!funOp || !funOp.getType())
-      return op.emitError(
-          "op expected fun attribute to refer to a defined symbol");
+      return op.emitOpError(
+          "expected fun attribute to refer to a defined symbol");
     if (failed(verifyFuncArgs(op, funType)))
       return failure();
   }
 
   SmallVector<AffineMap, 4> indexingMaps;
   indexingMaps.reserve(op.indexing_maps().size());
   for (auto en : llvm::enumerate(op.indexing_maps())) {
     auto idx = en.index();
     auto m = en.value().template cast<AffineMapAttr>().getValue();
     indexingMaps.push_back(m); // Save reference to map for further checks.
     auto view = (idx < nInputViews) ? op.getInputViewType(idx)
                                     : op.getOutputViewType(idx - nInputViews);
 
     if (m.getNumSymbols() != 0)
-      return op.emitError("op expected indexing_map #")
+      return op.emitOpError("expected indexing_map #")
              << idx << " to have no symbols";
 
     if (m.getNumDims() != nLoops)
-      return op.emitError("op expected indexing_map #")
+      return op.emitOpError("expected indexing_map #")
              << idx << " to have " << nLoops
              << " dim(s) to match the number of loops";
 
     if (m.getNumResults() == 1 && view.getRank() == 0) {
       auto cst = m.getResult(0).template dyn_cast<AffineConstantExpr>();
       if (!cst || cst.getValue() != 0)
-        return op.emitError("op expected indexing_map #")
+        return op.emitOpError("expected indexing_map #")
                << idx << " to be 0 to match 0-D view: " << view;
     }
 
     if (m.getNumResults() != view.getRank())
-      return op.emitError("op expected indexing_map #")
+      return op.emitOpError("expected indexing_map #")
              << idx << " results to match view rank: " << view;
   }
 
   auto concatMap = concatAffineMaps(indexingMaps);
   auto aggregateMap = inversePermutation(concatMap);
   if (!aggregateMap)
-    return op.emitError("op expected the concatenation of maps in indexing_map "
+    return op.emitOpError("expected the concatenation of maps in indexing_map "
                           "to be invertible");
 
   return success();
 }
 
 static LogicalResult verify(GenericOp op) { return verifyGenericOp(op); }
 static LogicalResult verify(IndexedGenericOp op) { return verifyGenericOp(op); }
 
 //===----------------------------------------------------------------------===//
LogicalResult verifyYield(YieldOp op, GenericOpType genericOp) {
   auto nOutputViews = genericOp.getNumOutputs();
   if (op.getNumOperands() != nOutputViews)
     return op.emitOpError("op expected ")
            << nOutputViews << " operand to match enclosing linalg.generic op";
 
   for (unsigned i = 0; i != nOutputViews; ++i) {
     auto elementType = genericOp.getOutputViewType(i).getElementType();
     if (op.getOperand(i)->getType() != elementType)
-      return op.emitError("type of return operand ")
+      return op.emitOpError("type of return operand ")
              << i << " (" << op.getOperand(i)->getType()
              << ") doesn't match view element type (" << elementType << ")";
   }
   return success();
 }
 
 static LogicalResult verify(YieldOp op) {
   auto *parentOp = op.getParentOp();

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

void transformIndexedGenericOpIndices(
   // `linalg.indexed_generic` comes in two flavours. One has a region with a
   // single block that defines the loop body. The other has a `fun` attribute
   // that refers to an existing function symbol. The `fun` function call will be
   // inserted in the loop body in that case.
   //
   // TODO(pifon): Add support for `linalg.indexed_generic` with `fun` attribute.
   auto &region = indexedGenericOp.region();
   if (region.empty()) {
-    indexedGenericOp.emitError("op expected a region");
+    indexedGenericOp.emitOpError("expected a region");
     return;
   }
   auto &block = region.getBlocks().front();
 
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPointToStart(&block);
   for (unsigned i = 0; i < indexedGenericOp.getNumLoops(); ++i) {
     auto rangeIndex = loopIndexToRangeIndex.find(i);