[mlir][Linalg] Clarify error message in YieldOp verification NFC

[ubfx]

Summary

The number of values yielded from a LinalgOp's payload has to match
the number of inits / outs operands of the LinalgOp.
These two numbers got mixed up in the respective error message, this
patch clarifies the message and updates the tests.

[mehdi_amini]

Thanks!

[nicolasvasilache]

thanks!

[ubfx]

Thank you for reviewing, @nicolasvasilache @mehdi_amini . Could one of you commit it to the repository for me?

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

return failure(parser.parseOperandList(opInfo) ||
                  parser.resolveOperands(opInfo, types, loc, result.operands));
 }
 
 // Check the operand number and types must match the element types of the
 // LinalgOp interface's shaped operands.
 static LogicalResult verifyYield(linalg::YieldOp op, LinalgOp linalgOp) {
   if (op.getNumOperands() != linalgOp.getNumDpsInits())
     return op.emitOpError("expected number of yield values (")
-           << linalgOp.getNumDpsInits()
-           << ") to match the number of operands of the enclosing "
-           << "LinalgOp (" << op.getNumOperands() << ")";
+           << op.getNumOperands()
+           << ") to match the number of inits / outs operands of the enclosing "
+           << "LinalgOp (" << linalgOp.getNumDpsInits() << ")";
 
   for (OpOperand &opOperand : op->getOpOperands()) {
     OpOperand *outputOperand =
         linalgOp.getDpsInitOperand(opOperand.getOperandNumber());
     Type elementType = getElementTypeOrSelf(outputOperand->get().getType());
     if (opOperand.get().getType() != elementType)
       return op.emitOpError("type of yield operand ")
              << (opOperand.getOperandNumber() + 1) << " ("

mlir/test/Dialect/Linalg/invalid.mlir

linalg.generic {
     indexing_maps =  [ affine_map<() -> (0)> ],
     iterator_types = []
   } ins(%arg0 : memref<f32>)
 }
 
 // -----
 
 func.func @generic_mismatched_num_returns(%arg0: memref<f32>) {
-  // expected-error @+6 {{op expected number of yield values (1) to match the number of operands of the enclosing LinalgOp (0)}}
+  // expected-error @+6 {{op expected number of yield values (0) to match the number of inits / outs operands of the enclosing LinalgOp (1)}}
   linalg.generic {
       indexing_maps =  [ affine_map<() -> ()> ],
       iterator_types = []}
       outs(%arg0 : memref<f32>) {
     ^bb(%0: f32):
       linalg.yield
   }
 }
linalg.generic {
     ins(%arg0 : memref<f32>)
    outs(%arg0 : memref<f32>) {
   }
 }
 
 // -----
 
 func.func @generic_mismatched_num_arguments(%arg0: memref<f32>) {
-  // expected-error @+6 {{'linalg.yield' op expected number of yield values (2) to match the number of operands of the enclosing LinalgOp (1)}}
+  // expected-error @+6 {{'linalg.yield' op expected number of yield values (1) to match the number of inits / outs operands of the enclosing LinalgOp (2)}}
   linalg.generic {
       indexing_maps =  [ affine_map<() -> ()>, affine_map<() -> ()> ],
       iterator_types = []}
       outs(%arg0, %arg0 : memref<f32>, memref<f32>) {
     ^bb(%f: f32):
       linalg.yield %f: f32
   }
 }

 func.func @map_binary_wrong_yield_operands(
     %lhs: tensor<64xf32>, %rhs: tensor<64xf32>, %init: tensor<64xf32>)
     -> tensor<64xf32> {
    %add = linalg.map
           ins(%lhs, %rhs : tensor<64xf32>, tensor<64xf32>)
           outs(%init:tensor<64xf32>)
           (%lhs_elem: f32, %rhs_elem: f32) {
             %0 = arith.addf %lhs_elem, %rhs_elem: f32
-            // expected-error @+1{{'linalg.yield' op expected number of yield values (1) to match the number of operands of the enclosing LinalgOp (2)}}
+            // expected-error @+1{{'linalg.yield' op expected number of yield values (2) to match the number of inits / outs operands of the enclosing LinalgOp (1)}}
             linalg.yield %0, %0: f32, f32
           }
   func.return %add : tensor<64xf32>
 }
 
 // -----
 
 func.func @map_input_mapper_arity_mismatch(