[libc] Remove operator T from cpp::expected.

[lntue]

Summary

The libc's equivalent of std::expected has a non-standard and
non-explicit operator T - https://github.com/llvm/llvm-project/issues/62738

[sivachandra]

libc/src/__support/File/dir.cpp

23

Is using *fd more idiomatic?

[lntue]

libc/src/__support/File/dir.cpp

23

I'm not sure if it's more idiomatic, but most places in our code base are already using .value(). Either usage is fine with me.

libc/src/__support/CPP/expected.h

public:
   constexpr expected(unexpected<E> unexp)
       : unexp(unexp.error()), is_expected(false) {}
 
   constexpr bool has_value() { return is_expected; }
 
   constexpr T value() { return exp; }
   constexpr E error() { return unexp; }
 
-  constexpr operator T() { return exp; }
   constexpr operator bool() { return is_expected; }
 
   constexpr T &operator*() { return exp; }
   constexpr const T &operator*() const { return exp; }
   constexpr T *operator->() { return &exp; }
   constexpr const T *operator->() const { return &exp; }
 };
 
 } // namespace __llvm_libc::cpp
 
 #endif // LLVM_LIBC_SUPPORT_CPP_EXPECTED_H

libc/src/__support/File/dir.cpp

 namespace __llvm_libc {
 
 ErrorOr<Dir *> Dir::open(const char *path) {
   auto fd = platform_opendir(path);
   if (!fd)
     return __llvm_libc::Error(fd.error());
 
   __llvm_libc::AllocChecker ac;
-  Dir *dir = new (ac) Dir(fd);
+  Dir *dir = new (ac) Dir(fd.value());
   if (!ac)
     return __llvm_libc::Error(ENOMEM);
   return dir;
 }
 
 ErrorOr<struct ::dirent *> Dir::read() {
   MutexLock lock(&mutex);
   if (readptr >= fillsize) {
     auto readsize = platform_fetch_dirents(fd, buffer);
     if (!readsize)
       return __llvm_libc::Error(readsize.error());
-    fillsize = readsize;
+    fillsize = readsize.value();
     readptr = 0;
   }
   if (fillsize == 0)
     return nullptr;
 
   struct ::dirent *d = reinterpret_cast<struct ::dirent *>(buffer + readptr);
 #ifdef __unix__
   // The d_reclen field is available on Linux but not required by POSIX.

libc/src/dirent/readdir.cpp

 
 LLVM_LIBC_FUNCTION(struct ::dirent *, readdir, (::DIR * dir)) {
   auto *d = reinterpret_cast<__llvm_libc::Dir *>(dir);
   auto dirent_val = d->read();
   if (!dirent_val) {
     libc_errno = dirent_val.error();
     return nullptr;
   }
-  return dirent_val;
+  return dirent_val.value();
 }
 
 } // namespace __llvm_libc

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

 #include "test/UnitTest/Test.h"
 
 #include <stdio.h> // For SEEK_* macros
 
 using File = __llvm_libc::File;
 constexpr char TEXT[] = "Hello, File";
 constexpr size_t TEXT_SIZE = sizeof(TEXT) - 1; // Ignore the null terminator
 
+LIBC_INLINE File *openfile(const char *file_name, const char *mode) {
+  auto error_or_file = __llvm_libc::openfile(file_name, mode);
+  return error_or_file.has_value() ? error_or_file.value() : nullptr;
+}
+
 TEST(LlvmLibcPlatformFileTest, CreateWriteCloseAndReadBack) {
   constexpr char FILENAME[] = "testdata/create_write_close_and_readback.test";
-  File *file = __llvm_libc::openfile(FILENAME, "w");
+  File *file = openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
   ASSERT_EQ(File::cleanup(file), 0);
 
-  file = __llvm_libc::openfile(FILENAME, "r");
+  file = 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::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, CreateWriteSeekAndReadBack) {
   constexpr char FILENAME[] = "testdata/create_write_seek_and_readback.test";
-  File *file = __llvm_libc::openfile(FILENAME, "w+");
+  File *file = 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::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, CreateAppendCloseAndReadBack) {
   constexpr char FILENAME[] = "testdata/create_append_close_and_readback.test";
-  File *file = __llvm_libc::openfile(FILENAME, "w");
+  File *file = openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
   ASSERT_EQ(File::cleanup(file), 0);
 
-  file = __llvm_libc::openfile(FILENAME, "a");
+  file = 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::cleanup(file), 0);
 
-  file = __llvm_libc::openfile(FILENAME, "r");
+  file = 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::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, CreateAppendSeekAndReadBack) {
   constexpr char FILENAME[] = "testdata/create_append_seek_and_readback.test";
-  File *file = __llvm_libc::openfile(FILENAME, "w");
+  File *file = openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
   ASSERT_EQ(File::cleanup(file), 0);
 
-  file = __llvm_libc::openfile(FILENAME, "a+");
+  file = 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);

 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");
+  File *file = 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::cleanup(file), 0);
 
-  file = __llvm_libc::openfile(FILENAME, "r");
+  file = 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::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, ReadSeekCurAndRead) {
   constexpr char FILENAME[] = "testdata/read_seek_cur_and_read.test";
-  File *file = __llvm_libc::openfile(FILENAME, "w");
+  File *file = 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::cleanup(file));
 
-  file = __llvm_libc::openfile(FILENAME, "r");
+  file = 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::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, IncorrectOperation) {
   constexpr char FILENAME[] = "testdata/incorrect_operation.test";
   char data[1] = {123};
 
-  File *file = __llvm_libc::openfile(FILENAME, "w");
+  File *file = 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::cleanup(file), 0);
 
-  file = __llvm_libc::openfile(FILENAME, "r");
+  file = 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::cleanup(file), 0);
 
-  file = __llvm_libc::openfile(FILENAME, "a");
+  file = 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::cleanup(file), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, StdOutStdErrSmokeTest) {
   EXPECT_FALSE(__llvm_libc::stdout == nullptr);
   EXPECT_FALSE(__llvm_libc::stderr == nullptr);
 }