Improve naming consistency

include/fmt/posix.h

@@ -113,12 +113,12 @@ typedef basic_cstring_view<char> cstring_view;
 typedef basic_cstring_view<wchar_t> wcstring_view;
 
 // An error code.
-class ErrorCode {
+class error_code {
  private:
   int value_;
 
  public:
-  explicit ErrorCode(int value = 0) FMT_NOEXCEPT : value_(value) {}
+  explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {}
 
   int get() const FMT_NOEXCEPT { return value_; }
 };
@@ -128,7 +128,7 @@ class buffered_file {
  private:
   FILE *file_;
 
-  friend class File;
+  friend class file;
 
   explicit buffered_file(FILE *f) : file_(f) {}
 
@@ -222,18 +222,18 @@ public:
   }
 };
 
-// A file. Closed file is represented by a File object with descriptor -1.
+// A file. Closed file is represented by a file object with descriptor -1.
 // Methods that are not declared with FMT_NOEXCEPT may throw
 // fmt::system_error in case of failure. Note that some errors such as
 // closing the file multiple times will cause a crash on Windows rather
 // than an exception. You can get standard behavior by overriding the
 // invalid parameter handler with _set_invalid_parameter_handler.
-class File {
+class file {
  private:
   int fd_;  // File descriptor.
 
-  // Constructs a File object with a given descriptor.
-  explicit File(int fd) : fd_(fd) {}
+  // Constructs a file object with a given descriptor.
+  explicit file(int fd) : fd_(fd) {}
 
  public:
   // Possible values for the oflag argument to the constructor.
@@ -243,11 +243,11 @@ class File {
     RDWR   = FMT_POSIX(O_RDWR)    // Open for reading and writing.
   };
 
-  // Constructs a File object which doesn't represent any file.
-  File() FMT_NOEXCEPT : fd_(-1) {}
+  // Constructs a file object which doesn't represent any file.
+  file() FMT_NOEXCEPT : fd_(-1) {}
 
-  // Opens a file and constructs a File object representing this file.
-  FMT_API File(cstring_view path, int oflag);
+  // Opens a file and constructs a file object representing this file.
+  FMT_API file(cstring_view path, int oflag);
 
 #if !FMT_USE_RVALUE_REFERENCES
   // Emulate a move constructor and a move assignment operator if rvalue
@@ -262,22 +262,22 @@ class File {
 
  public:
   // A "move constructor" for moving from a temporary.
-  File(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {}
+  file(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {}
 
   // A "move constructor" for moving from an lvalue.
-  File(File &other) FMT_NOEXCEPT : fd_(other.fd_) {
+  file(file &other) FMT_NOEXCEPT : fd_(other.fd_) {
     other.fd_ = -1;
   }
 
   // A "move assignment operator" for moving from a temporary.
-  File &operator=(Proxy p) {
+  file &operator=(Proxy p) {
     close();
     fd_ = p.fd;
     return *this;
   }
 
   // A "move assignment operator" for moving from an lvalue.
-  File &operator=(File &other) {
+  file &operator=(file &other) {
     close();
     fd_ = other.fd_;
     other.fd_ = -1;
@@ -285,7 +285,7 @@ class File {
   }
 
   // Returns a proxy object for moving from a temporary:
-  //   File file = File(...);
+  //   file f = file(...);
   operator Proxy() FMT_NOEXCEPT {
     Proxy p = {fd_};
     fd_ = -1;
@@ -294,14 +294,14 @@ class File {
 
 #else
  private:
-  FMT_DISALLOW_COPY_AND_ASSIGN(File);
+  FMT_DISALLOW_COPY_AND_ASSIGN(file);
 
  public:
-  File(File &&other) FMT_NOEXCEPT : fd_(other.fd_) {
+  file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) {
     other.fd_ = -1;
   }
 
-  File& operator=(File &&other) {
+  file& operator=(file &&other) {
     close();
     fd_ = other.fd_;
     other.fd_ = -1;
@@ -310,7 +310,7 @@ class File {
 #endif
 
   // Destroys the object closing the file it represents if any.
-  FMT_API ~File() FMT_DTOR_NOEXCEPT;
+  FMT_API ~file() FMT_DTOR_NOEXCEPT;
 
   // Returns the file descriptor.
   int descriptor() const FMT_NOEXCEPT { return fd_; }
@@ -330,7 +330,7 @@ class File {
 
   // Duplicates a file descriptor with the dup function and returns
   // the duplicate as a file object.
-  FMT_API static File dup(int fd);
+  FMT_API static file dup(int fd);
 
   // Makes fd be the copy of this file descriptor, closing fd first if
   // necessary.
@@ -338,14 +338,14 @@ class File {
 
   // Makes fd be the copy of this file descriptor, closing fd first if
   // necessary.
-  FMT_API void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT;
+  FMT_API void dup2(int fd, error_code &ec) FMT_NOEXCEPT;
 
   // Creates a pipe setting up read_end and write_end file objects for reading
   // and writing respectively.
-  FMT_API static void pipe(File &read_end, File &write_end);
+  FMT_API static void pipe(file &read_end, file &write_end);
 
   // Creates a buffered_file object associated with this file and detaches
-  // this File object from the file.
+  // this file object from the file.
   FMT_API buffered_file fdopen(const char *mode);
 };
 
@@ -410,7 +410,7 @@ FMT_END_NAMESPACE
 namespace std {
 // For compatibility with C++98.
 inline fmt::buffered_file &move(fmt::buffered_file &f) { return f; }
-inline fmt::File &move(fmt::File &f) { return f; }
+inline fmt::file &move(fmt::file &f) { return f; }
 }
 #endif
 

src/posix.cc

@@ -97,7 +97,7 @@ int buffered_file::fileno() const {
   return fd;
 }
 
-File::File(cstring_view path, int oflag) {
+file::file(cstring_view path, int oflag) {
   int mode = S_IRUSR | S_IWUSR;
 #if defined(_WIN32) && !defined(__MINGW32__)
   fd_ = -1;
@@ -109,14 +109,14 @@ File::File(cstring_view path, int oflag) {
     FMT_THROW(system_error(errno, "cannot open file {}", path.c_str()));
 }
 
-File::~File() FMT_NOEXCEPT {
+file::~file() FMT_NOEXCEPT {
   // Don't retry close in case of EINTR!
   // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
   if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
     report_system_error(errno, "cannot close file");
 }
 
-void File::close() {
+void file::close() {
   if (fd_ == -1)
     return;
   // Don't retry close in case of EINTR!
@@ -127,7 +127,7 @@ void File::close() {
     FMT_THROW(system_error(errno, "cannot close file"));
 }
 
-long long File::size() const {
+long long file::size() const {
 #ifdef _WIN32
   // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
   // is less than 0x0500 as is the case with some default MinGW builds.
@@ -148,12 +148,12 @@ long long File::size() const {
   if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
     FMT_THROW(system_error(errno, "cannot get file attributes"));
   static_assert(sizeof(long long) >= sizeof(file_stat.st_size),
-      "return type of File::size is not large enough");
+      "return type of file::size is not large enough");
   return file_stat.st_size;
 #endif
 }
 
-std::size_t File::read(void *buffer, std::size_t count) {
+std::size_t file::read(void *buffer, std::size_t count) {
   RWResult result = 0;
   FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
   if (result < 0)
@@ -161,7 +161,7 @@ std::size_t File::read(void *buffer, std::size_t count) {
   return internal::to_unsigned(result);
 }
 
-std::size_t File::write(const void *buffer, std::size_t count) {
+std::size_t file::write(const void *buffer, std::size_t count) {
   RWResult result = 0;
   FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
   if (result < 0)
@@ -169,16 +169,16 @@ std::size_t File::write(const void *buffer, std::size_t count) {
   return internal::to_unsigned(result);
 }
 
-File File::dup(int fd) {
+file file::dup(int fd) {
   // Don't retry as dup doesn't return EINTR.
   // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
   int new_fd = FMT_POSIX_CALL(dup(fd));
   if (new_fd == -1)
     FMT_THROW(system_error(errno, "cannot duplicate file descriptor {}", fd));
-  return File(new_fd);
+  return file(new_fd);
 }
 
-void File::dup2(int fd) {
+void file::dup2(int fd) {
   int result = 0;
   FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
   if (result == -1) {
@@ -187,14 +187,14 @@ void File::dup2(int fd) {
   }
 }
 
-void File::dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT {
+void file::dup2(int fd, error_code &ec) FMT_NOEXCEPT {
   int result = 0;
   FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
   if (result == -1)
-    ec = ErrorCode(errno);
+    ec = error_code(errno);
 }
 
-void File::pipe(File &read_end, File &write_end) {
+void file::pipe(file &read_end, file &write_end) {
   // Close the descriptors first to make sure that assignments don't throw
   // and there are no leaks.
   read_end.close();
@@ -213,11 +213,11 @@ void File::pipe(File &read_end, File &write_end) {
     FMT_THROW(system_error(errno, "cannot create pipe"));
   // The following assignments don't throw because read_fd and write_fd
   // are closed.
-  read_end = File(fds[0]);
-  write_end = File(fds[1]);
+  read_end = file(fds[0]);
+  write_end = file(fds[1]);
 }
 
-buffered_file File::fdopen(const char *mode) {
+buffered_file file::fdopen(const char *mode) {
   // Don't retry as fdopen doesn't return EINTR.
   FILE *f = FMT_POSIX_CALL(fdopen(fd_, mode));
   if (!f)

test/gtest-extra-test.cc

@@ -307,17 +307,17 @@ TEST(UtilTest, FormatSystemError) {
 #if FMT_USE_FILE_DESCRIPTORS
 
 using fmt::buffered_file;
-using fmt::ErrorCode;
-using fmt::File;
+using fmt::error_code;
+using fmt::file;
 
 TEST(ErrorCodeTest, Ctor) {
-  EXPECT_EQ(0, ErrorCode().get());
-  EXPECT_EQ(42, ErrorCode(42).get());
+  EXPECT_EQ(0, error_code().get());
+  EXPECT_EQ(42, error_code(42).get());
 }
 
 TEST(OutputRedirectTest, ScopedRedirect) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   {
     buffered_file file(write_end.fdopen("w"));
     std::fprintf(file.get(), "[[[");
@@ -332,10 +332,10 @@ TEST(OutputRedirectTest, ScopedRedirect) {
 
 // Test that OutputRedirect handles errors in flush correctly.
 TEST(OutputRedirectTest, FlushErrorInCtor) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   int write_fd = write_end.descriptor();
-  File write_copy = write_end.dup(write_fd);
+  file write_copy = write_end.dup(write_fd);
   buffered_file f = write_end.fdopen("w");
   // Put a character in a file buffer.
   EXPECT_EQ('x', fputc('x', f.get()));
@@ -350,7 +350,7 @@ TEST(OutputRedirectTest, FlushErrorInCtor) {
 TEST(OutputRedirectTest, DupErrorInCtor) {
   buffered_file f = open_buffered_file();
   int fd = (f.fileno)();
-  File copy = File::dup(fd);
+  file copy = file::dup(fd);
   FMT_POSIX(close(fd));
   scoped_ptr<OutputRedirect> redir;
   EXPECT_SYSTEM_ERROR_NOASSERT(redir.reset(new OutputRedirect(f.get())),
@@ -359,8 +359,8 @@ TEST(OutputRedirectTest, DupErrorInCtor) {
 }
 
 TEST(OutputRedirectTest, RestoreAndRead) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   buffered_file file(write_end.fdopen("w"));
   std::fprintf(file.get(), "[[[");
   OutputRedirect redir(file.get());
@@ -374,10 +374,10 @@ TEST(OutputRedirectTest, RestoreAndRead) {
 
 // Test that OutputRedirect handles errors in flush correctly.
 TEST(OutputRedirectTest, FlushErrorInRestoreAndRead) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   int write_fd = write_end.descriptor();
-  File write_copy = write_end.dup(write_fd);
+  file write_copy = write_end.dup(write_fd);
   buffered_file f = write_end.fdopen("w");
   OutputRedirect redir(f.get());
   // Put a character in a file buffer.
@@ -389,10 +389,10 @@ TEST(OutputRedirectTest, FlushErrorInRestoreAndRead) {
 }
 
 TEST(OutputRedirectTest, ErrorInDtor) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   int write_fd = write_end.descriptor();
-  File write_copy = write_end.dup(write_fd);
+  file write_copy = write_end.dup(write_fd);
   buffered_file f = write_end.fdopen("w");
   scoped_ptr<OutputRedirect> redir(new OutputRedirect(f.get()));
   // Put a character in a file buffer.

test/gtest-extra.cc

@@ -9,7 +9,7 @@
 
 #if FMT_USE_FILE_DESCRIPTORS
 
-using fmt::File;
+using fmt::file;
 
 void OutputRedirect::flush() {
 #if EOF != -1
@@ -30,14 +30,14 @@ void OutputRedirect::restore() {
   original_.close();
 }
 
-OutputRedirect::OutputRedirect(FILE *file) : file_(file) {
+OutputRedirect::OutputRedirect(FILE *f) : file_(f) {
   flush();
-  int fd = FMT_POSIX(fileno(file));
-  // Create a File object referring to the original file.
-  original_ = File::dup(fd);
+  int fd = FMT_POSIX(fileno(f));
+  // Create a file object referring to the original file.
+  original_ = file::dup(fd);
   // Create a pipe.
-  File write_end;
-  File::pipe(read_end_, write_end);
+  file write_end;
+  file::pipe(read_end_, write_end);
   // Connect the passed FILE object to the write end of the pipe.
   write_end.dup2(fd);
 }
@@ -69,7 +69,7 @@ std::string OutputRedirect::restore_and_read() {
   return content;
 }
 
-std::string read(File &f, std::size_t count) {
+std::string read(file &f, std::size_t count) {
   std::string buffer(count, '\0');
   std::size_t n = 0, offset = 0;
   do {

test/gtest-extra.h

@@ -74,8 +74,8 @@ std::string format_system_error(int error_code, fmt::string_view message);
 class OutputRedirect {
  private:
   FILE *file_;
-  fmt::File original_;  // Original file passed to redirector.
-  fmt::File read_end_;  // Read end of the pipe where the output is redirected.
+  fmt::file original_;  // Original file passed to redirector.
+  fmt::file read_end_;  // Read end of the pipe where the output is redirected.
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(OutputRedirect);
 
@@ -145,7 +145,7 @@ class SuppressAssert {
   EXPECT_SYSTEM_ERROR(SUPPRESS_ASSERT(statement), error_code, message)
 
 // Attempts to read count characters from a file.
-std::string read(fmt::File &f, std::size_t count);
+std::string read(fmt::file &f, std::size_t count);
 
 #define EXPECT_READ(file, expected_content) \
   EXPECT_EQ(expected_content, read(file, std::strlen(expected_content)))

test/posix-mock-test.cc

@@ -26,8 +26,8 @@
 #include "util.h"
 
 using fmt::buffered_file;
-using fmt::ErrorCode;
-using fmt::File;
+using fmt::error_code;
+using fmt::file;
 
 using testing::internal::scoped_ptr;
 using testing::_;
@@ -214,8 +214,8 @@ TEST(UtilTest, GetPageSize) {
 
 TEST(FileTest, OpenRetry) {
   write_file("test", "there must be something here");
-  scoped_ptr<File> f;
-  EXPECT_RETRY(f.reset(new File("test", File::RDONLY)),
+  scoped_ptr<file> f;
+  EXPECT_RETRY(f.reset(new file("test", file::RDONLY)),
                open, "cannot open file test");
 #ifndef _WIN32
   char c = 0;
@@ -224,9 +224,9 @@ TEST(FileTest, OpenRetry) {
 }
 
 TEST(FileTest, CloseNoRetryInDtor) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
-  scoped_ptr<File> f(new File(std::move(read_end)));
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  scoped_ptr<file> f(new file(std::move(read_end)));
   int saved_close_count = 0;
   EXPECT_WRITE(stderr, {
     close_count = 1;
@@ -238,8 +238,8 @@ TEST(FileTest, CloseNoRetryInDtor) {
 }
 
 TEST(FileTest, CloseNoRetry) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   close_count = 1;
   EXPECT_SYSTEM_ERROR(read_end.close(), EINTR, "cannot close file");
   EXPECT_EQ(2, close_count);
@@ -249,7 +249,7 @@ TEST(FileTest, CloseNoRetry) {
 TEST(FileTest, Size) {
   std::string content = "top secret, destroy before reading";
   write_file("test", content);
-  File f("test", File::RDONLY);
+  file f("test", file::RDONLY);
   EXPECT_GE(f.size(), 0);
   EXPECT_EQ(content.size(), static_cast<unsigned long long>(f.size()));
 #ifdef _WIN32
@@ -267,7 +267,7 @@ TEST(FileTest, Size) {
 
 TEST(FileTest, MaxSize) {
   write_file("test", "");
-  File f("test", File::RDONLY);
+  file f("test", file::RDONLY);
   fstat_sim = MAX_SIZE;
   EXPECT_GE(f.size(), 0);
   EXPECT_EQ(max_file_size(), f.size());
@@ -275,8 +275,8 @@ TEST(FileTest, MaxSize) {
 }
 
 TEST(FileTest, ReadRetry) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   enum { SIZE = 4 };
   write_end.write("test", SIZE);
   write_end.close();
@@ -288,8 +288,8 @@ TEST(FileTest, ReadRetry) {
 }
 
 TEST(FileTest, WriteRetry) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   enum { SIZE = 4 };
   std::size_t count = 0;
   EXPECT_RETRY(count = write_end.write("test", SIZE),
@@ -306,8 +306,8 @@ TEST(FileTest, WriteRetry) {
 
 #ifdef _WIN32
 TEST(FileTest, ConvertReadCount) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   char c;
   std::size_t size = UINT_MAX;
   if (sizeof(unsigned) != sizeof(std::size_t))
@@ -320,8 +320,8 @@ TEST(FileTest, ConvertReadCount) {
 }
 
 TEST(FileTest, ConvertWriteCount) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   char c;
   std::size_t size = UINT_MAX;
   if (sizeof(unsigned) != sizeof(std::size_t))
@@ -337,14 +337,14 @@ TEST(FileTest, ConvertWriteCount) {
 TEST(FileTest, DupNoRetry) {
   int stdout_fd = FMT_POSIX(fileno(stdout));
   dup_count = 1;
-  EXPECT_SYSTEM_ERROR(File::dup(stdout_fd), EINTR,
+  EXPECT_SYSTEM_ERROR(file::dup(stdout_fd), EINTR,
       fmt::format("cannot duplicate file descriptor {}", stdout_fd));
   dup_count = 0;
 }
 
 TEST(FileTest, Dup2Retry) {
   int stdout_fd = FMT_POSIX(fileno(stdout));
-  File f1 = File::dup(stdout_fd), f2 = File::dup(stdout_fd);
+  file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd);
   EXPECT_RETRY(f1.dup2(f2.descriptor()), dup2,
       fmt::format("cannot duplicate file descriptor {} to {}",
       f1.descriptor(), f2.descriptor()));
@@ -352,8 +352,8 @@ TEST(FileTest, Dup2Retry) {
 
 TEST(FileTest, Dup2NoExceptRetry) {
   int stdout_fd = FMT_POSIX(fileno(stdout));
-  File f1 = File::dup(stdout_fd), f2 = File::dup(stdout_fd);
-  ErrorCode ec;
+  file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd);
+  error_code ec;
   dup2_count = 1;
   f1.dup2(f2.descriptor(), ec);
 #ifndef _WIN32
@@ -365,16 +365,16 @@ TEST(FileTest, Dup2NoExceptRetry) {
 }
 
 TEST(FileTest, PipeNoRetry) {
-  File read_end, write_end;
+  file read_end, write_end;
   pipe_count = 1;
   EXPECT_SYSTEM_ERROR(
-      File::pipe(read_end, write_end), EINTR, "cannot create pipe");
+      file::pipe(read_end, write_end), EINTR, "cannot create pipe");
   pipe_count = 0;
 }
 
 TEST(FileTest, FdopenNoRetry) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   fdopen_count = 1;
   EXPECT_SYSTEM_ERROR(read_end.fdopen("r"),
       EINTR, "cannot associate stream with file descriptor");
@@ -394,8 +394,8 @@ TEST(BufferedFileTest, OpenRetry) {
 }
 
 TEST(BufferedFileTest, CloseNoRetryInDtor) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   scoped_ptr<buffered_file> f(new buffered_file(read_end.fdopen("r")));
   int saved_fclose_count = 0;
   EXPECT_WRITE(stderr, {
@@ -408,8 +408,8 @@ TEST(BufferedFileTest, CloseNoRetryInDtor) {
 }
 
 TEST(BufferedFileTest, CloseNoRetry) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   buffered_file f = read_end.fdopen("r");
   fclose_count = 1;
   EXPECT_SYSTEM_ERROR(f.close(), EINTR, "cannot close file");
@@ -418,8 +418,8 @@ TEST(BufferedFileTest, CloseNoRetry) {
 }
 
 TEST(BufferedFileTest, FilenoNoRetry) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   buffered_file f = read_end.fdopen("r");
   fileno_count = 1;
   EXPECT_SYSTEM_ERROR((f.fileno)(), EINTR, "cannot get file descriptor");

test/posix-test.cc

@@ -17,8 +17,8 @@
 #endif
 
 using fmt::buffered_file;
-using fmt::ErrorCode;
-using fmt::File;
+using fmt::error_code;
+using fmt::file;
 
 using testing::internal::scoped_ptr;
 
@@ -36,16 +36,16 @@ bool isclosed(int fd) {
 }
 
 // Opens a file for reading.
-File open_file() {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+file open_file() {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   write_end.write(FILE_CONTENT, std::strlen(FILE_CONTENT));
   write_end.close();
   return read_end;
 }
 
 // Attempts to write a string to a file.
-void write(File &f, fmt::string_view s) {
+void write(file &f, fmt::string_view s) {
   std::size_t num_chars_left = s.size();
   const char *ptr = s.data();
   do {
@@ -160,12 +160,12 @@ TEST(BufferedFileTest, Fileno) {
 #endif
   f = open_buffered_file();
   EXPECT_TRUE(f.fileno() != -1);
-  File copy = File::dup(f.fileno());
+  file copy = file::dup(f.fileno());
   EXPECT_READ(copy, FILE_CONTENT);
 }
 
 TEST(FileTest, DefaultCtor) {
-  File f;
+  file f;
   EXPECT_EQ(-1, f.descriptor());
 }
 
@@ -173,64 +173,64 @@ TEST(FileTest, OpenBufferedFileInCtor) {
   FILE *fp = safe_fopen("test-file", "w");
   std::fputs(FILE_CONTENT, fp);
   std::fclose(fp);
-  File f("test-file", File::RDONLY);
+  file f("test-file", file::RDONLY);
   ASSERT_TRUE(isopen(f.descriptor()));
 }
 
 TEST(FileTest, OpenBufferedFileError) {
-  EXPECT_SYSTEM_ERROR(File("nonexistent", File::RDONLY),
+  EXPECT_SYSTEM_ERROR(file("nonexistent", file::RDONLY),
       ENOENT, "cannot open file nonexistent");
 }
 
 TEST(FileTest, MoveCtor) {
-  File f = open_file();
+  file f = open_file();
   int fd = f.descriptor();
   EXPECT_NE(-1, fd);
-  File f2(std::move(f));
+  file f2(std::move(f));
   EXPECT_EQ(fd, f2.descriptor());
   EXPECT_EQ(-1, f.descriptor());
 }
 
 TEST(FileTest, MoveAssignment) {
-  File f = open_file();
+  file f = open_file();
   int fd = f.descriptor();
   EXPECT_NE(-1, fd);
-  File f2;
+  file f2;
   f2 = std::move(f);
   EXPECT_EQ(fd, f2.descriptor());
   EXPECT_EQ(-1, f.descriptor());
 }
 
 TEST(FileTest, MoveAssignmentClosesFile) {
-  File f = open_file();
-  File f2 = open_file();
+  file f = open_file();
+  file f2 = open_file();
   int old_fd = f2.descriptor();
   f2 = std::move(f);
   EXPECT_TRUE(isclosed(old_fd));
 }
 
-File OpenBufferedFile(int &fd) {
-  File f = open_file();
+file OpenBufferedFile(int &fd) {
+  file f = open_file();
   fd = f.descriptor();
   return f;
 }
 
 TEST(FileTest, MoveFromTemporaryInCtor) {
   int fd = 0xdead;
-  File f(OpenBufferedFile(fd));
+  file f(OpenBufferedFile(fd));
   EXPECT_EQ(fd, f.descriptor());
 }
 
 TEST(FileTest, MoveFromTemporaryInAssignment) {
   int fd = 0xdead;
-  File f;
+  file f;
   f = OpenBufferedFile(fd);
   EXPECT_EQ(fd, f.descriptor());
 }
 
 TEST(FileTest, MoveFromTemporaryInAssignmentClosesFile) {
   int fd = 0xdead;
-  File f = open_file();
+  file f = open_file();
   int old_fd = f.descriptor();
   f = OpenBufferedFile(fd);
   EXPECT_TRUE(isclosed(old_fd));
@@ -239,14 +239,14 @@ TEST(FileTest, MoveFromTemporaryInAssignmentClosesFile) {
 TEST(FileTest, CloseFileInDtor) {
   int fd = 0;
   {
-    File f = open_file();
+    file f = open_file();
     fd = f.descriptor();
   }
   EXPECT_TRUE(isclosed(fd));
 }
 
 TEST(FileTest, CloseErrorInDtor) {
-  scoped_ptr<File> f(new File(open_file()));
+  scoped_ptr<file> f(new file(open_file()));
   EXPECT_WRITE(stderr, {
       // The close function must be called inside EXPECT_WRITE, otherwise
       // the system may recycle closed file descriptor when redirecting the
@@ -258,7 +258,7 @@ TEST(FileTest, CloseErrorInDtor) {
 }
 
 TEST(FileTest, Close) {
-  File f = open_file();
+  file f = open_file();
   int fd = f.descriptor();
   f.close();
   EXPECT_EQ(-1, f.descriptor());
@@ -266,19 +266,19 @@ TEST(FileTest, Close) {
 }
 
 TEST(FileTest, CloseError) {
-  File f = open_file();
+  file f = open_file();
   FMT_POSIX(close(f.descriptor()));
   EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file");
   EXPECT_EQ(-1, f.descriptor());
 }
 
 TEST(FileTest, Read) {
-  File f = open_file();
+  file f = open_file();
   EXPECT_READ(f, FILE_CONTENT);
 }
 
 TEST(FileTest, ReadError) {
-  File f("test-file", File::WRONLY);
+  file f("test-file", file::WRONLY);
   char buf;
   // We intentionally read from a file opened in the write-only mode to
   // cause error.
@@ -286,23 +286,23 @@ TEST(FileTest, ReadError) {
 }
 
 TEST(FileTest, Write) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   write(write_end, "test");
   write_end.close();
   EXPECT_READ(read_end, "test");
 }
 
 TEST(FileTest, WriteError) {
-  File f("test-file", File::RDONLY);
+  file f("test-file", file::RDONLY);
   // We intentionally write to a file opened in the read-only mode to
   // cause error.
   EXPECT_SYSTEM_ERROR(f.write(" ", 1), EBADF, "cannot write to file");
 }
 
 TEST(FileTest, Dup) {
-  File f = open_file();
-  File copy = File::dup(f.descriptor());
+  file f = open_file();
+  file copy = file::dup(f.descriptor());
   EXPECT_NE(f.descriptor(), copy.descriptor());
   EXPECT_EQ(FILE_CONTENT, read(copy, std::strlen(FILE_CONTENT)));
 }
@@ -310,29 +310,29 @@ TEST(FileTest, Dup) {
 #ifndef __COVERITY__
 TEST(FileTest, DupError) {
   int value = -1;
-  EXPECT_SYSTEM_ERROR_NOASSERT(File::dup(value),
+  EXPECT_SYSTEM_ERROR_NOASSERT(file::dup(value),
       EBADF, "cannot duplicate file descriptor -1");
 }
 #endif
 
 TEST(FileTest, Dup2) {
-  File f = open_file();
-  File copy = open_file();
+  file f = open_file();
+  file copy = open_file();
   f.dup2(copy.descriptor());
   EXPECT_NE(f.descriptor(), copy.descriptor());
   EXPECT_READ(copy, FILE_CONTENT);
 }
 
 TEST(FileTest, Dup2Error) {
-  File f = open_file();
+  file f = open_file();
   EXPECT_SYSTEM_ERROR_NOASSERT(f.dup2(-1), EBADF,
     fmt::format("cannot duplicate file descriptor {} to -1", f.descriptor()));
 }
 
 TEST(FileTest, Dup2NoExcept) {
-  File f = open_file();
-  File copy = open_file();
-  ErrorCode ec;
+  file f = open_file();
+  file copy = open_file();
+  error_code ec;
   f.dup2(copy.descriptor(), ec);
   EXPECT_EQ(0, ec.get());
   EXPECT_NE(f.descriptor(), copy.descriptor());
@@ -340,15 +340,15 @@ TEST(FileTest, Dup2NoExcept) {
 }
 
 TEST(FileTest, Dup2NoExceptError) {
-  File f = open_file();
-  ErrorCode ec;
+  file f = open_file();
+  error_code ec;
   SUPPRESS_ASSERT(f.dup2(-1, ec));
   EXPECT_EQ(EBADF, ec.get());
 }
 
 TEST(FileTest, Pipe) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   EXPECT_NE(-1, read_end.descriptor());
   EXPECT_NE(-1, write_end.descriptor());
   write(write_end, "test");
@@ -356,14 +356,14 @@ TEST(FileTest, Pipe) {
 }
 
 TEST(FileTest, Fdopen) {
-  File read_end, write_end;
-  File::pipe(read_end, write_end);
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
   int read_fd = read_end.descriptor();
   EXPECT_EQ(read_fd, FMT_POSIX(fileno(read_end.fdopen("r").get())));
 }
 
 TEST(FileTest, FdopenError) {
-  File f;
+  file f;
   EXPECT_SYSTEM_ERROR_NOASSERT(
       f.fdopen("r"), EBADF, "cannot associate stream with file descriptor");
 }

test/printf-test.cc

@@ -478,8 +478,8 @@ TEST(PrintfTest, Examples) {
 }
 
 TEST(PrintfTest, PrintfError) {
-  fmt::File read_end, write_end;
-  fmt::File::pipe(read_end, write_end);
+  fmt::file read_end, write_end;
+  fmt::file::pipe(read_end, write_end);
   int result = fmt::fprintf(read_end.fdopen("r").get(), "test");
   EXPECT_LT(result, 0);
 }

test/util.cc

@@ -33,8 +33,8 @@ std::string get_system_error(int error_code) {
 const char *const FILE_CONTENT = "Don't panic!";
 
 fmt::buffered_file open_buffered_file(FILE **fp) {
-  fmt::File read_end, write_end;
-  fmt::File::pipe(read_end, write_end);
+  fmt::file read_end, write_end;
+  fmt::file::pipe(read_end, write_end);
   write_end.write(FILE_CONTENT, std::strlen(FILE_CONTENT));
   write_end.close();
   fmt::buffered_file f = read_end.fdopen("r");