Remove template alias nullability annotations.

These were deprecated before the last LTS release.

PiperOrigin-RevId: 762205726
Change-Id: I9d15a08967086296ecc9650a7ae0ae9c4973c405

Author: Abseil Team

CMake/AbseilDll.cmake

@@ -25,7 +25,6 @@ set(ABSL_INTERNAL_DLL_FILES
   "base/internal/low_level_alloc.cc"
   "base/internal/low_level_alloc.h"
   "base/internal/low_level_scheduling.h"
-  "base/internal/nullability_deprecated.h"
   "base/internal/per_thread_tls.h"
   "base/internal/poison.cc"
   "base/internal/poison.h"

absl/base/BUILD.bazel

@@ -82,7 +82,6 @@ cc_library(
 
 cc_library(
     name = "nullability",
-    srcs = ["internal/nullability_deprecated.h"],
     hdrs = ["nullability.h"],
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,

absl/base/CMakeLists.txt

@@ -72,8 +72,6 @@ absl_cc_library(
     nullability
   HDRS
     "nullability.h"
-  SRCS
-    "internal/nullability_deprecated.h"
   DEPS
     absl::config
     absl::core_headers

absl/base/internal/nullability_deprecated.h

@@ -184,7 +184,6 @@
 #define ABSL_BASE_NULLABILITY_H_
 
 #include "absl/base/config.h"
-#include "absl/base/internal/nullability_deprecated.h"
 
 // ABSL_POINTERS_DEFAULT_NONNULL
 //

absl/base/nullability.h

@@ -14,16 +14,13 @@
 
 #include "absl/base/nullability.h"
 
-#include <cassert>
 #include <memory>
 #include <type_traits>
 #include <utility>
 
 #include "gtest/gtest.h"
-#include "absl/base/attributes.h"
 
 namespace {
-namespace macro_annotations {
 void funcWithNonnullArg(int* absl_nonnull /*arg*/) {}
 template <typename T>
 void funcWithDeducedNonnullArg(T* absl_nonnull /*arg*/) {}
@@ -90,117 +87,4 @@ TEST(PassThroughTest, PassesThroughPointerToMemberFunction) {
   EXPECT_TRUE((std::is_same<absl_nullable T, T>::value));
   EXPECT_TRUE((std::is_same<absl_nullability_unknown T, T>::value));
 }
-}  // namespace macro_annotations
-
-// Allow testing of the deprecated type alias annotations.
-ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING
-
-using ::absl::Nonnull;
-using ::absl::NullabilityUnknown;
-using ::absl::Nullable;
-namespace type_alias_annotations {
-
-void funcWithNonnullArg(Nonnull<int*> /*arg*/) {}
-template <typename T>
-void funcWithDeducedNonnullArg(Nonnull<T*> /*arg*/) {}
-
-TEST(NonnullTest, NonnullArgument) {
-  int var = 0;
-  funcWithNonnullArg(&var);
-  funcWithDeducedNonnullArg(&var);
-}
-
-Nonnull<int*> funcWithNonnullReturn() {
-  static int var = 0;
-  return &var;
-}
-
-TEST(NonnullTest, NonnullReturn) {
-  auto var = funcWithNonnullReturn();
-  (void)var;
-}
-
-TEST(PassThroughTest, PassesThroughRawPointerToInt) {
-  EXPECT_TRUE((std::is_same<Nonnull<int*>, int*>::value));
-  EXPECT_TRUE((std::is_same<Nullable<int*>, int*>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<int*>, int*>::value));
-}
-
-TEST(PassThroughTest, PassesThroughRawPointerToVoid) {
-  EXPECT_TRUE((std::is_same<Nonnull<void*>, void*>::value));
-  EXPECT_TRUE((std::is_same<Nullable<void*>, void*>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<void*>, void*>::value));
-}
-
-TEST(PassThroughTest, PassesThroughUniquePointerToInt) {
-  using T = std::unique_ptr<int>;
-  EXPECT_TRUE((std::is_same<Nonnull<T>, T>::value));
-  EXPECT_TRUE((std::is_same<Nullable<T>, T>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<T>, T>::value));
-}
-
-TEST(PassThroughTest, PassesThroughSharedPointerToInt) {
-  using T = std::shared_ptr<int>;
-  EXPECT_TRUE((std::is_same<Nonnull<T>, T>::value));
-  EXPECT_TRUE((std::is_same<Nullable<T>, T>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<T>, T>::value));
-}
-
-TEST(PassThroughTest, PassesThroughSharedPointerToVoid) {
-  using T = std::shared_ptr<void>;
-  EXPECT_TRUE((std::is_same<Nonnull<T>, T>::value));
-  EXPECT_TRUE((std::is_same<Nullable<T>, T>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<T>, T>::value));
-}
-
-TEST(PassThroughTest, PassesThroughPointerToMemberObject) {
-  using T = decltype(&std::pair<int, int>::first);
-  EXPECT_TRUE((std::is_same<Nonnull<T>, T>::value));
-  EXPECT_TRUE((std::is_same<Nullable<T>, T>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<T>, T>::value));
-}
-
-TEST(PassThroughTest, PassesThroughPointerToMemberFunction) {
-  using T = decltype(&std::unique_ptr<int>::reset);
-  EXPECT_TRUE((std::is_same<Nonnull<T>, T>::value));
-  EXPECT_TRUE((std::is_same<Nullable<T>, T>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<T>, T>::value));
-}
-
-}  // namespace type_alias_annotations
-}  // namespace
-
-// Nullable ADL lookup test
-namespace util {
-// Helper for NullableAdlTest.  Returns true, denoting that argument-dependent
-// lookup found this implementation of DidAdlWin.  Must be in namespace
-// util itself, not a nested anonymous namespace.
-template <typename T>
-bool DidAdlWin(T*) {
-  return true;
-}
-
-// Because this type is defined in namespace util, an unqualified call to
-// DidAdlWin with a pointer to MakeAdlWin will find the above implementation.
-struct MakeAdlWin {};
-}  // namespace util
-
-namespace {
-// Returns false, denoting that ADL did not inspect namespace util.  If it
-// had, the better match (T*) above would have won out over the (...) here.
-bool DidAdlWin(...) { return false; }
-
-TEST(NullableAdlTest, NullableAddsNothingToArgumentDependentLookup) {
-  // Treatment: util::Nullable<int*> contributes nothing to ADL because
-  // int* itself doesn't.
-  EXPECT_FALSE(DidAdlWin((int*)nullptr));
-  EXPECT_FALSE(DidAdlWin((Nullable<int*>)nullptr));
-
-  // Control: Argument-dependent lookup does find the implementation in
-  // namespace util when the underlying pointee type resides there.
-  EXPECT_TRUE(DidAdlWin((util::MakeAdlWin*)nullptr));
-  EXPECT_TRUE(DidAdlWin((Nullable<util::MakeAdlWin*>)nullptr));
-}
-
-ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING
 }  // namespace