Reduce code size of ABSL_ASSIGN_OR_RETURN by avoiding dead StatusOr cleanup.

When the right-hand side of ABSL_ASSIGN_OR_RETURN returns a StatusOr via an
indirect return slot, its stack address escapes. As a result, callers previously
emitted full StatusOr destructor cleanup (an ok reload and Status::Unref) at
scope exit and on every later early return.

Store the StatusOr in a union with a no-op destructor instead:

* On error, move the Status out and return without running StatusOr cleanup.
* On OK, arm a small guard that destroys only the contained value at scope exit
  (or nothing when the value is trivially destructible), preserving value and
  view lifetimes.

Types derived from absl::StatusOr do not match the specialization and continue
to run the full StatusOr destructor via the primary template.

PiperOrigin-RevId: 1014908538
diff --git a/absl/status/BUILD.bazel b/absl/status/BUILD.bazel
index 09060ff..3508b11 100644
--- a/absl/status/BUILD.bazel
+++ b/absl/status/BUILD.bazel
@@ -227,7 +227,6 @@
         ":statusor",
         "//absl/base:config",
         "//absl/base:core_headers",
-        "//absl/meta:type_traits",
         "//absl/types:source_location",
     ],
 )
diff --git a/absl/status/CMakeLists.txt b/absl/status/CMakeLists.txt
index 5efa33b..13ff4a6 100644
--- a/absl/status/CMakeLists.txt
+++ b/absl/status/CMakeLists.txt
@@ -180,7 +180,6 @@
     absl::status
     absl::status_builder
     absl::statusor
-    absl::type_traits
   PUBLIC
 )
 
diff --git a/absl/status/status_macros.h b/absl/status/status_macros.h
index 4b1cc2b..965ea8e 100644
--- a/absl/status/status_macros.h
+++ b/absl/status/status_macros.h
@@ -22,7 +22,6 @@
 #define ABSL_STATUS_STATUS_MACROS_H_
 
 #include <cstddef>
-#include <memory>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -30,7 +29,6 @@
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
 #include "absl/base/optimization.h"
-#include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/status/status_builder.h"  // IWYU pragma: export
 #include "absl/status/statusor.h"
@@ -203,61 +201,6 @@
            T*, typename absl::StatusOr<typename T::value_type>*>>>
     : std::true_type {};
 
-template <typename T>
-class IndirectNonvirtualDestructor {
- public:
-  ABSL_ATTRIBUTE_ALWAYS_INLINE explicit IndirectNonvirtualDestructor(T* value)
-      : value_(value) {}
-  IndirectNonvirtualDestructor(const IndirectNonvirtualDestructor&) = delete;
-  IndirectNonvirtualDestructor& operator=(const IndirectNonvirtualDestructor&) =
-      delete;
-  ABSL_ATTRIBUTE_ALWAYS_INLINE ~IndirectNonvirtualDestructor() {
-    // Qualified call suppresses virtual dispatch when `T` is polymorphic.
-    value_->T::~T();
-  }
-
- private:
-  T* value_;
-};
-
-struct EmptySentinelType {};
-
-// Fallback for types derived from `absl::StatusOr`.
-template <typename StatusOrType>
-union AssignOrReturnStorage {
-  static_assert(!std::is_reference_v<StatusOrType>);
-  StatusOrType v;
-  ABSL_ATTRIBUTE_ALWAYS_INLINE ~AssignOrReturnStorage() { v.~StatusOrType(); }
-  [[nodiscard]] ABSL_ATTRIBUTE_ALWAYS_INLINE auto DestroyValueOnExit() {
-    return EmptySentinelType();
-  }
-};
-
-// Holds `absl::StatusOr<T>` in a union with a no-op destructor to suppress
-// `~StatusOr()` at scope exit. On error, the caller must move the status out of
-// `v` before returning. On OK, `DestroyValueOnExit()` destroys only `T` at
-// scope exit.
-//
-// Not a `struct` with an anonymous `union`: that would break aggregate
-// initialization for nontrivial `T`.
-template <typename T>
-union AssignOrReturnStorage<absl::StatusOr<T>> {
-  absl::StatusOr<T> v;
-  // Not `= default`, as that would delete the destructor for nontrivial `T`.
-  ABSL_ATTRIBUTE_ALWAYS_INLINE ~AssignOrReturnStorage() {}
-
-  [[nodiscard]] ABSL_ATTRIBUTE_ALWAYS_INLINE auto DestroyValueOnExit() {
-    if constexpr (std::is_trivially_destructible_v<T>) {
-      return EmptySentinelType();
-    } else {
-      return IndirectNonvirtualDestructor<T>(std::addressof(*v));
-    }
-  }
-};
-
-template <typename T>
-AssignOrReturnStorage(T&&) -> AssignOrReturnStorage<absl::remove_cvref_t<T>>;
-
 }  // namespace status_macro_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
