[absl] Mark `absl::NoDestructor` methods with `absl::Nonnull` as appropriate

* It is stated in prose that the methods on `absl::NoDestructor` can never return a null pointer
* Now this is annotated via nullability annotations as well

PiperOrigin-RevId: 611619075
Change-Id: I078a5628430b7b221c009a5dcb849efe30409c28

absl/base/BUILD.bazel

@@ -74,7 +74,10 @@ cc_library(
     hdrs = ["no_destructor.h"],
     hdrs = ["no_destructor.h"],
     copts = ABSL_DEFAULT_COPTS,
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
-    deps = [":config"],
+    deps = [
+        ":config",
+        ":nullability",
+    ],
 )
 )
 
 
 cc_library(
 cc_library(

absl/base/CMakeLists.txt

@@ -62,6 +62,7 @@ absl_cc_library(
     "no_destructor.h"
     "no_destructor.h"
   DEPS
   DEPS
     absl::config
     absl::config
+    absl::nullability
   COPTS
   COPTS
     ${ABSL_DEFAULT_COPTS}
     ${ABSL_DEFAULT_COPTS}
 )
 )

absl/base/no_destructor.h

@@ -41,6 +41,7 @@
 #include <utility>
 #include <utility>
 
 
 #include "absl/base/config.h"
 #include "absl/base/config.h"
+#include "absl/base/nullability.h"
 
 
 namespace absl {
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 ABSL_NAMESPACE_BEGIN
@@ -140,11 +141,11 @@ class NoDestructor {
   // Pretend to be a smart pointer to T with deep constness.
   // Pretend to be a smart pointer to T with deep constness.
   // Never returns a null pointer.
   // Never returns a null pointer.
   T& operator*() { return *get(); }
   T& operator*() { return *get(); }
-  T* operator->() { return get(); }
-  T* get() { return impl_.get(); }
+  absl::Nonnull<T*> operator->() { return get(); }
+  absl::Nonnull<T*> get() { return impl_.get(); }
   const T& operator*() const { return *get(); }
   const T& operator*() const { return *get(); }
-  const T* operator->() const { return get(); }
-  const T* get() const { return impl_.get(); }
+  absl::Nonnull<const T*> operator->() const { return get(); }
+  absl::Nonnull<const T*> get() const { return impl_.get(); }
 
 
  private:
  private:
   class DirectImpl {
   class DirectImpl {
@@ -152,8 +153,8 @@ class NoDestructor {
     template <typename... Args>
     template <typename... Args>
     explicit constexpr DirectImpl(Args&&... args)
     explicit constexpr DirectImpl(Args&&... args)
         : value_(std::forward<Args>(args)...) {}
         : value_(std::forward<Args>(args)...) {}
-    const T* get() const { return &value_; }
-    T* get() { return &value_; }
+    absl::Nonnull<const T*> get() const { return &value_; }
+    absl::Nonnull<T*> get() { return &value_; }
 
 
    private:
    private:
     T value_;
     T value_;
@@ -165,14 +166,14 @@ class NoDestructor {
     explicit PlacementImpl(Args&&... args) {
     explicit PlacementImpl(Args&&... args) {
       new (&space_) T(std::forward<Args>(args)...);
       new (&space_) T(std::forward<Args>(args)...);
     }
     }
-    const T* get() const {
+    absl::Nonnull<const T*> get() const {
       return Launder(reinterpret_cast<const T*>(&space_));
       return Launder(reinterpret_cast<const T*>(&space_));
     }
     }
-    T* get() { return Launder(reinterpret_cast<T*>(&space_)); }
+    absl::Nonnull<T*> get() { return Launder(reinterpret_cast<T*>(&space_)); }
 
 
    private:
    private:
     template <typename P>
     template <typename P>
-    static P* Launder(P* p) {
+    static absl::Nonnull<P*> Launder(absl::Nonnull<P*> p) {
 #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606L
 #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606L
       return std::launder(p);
       return std::launder(p);
 #elif ABSL_HAVE_BUILTIN(__builtin_launder)
 #elif ABSL_HAVE_BUILTIN(__builtin_launder)