[libc][NFC] Use operator delete to cleanup a File object.

[sivachandra]

Summary

The File API has been refactored to allow cleanup using operator delete.

[gchatelet]

libc/src/__support/File/file.h

206

Marking this function constexpr breaks gcc compilation as it expects all function calls down this one to be constexpr as well (i.e., File->close(), ...)

[sivachandra]

libc/src/__support/File/file.h

206

Fixed this now but it looks like we still have some way to go with similar cleanups to make it build with GCC: https://github.com/llvm/llvm-project/commit/fa715e2dad4adfe7f8922c299250b4463e1253c9

[gchatelet]

libc/src/__support/File/file.h

206

Absolutely, I'll send a few more fixes but we really need a GCC build bot to make it sustainable.

libc/src/__support/File/file.h

 //===--- A platform independent file data structure -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H
 #define LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H
 
+#include "src/__support/CPP/new.h"
 #include "src/__support/error_or.h"
 #include "src/__support/threads/mutex.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 namespace __llvm_libc {
 
public:
 
   using WriteFunc = FileIOResult(File *, const void *, size_t);
   using ReadFunc = FileIOResult(File *, void *, size_t);
   // The SeekFunc is expected to return the current offset of the external
   // file position indicator.
   using SeekFunc = ErrorOr<long>(File *, long, int);
   using CloseFunc = int(File *);
   using FlushFunc = int(File *);
+  // CleanupFunc is a function which does the equivalent of this:
+  //
+  // void my_file_cleanup(File *f) {
+  //   MyFile *file = reinterpret_cast<MyFile *>(f);
+  //   delete file;
+  // }
+  //
+  // Essentially, it a function which calls the delete operator on the
+  // platform file object to cleanup resources held by it.
+  using CleanupFunc = void(File *);
 
   using ModeFlags = uint32_t;
 
   // The three different types of flags below are to be used with '|' operator.
   // Their values correspond to mutually exclusive bits in a 32-bit unsigned
   // integer value. A flag set can include both READ and WRITE if the file
   // is opened in update mode (ie. if the file was opened with a '+' the mode
   // string.)
private:
   // Platfrom specific functions which create new file objects should initialize
   // these fields suitably via the constructor. Typically, they should be simple
   // syscall wrappers for the corresponding functionality.
   WriteFunc *platform_write;
   ReadFunc *platform_read;
   SeekFunc *platform_seek;
   CloseFunc *platform_close;
   FlushFunc *platform_flush;
+  CleanupFunc *platform_cleanup;
 
   Mutex mutex;
 
   // For files which are readable, we should be able to support one ungetc
   // operation even if |buf| is nullptr. So, in the constructor of File, we
   // set |buf| to point to this buffer character.
   uint8_t ungetc_buf;
 
public:
     explicit FileLock(File *f) : file(f) { file->lock(); }
 
     ~FileLock() { file->unlock(); }
 
     FileLock(const FileLock &) = delete;
     FileLock(FileLock &&) = delete;
   };
 
+  // This is private function and is not to be called by the users of
+  // File and its derived classes. The correct way to close a file is
+  // to call the File::cleanup function.
+  int close() {
+    {
+      FileLock lock(this);
+      if (prev_op == FileOp::WRITE && pos > 0) {
+        auto buf_result = platform_write(this, buf, pos);
+        if (buf_result.has_error() || buf_result.value < pos) {
+          err = true;
+          return buf_result.error;
+        }
+      }
+      int result = platform_close(this);
+      if (result != 0)
+        return result;
+    }
+    return 0;
+  }
+
 protected:
   constexpr bool write_allowed() const {
     return mode & (static_cast<ModeFlags>(OpenMode::WRITE) |
                    static_cast<ModeFlags>(OpenMode::APPEND) |
                    static_cast<ModeFlags>(OpenMode::PLUS));
   }
 
   constexpr bool read_allowed() const {
     return mode & (static_cast<ModeFlags>(OpenMode::READ) |
                    static_cast<ModeFlags>(OpenMode::PLUS));
   }
 
