[mlir][scf][bufferize] Update verifyAnalysis error message

[springerm]

Summary

The previous error message was technically incorrect. We do not compare equivalence of YieldOp operands and ForOp operands.

Depends On D124933

mlir/lib/Dialect/SCF/Transforms/BufferizableOpInterfaceImpl.cpp

for (OpResult opResult : op->getOpResults()) {
       if (!opResult.getType().isa<TensorType>())
         continue;
 
       // Note: This is overly strict. We should check for aliasing bufferized
       // values. But we don't have a "must-alias" analysis yet.
       if (bufferRelation(op, opResult, state) != BufferRelation::Equivalent)
         return yieldOp->emitError()
                << "Yield operand #" << opResult.getResultNumber()
-               << " does not bufferize to a buffer that is aliasing the "
-                  "matching enclosing scf::for operand";
+               << " is not equivalent to the corresponding iter bbArg";
     }
 
     return success();
   }
 };
 
 /// Bufferization of scf.yield. Bufferized as part of their enclosing ops, so
 /// this is for analysis only.

mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize-invalid.mlir

%r0:2 = scf.for %i = %lb to %ub step %step iter_args(%tA = %A, %tB = %B)
       -> (tensor<?xf32>, tensor<?xf32>)
   {
     %ttA = tensor.insert_slice %C into %tA[0][4][1] : tensor<4xf32> into tensor<?xf32>
     %ttB = tensor.insert_slice %C into %tB[0][4][1] : tensor<4xf32> into tensor<?xf32>
 
     // Throw a wrench in the system by swapping yielded values: this result in a
     // ping-pong of values at each iteration on which we currently want to fail.
 
-    // expected-error @+1 {{Yield operand #0 does not bufferize to a buffer that is aliasing}}
+    // expected-error @+1 {{Yield operand #0 is not equivalent to the corresponding iter bbArg}}
     scf.yield %ttB, %ttA : tensor<?xf32>, tensor<?xf32>
   }
 
   %f0 = tensor.extract %r0#0[%step] : tensor<?xf32>
   %f1 = tensor.extract %r0#1[%step] : tensor<?xf32>
   return %f0, %f1: f32, f32
 }
 
 // -----
 
 func.func private @fun_with_side_effects(%A: tensor<?xf32> {bufferization.writable = true})
 
 func.func @foo(%A: tensor<?xf32> {bufferization.writable = true}) -> (tensor<?xf32>) {
   call @fun_with_side_effects(%A) : (tensor<?xf32>) -> ()
   return %A: tensor<?xf32>
 }
 
 func.func @scf_yield_needs_copy(%A : tensor<?xf32> {bufferization.writable = true}, %iters : index) {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %res = scf.for %arg0 = %c0 to %iters step %c1 iter_args(%bbarg = %A) -> (tensor<?xf32>) {
     %r = func.call @foo(%A) : (tensor<?xf32>) -> (tensor<?xf32>)
-    // expected-error @+1 {{Yield operand #0 does not bufferize to a buffer that is aliasing}}
+    // expected-error @+1 {{Yield operand #0 is not equivalent to the corresponding iter bbArg}}
     scf.yield %r : tensor<?xf32>
   }
   call @fun_with_side_effects(%res) : (tensor<?xf32>) -> ()
   return
 }
 
 // -----