[NFC][llvm-libtool-darwin] Clean up names

[Roger]

Summary

Removing unclear abbreviations.

[jhenderson]

It would be preferable if this change was made first before your other changes, I think. That way you don't add stuff that is just going to be immediately changed again. Other than that and the nit, LGTM.

llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp

234

Nit: clang-format your changes.

[Roger]

Ran clang-tidy.

[Roger]

In D113215#3111004, @jhenderson wrote:

It would be preferable if this change was made first before your other changes, I think. That way you don't add stuff that is just going to be immediately changed again. Other than that and the nit, LGTM.

Good point, I'll remember that for next time :)

[Roger]

Moving this to lower in the diff stack

[Roger]

Rebasing.

[Roger]

Rebase

llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp

else
       return C.ArchCPUSubtype == FileCPUSubtype;
 
   default:
     return true;
   }
 }
 
 static Error verifyAndAddMachOObject(MembersPerArchitectureMap &Members,
                                      NewArchiveMember Member, const Config &C) {
   auto MBRef = Member.Buf->getMemBufferRef();
   Expected<std::unique_ptr<object::ObjectFile>> ObjOrErr =
       object::ObjectFile::createObjectFile(MBRef);
 
   // Throw error if not a valid object file.
   if (!ObjOrErr)
     return createFileError(Member.MemberName, ObjOrErr.takeError());
 
static Error verifyAndAddIRObject(MembersPerArchitectureMap &Members,
 
   uint64_t FileCPUID = getCPUID(*FileCPUTypeOrErr, *FileCPUSubTypeOrErr);
   Members[FileCPUID].push_back(std::move(Member));
   return Error::success();
 }
 
 static Error addChildMember(MembersPerArchitectureMap &Members,
                             const object::Archive::Child &M, const Config &C) {
-  Expected<NewArchiveMember> NMOrErr =
+  Expected<NewArchiveMember> NewMemberOrErr =
       NewArchiveMember::getOldMember(M, C.Deterministic);
-  if (!NMOrErr)
-    return NMOrErr.takeError();
+  if (!NewMemberOrErr)
+    return NewMemberOrErr.takeError();
+  auto &NewMember = *NewMemberOrErr;
 
-  file_magic Magic = identify_magic(NMOrErr->Buf->getBuffer());
+  file_magic Magic = identify_magic(NewMember.Buf->getBuffer());
 
   if (Magic == file_magic::bitcode)
-    return verifyAndAddIRObject(Members, std::move(*NMOrErr), C);
+    return verifyAndAddIRObject(Members, std::move(NewMember), C);
 
-  return verifyAndAddMachOObject(Members, std::move(*NMOrErr), C);
+  return verifyAndAddMachOObject(Members, std::move(NewMember), C);
 }
 
 static Error processArchive(MembersPerArchitectureMap &Members,
                             object::Archive &Lib, StringRef FileName,
                             const Config &C) {
   Error Err = Error::success();
   for (const object::Archive::Child &Child : Lib.children(Err))
     if (Error E = addChildMember(Members, Child, C))
       return createFileError(FileName, std::move(E));
   if (Err)
     return createFileError(FileName, std::move(Err));
 
   return Error::success();
 }
 
 static Error
 addArchiveMembers(MembersPerArchitectureMap &Members,
                   std::vector<std::unique_ptr<MemoryBuffer>> &ArchiveBuffers,
-                  NewArchiveMember NM, StringRef FileName, const Config &C) {
+                  NewArchiveMember NewMember, StringRef FileName,
+                  const Config &C) {
   Expected<std::unique_ptr<Archive>> LibOrErr =
-      object::Archive::create(NM.Buf->getMemBufferRef());
+      object::Archive::create(NewMember.Buf->getMemBufferRef());
   if (!LibOrErr)
     return createFileError(FileName, LibOrErr.takeError());
 
   if (Error E = processArchive(Members, **LibOrErr, FileName, C))
     return E;
 
   // Update vector ArchiveBuffers with the MemoryBuffers to transfer
   // ownership.
-  ArchiveBuffers.push_back(std::move(NM.Buf));
+  ArchiveBuffers.push_back(std::move(NewMember.Buf));
   return Error::success();
 }
 
 static Error addUniversalMembers(
     MembersPerArchitectureMap &Members,
     std::vector<std::unique_ptr<MemoryBuffer>> &UniversalBuffers,
-    NewArchiveMember NM, StringRef FileName, const Config &C) {
+    NewArchiveMember NewMember, StringRef FileName, const Config &C) {
   Expected<std::unique_ptr<MachOUniversalBinary>> BinaryOrErr =
-      MachOUniversalBinary::create(NM.Buf->getMemBufferRef());
+      MachOUniversalBinary::create(NewMember.Buf->getMemBufferRef());
   if (!BinaryOrErr)
     return createFileError(FileName, BinaryOrErr.takeError());
 
   auto *UO = BinaryOrErr->get();
   for (const MachOUniversalBinary::ObjectForArch &O : UO->objects()) {
 
     Expected<std::unique_ptr<MachOObjectFile>> MachOObjOrErr =
         O.getAsObjectFile();
for (const MachOUniversalBinary::ObjectForArch &O : UO->objects()) {
     Error CombinedError = joinErrors(
         ArchiveOrError.takeError(),
         joinErrors(IRObjectOrError.takeError(), MachOObjOrErr.takeError()));
     return createFileError(FileName, std::move(CombinedError));
   }
 
   // Update vector UniversalBuffers with the MemoryBuffers to transfer
   // ownership.
-  UniversalBuffers.push_back(std::move(NM.Buf));
+  UniversalBuffers.push_back(std::move(NewMember.Buf));
   return Error::success();
 }
 
 static Error addMember(MembersPerArchitectureMap &Members,
                        std::vector<std::unique_ptr<MemoryBuffer>> &FileBuffers,
                        StringRef FileName, const Config &C) {
-  Expected<NewArchiveMember> NMOrErr =
+  Expected<NewArchiveMember> NewMemberOrErr =
       NewArchiveMember::getFile(FileName, C.Deterministic);
-  if (!NMOrErr)
-    return createFileError(FileName, NMOrErr.takeError());
+  if (!NewMemberOrErr)
+    return createFileError(FileName, NewMemberOrErr.takeError());
+  auto &NewMember = *NewMemberOrErr;
 
   // For regular archives, use the basename of the object path for the member
   // name.
-  NMOrErr->MemberName = sys::path::filename(NMOrErr->MemberName);
-  file_magic Magic = identify_magic(NMOrErr->Buf->getBuffer());
+  NewMember.MemberName = sys::path::filename(NewMember.MemberName);
+  file_magic Magic = identify_magic(NewMember.Buf->getBuffer());
 
   // Flatten archives.
   if (Magic == file_magic::archive)
-    return addArchiveMembers(Members, FileBuffers, std::move(*NMOrErr),
+    return addArchiveMembers(Members, FileBuffers, std::move(NewMember),
                              FileName, C);
 
   // Flatten universal files.
   if (Magic == file_magic::macho_universal_binary)
-    return addUniversalMembers(Members, FileBuffers, std::move(*NMOrErr),
+    return addUniversalMembers(Members, FileBuffers, std::move(NewMember),
                                FileName, C);
 
   // Bitcode files.
   if (Magic == file_magic::bitcode)
-    return verifyAndAddIRObject(Members, std::move(*NMOrErr), C);
+    return verifyAndAddIRObject(Members, std::move(NewMember), C);
 
-  return verifyAndAddMachOObject(Members, std::move(*NMOrErr), C);
+  return verifyAndAddMachOObject(Members, std::move(NewMember), C);
 }
 
 static Expected<SmallVector<Slice, 2>>
 buildSlices(ArrayRef<OwningBinary<Archive>> OutputBinaries) {
   SmallVector<Slice, 2> Slices;
 
   for (const auto &OB : OutputBinaries) {
     const Archive &A = *OB.getBinary();