[libc][NFC] add arrow operator to optional

[sivachandra]

Good to go after adding smoke tests.

libc/src/__support/CPP/optional.h

78

For consistency with operator*, make it const & and add a non-const & flavor also.

[michaelrj]

add tests and non-const version

libc/src/__support/CPP/optional.h

78

If I change this to be a reference, then to use the -> operator the contained object must also support the -> operator. Here's the error message when I try it:
error: member reference type 'const __llvm_libc::cpp::StringView' is not a pointer

I think it's more useful to leave it as is, so that it works as expected without additional effort.

libc/src/__support/CPP/optional.h

public:
   constexpr optional &operator=(nullopt_t) {
     reset();
     return *this;
   }
 
   constexpr T &operator*() & { return Storage.StoredValue; }
 
   constexpr const T &operator*() const & { return Storage.StoredValue; }
+
+  constexpr T *operator->() { return &Storage.StoredValue; }
+
+  constexpr const T *operator->() const { return &Storage.StoredValue; }
 };
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_OPTIONAL_H

libc/test/src/__support/CPP/optional_test.cpp

 //===-- Unittests for Optional --------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/CPP/optional.h"
 #include "utils/UnitTest/Test.h"
 
 using __llvm_libc::cpp::nullopt;
 using __llvm_libc::cpp::optional;
 
-// This has clase has two properties for testing:
-// 1) No default constructor
-// 2) A non-trivial destructor with an observable side-effect
+// This class has three properties for testing:
+// 1) No default constructor.
+// 2) A non-trivial destructor with an observable side-effect.
+// 3) Functions that can be called explicitly.
 class Contrived {
   int *_a;
 
 public:
   Contrived(int *a) : _a(a) {}
   ~Contrived() { (*_a)++; }
+
+  int get_a() { return *_a; }
+  void inc_a() { (*_a)++; }
 };
 
 TEST(LlvmLibcOptionalTest, Tests) {
   optional<int> Trivial1(12);
   ASSERT_TRUE(Trivial1.has_value());
   ASSERT_EQ(Trivial1.value(), 12);
   ASSERT_EQ(*Trivial1, 12);
   Trivial1.reset();
TEST(LlvmLibcOptionalTest, Tests) {
   ASSERT_TRUE(Trivial4.has_value());
   ASSERT_EQ(Trivial4.value(), 12);
 
   // Test that assigning an option to another works when unset
   optional<int> Trivial5;
   ASSERT_FALSE(Trivial5.has_value());
   optional<int> Trivial6 = Trivial5;
   ASSERT_FALSE(Trivial6.has_value());
+
+  // Test operator->
+  int arrow_num = 5;
+  optional<Contrived> arrow_test(&arrow_num);
+  ASSERT_TRUE(arrow_test.has_value());
+  ASSERT_EQ(arrow_test->get_a(), arrow_num);
+  arrow_num = 10;
+  ASSERT_EQ(arrow_test->get_a(), arrow_num);
+  arrow_test->inc_a();
+  ASSERT_EQ(arrow_test->get_a(), arrow_num);
+  ASSERT_EQ(arrow_num, 11);
+  arrow_test.reset();
 }