[mlir][NFC] Replace some llvm::find with llvm::is_contained.

[jacquesguan]

Summary

This patch replaces some llvm::find with llvm::is_contained, it should be more clear.

[rriddle]

mlir/lib/Dialect/SCF/SCF.cpp

2469–2470

Can you remove this lambda all together?

[jacquesguan]

address comment.

mlir/lib/Dialect/SCF/SCF.cpp

2469–2470

done.

mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.td

let methods = [
           SmallVector<OpOperand *> result;
           auto bufferizableOp =
               cast<BufferizableOpInterface>($_op.getOperation());
           for (OpOperand &opOperand : $_op.getOperation()->getOpOperands()) {
             if (!opOperand.get().getType().isa<TensorType>())
               continue;
             SmallVector<OpResult> aliasingOpResults =
                 bufferizableOp.getAliasingOpResult(opOperand, state);
-            if (llvm::find(aliasingOpResults, opResult)
-                != aliasingOpResults.end())
+            if (llvm::is_contained(aliasingOpResults, opResult))
               result.push_back(&opOperand);
           }
           return result;
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return the buffer relation between the given OpResult and its aliasing

mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp

if (!compare || !select || !terminator)
     return false;
 
   // Block arguments must be compared.
   if (compare->getOperands() != block.getArguments())
     return false;
 
   // Detect whether the comparison is less-than or greater-than, otherwise bail.
   bool isLess;
-  if (llvm::find(lessThanPredicates, compare.getPredicate()) !=
-      lessThanPredicates.end()) {
+  if (llvm::is_contained(lessThanPredicates, compare.getPredicate())) {
     isLess = true;
-  } else if (llvm::find(greaterThanPredicates, compare.getPredicate()) !=
-             greaterThanPredicates.end()) {
+  } else if (llvm::is_contained(greaterThanPredicates,
+                                compare.getPredicate())) {
     isLess = false;
   } else {
     return false;
   }
 
   if (select.getCondition() != compare.getResult())
     return false;
 

mlir/lib/Dialect/Bufferization/Transforms/Bufferize.cpp

if (!options) {
       opt.bufferizeFunctionBoundaries = bufferizeFunctionBoundaries;
       opt.promoteBufferResultsToOutParams = promoteBufferResultsToOutParams;
       opt.unknownTypeConversion = parseLayoutMapOption(unknownTypeConversion);
 
       OpFilter::Entry::FilterFn filterFn =
           [&](Operation *op) {
             // Filter may be specified via options.
             if (this->dialectFilter.hasValue())
-              return llvm::find(this->dialectFilter,
-                                op->getDialect()->getNamespace()) !=
-                     this->dialectFilter.end();
+              return llvm::is_contained(this->dialectFilter,
+                                        op->getDialect()->getNamespace());
             // No filter specified: All other ops are allowed.
             return true;
           };
       opt.opFilter.allowOperation(filterFn);
     } else {
       opt = *options;
     }
 

mlir/lib/Dialect/SCF/SCF.cpp

LogicalResult matchAndRewrite(ParallelOp op,
                                 PatternRewriter &rewriter) const override {
     Block &outerBody = op.getLoopBody().front();
     if (!llvm::hasSingleElement(outerBody.without_terminator()))
       return failure();
 
     auto innerOp = dyn_cast<ParallelOp>(outerBody.front());
     if (!innerOp)
       return failure();
 
-    auto hasVal = [](const auto &range, Value val) {
-      return llvm::find(range, val) != range.end();
-    };
-
     for (auto val : outerBody.getArguments())
-      if (hasVal(innerOp.getLowerBound(), val) ||
-          hasVal(innerOp.getUpperBound(), val) ||
-          hasVal(innerOp.getStep(), val))
+      if (llvm::is_contained(innerOp.getLowerBound(), val) ||
+          llvm::is_contained(innerOp.getUpperBound(), val) ||
+          llvm::is_contained(innerOp.getStep(), val))
         return failure();
 
     // Reductions are not supported yet.
     if (!op.getInitVals().empty() || !innerOp.getInitVals().empty())
       return failure();
 
     auto bodyBuilder = [&](OpBuilder &builder, Location /*loc*/,
                            ValueRange iterVals, ValueRange) {

mlir/lib/Dialect/SCF/Utils/AffineCanonicalizationUtils.cpp

LogicalResult scf::canonicalizeMinMaxOpInLoop(RewriterBase &rewriter,
                                               ValueRange operands, bool isMin,
                                               LoopMatcherFn loopMatcher) {
   FlatAffineValueConstraints constraints;
   DenseSet<Value> allIvs;
 
   // Find all iteration variables among `minOp`'s operands add constrain them.
   for (Value operand : operands) {
     // Skip duplicate ivs.
-    if (llvm::find(allIvs, operand) != allIvs.end())
+    if (llvm::is_contained(allIvs, operand))
       continue;
 
     // If `operand` is an iteration variable: Find corresponding loop
     // bounds and step.
     Value iv = operand;
     Value lb, ub, step;
     if (failed(loopMatcher(operand, lb, ub, step)))
       continue;