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());