Use *{Map,Set}::contains (NFC)

[nikic]

LGTM

[kuhar]

LGTM

bolt/include/bolt/Core/BinaryFunction.h

uint64_t getImageSize() const {
     return getLayout().getMainFragment().getImageSize();
   }
 
   /// Return true if the function is a secondary fragment of another function.
   bool isFragment() const { return IsFragment; }
 
   /// Returns if this function is a child of \p Other function.
   bool isChildOf(const BinaryFunction &Other) const {
-    return llvm::is_contained(ParentFragments, &Other);
+    return ParentFragments.contains(&Other);
   }
 
   /// Set the profile data for the number of times the function was called.
   BinaryFunction &setExecutionCount(uint64_t Count) {
     ExecutionCount = Count;
     return *this;
   }
 

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

 bool lazyMapOfSetsIntersectionExists(const MapTy &Map, const ElemTy &E1,
                                      const ElemTy &E2) {
   auto E1Iterator = Map.find(E1);
   auto E2Iterator = Map.find(E2);
   if (E1Iterator == Map.end() || E2Iterator == Map.end())
     return false;
 
   for (const auto &E1SetElem : E1Iterator->second)
-    if (llvm::is_contained(E2Iterator->second, E1SetElem))
+    if (E2Iterator->second.contains(E1SetElem))
       return true;
 
   return false;
 }
 
 /// Implements the heuristic that marks two parameters related if there is
 /// a usage for both in the same strict expression subtree. A strict
 /// expression subtree is a tree which only includes Expr nodes, i.e. no

clang/lib/AST/ASTContext.cpp

void ASTContext::forEachMultiversionedFunctionVersion(
   FD = FD->getMostRecentDecl();
   // FIXME: The order of traversal here matters and depends on the order of
   // lookup results, which happens to be (mostly) oldest-to-newest, but we
   // shouldn't rely on that.
   for (auto *CurDecl :
        FD->getDeclContext()->getRedeclContext()->lookup(FD->getDeclName())) {
     FunctionDecl *CurFD = CurDecl->getAsFunction()->getMostRecentDecl();
     if (CurFD && hasSameType(CurFD->getType(), FD->getType()) &&
-        !llvm::is_contained(SeenDecls, CurFD)) {
+        !SeenDecls.contains(CurFD)) {
       SeenDecls.insert(CurFD);
       Pred(CurFD);
     }
   }
 }
 
 CallingConv ASTContext::getDefaultCallingConvention(bool IsVariadic,
                                                     bool IsCXXMethod,

clang/lib/Lex/Lexer.cpp

void Lexer::codeCompleteIncludedFile(const char *PathStart,
   // if any.
   while (CompletionPoint < BufferEnd) {
     char Next = *(CompletionPoint + 1);
     if (Next == 0 || Next == '\r' || Next == '\n')
       break;
     ++CompletionPoint;
     if (Next == (IsAngled ? '>' : '"'))
       break;
-    if (llvm::is_contained(SlashChars, Next))
+    if (SlashChars.contains(Next))
       break;
   }
 
   PP->setCodeCompletionTokenRange(
       FileLoc.getLocWithOffset(StartOfFilename - BufferStart),
       FileLoc.getLocWithOffset(CompletionPoint - BufferStart));
   PP->CodeCompleteIncludedFile(Dir, IsAngled);
 }

clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp

for (const CheckerInfo &Checker : Data.Checkers) {
     // Enable the checker.
     Tmp.insert(&Checker);
   }
 
   // Calculate enabled checkers with the correct registration order. As this is
   // done recursively, its arguably cheaper, but for sure less error prone to
   // recalculate from scratch.
   auto IsEnabled = [&](const CheckerInfo *Checker) {
-    return llvm::is_contained(Tmp, Checker);
+    return Tmp.contains(Checker);
   };
   for (const CheckerInfo &Checker : Data.Checkers) {
     if (!Checker.isEnabled(Mgr))
       continue;
 
     CheckerInfoSet Deps;
 
     collectWeakDependencies(Checker.WeakDependencies, Mgr, Deps, IsEnabled);
if (PackageIt != Data.Packages.end()) {
                           SuppliedOption, AnOpts, Diags);
       continue;
     }
 
     Diags.Report(diag::err_unknown_analyzer_checker_or_package)
         << SuppliedCheckerOrPackage;
   }
 }
