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: 1008379647
diff --git a/absl/status/BUILD.bazel b/absl/status/BUILD.bazel
index 3508b11..09060ff 100644
--- a/absl/status/BUILD.bazel
+++ b/absl/status/BUILD.bazel
@@ -227,6 +227,7 @@
         ":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 13ff4a6..5efa33b 100644
--- a/absl/status/CMakeLists.txt
+++ b/absl/status/CMakeLists.txt
@@ -180,6 +180,7 @@
     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 965ea8e..4b1cc2b 100644
--- a/absl/status/status_macros.h
+++ b/absl/status/status_macros.h
@@ -22,6 +22,7 @@
 #define ABSL_STATUS_STATUS_MACROS_H_
 
 #include <cstddef>
+#include <memory>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -29,6 +30,7 @@
 #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"
@@ -201,6 +203,61 @@
            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
@@ -221,7 +278,8 @@
       lhs, rexpr,                                                              \
       return_keyword absl::Status(                                             \
           std::move(ABSL_INTERNAL_STATUS_MACROS_IMPL_CONCAT_(_status_or_value, \
-                                                             __LINE__))        \
+                                                             __LINE__)         \
+                        .v)                                                    \
               .status(),                                                       \
           absl::SourceLocation::current()))
 
@@ -232,18 +290,29 @@
       lhs, rexpr, /* NOLINTNEXTLINE(misc-const-correctness) */                 \
       absl::StatusBuilder _(                                                   \
           std::move(ABSL_INTERNAL_STATUS_MACROS_IMPL_CONCAT_(_status_or_value, \
-                                                             __LINE__))        \
+                                                             __LINE__)         \
+                        .v)                                                    \
               .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, lhs, rexpr, error_expression)                                  \
-  auto statusor = (rexpr);                                                   \
-  if (ABSL_PREDICT_FALSE(!statusor.ok())) {                                  \
+    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())) {                          \
     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 " \
@@ -252,11 +321,11 @@
   {                                                                          \
     static_assert(                                                           \
         absl::status_macro_internal::IsAllowedStatusOrMacroType<             \
-            std::remove_const_t<decltype(statusor)>>(),                      \
+            decltype(statusor_union.v)>(),                                   \
         "ABSL_ASSIGN_OR_RETURN should only be used with absl::StatusOr<>");  \
   }                                                                          \
   ABSL_INTERNAL_STATUS_MACROS_IMPL_UNPARENTHESIZE_IF_PARENTHESIZED(lhs) =    \
-      (*std::move(statusor))
+      (*std::move(statusor_union.v))
 
 // 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 7b5751d..e5578b4 100644
--- a/absl/status/status_macros_test.cc
+++ b/absl/status/status_macros_test.cc
@@ -400,6 +400,71 @@
   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());