Migrate cel::optional_ref to absl::optional_ref

PiperOrigin-RevId: 991014396

Author: jcking

common/BUILD

@@ -976,9 +976,8 @@ cc_library(
     hdrs = ["optional_ref.h"],
     deps = [
         "@com_google_absl//absl/base:core_headers",
-        "@com_google_absl//absl/base:nullability",
         "@com_google_absl//absl/types:optional",
-        "@com_google_absl//absl/utility",
+        "@com_google_absl//absl/types:optional_ref",
     ],
 )
 

common/optional_ref.h

@@ -15,144 +15,34 @@
 #ifndef THIRD_PARTY_CEL_CPP_OPTIONAL_REF_H_
 #define THIRD_PARTY_CEL_CPP_OPTIONAL_REF_H_
 
-#include <memory>
+#include <optional>
 #include <type_traits>
 
-#include "absl/base/attributes.h"
 #include "absl/base/macros.h"
-#include "absl/base/nullability.h"
-#include "absl/base/optimization.h"
-#include "absl/types/optional.h"
-#include "absl/utility/utility.h"
+#include "absl/types/optional_ref.h"
 
 namespace cel {
 
 // `optional_ref<T>` looks and feels like `absl::optional<T>`, but instead of
 // owning the underlying value, it retains a reference to the value it accepts
 // in its constructor.
 template <typename T>
-class optional_ref final {
- public:
-  static_assert(!std::is_reference_v<T>, "T must not be a reference.");
-  static_assert(!std::is_same_v<absl::nullopt_t, std::remove_cv_t<T>>,
-                "optional_ref<absl::nullopt_t> is not allowed.");
-  static_assert(!std::is_same_v<absl::in_place_t, std::remove_cv_t<T>>,
-                "optional_ref<absl::in_place_t> is not allowed.");
-
-  using value_type = T;
-
-  optional_ref() = default;
-
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr optional_ref(absl::nullopt_t) : optional_ref() {}
-
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr optional_ref(T& value ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : value_(std::addressof(value)) {}
-
-  template <
-      typename U,
-      typename = std::enable_if_t<std::conjunction_v<
-          std::is_const<T>, std::is_same<std::decay_t<U>, std::decay_t<T>>>>>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr optional_ref(
-      const absl::optional<U>& value ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : value_(value.has_value() ? std::addressof(*value) : nullptr) {}
-
-  template <typename U, typename = std::enable_if_t<
-                            std::is_same_v<std::decay_t<U>, std::decay_t<T>>>>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr optional_ref(absl::optional<U>& value ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : value_(value.has_value() ? std::addressof(*value) : nullptr) {}
-
-  template <
-      typename U,
-      typename = std::enable_if_t<std::conjunction_v<
-          std::negation<std::is_same<U, T>>,
-          std::is_convertible<std::add_pointer_t<U>, std::add_pointer_t<T>>>>>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr optional_ref(const optional_ref<U>& other) : value_(other.value_) {}
-
-  optional_ref(const optional_ref<T>&) = default;
-
-  optional_ref<T>& operator=(const optional_ref<T>&) = delete;
-
-  constexpr bool has_value() const { return value_ != nullptr; }
-
-  constexpr explicit operator bool() const { return has_value(); }
-
-  constexpr T& value() const {
-    return ABSL_PREDICT_TRUE(has_value())
-               ? *value_
-               // Replicate the same error logic as in `absl::optional`'s
-               // `value()`. It either throws an exception or aborts the
-               // program. We intentionally ignore the return value of
-               // the constructed optional's value as we only need to run
-               // the code for error checking.
-               : ((void)absl::optional<T>().value(), *value_);
-  }
-
-  constexpr T& operator*() const {
-    ABSL_ASSERT(has_value());
-    return *value_;
-  }
-
-  constexpr T* absl_nonnull operator->() const {
-    ABSL_ASSERT(has_value());
-    return value_;
-  }
-
- private:
-  template <typename U>
-  friend class optional_ref;
-
-  T* const value_ = nullptr;
-};
-
-template <typename T>
-optional_ref(const T&) -> optional_ref<const T>;
-
-template <typename T>
-optional_ref(T&) -> optional_ref<T>;
-
-template <typename T>
-optional_ref(const absl::optional<T>&) -> optional_ref<const T>;
-
-template <typename T>
-optional_ref(absl::optional<T>&) -> optional_ref<T>;
-
-template <typename T>
-constexpr bool operator==(const optional_ref<T>& lhs, absl::nullopt_t) {
-  return !lhs.has_value();
-}
-
-template <typename T>
-constexpr bool operator==(absl::nullopt_t, const optional_ref<T>& rhs) {
-  return !rhs.has_value();
-}
-
-template <typename T>
-constexpr bool operator!=(const optional_ref<T>& lhs, absl::nullopt_t) {
-  return !operator==(lhs, absl::nullopt);
-}
-
-template <typename T>
-constexpr bool operator!=(absl::nullopt_t, const optional_ref<T>& rhs) {
-  return !operator==(absl::nullopt, rhs);
-}
+using optional_ref ABSL_DEPRECATE_AND_INLINE() = absl::optional_ref<T>;
 
 namespace common_internal {
 
 template <typename T>
-absl::optional<std::decay_t<T>> AsOptional(optional_ref<T> ref) {
+[[nodiscard]]
+std::optional<std::decay_t<T>> AsOptional(absl::optional_ref<T> ref) {
   if (ref) {
     return *ref;
   }
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 template <typename T>
-absl::optional<T> AsOptional(absl::optional<T> opt) {
+[[nodiscard]]
+std::optional<T> AsOptional(std::optional<T> opt) {
   return opt;
 }