+  ~File() {
+    if (own_buf)
+      delete buf;
+  }
+
 public:
   // We want this constructor to be constexpr so that global file objects
   // like stdout do not require invocation of the constructor which can
   // potentially lead to static initialization order fiasco. Consequently,
   // we will assume that the |buffer| and |buffer_size| argument are
   // meaningful - that is, |buffer| is nullptr if and only if |buffer_size|
   // is zero. This way, we will not have to employ the semantics of
   // the set_buffer method and allocate a buffer.
   constexpr File(WriteFunc *wf, ReadFunc *rf, SeekFunc *sf, CloseFunc *cf,
-                 FlushFunc *ff, uint8_t *buffer, size_t buffer_size,
-                 int buffer_mode, bool owned, ModeFlags modeflags)
+                 FlushFunc *ff, CleanupFunc *clf, uint8_t *buffer,
+                 size_t buffer_size, int buffer_mode, bool owned,
+                 ModeFlags modeflags)
       : platform_write(wf), platform_read(rf), platform_seek(sf),
-        platform_close(cf), platform_flush(ff), mutex(false, false, false),
-        ungetc_buf(0), buf(buffer), bufsize(buffer_size), bufmode(buffer_mode),
-        own_buf(owned), mode(modeflags), pos(0), prev_op(FileOp::NONE),
-        read_limit(0), eof(false), err(false) {
+        platform_close(cf), platform_flush(ff), platform_cleanup(clf),
+        mutex(false, false, false), ungetc_buf(0), buf(buffer),
+        bufsize(buffer_size), bufmode(buffer_mode), own_buf(owned),
+        mode(modeflags), pos(0), prev_op(FileOp::NONE), read_limit(0),
+        eof(false), err(false) {
     adjust_buf();
   }
 
+  // Close |f| and cleanup resources held by it.
+  // Returns the non-zero error value if an error occurs when closing the
+  // file.
+  static constexpr int cleanup(File *f) {
+    int close_result = f->close();
+    if (close_result != 0)
+      return close_result;
+    f->platform_cleanup(f);
+    return 0;
+  }
+
   // Buffered write of |len| bytes from |data| without the file lock.
   FileIOResult write_unlocked(const void *data, size_t len);
 
   // Buffered write of |len| bytes from |data| under the file lock.
   FileIOResult write(const void *data, size_t len) {
     FileLock l(this);
     return write_unlocked(data, len);
   }
public:
   // if:
   //   1. |buffer| is not a nullptr but |size| is zero.
   //   2. |buffer_mode| is not one of _IOLBF, IOFBF or _IONBF.
   //   3. If an allocation was required but the allocation failed.
   // For cases 1 and 2, the error returned in EINVAL. For case 3, error returned
   // is ENOMEM.
   int set_buffer(void *buffer, size_t size, int buffer_mode);
 
-  // Closes the file stream and frees up all resources owned by it.
-  int close();
-
   void lock() { mutex.lock(); }
   void unlock() { mutex.unlock(); }
 
   bool error_unlocked() const { return err; }
 
   bool error() {
     FileLock l(this);
     return error_unlocked();
if (read_allowed() && (buf == nullptr || bufsize == 0)) {
       // affect the behavior experienced by the user.
       buf = &ungetc_buf;
       bufsize = 1;
       own_buf = false; // We shouldn't call free on |buf| when closing the file.
     }
   }
 };
 
+// Platform specific file implementations can simply pass a pointer to a
+// a specialization of this function as the CleanupFunc argument to the
+// File constructor. The template type argument FileType should replaced
+// with the type of the platform specific file implementation.
+template <typename FileType> void cleanup_file(File *f) {
+  auto *file = reinterpret_cast<FileType *>(f);
+  delete file;
+}
+
 // The implementaiton of this function is provided by the platfrom_file
 // library.
 ErrorOr<File *> openfile(const char *path, const char *mode);
 
 // The platform_file library should implement it if it relevant for that
 // platform.
 int get_fileno(File *f);
 
 extern File *stdin;
 extern File *stdout;
 extern File *stderr;
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H

libc/src/__support/File/file.cpp

if (prev_op == FileOp::WRITE && pos > 0) {
     }
     pos = 0;
     return platform_flush(this);
   }
   // TODO: Add POSIX behavior for input streams.
   return 0;
 }
 
