[llvm-link][NFC] Minor cleanup

[sdmitriev]

Summary

llvm::Linker::linkModules() is a static member, so there is no need
to pass reference to llvm::Linker instance to loadArFile() function.

[tra]

llvm::Linker::linkModules() is a static member, so there is no need
to pass reference to llvm::Linker instance to loadArFile() function.

I think you are relying on implementation details here. All you know within the llvm-link.cpp is that you're operating on an instance of class Linker. How it's implemented and whether Linker::linkModules happens to be a static member may change at any point in time.
Eliminating one function argument does not buy us anything here, as far as I can see.

[sdmitriev]

Well, when you use a class you have to know the interface it defines, so this is not about the implementation details, but about the interface provided by the class. llvm::Linker::linkModules(), as it is defined today, is a static member of the class, so it does not require an instance of llvm::Linker class to be called. Adding an additional parameter to loadArFile just in case does not buy as anything at all except unneeded redundancy. And, by the way, this function is called as a static member (i.e. Linker::linkModules()) everywhere in LLVM sources except llvm-link.cpp:

llvm/lib/Linker/LinkModules.cpp, line 605
llvm/tools/bugpoint/BugDriver.cpp, line 149
llvm/tools/bugpoint/Miscompilation.cpp, lines 233, 396, ...
llvm/unittests/Linker/LinkModulesTest.cpp, lines 101, 175, 182, ...

[tra]

In D92918#2444389, @sdmitriev wrote:

And, by the way, this function is called as a static member (i.e. Linker::linkModules()) everywhere in LLVM sources except llvm-link.cpp:

Fair enough. Making the calls consistent is beneficial.

llvm/tools/llvm-link/llvm-link.cpp

static std::unique_ptr<Module> loadFile(const char *argv0,
   if (MaterializeMetadata) {
     ExitOnErr(Result->materializeMetadata());
     UpgradeDebugInfo(*Result);
   }
 
   return Result;
 }
 
-static std::unique_ptr<Module> loadArFile(const char *Argv0,
-                                          std::unique_ptr<MemoryBuffer> Buffer,
-                                          LLVMContext &Context, Linker &L,
-                                          unsigned OrigFlags,
-                                          unsigned ApplicableFlags) {
+static std::unique_ptr<Module>
+loadArFile(const char *Argv0, std::unique_ptr<MemoryBuffer> Buffer,
+           LLVMContext &Context, unsigned OrigFlags, unsigned ApplicableFlags) {
   std::unique_ptr<Module> Result(new Module("ArchiveModule", Context));
   StringRef ArchiveName = Buffer->getBufferIdentifier();
   if (Verbose)
     errs() << "Reading library archive file '" << ArchiveName
            << "' to memory\n";
   Error Err = Error::success();
   object::Archive Archive(*Buffer, Err);
   ExitOnErr(std::move(Err));
   for (const object::Archive::Child &C : Archive.children(Err)) {
     Expected<StringRef> Ename = C.getName();
     if (Error E = Ename.takeError()) {
       errs() << Argv0 << ": ";
       WithColor::error()
           << " failed to read name of archive member"
           << ArchiveName << "'\n";
       return nullptr;
-    };
+    }
     std::string ChildName = Ename.get().str();
     if (Verbose)
       errs() << "Parsing member '" << ChildName
              << "' of archive library to module.\n";
     SMDiagnostic ParseErr;
     Expected<MemoryBufferRef> MemBuf = C.getMemoryBufferRef();
     if (Error E = MemBuf.takeError()) {
       errs() << Argv0 << ": ";
if (!M.get()) {
       errs() << Argv0 << ": ";
       WithColor::error() << " parsing member '" << ChildName
                          << "' of archive library failed'" << ArchiveName
                          << "'\n";
       return nullptr;
     }
     if (Verbose)
       errs() << "Linking member '" << ChildName << "' of archive library.\n";
-    if (L.linkModules(*Result, std::move(M), ApplicableFlags))
+    if (Linker::linkModules(*Result, std::move(M), ApplicableFlags))
       return nullptr;
     ApplicableFlags = OrigFlags;
   } // end for each child
   ExitOnErr(std::move(Err));
   return Result;
 }
 
 namespace {
static bool linkFiles(const char *argv0, LLVMContext &Context, Linker &L,
   // Similar to some flags, internalization doesn't apply to the first file.
   bool InternalizeLinkedSymbols = false;
   for (const auto &File : Files) {
     std::unique_ptr<MemoryBuffer> Buffer =
         ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(File)));
 
     std::unique_ptr<Module> M =
         identify_magic(Buffer->getBuffer()) == file_magic::archive
-            ? loadArFile(argv0, std::move(Buffer), Context, L, Flags,
+            ? loadArFile(argv0, std::move(Buffer), Context, Flags,
                          ApplicableFlags)
             : loadFile(argv0, std::move(Buffer), Context);
     if (!M.get()) {
       errs() << argv0 << ": ";
       WithColor::error() << " loading file '" << File << "'\n";
       return false;
     }