Migrate {starts,ends}with_insensitive to {starts,ends}_with_insensitive (NFC)

[kazu]

Summary

This patch migrates uses of StringRef::{starts,ends}with_insensitive
to StringRef::{starts,ends}_with_insensitive so that we can use names
similar to those used in std::string_view.

Note that the llvm/ directory has migrated in commit
6c3ea866e93003e16fc55d3b5cedd3bc371d1fde.

I'll post a separate patch to deprecate
StringRef::{starts,ends}with_insensitive.

[MyDeveloperDay]

no concerns from the clang-format front.

clang-tools-extra/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

bool checkIfFixItHintIsApplicable(
   return true;
 }
 
 bool nameMatch(StringRef L, StringRef R, bool Strict) {
   if (Strict)
     return L.empty() || R.empty() || L == R;
   // We allow two names if one is a prefix/suffix of the other, ignoring case.
   // Important special case: this is true if either parameter has no name!
-  return L.startswith_insensitive(R) || R.startswith_insensitive(L) ||
-         L.endswith_insensitive(R) || R.endswith_insensitive(L);
+  return L.starts_with_insensitive(R) || R.starts_with_insensitive(L) ||
+         L.ends_with_insensitive(R) || R.ends_with_insensitive(L);
 }
 
 DifferingParamsContainer
 findDifferingParamsInDeclaration(const FunctionDecl *ParameterSourceDeclaration,
                                  const FunctionDecl *OtherDeclaration,
                                  const FunctionDecl *OriginalDeclaration,
                                  bool Strict) {
   DifferingParamsContainer DifferingParams;

clang-tools-extra/clang-tidy/readability/SuspiciousCallArgumentCheck.cpp

 }
 
 /// Check whether the shorter String is a prefix of the longer String.
 static bool applyPrefixHeuristic(StringRef Arg, StringRef Param,
                                  int8_t Threshold) {
   StringRef Shorter = Arg.size() < Param.size() ? Arg : Param;
   StringRef Longer = Arg.size() >= Param.size() ? Arg : Param;
 
-  if (Longer.startswith_insensitive(Shorter))
+  if (Longer.starts_with_insensitive(Shorter))
     return percentage(Shorter.size(), Longer.size()) > Threshold;
 
   return false;
 }
 
 /// Check whether the shorter String is a suffix of the longer String.
 static bool applySuffixHeuristic(StringRef Arg, StringRef Param,
                                  int8_t Threshold) {
   StringRef Shorter = Arg.size() < Param.size() ? Arg : Param;
   StringRef Longer = Arg.size() >= Param.size() ? Arg : Param;
 
-  if (Longer.endswith_insensitive(Shorter))
+  if (Longer.ends_with_insensitive(Shorter))
     return percentage(Shorter.size(), Longer.size()) > Threshold;
 
   return false;
 }
 
 static bool applySubstringHeuristic(StringRef Arg, StringRef Param,
                                     int8_t Threshold) {
 

clang-tools-extra/clangd/CodeComplete.cpp

private:
   }
 
   std::optional<float> fuzzyScore(const CompletionCandidate &C) {
     // Macros can be very spammy, so we only support prefix completion.
     if (((C.SemaResult &&
           C.SemaResult->Kind == CodeCompletionResult::RK_Macro) ||
          (C.IndexResult &&
           C.IndexResult->SymInfo.Kind == index::SymbolKind::Macro)) &&
-        !C.Name.startswith_insensitive(Filter->pattern()))
+        !C.Name.starts_with_insensitive(Filter->pattern()))
       return std::nullopt;
     return Filter->match(C.Name);
   }
 
   CodeCompletion::Scores
   evaluateCompletion(const SymbolQualitySignals &Quality,
                      const SymbolRelevanceSignals &Relevance) {
     using RM = CodeCompleteOptions::CodeCompletionRankingModel;

clang-tools-extra/clangd/CompileCommands.cpp

enum DriverMode : unsigned char {
   DM_CC1 = 4, // When invoked as 'clang -cc1' or after '-Xclang'
   DM_All = 7
 };
 
 // Examine args list to determine if we're in GCC, CL-compatible, or cc1 mode.
 DriverMode getDriverMode(const std::vector<std::string> &Args) {
   DriverMode Mode = DM_GCC;
   llvm::StringRef Argv0 = Args.front();
-  if (Argv0.endswith_insensitive(".exe"))
+  if (Argv0.ends_with_insensitive(".exe"))
     Argv0 = Argv0.drop_back(strlen(".exe"));
-  if (Argv0.endswith_insensitive("cl"))
+  if (Argv0.ends_with_insensitive("cl"))
     Mode = DM_CL;
   for (const llvm::StringRef Arg : Args) {
     if (Arg == "--driver-mode=cl") {
       Mode = DM_CL;
       break;
     }
     if (Arg == "-cc1") {
       Mode = DM_CC1;

clang-tools-extra/clangd/InlayHints.cpp

void processCall(const FunctionDecl *Callee,
     }
   }
 
   static bool isSetter(const FunctionDecl *Callee, const NameVec &ParamNames) {
     if (ParamNames.size() != 1)
       return false;
 
     StringRef Name = getSimpleName(*Callee);
-    if (!Name.startswith_insensitive("set"))
+    if (!Name.starts_with_insensitive("set"))
       return false;
 
     // In addition to checking that the function has one parameter and its
     // name starts with "set", also check that the part after "set" matches
     // the name of the parameter (ignoring case). The idea here is that if
     // the parameter name differs, it may contain extra information that
     // may be useful to show in a hint, as in:
     //   void setTimeout(int timeoutMillis);

clang/lib/Analysis/RetainSummaryManager.cpp

static bool hasRCAnnotation(const Decl *D, StringRef rcAnnotation) {
   for (const auto *Ann : D->specific_attrs<AnnotateAttr>()) {
     if (Ann->getAnnotation() == rcAnnotation)
       return true;
   }
   return false;
 }
 
 static bool isRetain(const FunctionDecl *FD, StringRef FName) {
-  return FName.startswith_insensitive("retain") ||
-         FName.endswith_insensitive("retain");
+  return FName.starts_with_insensitive("retain") ||
+         FName.ends_with_insensitive("retain");
 }
 
 static bool isRelease(const FunctionDecl *FD, StringRef FName) {
-  return FName.startswith_insensitive("release") ||
-         FName.endswith_insensitive("release");
+  return FName.starts_with_insensitive("release") ||
+         FName.ends_with_insensitive("release");
 }
 
 static bool isAutorelease(const FunctionDecl *FD, StringRef FName) {
-  return FName.startswith_insensitive("autorelease") ||
-         FName.endswith_insensitive("autorelease");
+  return FName.starts_with_insensitive("autorelease") ||
+         FName.ends_with_insensitive("autorelease");
 }
 
 static bool isMakeCollectable(StringRef FName) {
   return FName.contains_insensitive("MakeCollectable");
 }
 
 /// A function is OSObject related if it is declared on a subclass
 /// of OSObject, or any of the parameters is a subclass of an OSObject.

clang/lib/CodeGen/TargetInfo.cpp

 
 static std::string qualifyWindowsLibrary(llvm::StringRef Lib) {
   // If the argument does not end in .lib, automatically add the suffix.
   // If the argument contains a space, enclose it in quotes.
   // This matches the behavior of MSVC.
   bool Quote = Lib.contains(' ');
   std::string ArgStr = Quote ? "\"" : "";
   ArgStr += Lib;
-  if (!Lib.endswith_insensitive(".lib") && !Lib.endswith_insensitive(".a"))
+  if (!Lib.ends_with_insensitive(".lib") && !Lib.ends_with_insensitive(".a"))
     ArgStr += ".lib";
   ArgStr += Quote ? "\"" : "";
   return ArgStr;
 }
 
 class WinX86_32TargetCodeGenInfo : public X86_32TargetCodeGenInfo {
 public:
   WinX86_32TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT,

clang/lib/Driver/Driver.cpp

static llvm::Triple computeTargetTriple(const Driver &D,
   }
 
   // If target is RISC-V adjust the target triple according to
   // provided architecture name
   if (Target.isRISCV()) {
     if (Args.hasArg(options::OPT_march_EQ) ||
         Args.hasArg(options::OPT_mcpu_EQ)) {
       StringRef ArchName = tools::riscv::getRISCVArch(Args, Target);
-      if (ArchName.startswith_insensitive("rv32"))
+      if (ArchName.starts_with_insensitive("rv32"))
         Target.setArch(llvm::Triple::riscv32);
-      else if (ArchName.startswith_insensitive("rv64"))
+      else if (ArchName.starts_with_insensitive("rv64"))
         Target.setArch(llvm::Triple::riscv64);
     }
   }
 
   return Target;
 }
 
 // Parse the LTO options and record the type of LTO compilation
case llvm::Triple::Win32:
         break;
       case llvm::Triple::Itanium:
         TC = std::make_unique<toolchains::CrossWindowsToolChain>(*this, Target,
                                                                   Args);
         break;
       case llvm::Triple::MSVC:
       case llvm::Triple::UnknownEnvironment:
         if (Args.getLastArgValue(options::OPT_fuse_ld_EQ)
-                .startswith_insensitive("bfd"))
+                .starts_with_insensitive("bfd"))
           TC = std::make_unique<toolchains::CrossWindowsToolChain>(
               *this, Target, Args);
         else
           TC =
               std::make_unique<toolchains::MSVCToolChain>(*this, Target, Args);
         break;
       }
       break;

clang/lib/Driver/OffloadBundler.cpp

return OffloadKind == "host" || OffloadKind == "openmp" ||
          OffloadKind == "hip" || OffloadKind == "hipv4";
 }
 
 bool OffloadTargetInfo::isOffloadKindCompatible(
     const StringRef TargetOffloadKind) const {
   if (OffloadKind == TargetOffloadKind)
     return true;
   if (BundlerConfig.HipOpenmpCompatible) {
-    bool HIPCompatibleWithOpenMP = OffloadKind.startswith_insensitive("hip") &&
+    bool HIPCompatibleWithOpenMP = OffloadKind.starts_with_insensitive("hip") &&
                                    TargetOffloadKind == "openmp";
     bool OpenMPCompatibleWithHIP =
         OffloadKind == "openmp" &&
-        TargetOffloadKind.startswith_insensitive("hip");
+        TargetOffloadKind.starts_with_insensitive("hip");
     return HIPCompatibleWithOpenMP || OpenMPCompatibleWithHIP;
   }
   return false;
 }
 
 bool OffloadTargetInfo::isTripleValid() const {
   return !Triple.str().empty() && Triple.getArch() != Triple::UnknownArch;
 }

clang/lib/Driver/ToolChains/Arch/RISCV.cpp

StringRef riscv::getRISCVArch(const llvm::opt::ArgList &Args,
   // ilp32e -> rv32e
   // ilp32 | ilp32f | ilp32d -> rv32imafdc
   // lp64 | lp64f | lp64d -> rv64imafdc
   if (const Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
     StringRef MABI = A->getValue();
 
     if (MABI.equals_insensitive("ilp32e"))
       return "rv32e";
-    else if (MABI.startswith_insensitive("ilp32"))
+    else if (MABI.starts_with_insensitive("ilp32"))
       return "rv32imafdc";
-    else if (MABI.startswith_insensitive("lp64"))
+    else if (MABI.starts_with_insensitive("lp64"))
       return "rv64imafdc";
   }
 
   // 4. Choose a default based on the triple
   //
   // We deviate from GCC's defaults here:
   // - On `riscv{XLEN}-unknown-elf` we default to `rv{XLEN}imac`
   // - On all other OSs we use `rv{XLEN}imafdc` (equivalent to `rv{XLEN}gc`)

clang/lib/Driver/ToolChains/Clang.cpp

for (unsigned I = 0; I < Inputs.size(); ++I) {
 
     // TODO: Replace parsing of -march flag. Can be done by storing GPUArch
     //       with each toolchain.
     StringRef GPUArchName;
     if (CurKind == Action::OFK_OpenMP) {
       // Extract GPUArch from -march argument in TC argument list.
       for (unsigned ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) {
         auto ArchStr = StringRef(TCArgs.getArgString(ArgIndex));
-        auto Arch = ArchStr.startswith_insensitive("-march=");
+        auto Arch = ArchStr.starts_with_insensitive("-march=");
         if (Arch) {
           GPUArchName = ArchStr.substr(7);
           Triples += "-";
           break;
         }
       }
       Triples += GPUArchName.str();
     }
for (unsigned I = 0; I < DepInfo.size(); ++I) {
     }
     // TODO: Replace parsing of -march flag. Can be done by storing GPUArch
     //       with each toolchain.
     StringRef GPUArchName;
     if (Dep.DependentOffloadKind == Action::OFK_OpenMP) {
       // Extract GPUArch from -march argument in TC argument list.
       for (unsigned ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) {
         StringRef ArchStr = StringRef(TCArgs.getArgString(ArgIndex));
-        auto Arch = ArchStr.startswith_insensitive("-march=");
+        auto Arch = ArchStr.starts_with_insensitive("-march=");
         if (Arch) {
           GPUArchName = ArchStr.substr(7);
           Triples += "-";
           break;
         }
       }
       Triples += GPUArchName.str();
     }

clang/lib/Format/Format.cpp

const char *StyleOptionHelpDescription =
     "3. 'file:<format_file_path>' to explicitly specify\n"
     "   the configuration file.\n"
     "4. \"{key: value, ...}\" to set specific parameters, e.g.:\n"
     "   --style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
 
 static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
   if (FileName.endswith(".java"))
     return FormatStyle::LK_Java;
-  if (FileName.endswith_insensitive(".js") ||
-      FileName.endswith_insensitive(".mjs") ||
-      FileName.endswith_insensitive(".ts")) {
+  if (FileName.ends_with_insensitive(".js") ||
+      FileName.ends_with_insensitive(".mjs") ||
+      FileName.ends_with_insensitive(".ts")) {
     return FormatStyle::LK_JavaScript; // (module) JavaScript or TypeScript.
   }
   if (FileName.endswith(".m") || FileName.endswith(".mm"))
     return FormatStyle::LK_ObjC;
-  if (FileName.endswith_insensitive(".proto") ||
-      FileName.endswith_insensitive(".protodevel")) {
+  if (FileName.ends_with_insensitive(".proto") ||
+      FileName.ends_with_insensitive(".protodevel")) {
     return FormatStyle::LK_Proto;
   }
-  if (FileName.endswith_insensitive(".textpb") ||
-      FileName.endswith_insensitive(".pb.txt") ||
-      FileName.endswith_insensitive(".textproto") ||
-      FileName.endswith_insensitive(".asciipb")) {
+  if (FileName.ends_with_insensitive(".textpb") ||
+      FileName.ends_with_insensitive(".pb.txt") ||
+      FileName.ends_with_insensitive(".textproto") ||
+      FileName.ends_with_insensitive(".asciipb")) {
     return FormatStyle::LK_TextProto;
   }
-  if (FileName.endswith_insensitive(".td"))
+  if (FileName.ends_with_insensitive(".td"))
     return FormatStyle::LK_TableGen;
-  if (FileName.endswith_insensitive(".cs"))
+  if (FileName.ends_with_insensitive(".cs"))
     return FormatStyle::LK_CSharp;
-  if (FileName.endswith_insensitive(".json"))
+  if (FileName.ends_with_insensitive(".json"))
     return FormatStyle::LK_Json;
-  if (FileName.endswith_insensitive(".sv") ||
-      FileName.endswith_insensitive(".svh") ||
-      FileName.endswith_insensitive(".v") ||
-      FileName.endswith_insensitive(".vh")) {
+  if (FileName.ends_with_insensitive(".sv") ||
+      FileName.ends_with_insensitive(".svh") ||
+      FileName.ends_with_insensitive(".v") ||
+      FileName.ends_with_insensitive(".vh")) {
     return FormatStyle::LK_Verilog;
   }
   return FormatStyle::LK_Cpp;
 }
 
 FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code) {
   const auto GuessedLanguage = getLanguageByFileName(FileName);
   if (GuessedLanguage == FormatStyle::LK_Cpp) {
if (Style.InheritsParentConfig) {
           llvm::MemoryBuffer::getMemBuffer(StyleName, Source, false));
     } else {
       return Style;
     }
   }
 
   // User provided clang-format file using -style=file:path/to/format/file.
   if (!Style.InheritsParentConfig &&
-      StyleName.startswith_insensitive("file:")) {
+      StyleName.starts_with_insensitive("file:")) {
     auto ConfigFile = StyleName.substr(5);
     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
         loadAndParseConfigFile(ConfigFile, FS, &Style, AllowUnknownOptions);
     if (auto EC = Text.getError()) {
       return make_string_error("Error reading " + ConfigFile + ": " +
                                EC.message());
     }
 

clang/lib/Sema/SemaChecking.cpp

bool Sema::SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
   // valid here but if the string is of one the forms described in ACLE then we
   // can check that the supplied fields are integers and within the valid
   // ranges.
   if (Fields.size() > 1) {
     bool FiveFields = Fields.size() == 5;
 
     bool ValidString = true;
     if (IsARMBuiltin) {
-      ValidString &= Fields[0].startswith_insensitive("cp") ||
-                     Fields[0].startswith_insensitive("p");
+      ValidString &= Fields[0].starts_with_insensitive("cp") ||
+                     Fields[0].starts_with_insensitive("p");
       if (ValidString)
         Fields[0] = Fields[0].drop_front(
-            Fields[0].startswith_insensitive("cp") ? 2 : 1);
+            Fields[0].starts_with_insensitive("cp") ? 2 : 1);
 
-      ValidString &= Fields[2].startswith_insensitive("c");
+      ValidString &= Fields[2].starts_with_insensitive("c");
       if (ValidString)
         Fields[2] = Fields[2].drop_front(1);
 
       if (FiveFields) {
-        ValidString &= Fields[3].startswith_insensitive("c");
+        ValidString &= Fields[3].starts_with_insensitive("c");
         if (ValidString)
           Fields[3] = Fields[3].drop_front(1);
       }
     }
 
     SmallVector<int, 5> Ranges;
     if (FiveFields)
       Ranges.append({IsAArch64Builtin ? 1 : 15, 7, 15, 15, 7});

clang/lib/Sema/SemaCodeComplete.cpp

for (auto It = FS.dir_begin(Dir, EC);
         if (LookupType == DirectoryLookup::LT_Framework &&
             NativeRelDir.empty() && !Filename.consume_back(".framework"))
           break;
 
         AddCompletion(Filename, /*IsDirectory=*/true);
         break;
       case llvm::sys::fs::file_type::regular_file: {
         // Only files that really look like headers. (Except in special dirs).
-        const bool IsHeader = Filename.endswith_insensitive(".h") ||
-                              Filename.endswith_insensitive(".hh") ||
-                              Filename.endswith_insensitive(".hpp") ||
-                              Filename.endswith_insensitive(".hxx") ||
-                              Filename.endswith_insensitive(".inc") ||
+        const bool IsHeader = Filename.ends_with_insensitive(".h") ||
+                              Filename.ends_with_insensitive(".hh") ||
+                              Filename.ends_with_insensitive(".hpp") ||
+                              Filename.ends_with_insensitive(".hxx") ||
+                              Filename.ends_with_insensitive(".inc") ||
                               (ExtensionlessHeaders && !Filename.contains('.'));
         if (!IsHeader)
           break;
         AddCompletion(Filename, /*IsDirectory=*/false);
         break;
       }
       default:
         break;

clang/lib/Sema/SemaOpenMP.cpp

ExprResult Sema::ActOnOpenMPCall(ExprResult Call, Scope *Scope,
   if (!CE)
     return Call;
 
   FunctionDecl *CalleeFnDecl = CE->getDirectCallee();
   if (!CalleeFnDecl)
     return Call;
 
   if (LangOpts.OpenMP >= 51 && CalleeFnDecl->getIdentifier() &&
-      CalleeFnDecl->getName().startswith_insensitive("omp_")) {
+      CalleeFnDecl->getName().starts_with_insensitive("omp_")) {
     // checking for any calls inside an Order region
     if (Scope && Scope->isOpenMPOrderClauseScope())
       Diag(LParenLoc, diag::err_omp_unexpected_call_to_omp_runtime_api);
   }
 
   if (!CalleeFnDecl->hasAttr<OMPDeclareVariantAttr>())
     return Call;
 

clang/lib/StaticAnalyzer/Checkers/ContainerModeling.cpp

 }
 
 namespace {
 
 bool isBeginCall(const FunctionDecl *Func) {
   const auto *IdInfo = Func->getIdentifier();
   if (!IdInfo)
     return false;
-  return IdInfo->getName().endswith_insensitive("begin");
+  return IdInfo->getName().ends_with_insensitive("begin");
 }
 
 bool isEndCall(const FunctionDecl *Func) {
   const auto *IdInfo = Func->getIdentifier();
   if (!IdInfo)
     return false;
-  return IdInfo->getName().endswith_insensitive("end");
+  return IdInfo->getName().ends_with_insensitive("end");
 }
 
 const CXXRecordDecl *getCXXRecordDecl(ProgramStateRef State,
                                       const MemRegion *Reg) {
   auto TI = getDynamicTypeInfo(State, Reg);
   if (!TI.isValid())
     return nullptr;
 

clang/lib/StaticAnalyzer/Checkers/Iterator.cpp

bool isIteratorType(const QualType &Type) {
   return isIterator(CRD);
 }
 
 bool isIterator(const CXXRecordDecl *CRD) {
   if (!CRD)
     return false;
 
   const auto Name = CRD->getName();
-  if (!(Name.endswith_insensitive("iterator") ||
-        Name.endswith_insensitive("iter") || Name.endswith_insensitive("it")))
+  if (!(Name.ends_with_insensitive("iterator") ||
+        Name.ends_with_insensitive("iter") || Name.ends_with_insensitive("it")))
     return false;
 
   bool HasCopyCtor = false, HasCopyAssign = true, HasDtor = false,
        HasPreIncrOp = false, HasPostIncrOp = false, HasDerefOp = false;
   for (const auto *Method : CRD->methods()) {
     if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(Method)) {
       if (Ctor->isCopyConstructor()) {
         HasCopyCtor = !Ctor->isDeleted() && Ctor->getAccess() == AS_public;

clang/lib/Tooling/Inclusions/HeaderIncludes.cpp

bool IncludeCategoryManager::isMainHeader(StringRef IncludeName) const {
   //  1) foo.h => foo.cc
   //  2) foo.h => foo.cu.cc
   //  3) foo.proto.h => foo.proto.cc
   //
   // non-main-header examples:
   //  1) foo.h => bar.cc
   //  2) foo.proto.h => foo.cc
   StringRef Matching;
-  if (MatchingFileStem.startswith_insensitive(HeaderStem))
+  if (MatchingFileStem.starts_with_insensitive(HeaderStem))
     Matching = MatchingFileStem; // example 1), 2)
   else if (FileStem.equals_insensitive(HeaderStem))
     Matching = FileStem; // example 3)
   if (!Matching.empty()) {
     llvm::Regex MainIncludeRegex(HeaderStem.str() + Style.IncludeIsMainRegex,
                                  llvm::Regex::IgnoreCase);
     if (MainIncludeRegex.match(Matching))
       return true;

lld/COFF/Driver.cpp

void LinkerDriver::addBuffer(std::unique_ptr<MemoryBuffer> mb,
   case file_magic::coff_cl_gl_object:
     error(filename + ": is not a native COFF file. Recompile without /GL");
     break;
   case file_magic::pecoff_executable:
     if (ctx.config.mingw) {
       ctx.symtab.addFile(make<DLLFile>(ctx, mbref));
       break;
     }
-    if (filename.endswith_insensitive(".dll")) {
+    if (filename.ends_with_insensitive(".dll")) {
       error(filename + ": bad file type. Did you specify a DLL instead of an "
                        "import library?");
       break;
     }
     [[fallthrough]];
   default:
     error(mbref.getBufferIdentifier() + ": unknown file type");
     break;
std::optional<StringRef> LinkerDriver::findFile(StringRef filename) {
   StringRef path = doFindFile(filename);
 
   if (std::optional<sys::fs::UniqueID> id = getUniqueID(path)) {
     bool seen = !visitedFiles.insert(*id).second;
     if (seen)
       return std::nullopt;
   }
 
-  if (path.endswith_insensitive(".lib"))
+  if (path.ends_with_insensitive(".lib"))
     visitedLibs.insert(std::string(sys::path::filename(path).lower()));
   return path;
 }
 
 // MinGW specific. If an embedded directive specified to link to
 // foo.lib, but it isn't found, try libfoo.a instead.
 StringRef LinkerDriver::doFindLibMinGW(StringRef filename) {
   if (filename.contains('/') || filename.contains('\\'))

lld/COFF/DriverUtils.cpp

 // Parses a string in the form of "EMBED[,=<integer>]|NO".
 // Results are directly written to
 // Config.
 void LinkerDriver::parseManifest(StringRef arg) {
   if (arg.equals_insensitive("no")) {
     ctx.config.manifest = Configuration::No;
     return;
   }
-  if (!arg.startswith_insensitive("embed"))
+  if (!arg.starts_with_insensitive("embed"))
     fatal("invalid option " + arg);
   ctx.config.manifest = Configuration::Embed;
   arg = arg.substr(strlen("embed"));
   if (arg.empty())
     return;
-  if (!arg.startswith_insensitive(",id="))
+  if (!arg.starts_with_insensitive(",id="))
     fatal("invalid option " + arg);
   arg = arg.substr(strlen(",id="));
   if (arg.getAsInteger(0, ctx.config.manifestID))
     fatal("invalid option " + arg);
 }
 
 // Parses a string in the form of "level=<string>|uiAccess=<string>|NO".
 // Results are directly written to Config.
 void LinkerDriver::parseManifestUAC(StringRef arg) {
   if (arg.equals_insensitive("no")) {
     ctx.config.manifestUAC = false;
     return;
   }
   for (;;) {
     arg = arg.ltrim();
     if (arg.empty())
       return;
-    if (arg.startswith_insensitive("level=")) {
+    if (arg.starts_with_insensitive("level=")) {
       arg = arg.substr(strlen("level="));
       std::tie(ctx.config.manifestLevel, arg) = arg.split(" ");
       continue;
     }
-    if (arg.startswith_insensitive("uiaccess=")) {
+    if (arg.starts_with_insensitive("uiaccess=")) {
       arg = arg.substr(strlen("uiaccess="));
       std::tie(ctx.config.manifestUIAccess, arg) = arg.split(" ");
       continue;
     }
     fatal("invalid option " + arg);
   }
 }
 
ParsedDirectives ArgParser::parseDirectives(StringRef s) {
   ParsedDirectives result;
   SmallVector<const char *, 16> rest;
 
   // Handle /EXPORT and /INCLUDE in a fast path. These directives can appear for
   // potentially every symbol in the object, so they must be handled quickly.
   SmallVector<StringRef, 16> tokens;
   cl::TokenizeWindowsCommandLineNoCopy(s, saver(), tokens);
   for (StringRef tok : tokens) {
-    if (tok.startswith_insensitive("/export:") ||
-        tok.startswith_insensitive("-export:"))
+    if (tok.starts_with_insensitive("/export:") ||
+        tok.starts_with_insensitive("-export:"))
       result.exports.push_back(tok.substr(strlen("/export:")));
-    else if (tok.startswith_insensitive("/include:") ||
-             tok.startswith_insensitive("-include:"))
+    else if (tok.starts_with_insensitive("/include:") ||
+             tok.starts_with_insensitive("-include:"))
       result.includes.push_back(tok.substr(strlen("/include:")));
-    else if (tok.startswith_insensitive("/exclude-symbols:") ||
-             tok.startswith_insensitive("-exclude-symbols:"))
+    else if (tok.starts_with_insensitive("/exclude-symbols:") ||
+             tok.starts_with_insensitive("-exclude-symbols:"))
       result.excludes.push_back(tok.substr(strlen("/exclude-symbols:")));
     else {
       // Copy substrings that are not valid C strings. The tokenizer may have
       // already copied quoted arguments for us, so those do not need to be
       // copied again.
       bool HasNul = tok.end() != s.end() && tok.data()[tok.size()] == '\0';
       rest.push_back(HasNul ? tok.data() : saver().save(tok).data());
     }

lld/Common/Args.cpp

for (StringRef s : arr) {
     s = s.trim();
     if (!s.empty() && s[0] != '#')
       ret.push_back(s);
   }
   return ret;
 }
 
 StringRef lld::args::getFilenameWithoutExe(StringRef path) {
-  if (path.endswith_insensitive(".exe"))
+  if (path.ends_with_insensitive(".exe"))
     return sys::path::stem(path);
   return sys::path::filename(path);
 }

lld/ELF/ScriptParser.cpp

 }
 
 // Parses Tok as an integer. It recognizes hexadecimal (prefixed with
 // "0x" or suffixed with "H") and decimal numbers. Decimal numbers may
 // have "K" (Ki) or "M" (Mi) suffixes.
 static std::optional<uint64_t> parseInt(StringRef tok) {
   // Hexadecimal
   uint64_t val;
-  if (tok.startswith_insensitive("0x")) {
+  if (tok.starts_with_insensitive("0x")) {
     if (!to_integer(tok.substr(2), val, 16))
       return std::nullopt;
     return val;
   }
-  if (tok.endswith_insensitive("H")) {
+  if (tok.ends_with_insensitive("H")) {
     if (!to_integer(tok.drop_back(), val, 16))
       return std::nullopt;
     return val;
   }
 
   // Decimal
-  if (tok.endswith_insensitive("K")) {
+  if (tok.ends_with_insensitive("K")) {
     if (!to_integer(tok.drop_back(), val, 10))
       return std::nullopt;
     return val * 1024;
   }
-  if (tok.endswith_insensitive("M")) {
+  if (tok.ends_with_insensitive("M")) {
     if (!to_integer(tok.drop_back(), val, 10))
       return std::nullopt;
     return val * 1024 * 1024;
   }
   if (!to_integer(tok, val, 10))
     return std::nullopt;
   return val;
 }

lld/MinGW/Driver.cpp

for (auto *a : args.filtered(OPT_L)) {
     add("-libpath:" + StringRef(a->getValue()));
   }
 
   StringRef prefix = "";
   bool isStatic = false;
   for (auto *a : args) {
     switch (a->getOption().getID()) {
     case OPT_INPUT:
-      if (StringRef(a->getValue()).endswith_insensitive(".def"))
+      if (StringRef(a->getValue()).ends_with_insensitive(".def"))
         add("-def:" + StringRef(a->getValue()));
       else
         add(prefix + StringRef(a->getValue()));
       break;
     case OPT_l:
       add(prefix + searchLibrary(a->getValue(), searchPaths, isStatic));
       break;
     case OPT_whole_archive:

lld/tools/lld/lld.cpp

if (v.size() > 1 && v[1] == StringRef("-flavor")) {
     if (f == Invalid)
       die("Unknown flavor: " + StringRef(v[2]));
     v.erase(v.begin() + 1, v.begin() + 3);
     return f;
   }
 
   // Deduct the flavor from argv[0].
   StringRef arg0 = path::filename(v[0]);
-  if (arg0.endswith_insensitive(".exe"))
+  if (arg0.ends_with_insensitive(".exe"))
     arg0 = arg0.drop_back(4);
   return parseProgname(arg0);
 }
 
 bool inTestOutputDisabled = false;
 
 /// Universal linker main(). This linker emulates the gnu, darwin, or
 /// windows linker based on the argv[0] or -flavor option.