-int File::close() {
-  {
-    FileLock lock(this);
-    if (prev_op == FileOp::WRITE && pos > 0) {
-      auto buf_result = platform_write(this, buf, pos);
-      if (buf_result.has_error() || buf_result.value < pos) {
-        err = true;
-        return buf_result.error;
-      }
-    }
-    int result = platform_close(this);
-    if (result != 0)
-      return result;
-    if (own_buf)
-      free(buf);
-  }
-  free(this);
-  return 0;
-}
-
 int File::set_buffer(void *buffer, size_t size, int buffer_mode) {
   // We do not need to lock the file as this method should be called before
   // other operations are performed on the file.
 
   if (buffer != nullptr && size == 0)
     return EINVAL;
 
   switch (buffer_mode) {

libc/src/__support/File/linux_file.cpp

 
 class LinuxFile : public File {
   int fd;
 
 public:
   constexpr LinuxFile(int file_descriptor, uint8_t *buffer, size_t buffer_size,
                       int buffer_mode, bool owned, File::ModeFlags modeflags)
       : File(&write_func, &read_func, &seek_func, &close_func, flush_func,
-             buffer, buffer_size, buffer_mode, owned, modeflags),
+             &cleanup_file<LinuxFile>, buffer, buffer_size, buffer_mode, owned,
+             modeflags),
         fd(file_descriptor) {}
 
   int get_fd() const { return fd; }
 };
 
 namespace {
 
 FileIOResult write_func(File *f, const void *data, size_t size) {

libc/src/stdio/fclose.cpp

 #include "src/__support/File/file.h"
 
 #include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fclose, (::FILE * stream)) {
-  int result = reinterpret_cast<__llvm_libc::File *>(stream)->close();
+  auto *file = reinterpret_cast<__llvm_libc::File *>(stream);
+  int result = File::cleanup(file);
   if (result != 0) {
     errno = result;
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fopencookie.cpp

class CookieFile : public __llvm_libc::File {
   static ErrorOr<long> cookie_seek(File *f, long offset, int whence);
   static int cookie_close(File *f);
   static int cookie_flush(File *);
 
 public:
   CookieFile(void *c, cookie_io_functions_t cops, uint8_t *buffer,
              size_t bufsize, File::ModeFlags mode)
       : File(&cookie_write, &cookie_read, &CookieFile::cookie_seek,
-             &cookie_close, &cookie_flush, buffer, bufsize,
-             0 /* default buffering mode */, true /* File owns buffer */, mode),
+             &cookie_close, &cookie_flush, &cleanup_file<CookieFile>, buffer,
+             bufsize, 0 /* default buffering mode */,
+             true /* File owns buffer */, mode),
         cookie(c), ops(cops) {}
 };
 
 FileIOResult CookieFile::cookie_write(File *f, const void *data, size_t size) {
   auto cookie_file = reinterpret_cast<CookieFile *>(f);
   if (cookie_file->ops.write == nullptr)
     return 0;
   return cookie_file->ops.write(cookie_file->cookie,

libc/test/src/__support/File/file_test.cpp

 #include "utils/UnitTest/Test.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
 using ModeFlags = __llvm_libc::File::ModeFlags;
 using MemoryView = __llvm_libc::memory::testing::MemoryView;
 using __llvm_libc::ErrorOr;
+using __llvm_libc::File;
 using __llvm_libc::FileIOResult;
 
-class StringFile : public __llvm_libc::File {
+class StringFile : public File {
   static constexpr size_t SIZE = 512;
   size_t pos;
   char str[SIZE] = {0};
   size_t eof_marker;
   bool write_append;
 
   static FileIOResult str_read(__llvm_libc::File *f, void *data, size_t len);
   static FileIOResult str_write(__llvm_libc::File *f, const void *data,
                                 size_t len);
   static ErrorOr<long> str_seek(__llvm_libc::File *f, long offset, int whence);
   static int str_close(__llvm_libc::File *f) { return 0; }
   static int str_flush(__llvm_libc::File *f) { return 0; }
 
 public:
   explicit StringFile(char *buffer, size_t buflen, int bufmode, bool owned,
                       ModeFlags modeflags)
       : __llvm_libc::File(&str_write, &str_read, &str_seek, &str_close,
-                          &str_flush, reinterpret_cast<uint8_t *>(buffer),
-                          buflen, bufmode, owned, modeflags),
+                          &str_flush, &__llvm_libc::cleanup_file<StringFile>,
+                          reinterpret_cast<uint8_t *>(buffer), buflen, bufmode,
+                          owned, modeflags),
         pos(0), eof_marker(0), write_append(false) {
     if (modeflags & static_cast<ModeFlags>(__llvm_libc::File::OpenMode::APPEND))
       write_append = true;
   }
 
   void reset() { pos = 0; }
   size_t get_pos() const { return pos; }
   char *get_str() { return str; }
TEST(LlvmLibcFileTest, WriteOnly) {
   {
     // This is not a readable file.
     auto result = f->read(read_data, sizeof(data));
     EXPECT_EQ(result.value, size_t(0));
     EXPECT_TRUE(f->error());
     EXPECT_TRUE(result.has_error());
   }
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(File::cleanup(f), 0);
 }
 
 TEST(LlvmLibcFileTest, WriteLineBuffered) {
   const char data[] = "hello\n file";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
 
   char file_buffer_line[FILE_BUFFER_SIZE];
   char file_buffer_full[FILE_BUFFER_SIZE];
TEST(LlvmLibcFileTest, WriteLineBuffered) {
   ASSERT_EQ(f_line->flush(), 0);
   ASSERT_EQ(f_full->flush(), 0);
 
   EXPECT_EQ(f_line->get_pos(), sizeof(data) + sizeof(data2));
   MemoryView dst_line_final(f_line->get_str(), 37);
   EXPECT_MEM_EQ(src3, dst_line_final);
   EXPECT_MEM_EQ(src3, dst_full_final);
 
-  ASSERT_EQ(f_line->close(), 0);
-  ASSERT_EQ(f_full->close(), 0);
+  ASSERT_EQ(File::cleanup(f_line), 0);
+  ASSERT_EQ(File::cleanup(f_full), 0);
 }
 
 TEST(LlvmLibcFileTest, WriteUnbuffered) {
   const char data[] = "written immediately";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(data) + 1;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IONBF, false, "w");
 
   ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
   EXPECT_EQ(f->get_pos(),
             sizeof(data)); // no buffering means this is written immediately.
   EXPECT_STREQ(f->get_str(), data);
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(File::cleanup(f), 0);
 }
 
 TEST(LlvmLibcFileTest, ReadOnly) {
   const char initial_content[] = "1234567890987654321";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "r");
TEST(LlvmLibcFileTest, ReadOnly) {
   {
     // This is not a writable file.
     auto result = f->write(initial_content, sizeof(initial_content));
     EXPECT_EQ(result.value, size_t(0));
     EXPECT_TRUE(f->error());
     EXPECT_TRUE(result.has_error());
   }
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(File::cleanup(f), 0);
 }
 
 TEST(LlvmLibcFileTest, ReadSeekCurAndRead) {
   const char initial_content[] = "1234567890987654321";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "r");
   f->reset_and_fill(initial_content, sizeof(initial_content));
 
   constexpr size_t READ_SIZE = 5;
   char data[READ_SIZE];
   data[READ_SIZE - 1] = '\0';
   ASSERT_EQ(f->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
   ASSERT_STREQ(data, "1234");
   ASSERT_EQ(f->seek(5, SEEK_CUR).value(), 0);
   ASSERT_EQ(f->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
   ASSERT_STREQ(data, "0987");
   ASSERT_EQ(f->seek(-5, SEEK_CUR).value(), 0);
   ASSERT_EQ(f->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
   ASSERT_STREQ(data, "9098");
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(File::cleanup(f), 0);
 }
 
 TEST(LlvmLibcFileTest, AppendOnly) {
   const char initial_content[] = "1234567890987654321";
   const char write_data[] = "append";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(write_data) * 3 / 2;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
TEST(LlvmLibcFileTest, AppendOnly) {
 
   // Write should succeed but will be buffered in the file stream.
   ASSERT_EQ(f->write(write_data, sizeof(write_data)).value, sizeof(write_data));
   EXPECT_EQ(f->get_pos(), size_t(0));
   // Flushing will write to the file.
   EXPECT_EQ(f->flush(), int(0));
   EXPECT_EQ(f->get_pos(), sizeof(write_data) + sizeof(initial_content));
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(File::cleanup(f), 0);
 }
 
 TEST(LlvmLibcFileTest, WriteUpdate) {
   const char data[] = "hello, file";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "w+");
 
   ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
   EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
 
   ASSERT_EQ(f->seek(0, SEEK_SET).value(), 0);
 
   // Seek flushes the stream buffer so we can read the previously written data.
   char read_data[sizeof(data)];
   ASSERT_EQ(f->read(read_data, sizeof(data)).value, sizeof(data));
   EXPECT_STREQ(read_data, data);
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(File::cleanup(f), 0);
 }
 
 TEST(LlvmLibcFileTest, ReadUpdate) {
   const char initial_content[] = "1234567890987654321";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "r+");
TEST(LlvmLibcFileTest, ReadUpdate) {
   const char write_data[] = "hello, file";
   ASSERT_EQ(sizeof(write_data), f->write(write_data, sizeof(write_data)).value);
   EXPECT_STREQ(file_buffer, write_data);
   ASSERT_EQ(f->flush(), 0);
   MemoryView dst2(f->get_str(), sizeof(write_data)),
       src2(write_data, sizeof(write_data));
   EXPECT_MEM_EQ(src2, dst2);
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(File::cleanup(f), 0);
 }
 
 TEST(LlvmLibcFileTest, AppendUpdate) {
   const char initial_content[] = "1234567890987654321";
   const char data[] = "hello, file";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
TEST(LlvmLibcFileTest, AppendUpdate) {
   // Reads can happen from any point.
   ASSERT_EQ(f->seek(0, SEEK_SET).value(), 0);
   constexpr size_t READ_SIZE = 10;
   char read_data[READ_SIZE];
   ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE).value);
   MemoryView src4(initial_content, READ_SIZE), dst4(read_data, READ_SIZE);
   EXPECT_MEM_EQ(src4, dst4);
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(File::cleanup(f), 0);
 }
 
 TEST(LlvmLibcFileTest, SmallBuffer) {
   const char WRITE_DATA[] = "small buffer";
   constexpr size_t WRITE_SIZE = sizeof(WRITE_DATA);
   constexpr size_t FILE_BUFFER_SIZE = sizeof(WRITE_DATA) / 2 - 1;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "w");
 
   ASSERT_EQ(WRITE_SIZE, f->write(WRITE_DATA, WRITE_SIZE).value);
   // Since data much larger than the buffer is being written, all of it should
   // be available in the file without a flush operation.
   EXPECT_EQ(f->get_pos(), sizeof(WRITE_DATA));
   ASSERT_STREQ(f->get_str(), WRITE_DATA);
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(File::cleanup(f), 0);
 }
 
 TEST(LlvmLibcFileTest, ZeroLengthBuffer) {
   const char WRITE_DATA[] = "small buffer";
   constexpr size_t WRITE_SIZE = sizeof(WRITE_DATA);
   StringFile *f_fbf = new_string_file(nullptr, 0, _IOFBF, true, "w");
   StringFile *f_lbf = new_string_file(nullptr, 0, _IOLBF, true, "w");
   StringFile *f_nbf = new_string_file(nullptr, 0, _IONBF, true, "w");
 
   ASSERT_EQ(WRITE_SIZE, f_fbf->write(WRITE_DATA, WRITE_SIZE).value);
   ASSERT_EQ(WRITE_SIZE, f_lbf->write(WRITE_DATA, WRITE_SIZE).value);
   ASSERT_EQ(WRITE_SIZE, f_nbf->write(WRITE_DATA, WRITE_SIZE).value);
   // Since there is no buffer space, all of the written data should
   // be available in the file without a flush operation.
   EXPECT_EQ(f_fbf->get_pos(), sizeof(WRITE_DATA));
   EXPECT_EQ(f_lbf->get_pos(), sizeof(WRITE_DATA));
   EXPECT_EQ(f_nbf->get_pos(), sizeof(WRITE_DATA));
   ASSERT_STREQ(f_fbf->get_str(), WRITE_DATA);
   ASSERT_STREQ(f_lbf->get_str(), WRITE_DATA);
   ASSERT_STREQ(f_nbf->get_str(), WRITE_DATA);
 
-  ASSERT_EQ(f_fbf->close(), 0);
-  ASSERT_EQ(f_lbf->close(), 0);
-  ASSERT_EQ(f_nbf->close(), 0);
+  ASSERT_EQ(File::cleanup(f_fbf), 0);
+  ASSERT_EQ(File::cleanup(f_lbf), 0);
+  ASSERT_EQ(File::cleanup(f_nbf), 0);
 }
 
 TEST(LlvmLibcFileTest, WriteNothing) {
   const char WRITE_DATA[] = "";
   constexpr size_t WRITE_SIZE = 0;
   constexpr size_t FILE_BUFFER_SIZE = 5;
   char file_buffer_fbf[FILE_BUFFER_SIZE];
   char file_buffer_lbf[FILE_BUFFER_SIZE];
   char file_buffer_nbf[FILE_BUFFER_SIZE];
   StringFile *f_fbf =
       new_string_file(file_buffer_fbf, FILE_BUFFER_SIZE, _IOFBF, false, "w");
   StringFile *f_lbf =
       new_string_file(file_buffer_lbf, FILE_BUFFER_SIZE, _IOLBF, false, "w");
   StringFile *f_nbf =
       new_string_file(file_buffer_nbf, FILE_BUFFER_SIZE, _IONBF, false, "w");
 
   ASSERT_EQ(WRITE_SIZE, f_fbf->write(WRITE_DATA, WRITE_SIZE).value);
   ASSERT_EQ(WRITE_SIZE, f_lbf->write(WRITE_DATA, WRITE_SIZE).value);
   ASSERT_EQ(WRITE_SIZE, f_nbf->write(WRITE_DATA, WRITE_SIZE).value);
 
   ASSERT_FALSE(f_fbf->error_unlocked());
   ASSERT_FALSE(f_lbf->error_unlocked());
   ASSERT_FALSE(f_nbf->error_unlocked());
 
-  ASSERT_EQ(f_fbf->close(), 0);
-  ASSERT_EQ(f_lbf->close(), 0);
-  ASSERT_EQ(f_nbf->close(), 0);
+  ASSERT_EQ(File::cleanup(f_fbf), 0);
+  ASSERT_EQ(File::cleanup(f_lbf), 0);
+  ASSERT_EQ(File::cleanup(f_nbf), 0);
 }

libc/test/src/__support/File/platform_file_test.cpp

 constexpr char TEXT[] = "Hello, File";
 constexpr size_t TEXT_SIZE = sizeof(TEXT) - 1; // Ignore the null terminator
 
 TEST(LlvmLibcPlatformFileTest, CreateWriteCloseAndReadBack) {
   constexpr char FILENAME[] = "testdata/create_write_close_and_readback.test";
   File *file = __llvm_libc::openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 
   file = __llvm_libc::openfile(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
   char data[sizeof(TEXT)];
   ASSERT_EQ(file->read(data, TEXT_SIZE).value, TEXT_SIZE);
   data[TEXT_SIZE] = '\0';
   ASSERT_STREQ(data, TEXT);
 
   // Reading more data should trigger EOF.
   ASSERT_EQ(file->read(data, TEXT_SIZE).value, size_t(0));
   ASSERT_TRUE(file->iseof());
 
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, CreateWriteSeekAndReadBack) {
   constexpr char FILENAME[] = "testdata/create_write_seek_and_readback.test";
   File *file = __llvm_libc::openfile(FILENAME, "w+");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
 
   ASSERT_EQ(file->seek(0, SEEK_SET).value(), 0);
 
   char data[sizeof(TEXT)];
   ASSERT_EQ(file->read(data, TEXT_SIZE).value, TEXT_SIZE);
   data[TEXT_SIZE] = '\0';
   ASSERT_STREQ(data, TEXT);
 
   // Reading more data should trigger EOF.
   ASSERT_EQ(file->read(data, TEXT_SIZE).value, size_t(0));
   ASSERT_TRUE(file->iseof());
 
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, CreateAppendCloseAndReadBack) {
   constexpr char FILENAME[] = "testdata/create_append_close_and_readback.test";
   File *file = __llvm_libc::openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 
   file = __llvm_libc::openfile(FILENAME, "a");
   ASSERT_FALSE(file == nullptr);
   constexpr char APPEND_TEXT[] = " Append Text";
   constexpr size_t APPEND_TEXT_SIZE = sizeof(APPEND_TEXT) - 1;
   ASSERT_EQ(file->write(APPEND_TEXT, APPEND_TEXT_SIZE).value, APPEND_TEXT_SIZE);
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 
   file = __llvm_libc::openfile(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
   constexpr size_t READ_SIZE = TEXT_SIZE + APPEND_TEXT_SIZE;
   char data[READ_SIZE + 1];
   ASSERT_EQ(file->read(data, READ_SIZE).value, READ_SIZE);
   data[READ_SIZE] = '\0';
   ASSERT_STREQ(data, "Hello, File Append Text");
 
   // Reading more data should trigger EOF.
   ASSERT_EQ(file->read(data, READ_SIZE).value, size_t(0));
   ASSERT_TRUE(file->iseof());
 
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, CreateAppendSeekAndReadBack) {
   constexpr char FILENAME[] = "testdata/create_append_seek_and_readback.test";
   File *file = __llvm_libc::openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 
   file = __llvm_libc::openfile(FILENAME, "a+");
   ASSERT_FALSE(file == nullptr);
   constexpr char APPEND_TEXT[] = " Append Text";
   constexpr size_t APPEND_TEXT_SIZE = sizeof(APPEND_TEXT) - 1;
   ASSERT_EQ(file->write(APPEND_TEXT, APPEND_TEXT_SIZE).value, APPEND_TEXT_SIZE);
 
   ASSERT_EQ(file->seek(-APPEND_TEXT_SIZE, SEEK_END).value(), 0);
   char data[APPEND_TEXT_SIZE + 1];
   ASSERT_EQ(file->read(data, APPEND_TEXT_SIZE).value, APPEND_TEXT_SIZE);
   data[APPEND_TEXT_SIZE] = '\0';
   ASSERT_STREQ(data, APPEND_TEXT);
 
   // Reading more data should trigger EOF.
   ASSERT_EQ(file->read(data, APPEND_TEXT_SIZE).value, size_t(0));
   ASSERT_TRUE(file->iseof());
 
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, LargeFile) {
   constexpr size_t DATA_SIZE = File::DEFAULT_BUFFER_SIZE >> 2;
   constexpr char BYTE = 123;
   char write_data[DATA_SIZE];
   for (size_t i = 0; i < DATA_SIZE; ++i)
     write_data[i] = BYTE;
 
   constexpr char FILENAME[] = "testdata/large_file.test";
   File *file = __llvm_libc::openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
 
   constexpr int REPEAT = 5;
   for (int i = 0; i < REPEAT; ++i) {
     ASSERT_EQ(file->write(write_data, DATA_SIZE).value, DATA_SIZE);
   }
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 
   file = __llvm_libc::openfile(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
   constexpr size_t READ_SIZE = DATA_SIZE * REPEAT;
   char data[READ_SIZE] = {0};
   ASSERT_EQ(file->read(data, READ_SIZE).value, READ_SIZE);
 
   for (size_t i = 0; i < READ_SIZE; ++i)
     ASSERT_EQ(data[i], BYTE);
 
   // Reading more data should trigger EOF.
   ASSERT_EQ(file->read(data, 1).value, size_t(0));
   ASSERT_TRUE(file->iseof());
 
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, ReadSeekCurAndRead) {
   constexpr char FILENAME[] = "testdata/read_seek_cur_and_read.test";
   File *file = __llvm_libc::openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   constexpr char CONTENT[] = "1234567890987654321";
   ASSERT_EQ(sizeof(CONTENT) - 1,
             file->write(CONTENT, sizeof(CONTENT) - 1).value);
-  ASSERT_EQ(0, file->close());
+  ASSERT_EQ(0, File::cleanup(file));
 
   file = __llvm_libc::openfile(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
 
   constexpr size_t READ_SIZE = 5;
   char data[READ_SIZE];
   data[READ_SIZE - 1] = '\0';
   ASSERT_EQ(file->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
   ASSERT_STREQ(data, "1234");
   ASSERT_EQ(file->seek(5, SEEK_CUR).value(), 0);
   ASSERT_EQ(file->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
   ASSERT_STREQ(data, "0987");
   ASSERT_EQ(file->seek(-5, SEEK_CUR).value(), 0);
   ASSERT_EQ(file->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
   ASSERT_STREQ(data, "9098");
 
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, IncorrectOperation) {
   constexpr char FILENAME[] = "testdata/incorrect_operation.test";
   char data[1] = {123};
 
   File *file = __llvm_libc::openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(file->read(data, 1).value, size_t(0)); // Cannot read
   ASSERT_FALSE(file->iseof());
   ASSERT_TRUE(file->error());
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 
   file = __llvm_libc::openfile(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(file->write(data, 1).value, size_t(0)); // Cannot write
   ASSERT_FALSE(file->iseof());
   ASSERT_TRUE(file->error());
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 
   file = __llvm_libc::openfile(FILENAME, "a");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(file->read(data, 1).value, size_t(0)); // Cannot read
   ASSERT_FALSE(file->iseof());
   ASSERT_TRUE(file->error());
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(File::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, StdOutStdErrSmokeTest) {
   EXPECT_FALSE(__llvm_libc::stdout == nullptr);
   EXPECT_FALSE(__llvm_libc::stderr == nullptr);
 }