-

llvm/include/llvm/Support/CommandLine.h

public:
   bool isSink() const { return getMiscFlags() & cl::Sink; }
   bool isDefaultOption() const { return getMiscFlags() & cl::DefaultOption; }
 
   bool isConsumeAfter() const {
     return getNumOccurrencesFlag() == cl::ConsumeAfter;
   }
 
   bool isInAllSubCommands() const {
-    return llvm::is_contained(Subs, &SubCommand::getAll());
+    return Subs.contains(&SubCommand::getAll());
   }
 
   //-------------------------------------------------------------------------===
   // Accessor functions set by OptionModifiers
   //
   void setArgStr(StringRef S);
   void setDescription(StringRef S) { HelpStr = S; }
   void setValueStr(StringRef S) { ValueStr = S; }

llvm/lib/CodeGen/FixupStatepointCallerSaved.cpp

for (unsigned Idx = StatepointOpers(&MI).getVarIdx(),
       MachineOperand &MO = MI.getOperand(Idx);
       // Leave `undef` operands as is, StackMaps will rewrite them
       // into a constant.
       if (!MO.isReg() || MO.isImplicit() || MO.isUndef())
         continue;
       Register Reg = MO.getReg();
       assert(Reg.isPhysical() && "Only physical regs are expected");
 
-      if (isCalleeSaved(Reg) && (AllowGCPtrInCSR || !is_contained(GCRegs, Reg)))
+      if (isCalleeSaved(Reg) && (AllowGCPtrInCSR || !GCRegs.contains(Reg)))
         continue;
 
       LLVM_DEBUG(dbgs() << "Will spill " << printReg(Reg, &TRI) << " at index "
                         << Idx << "\n");
 
       if (VisitedRegs.insert(Reg).second)
         RegsToSpill.push_back(Reg);
       OpsToSpill.push_back(Idx);

llvm/lib/IR/DebugInfoMetadata.cpp

 }
 
 bool DIExpression::hasAllLocationOps(unsigned N) const {
   SmallDenseSet<uint64_t, 4> SeenOps;
   for (auto ExprOp : expr_ops())
     if (ExprOp.getOp() == dwarf::DW_OP_LLVM_arg)
       SeenOps.insert(ExprOp.getArg(0));
   for (uint64_t Idx = 0; Idx < N; ++Idx)
-    if (!is_contained(SeenOps, Idx))
+    if (!SeenOps.contains(Idx))
       return false;
   return true;
 }
 
 const DIExpression *DIExpression::extractAddressClass(const DIExpression *Expr,
                                                       unsigned &AddrClass) {
   // FIXME: This seems fragile. Nothing that verifies that these elements
   // actually map to ops and not operands.

llvm/lib/Support/CommandLine.cpp

 void cl::AddExtraVersionPrinter(VersionPrinterTy func) {
   CommonOptions->ExtraVersionPrinters.push_back(func);
 }
 
 StringMap<Option *> &cl::getRegisteredOptions(SubCommand &Sub) {
   initCommonOptions();
   auto &Subs = GlobalParser->RegisteredSubCommands;
   (void)Subs;
-  assert(is_contained(Subs, &Sub));
+  assert(Subs.contains(&Sub));
   return Sub.OptionsMap;
 }
 
 iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
 cl::getRegisteredSubcommands() {
   return GlobalParser->getRegisteredSubcommands();
 }
 

llvm/lib/Transforms/Scalar/GVNSink.cpp

public:
   // resultant order of elements in Blocks needs to be deterministic.
   // Using SmallPtrSet instead causes non-deterministic order while
   // copying. And we cannot simply sort Blocks as they need to match the
   // corresponding Values.
   SmallSetVector<BasicBlock *, 4> &getActiveBlocks() { return ActiveBlocks; }
 
   void restrictToBlocks(SmallSetVector<BasicBlock *, 4> &Blocks) {
     for (auto II = Insts.begin(); II != Insts.end();) {
-      if (!llvm::is_contained(Blocks, (*II)->getParent())) {
+      if (!Blocks.contains((*II)->getParent())) {
         ActiveBlocks.remove((*II)->getParent());
         II = Insts.erase(II);
       } else {
         ++II;
       }
     }
   }
 
public:
 
   /// Restrict the PHI's contents down to only \c NewBlocks.
   /// \c NewBlocks must be a subset of \c this->Blocks.
   void restrictToBlocks(const SmallSetVector<BasicBlock *, 4> &NewBlocks) {
     auto BI = Blocks.begin();
     auto VI = Values.begin();
     while (BI != Blocks.end()) {
       assert(VI != Values.end());
-      if (!llvm::is_contained(NewBlocks, *BI)) {
+      if (!NewBlocks.contains(*BI)) {
         BI = Blocks.erase(BI);
         VI = Values.erase(VI);
       } else {
         ++BI;
         ++VI;
       }
     }
     assert(Blocks.size() == NewBlocks.size());

llvm/tools/llvm-exegesis/lib/Analysis.cpp

 
 namespace {
 
 enum EscapeTag { kEscapeCsv, kEscapeHtml, kEscapeHtmlString };
 
 template <EscapeTag Tag> void writeEscaped(raw_ostream &OS, const StringRef S);
 
 template <> void writeEscaped<kEscapeCsv>(raw_ostream &OS, const StringRef S) {
-  if (!llvm::is_contained(S, kCsvSep)) {
+  if (!S.contains(kCsvSep)) {
     OS << S;
   } else {
     // Needs escaping.
     OS << '"';
     for (const char C : S) {
       if (C == '"')
         OS << "\"\"";
       else

llvm/utils/UnicodeData/UnicodeNameMappingGenerator.cpp

int main(int argc, char **argv) {
   Trie T;
   uint32_t NameCount = 0;
   std::size_t LongestName = 0;
   auto Entries = loadDataFiles(argv[1], argv[2]);
   for (const std::pair<const char32_t, std::string> &Entry : Entries) {
     char32_t Codepoint = Entry.first;
     const std::string &Name = Entry.second;
     // Ignore names which are not valid.
-    if (Name.empty() || !llvm::all_of(Name, [](char C) {
-          return llvm::is_contained(Letters, C);
-        })) {
+    if (Name.empty() ||
+        !llvm::all_of(Name, [](char C) { return Letters.contains(C); })) {
       continue;
     }
     printf("%06x: %s\n", static_cast<unsigned int>(Codepoint), Name.c_str());
     T.insert(Name, Codepoint);
     LongestName =
         std::max(LongestName, std::size_t(llvm::count_if(Name, llvm::isAlnum)));
     NameCount++;
   }

mlir/lib/AsmParser/Parser.cpp

ParseResult Parser::codeCompleteDialectOrElidedOpName(SMLoc loc) {
   // Check to see if there is anything else on the current line. This check
   // isn't strictly necessary, but it does avoid unnecessarily triggering
   // completions for operations and dialects in situations where we don't want
   // them (e.g. at the end of an operation).
   auto shouldIgnoreOpCompletion = [&]() {
     const char *bufBegin = state.lex.getBufferBegin();
     const char *it = loc.getPointer() - 1;
     for (; it > bufBegin && *it != '\n'; --it)
-      if (!llvm::is_contained(StringRef(" \t\r"), *it))
+      if (!StringRef(" \t\r").contains(*it))
         return true;
     return false;
   };
   if (shouldIgnoreOpCompletion())
     return failure();
 
   // The completion here is either for a dialect name, or an operation name
   // whose dialect prefix was elided. For this we simply invoke both of the

mlir/lib/Dialect/GPU/TransformOps/GPUTransformOps.cpp

checkMappingAttributeTypes(std::optional<TransformOpInterface> transformOp,
   countMappingTypes += hasThreadMapping ? 1 : 0;
   if (countMappingTypes > 1) {
     return failureHelper(transformOp, forallOp,
                          "cannot mix different mapping types, use nesting");
   }
 
   DenseSet<Attribute> seen;
   for (Attribute map : forallOp.getMapping()->getValue()) {
-    if (llvm::is_contained(seen, map)) {
+    if (seen.contains(map)) {
       return failureHelper(transformOp, forallOp,
                            "duplicated attribute, cannot map different loops "
                            "to the same processor");
     }
     seen.insert(map);
   }
 
   return DiagnosedSilenceableFailure::success();

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

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