[NFC][lld][COFF] Rename findFile* methods

[aeubanks]

Summary

findFile returns null if we've already seen the file, make that clearer.

[rnk]

I think it's an improvement, but I want feedback from @mstorsjo

[mstorsjo]

LGTM - I think this is slightly more understandable. (I don't have all these codepaths freshly in mind right now, but from reading the diff, it looks reasonable and clearly more understandable than before.)

lld/COFF/Driver.h

public:
   MemoryBufferRef takeBuffer(std::unique_ptr<MemoryBuffer> mb);
 
   void enqueuePath(StringRef path, bool wholeArchive, bool lazy);
 
   std::unique_ptr<llvm::TarWriter> tar; // for /linkrepro
 
 private:
   // Searches a file from search paths.
-  std::optional<StringRef> findFile(StringRef filename);
-  std::optional<StringRef> findLib(StringRef filename);
-  StringRef doFindFile(StringRef filename);
-  StringRef doFindLib(StringRef filename);
-  StringRef doFindLibMinGW(StringRef filename);
+  std::optional<StringRef> findFileIfNew(StringRef filename);
+  std::optional<StringRef> findLibIfNew(StringRef filename);
+  StringRef findFile(StringRef filename);
+  StringRef findLib(StringRef filename);
+  StringRef findLibMinGW(StringRef filename);
 
   bool findUnderscoreMangle(StringRef sym);
 
   // Determines the location of the sysroot based on `args`, environment, etc.
   void detectWinSysRoot(const llvm::opt::InputArgList &args);
 
   // Symbol names are mangled by prepending "_" on x86.
   StringRef mangle(StringRef sym);

lld/COFF/Driver.cpp

enqueueTask([=]() {
     if (ec) {
       // Retry reading the file (synchronously) now that we may have added
       // winsysroot search paths from SymbolTable::addFile().
       // Retrying synchronously is important for keeping the order of inputs
       // consistent.
       // This makes it so that if the user passes something in the winsysroot
       // before something we can find with an architecture, we won't find the
       // winsysroot file.
-      if (std::optional<StringRef> retryPath = findFile(pathStr)) {
+      if (std::optional<StringRef> retryPath = findFileIfNew(pathStr)) {
         auto retryMb = MemoryBuffer::getFile(*retryPath, /*IsText=*/false,
                                              /*RequiresNullTerminator=*/false);
         ec = retryMb.getError();
         if (!ec)
           mb = std::move(*retryMb);
       } else {
         // We've already handled this file.
         return;
for (auto *arg : directives.args) {
     switch (arg->getOption().getID()) {
     case OPT_aligncomm:
       parseAligncomm(arg->getValue());
       break;
     case OPT_alternatename:
       parseAlternateName(arg->getValue());
       break;
     case OPT_defaultlib:
-      if (std::optional<StringRef> path = findLib(arg->getValue()))
+      if (std::optional<StringRef> path = findLibIfNew(arg->getValue()))
         enqueuePath(*path, false, false);
       break;
     case OPT_entry:
       ctx.config.entry = addUndefined(mangle(arg->getValue()));
       break;
     case OPT_failifmismatch:
       checkFailIfMismatch(arg->getValue(), file);
       break;
     case OPT_incl:
       addUndefined(arg->getValue());
       break;
     case OPT_manifestdependency:
       ctx.config.manifestDependencies.insert(arg->getValue());
       break;
     case OPT_merge:
       parseMerge(arg->getValue());
       break;
     case OPT_nodefaultlib:
-      ctx.config.noDefaultLibs.insert(doFindLib(arg->getValue()).lower());
+      ctx.config.noDefaultLibs.insert(findLib(arg->getValue()).lower());
       break;
     case OPT_release:
       ctx.config.writeCheckSum = true;
       break;
     case OPT_section:
       parseSection(arg->getValue());
       break;
     case OPT_stack:
default:
       error(arg->getSpelling() + " is not allowed in .drectve (" +
             toString(file) + ")");
     }
   }
 }
 
 // Find file from search paths. You can omit ".obj", this function takes
 // care of that. Note that the returned path is not guaranteed to exist.
-StringRef LinkerDriver::doFindFile(StringRef filename) {
+StringRef LinkerDriver::findFile(StringRef filename) {
   auto getFilename = [this](StringRef filename) -> StringRef {
     if (ctx.config.vfs)
       if (auto statOrErr = ctx.config.vfs->status(filename))
         return saver().save(statOrErr->getName());
     return filename;
   };
 
   bool hasPathSep = (filename.find_first_of("/\\") != StringRef::npos);
static std::optional<sys::fs::UniqueID> getUniqueID(StringRef path) {
   sys::fs::UniqueID ret;
   if (sys::fs::getUniqueID(path, ret))
     return std::nullopt;
   return ret;
 }
 
 // Resolves a file path. This never returns the same path
 // (in that case, it returns std::nullopt).
-std::optional<StringRef> LinkerDriver::findFile(StringRef filename) {
-  StringRef path = doFindFile(filename);
+std::optional<StringRef> LinkerDriver::findFileIfNew(StringRef filename) {
+  StringRef path = findFile(filename);
 
   if (std::optional<sys::fs::UniqueID> id = getUniqueID(path)) {
     bool seen = !visitedFiles.insert(*id).second;
     if (seen)
       return std::nullopt;
   }
 
   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) {
+StringRef LinkerDriver::findLibMinGW(StringRef filename) {
   if (filename.contains('/') || filename.contains('\\'))
     return filename;
 
   SmallString<128> s = filename;
   sys::path::replace_extension(s, ".a");
   StringRef libName = saver().save("lib" + s.str());
-  return doFindFile(libName);
+  return findFile(libName);
 }
 
 // Find library file from search path.
-StringRef LinkerDriver::doFindLib(StringRef filename) {
+StringRef LinkerDriver::findLib(StringRef filename) {
   // Add ".lib" to Filename if that has no file extension.
   bool hasExt = filename.contains('.');
   if (!hasExt)
     filename = saver().save(filename + ".lib");
-  StringRef ret = doFindFile(filename);
+  StringRef ret = findFile(filename);
   // For MinGW, if the find above didn't turn up anything, try
   // looking for a MinGW formatted library name.
   if (ctx.config.mingw && ret == filename)
-    return doFindLibMinGW(filename);
+    return findLibMinGW(filename);
   return ret;
 }
 
 // Resolves a library path. /nodefaultlib options are taken into
 // consideration. This never returns the same path (in that case,
 // it returns std::nullopt).
-std::optional<StringRef> LinkerDriver::findLib(StringRef filename) {
+std::optional<StringRef> LinkerDriver::findLibIfNew(StringRef filename) {
   if (ctx.config.noDefaultLibAll)
     return std::nullopt;
   if (!visitedLibs.insert(filename.lower()).second)
     return std::nullopt;
 
-  StringRef path = doFindLib(filename);
+  StringRef path = findLib(filename);
   if (ctx.config.noDefaultLibs.count(path.lower()))
     return std::nullopt;
 
   if (std::optional<sys::fs::UniqueID> id = getUniqueID(path))
     if (!visitedFiles.insert(*id).second)
       return std::nullopt;
   return path;
 }
if (!ctx.config.exports.empty())
       return;
     if (args.hasArg(OPT_exclude_all_symbols))
       return;
   }
 
   AutoExporter exporter(ctx, excludedSymbols);
 
   for (auto *arg : args.filtered(OPT_wholearchive_file))
-    if (std::optional<StringRef> path = doFindFile(arg->getValue()))
+    if (std::optional<StringRef> path = findFile(arg->getValue()))
       exporter.addWholeArchive(*path);
 
   for (auto *arg : args.filtered(OPT_exclude_symbols)) {
     SmallVector<StringRef, 2> vec;
     StringRef(arg->getValue()).split(vec, ',');
     for (StringRef sym : vec)
       exporter.addExcludedSymbol(mangle(sym));
   }
if (auto *arg = args.getLastArg(OPT_machine)) {
     config->machine = getMachineType(arg->getValue());
     if (config->machine == IMAGE_FILE_MACHINE_UNKNOWN)
       fatal(Twine("unknown /machine argument: ") + arg->getValue());
     addWinSysRootLibSearchPaths();
   }
 
   // Handle /nodefaultlib:<filename>
   for (auto *arg : args.filtered(OPT_nodefaultlib))
-    config->noDefaultLibs.insert(doFindLib(arg->getValue()).lower());
+    config->noDefaultLibs.insert(findLib(arg->getValue()).lower());
 
   // Handle /nodefaultlib
   if (args.hasArg(OPT_nodefaultlib_all))
     config->noDefaultLibAll = true;
 
   // Handle /base
   if (auto *arg = args.getLastArg(OPT_base))
     parseNumbers(arg->getValue(), &config->imageBase);
if (config->incremental && config->doICF != ICFLevel::None) {
     config->incremental = false;
   }
 
   if (errorCount())
     return;
 
   std::set<sys::fs::UniqueID> wholeArchives;
   for (auto *arg : args.filtered(OPT_wholearchive_file))
-    if (std::optional<StringRef> path = doFindFile(arg->getValue()))
+    if (std::optional<StringRef> path = findFile(arg->getValue()))
       if (std::optional<sys::fs::UniqueID> id = getUniqueID(*path))
         wholeArchives.insert(*id);
 
   // A predicate returning true if a given path is an argument for
   // /wholearchive:, or /wholearchive is enabled globally.
   // This function is a bit tricky because "foo.obj /wholearchive:././foo.obj"
   // needs to be handled as "/wholearchive:foo.obj foo.obj".
   auto isWholeArchive = [&](StringRef path) -> bool {
case OPT_end_lib:
       inLib = false;
       break;
     case OPT_start_lib:
       if (inLib)
         error("nested " + arg->getSpelling());
       inLib = true;
       break;
     case OPT_wholearchive_file:
-      if (std::optional<StringRef> path = findFile(arg->getValue()))
+      if (std::optional<StringRef> path = findFileIfNew(arg->getValue()))
         enqueuePath(*path, true, inLib);
       break;
     case OPT_INPUT:
-      if (std::optional<StringRef> path = findFile(arg->getValue()))
+      if (std::optional<StringRef> path = findFileIfNew(arg->getValue()))
         enqueuePath(*path, isWholeArchive(*path), inLib);
       break;
     default:
       // Ignore other options.
       break;
     }
   }
 
if (config->machine == IMAGE_FILE_MACHINE_UNKNOWN) {
     config->machine = AMD64;
     addWinSysRootLibSearchPaths();
   }
   config->wordsize = config->is64() ? 8 : 4;
 
   // Process files specified as /defaultlib. These must be processed after
   // addWinSysRootLibSearchPaths(), which is why they are in a separate loop.
   for (auto *arg : args.filtered(OPT_defaultlib))
-    if (std::optional<StringRef> path = findLib(arg->getValue()))
+    if (std::optional<StringRef> path = findLibIfNew(arg->getValue()))
       enqueuePath(*path, false, false);
   run();
   if (errorCount())
     return;
 
   // Handle /RELEASE
   if (args.hasArg(OPT_release))
     config->writeCheckSum = true;