simplify

Created using spr 1.3.4

Author: vitalybuka

libcxx/docs/ReleaseNotes/21.rst

@@ -41,7 +41,7 @@ Implemented Papers
 - N4258: Cleaning-up noexcept in the Library (`Github <https://github.com/llvm/llvm-project/issues/99937>`__)
 - P0767R1: Deprecate POD (`Github <https://github.com/llvm/llvm-project/issues/104013>`__)
 - P1361R2: Integration of chrono with text formatting (`Github <https://github.com/llvm/llvm-project/issues/100014>`__)
-- P2255R2: A type trait to detect reference binding to temporary (implemented the type traits only) (`Github <https://github.com/llvm/llvm-project/issues/105180>`)
+- P2255R2: A type trait to detect reference binding to temporary (implemented the type traits only) (`Github <https://github.com/llvm/llvm-project/issues/105180>`__)
 
 Improvements and New Features
 -----------------------------

lldb/source/Core/DataFileCache.cpp

@@ -132,11 +132,6 @@ bool DataFileCache::SetCachedData(llvm::StringRef key,
       if (file_or_err) {
         llvm::CachedFileStream *cfs = file_or_err->get();
         cfs->OS->write((const char *)data.data(), data.size());
-        if (llvm::Error err = cfs->commit()) {
-          Log *log = GetLog(LLDBLog::Modules);
-          LLDB_LOG_ERROR(log, std::move(err),
-                         "failed to commit to the cache for key: {0}");
-        }
         return true;
       } else {
         Log *log = GetLog(LLDBLog::Modules);

llvm/include/llvm/IR/ModuleSummaryIndex.h

@@ -1311,66 +1311,17 @@ class CfiFunctionIndex {
     GlobalValue::GUID operator*() const { return this->wrapped()->first; }
   };
 
-  // Iterates merged values of the DenseMap.
-  class SymbolIterator
-      : public iterator_facade_base<SymbolIterator, std::forward_iterator_tag,
-                                    std::string> {
-    using base = SymbolIterator::iterator_facade_base;
-
-    IndexIterator Outer;
-    IndexIterator OuterEnd;
-    NestedIterator Inner;
-
-  public:
-    SymbolIterator() = default;
-    SymbolIterator(IndexIterator Outer, IndexIterator OuterEnd)
-        : Outer(Outer), OuterEnd(OuterEnd),
-          Inner(Outer != OuterEnd ? Outer->second.begin() : NestedIterator{}) {}
-    SymbolIterator(SymbolIterator &R) = default;
-
-    const std::string &operator*() const { return *Inner; }
-
-    SymbolIterator &operator++() {
-      // `DenseMap` never contains empty sets. So:
-      // 1. `Outer` points to non-empty set, if `Outer` != `OuterEnd`.
-      // 2. `Inner` always is valid and dereferenceable, if `Outer` !=
-      // `OuterEnd`.
-      assert(Outer != OuterEnd);
-      assert(!Outer->second.empty());
-      ++Inner;
-      if (Inner == Outer->second.end()) {
-        ++Outer;
-        Inner = Outer != OuterEnd ? Outer->second.begin() : NestedIterator{};
-      }
-      return *this;
-    }
-
-    SymbolIterator &operator=(const SymbolIterator &R) {
-      if (this != &R) {
-        Outer = R.Outer;
-        OuterEnd = R.OuterEnd;
-        Inner = R.Inner;
-      }
-      return *this;
-    }
-
-    bool operator==(const SymbolIterator &R) const {
-      return Outer == R.Outer && Inner == R.Inner;
-    }
-  };
-
   CfiFunctionIndex() = default;
   template <typename It> CfiFunctionIndex(It B, It E) {
     for (; B != E; ++B)
       emplace(*B);
   }
 
-  SymbolIterator begin() const {
-    return SymbolIterator(Index.begin(), Index.end());
-  }
-
-  SymbolIterator end() const {
-    return SymbolIterator(Index.end(), Index.end());
+  std::vector<StringRef> symbols() const {
+    std::vector<StringRef> Symbols;
+    for (auto &[GUID, Syms] : Index)
+      Symbols.insert(Symbols.end(), Syms.begin(), Syms.end());
+    return Symbols;
   }
 
   GUIDIterator guid_begin() const { return GUIDIterator(Index.begin()); }

llvm/include/llvm/IR/ModuleSummaryIndexYAML.h

@@ -349,11 +349,11 @@ template <> struct MappingTraits<ModuleSummaryIndex> {
     if (io.outputting()) {
       std::vector<StringRef> CfiFunctionDefs(index.CfiFunctionDefs.begin(),
                                              index.CfiFunctionDefs.end());
-      std::sort(CfiFunctionDefs.begin(), CfiFunctionDefs.end());
+      llvm::sort(CfiFunctionDefs);
       io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);
       std::vector<StringRef> CfiFunctionDecls(index.CfiFunctionDecls.begin(),
                                               index.CfiFunctionDecls.end());
-      std::sort(CfiFunctionDecls.begin(), CfiFunctionDecls.end());
+      llvm::sort(CfiFunctionDecls);
       io.mapOptional("CfiFunctionDecls", CfiFunctionDecls);
     } else {
       std::vector<std::string> CfiFunctionDefs;

llvm/include/llvm/Support/Caching.h

@@ -24,32 +24,15 @@ class MemoryBuffer;
 /// This class wraps an output stream for a file. Most clients should just be
 /// able to return an instance of this base class from the stream callback, but
 /// if a client needs to perform some action after the stream is written to,
-/// that can be done by deriving from this class and overriding the destructor
-/// or the commit() method.
+/// that can be done by deriving from this class and overriding the destructor.
 class CachedFileStream {
 public:
   CachedFileStream(std::unique_ptr<raw_pwrite_stream> OS,
                    std::string OSPath = "")
       : OS(std::move(OS)), ObjectPathName(OSPath) {}
-
-  /// Must be called exactly once after the writes to OS have been completed
-  /// but before the CachedFileStream object is destroyed.
-  virtual Error commit() {
-    if (Committed)
-      return createStringError(make_error_code(std::errc::invalid_argument),
-                               Twine("CacheStream already committed."));
-    Committed = true;
-
-    return Error::success();
-  }
-
-  bool Committed = false;
   std::unique_ptr<raw_pwrite_stream> OS;
   std::string ObjectPathName;
-  virtual ~CachedFileStream() {
-    if (!Committed)
-      report_fatal_error("CachedFileStream was not committed.\n");
-  }
+  virtual ~CachedFileStream() = default;
 };
 
 /// This type defines the callback to add a file that is generated on the fly.

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

@@ -5070,7 +5070,7 @@ void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
     Functions.insert(Functions.end(), Defs.begin(), Defs.end());
   }
   if (!Functions.empty()) {
-    std::sort(Functions.begin(), Functions.end());
+    llvm::sort(Functions);
     for (const auto &S : Functions) {
       NameVals.push_back(StrtabBuilder.add(S));
       NameVals.push_back(S.size());
@@ -5085,7 +5085,7 @@ void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
     Functions.insert(Functions.end(), Decls.begin(), Decls.end());
   }
   if (!Functions.empty()) {
-    std::sort(Functions.begin(), Functions.end());
+    llvm::sort(Functions);
     for (const auto &S : Functions) {
       NameVals.push_back(StrtabBuilder.add(S));
       NameVals.push_back(S.size());

llvm/lib/CGData/CodeGenData.cpp

@@ -233,9 +233,6 @@ void saveModuleForTwoRounds(const Module &TheModule, unsigned Task,
 
   WriteBitcodeToFile(TheModule, *Stream->OS,
                      /*ShouldPreserveUseListOrder=*/true);
-
-  if (Error Err = Stream->commit())
-    report_fatal_error(std::move(Err));
 }
 
 std::unique_ptr<Module> loadModuleForTwoRounds(BitcodeModule &OrigModule,

llvm/lib/Debuginfod/Debuginfod.cpp

@@ -188,11 +188,6 @@ class StreamedHTTPResponseHandler : public HTTPResponseHandler {
 public:
   StreamedHTTPResponseHandler(CreateStreamFn CreateStream, HTTPClient &Client)
       : CreateStream(CreateStream), Client(Client) {}
-
-  /// Must be called exactly once after the writes have been completed
-  /// but before the StreamedHTTPResponseHandler object is destroyed.
-  Error commit();
-
   virtual ~StreamedHTTPResponseHandler() = default;
 
   Error handleBodyChunk(StringRef BodyChunk) override;
@@ -215,12 +210,6 @@ Error StreamedHTTPResponseHandler::handleBodyChunk(StringRef BodyChunk) {
   return Error::success();
 }
 
-Error StreamedHTTPResponseHandler::commit() {
-  if (FileStream)
-    return FileStream->commit();
-  return Error::success();
-}
-
 // An over-accepting simplification of the HTTP RFC 7230 spec.
 static bool isHeader(StringRef S) {
   StringRef Name;
@@ -309,8 +298,6 @@ Expected<std::string> getCachedOrDownloadArtifact(
       Error Err = Client.perform(Request, Handler);
       if (Err)
         return std::move(Err);
-      if ((Err = Handler.commit()))
-        return std::move(Err);
 
       unsigned Code = Client.responseCode();
       if (Code && Code != 200)

llvm/lib/LTO/LTOBackend.cpp

@@ -460,9 +460,6 @@ static void codegen(const Config &Conf, TargetMachine *TM,
 
   if (DwoOut)
     DwoOut->keep();
-
-  if (Error Err = Stream->commit())
-    report_fatal_error(std::move(Err));
 }
 
 static void splitCodeGen(const Config &C, TargetMachine *TM,

llvm/lib/Support/Caching.cpp

@@ -88,10 +88,9 @@ Expected<FileCache> llvm::localCache(const Twine &CacheNameRef,
             AddBuffer(std::move(AddBuffer)), TempFile(std::move(TempFile)),
             ModuleName(ModuleName), Task(Task) {}
 
-      Error commit() override {
-        Error E = CachedFileStream::commit();
-        if (E)
-          return E;
+      ~CacheStream() {
+        // TODO: Manually commit rather than using non-trivial destructor,
+        // allowing to replace report_fatal_errors with a return Error.
 
         // Make sure the stream is closed before committing it.
         OS.reset();
@@ -101,12 +100,10 @@ Expected<FileCache> llvm::localCache(const Twine &CacheNameRef,
             MemoryBuffer::getOpenFile(
                 sys::fs::convertFDToNativeFile(TempFile.FD), ObjectPathName,
                 /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
-        if (!MBOrErr) {
-          std::error_code EC = MBOrErr.getError();
-          return createStringError(EC, Twine("Failed to open new cache file ") +
-                                           TempFile.TmpName + ": " +
-                                           EC.message() + "\n");
-        }
+        if (!MBOrErr)
+          report_fatal_error(Twine("Failed to open new cache file ") +
+                             TempFile.TmpName + ": " +
+                             MBOrErr.getError().message() + "\n");
 
         // On POSIX systems, this will atomically replace the destination if
         // it already exists. We try to emulate this on Windows, but this may
@@ -117,14 +114,11 @@ Expected<FileCache> llvm::localCache(const Twine &CacheNameRef,
         // AddBuffer a copy of the bytes we wrote in that case. We do this
         // instead of just using the existing file, because the pruner might
         // delete the file before we get a chance to use it.
-        E = TempFile.keep(ObjectPathName);
+        Error E = TempFile.keep(ObjectPathName);
         E = handleErrors(std::move(E), [&](const ECError &E) -> Error {
           std::error_code EC = E.convertToErrorCode();
           if (EC != errc::permission_denied)
-            return createStringError(
-                EC, Twine("Failed to rename temporary file ") +
-                        TempFile.TmpName + " to " + ObjectPathName + ": " +
-                        EC.message() + "\n");
+            return errorCodeToError(EC);
 
           auto MBCopy = MemoryBuffer::getMemBufferCopy((*MBOrErr)->getBuffer(),
                                                        ObjectPathName);
@@ -137,10 +131,11 @@ Expected<FileCache> llvm::localCache(const Twine &CacheNameRef,
         });
 
         if (E)
-          return E;
+          report_fatal_error(Twine("Failed to rename temporary file ") +
+                             TempFile.TmpName + " to " + ObjectPathName + ": " +
+                             toString(std::move(E)) + "\n");
 
         AddBuffer(Task, ModuleName, std::move(*MBOrErr));
-        return Error::success();
       }
     };