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

[Roger]

Removing unnecessary else statements.

[• toddcarmay]

This comment was removed by tstellar.

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;
-  } 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,
-                               C.Deterministic,
-                               /*Thin=*/false);
-      if (!OutputBufferOrErr)
-        return OutputBufferOrErr.takeError();
-      std::unique_ptr<MemoryBuffer> &OutputBuffer = OutputBufferOrErr.get();
+    return writeArchive(OutputFile, NewMembers.begin()->second,
+                        /*Thin=*/false);
+  }
+
 
-      Expected<std::unique_ptr<Archive>> ArchiveOrError =
-          Archive::create(OutputBuffer->getMemBufferRef());
-      if (!ArchiveOrError)
-        return ArchiveOrError.takeError();
-      std::unique_ptr<Archive> &A = ArchiveOrError.get();
 
-      OutputBinaries.push_back(
-          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 Error::success();
+  return writeUniversalBinary(*Slices, OutputFile);
 }
 
 static Expected<Config> parseCommandLine(int Argc, char **Argv) {
   Config C;
   cl::ParseCommandLineOptions(Argc, Argv, "llvm-libtool-darwin\n");
 
   if (LibraryOperation == Operation::None) {
     if (!VersionOption) {