@@ -278,8 +221,7 @@
       lhs, rexpr,                                                              \
       return_keyword absl::Status(                                             \
           std::move(ABSL_INTERNAL_STATUS_MACROS_IMPL_CONCAT_(_status_or_value, \
-                                                             __LINE__)         \
-                        .v)                                                    \
+                                                             __LINE__))        \
               .status(),                                                       \
           absl::SourceLocation::current()))
 
@@ -290,29 +232,18 @@
       lhs, rexpr, /* NOLINTNEXTLINE(misc-const-correctness) */                 \
       absl::StatusBuilder _(                                                   \
           std::move(ABSL_INTERNAL_STATUS_MACROS_IMPL_CONCAT_(_status_or_value, \
-                                                             __LINE__)         \
-                        .v)                                                    \
+                                                             __LINE__))        \
               .status(),                                                       \
           absl::SourceLocation::current());                                    \
       (void)_; /* error_expression is allowed to not use this variable */      \
       return_keyword(error_expression))
 
-// REQUIRES: `error_expression` must move the status out of `statusor_union.v`
-// and must not fall through, since `~StatusOr()` is suppressed.
 #define ABSL_INTERNAL_STATUS_MACROS_IMPL_ASSIGN_OR_RETURN_(                  \
-    statusor_union, lhs, rexpr, error_expression)                            \
-  absl::status_macro_internal::AssignOrReturnStorage statusor_union = {      \
-      (rexpr)};                                                              \
-  static_assert(                                                             \
-      !std::is_const_v<decltype(statusor_union)>,                            \
-      "Do not const-qualify ABSL_ASSIGN_OR_RETURN; put const on the lhs");   \
-  if (ABSL_PREDICT_FALSE(!statusor_union.v.ok())) {                          \
+    statusor, lhs, rexpr, error_expression)                                  \
+  auto statusor = (rexpr);                                                   \
+  if (ABSL_PREDICT_FALSE(!statusor.ok())) {                                  \
     error_expression;                                                        \
   }                                                                          \
