Remove unnecessary conditionals around errors.

[Roger]

Summary

The existing code has unnecessary logic to indirectly pass
errors through function calls. This diff gets rid of the fluff.

Test Plan: Existing unit tests

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

static Error addChildMember(MembersPerArchitectureMap &Members,
   if (!NMOrErr)
     return NMOrErr.takeError();
 
   file_magic Magic = identify_magic(NMOrErr->Buf->getBuffer());
 
   if (Magic == file_magic::bitcode)
     return verifyAndAddIRObject(Members, std::move(*NMOrErr), C);
 
-  if (Error E = verifyAndAddMachOObject(Members, std::move(*NMOrErr), C))
-    return E;
-
-  return Error::success();
+  return verifyAndAddMachOObject(Members, std::move(*NMOrErr), 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))
static Error addMember(MembersPerArchitectureMap &Members,
   if (Magic == file_magic::macho_universal_binary)
     return addUniversalMembers(Members, FileBuffers, std::move(*NMOrErr),
                                FileName, C);
 
   // Bitcode files.
   if (Magic == file_magic::bitcode)
     return verifyAndAddIRObject(Members, std::move(*NMOrErr), C);
 
-  if (Error E = verifyAndAddMachOObject(Members, std::move(*NMOrErr), C))
-    return E;
-  return Error::success();
+  return verifyAndAddMachOObject(Members, std::move(*NMOrErr), 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();
if (!ArchType.empty()) {
     if (NewMembers.find(ArchCPUID) == NewMembers.end())
       return createStringError(std::errc::invalid_argument,
                                "no library created (no object files in input "
                                "files matching -arch_only %s)",
                                ArchType.c_str());
   }
 
   if (NewMembers.size() == 1) {
-    if (Error E =
-            writeArchive(OutputFile, NewMembers.begin()->second,
-                         /*WriteSymtab=*/true,
-                         /*Kind=*/object::Archive::K_DARWIN, C.Deterministic,
-                         /*Thin=*/false))
-      return E;
+    return writeArchive(OutputFile, NewMembers.begin()->second,
+                        /*Thin=*/false);
   } else {
     SmallVector<OwningBinary<Archive>, 2> OutputBinaries;
     for (const std::pair<const uint64_t, std::vector<NewArchiveMember>> &M :
          NewMembers) {
       Expected<std::unique_ptr<MemoryBuffer>> OutputBufferOrErr =
           writeArchiveToBuffer(M.second,
                                /*WriteSymtab=*/true,
                                /*Kind=*/object::Archive::K_DARWIN,
for (const std::pair<const uint64_t, std::vector<NewArchiveMember>> &M :
           OwningBinary<Archive>(std::move(A), std::move(OutputBuffer)));
     }
 
     Expected<SmallVector<Slice, 2>> Slices = buildSlices(OutputBinaries);
     if (!Slices)
       return Slices.takeError();
 
     llvm::stable_sort(*Slices);
-    if (Error E = writeUniversalBinary(*Slices, OutputFile))
-      return E;
+    return writeUniversalBinary(*Slices, OutputFile);
   }
-  return Error::success();
 }
 
 static Expected<Config> parseCommandLine(int Argc, char **Argv) {
   Config C;
   cl::ParseCommandLineOptions(Argc, Argv, "llvm-libtool-darwin\n");
 
   if (LibraryOperation == Operation::None) {
     if (!VersionOption) {