Move factory methods out of their classes.

[ruiu]

Summary

InMemoryBuffer and OnDiskBuffer classes have both factory methods and
public constructors, and that looks a bit odd. This patch makes factory
methods non-member function to fix it.

llvm/lib/Support/FileOutputBuffer.cpp

 // as the final output file. The final output file is atomically replaced
 // with the temporary file on commit().
 class OnDiskBuffer : public FileOutputBuffer {
 public:
   OnDiskBuffer(StringRef Path, StringRef TempPath,
                std::unique_ptr<fs::mapped_file_region> Buf)
       : FileOutputBuffer(Path), Buffer(std::move(Buf)), TempPath(TempPath) {}
 
-  static ErrorOr<std::unique_ptr<OnDiskBuffer>>
-  create(StringRef Path, size_t Size, unsigned Mode);
-
   uint8_t *getBufferStart() const override { return (uint8_t *)Buffer->data(); }
 
   uint8_t *getBufferEnd() const override {
     return (uint8_t *)Buffer->data() + Buffer->size();
   }
 
   size_t getBufferSize() const override { return Buffer->size(); }
 

 
 // A FileOutputBuffer which keeps data in memory and writes to the final
 // output file on commit(). This is used only when we cannot use OnDiskBuffer.
 class InMemoryBuffer : public FileOutputBuffer {
 public:
   InMemoryBuffer(StringRef Path, MemoryBlock Buf, unsigned Mode)
       : FileOutputBuffer(Path), Buffer(Buf), Mode(Mode) {}
 
-  static ErrorOr<std::unique_ptr<InMemoryBuffer>>
-  create(StringRef Path, size_t Size, unsigned Mode) {
-    std::error_code EC;
-    MemoryBlock MB = Memory::allocateMappedMemory(
-        Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
-    if (EC)
-      return EC;
-    return llvm::make_unique<InMemoryBuffer>(Path, MB, Mode);
-  }
-
   uint8_t *getBufferStart() const override { return (uint8_t *)Buffer.base(); }
 
   uint8_t *getBufferEnd() const override {
     return (uint8_t *)Buffer.base() + Buffer.size();
   }
 
   size_t getBufferSize() const override { return Buffer.size(); }
 
   std::error_code commit() override {
     int FD;
     std::error_code EC;
     if (auto EC = openFileForWrite(FinalPath, FD, fs::F_None, Mode))
       return EC;
     raw_fd_ostream OS(FD, /*shouldClose=*/true, /*unbuffered=*/true);
     OS << StringRef((const char *)Buffer.base(), Buffer.size());
     return std::error_code();
   }
 
 private:
   OwningMemoryBlock Buffer;
   unsigned Mode;
 };
 
-ErrorOr<std::unique_ptr<OnDiskBuffer>>
-OnDiskBuffer::create(StringRef Path, size_t Size, unsigned Mode) {
+static ErrorOr<std::unique_ptr<OnDiskBuffer>>
+createOnDiskBuffer(StringRef Path, size_t Size, unsigned Mode) {
   // Create new file in same directory but with random name.
   SmallString<128> TempPath;
   int FD;
   if (auto EC = fs::createUniqueFile(Path + ".tmp%%%%%%%", FD, TempPath, Mode))
     return EC;
 
   sys::RemoveFileOnSignal(TempPath);
 
#endif
   auto MappedFile = llvm::make_unique<fs::mapped_file_region>(
       FD, fs::mapped_file_region::readwrite, Size, 0, EC);
   close(FD);
   if (EC)
     return EC;
   return llvm::make_unique<OnDiskBuffer>(Path, TempPath, std::move(MappedFile));
 }
 
+static ErrorOr<std::unique_ptr<InMemoryBuffer>>
+createInMemoryBuffer(StringRef Path, size_t Size, unsigned Mode) {
+  std::error_code EC;
+  MemoryBlock MB = Memory::allocateMappedMemory(
+      Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
+  if (EC)
+    return EC;
+  return llvm::make_unique<InMemoryBuffer>(Path, MB, Mode);
+}
+
 // Create an instance of FileOutputBuffer.
 ErrorOr<std::unique_ptr<FileOutputBuffer>>
 FileOutputBuffer::create(StringRef Path, size_t Size, unsigned Flags) {
   unsigned Mode = fs::all_read | fs::all_write;
   if (Flags & F_executable)
     Mode |= fs::all_exe;
 
   fs::file_status Stat;
   fs::status(Path, Stat);
 
   // Usually, we want to create OnDiskBuffer to create a temporary file in
   // the same directory as the destination file and atomically replaces it
   // by rename(2).
   //
   // However, if the destination file is a special file, we don't want to
   // use rename (e.g. we don't want to replace /dev/null with a regular
   // file.) If that's the case, we create an in-memory buffer, open the
   // destination file and write to it on commit().
   switch (Stat.type()) {
   case fs::file_type::directory_file:
     return errc::is_a_directory;
   case fs::file_type::regular_file:
   case fs::file_type::file_not_found:
   case fs::file_type::status_error:
-    return OnDiskBuffer::create(Path, Size, Mode);
+    return createOnDiskBuffer(Path, Size, Mode);
   default:
-    return InMemoryBuffer::create(Path, Size, Mode);
+    return createInMemoryBuffer(Path, Size, Mode);
   }
 }