-  /* Declared before `lhs` so `statusor_union.v`'s value outlives `lhs`      \
-   * (e.g. when `lhs` is a view into the contained value). */                \
-  [[maybe_unused]] const auto ABSL_INTERNAL_STATUS_MACROS_IMPL_CONCAT_(      \
-      statusor_union, _destroyer) = statusor_union.DestroyValueOnExit();     \
   {                                                                          \
     static_assert(!HasPotentialConditionalOperator(#lhs, sizeof(#lhs) - 1),  \
                   "Identified potential conditional operator, consider not " \
@@ -321,11 +252,11 @@
   {                                                                          \
     static_assert(                                                           \
         absl::status_macro_internal::IsAllowedStatusOrMacroType<             \
-            decltype(statusor_union.v)>(),                                   \
+            std::remove_const_t<decltype(statusor)>>(),                      \
         "ABSL_ASSIGN_OR_RETURN should only be used with absl::StatusOr<>");  \
   }                                                                          \
   ABSL_INTERNAL_STATUS_MACROS_IMPL_UNPARENTHESIZE_IF_PARENTHESIZED(lhs) =    \
-      (*std::move(statusor_union.v))
+      (*std::move(statusor))
 
 // Internal helpers for macro expansion.
 #define ABSL_INTERNAL_STATUS_MACROS_IMPL_EAT(...)
diff --git a/absl/status/status_macros_test.cc b/absl/status/status_macros_test.cc
index e5578b4..7b5751d 100644
--- a/absl/status/status_macros_test.cc
+++ b/absl/status/status_macros_test.cc
@@ -400,71 +400,6 @@
   CheckSourceLocation(result.status(), {func3_line, func4_line});
 }
 
-TEST(AssignOrReturn, DestroysValueOnlyOnOkAtScopeExit) {
-  int live = 0;
-  struct Counted {
-    int* live;
-    explicit Counted(int* l) : live(l) { ++*live; }
-    Counted(const Counted& o) : live(o.live) { ++*live; }
-    Counted(Counted&& o) : live(o.live) { ++*live; }
-    Counted& operator=(const Counted&) = delete;
-    Counted& operator=(Counted&&) = delete;
-    ~Counted() { --*live; }
-  };
-
-  const std::string kLong(64, 'x');
-  auto ok_fn = [&]() -> absl::Status {
-    ABSL_ASSIGN_OR_RETURN(Counted c [[maybe_unused]],
-                          absl::StatusOr<Counted>(Counted(&live)));
-    // Both `c` and the moved-from value in the macro's hidden `StatusOr` stay
-    // alive until scope exit (so views like `view` below remain valid).
-    EXPECT_EQ(live, 2);
-    ABSL_ASSIGN_OR_RETURN(absl::string_view view,
-                          absl::StatusOr<std::string>(kLong));
-    EXPECT_EQ(view, kLong);
-    ABSL_ASSIGN_OR_RETURN(std::string const_str,
-                          absl::StatusOr<const std::string>(kLong));
-    EXPECT_EQ(const_str, kLong);
-    return absl::OkStatus();
-  };
-  EXPECT_EQ(ok_fn(), absl::OkStatus());
-  EXPECT_EQ(live, 0);
-
-  auto err_fn = [&]() -> absl::Status {
-    ABSL_ASSIGN_OR_RETURN(Counted c [[maybe_unused]],
-                          absl::StatusOr<Counted>(ReturnError("EXPECTED")));
-    return absl::OkStatus();
-  };
-  EXPECT_THAT(err_fn().message(), Eq("EXPECTED"));
-  EXPECT_EQ(live, 0);
-}
-
-TEST(AssignOrReturn, WorksWithStatusOrSubclass) {
-  struct DerivedStatusOr : absl::StatusOr<std::string> {
-    using absl::StatusOr<std::string>::StatusOr;
-  };
-  const std::string kLong(64, 'y');
-  auto fn = [&]() -> absl::Status {
-    ABSL_ASSIGN_OR_RETURN(std::string s, DerivedStatusOr(kLong));
-    EXPECT_EQ(s, kLong);
-    ABSL_ASSIGN_OR_RETURN(s, DerivedStatusOr(ReturnError("EXPECTED")));
-    return absl::OkStatus();
-  };
-  EXPECT_THAT(fn().message(), Eq("EXPECTED"));
-}
-
-TEST(AssignOrReturn, WorksWithArrayReference) {
-  int arr[2] = {10, 20};
-  auto fn = [&]() -> absl::Status {
-    ABSL_ASSIGN_OR_RETURN(auto& ref, absl::StatusOr<int(&)[2]>(arr));
-    static_assert(std::is_same_v<decltype(ref), int(&)[2]>);
-    EXPECT_EQ(ref[0], 10);
-    EXPECT_EQ(ref[1], 20);
-    return absl::OkStatus();
-  };
-  EXPECT_EQ(fn(), absl::OkStatus());
-}
-
 TEST(ReturnIfError, Works) {
   auto func = []() -> absl::Status {
     ABSL_RETURN_IF_ERROR(ReturnOk());