Add lifetimebound to absl::implicit_cast and make it work for rvalue references as it already does with lvalue references

PiperOrigin-RevId: 817776717
Change-Id: I9b01d04c05b73ff21462fbe42d5e9fc0e677a971

Author: Abseil Team

absl/base/BUILD.bazel

@@ -602,6 +602,22 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "casts_test",
+    size = "small",
+    srcs = [
+        "casts_test.cc",
+    ],
+    copts = ABSL_TEST_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [
+        ":base",
+        ":core_headers",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)
+
 cc_test(
     name = "no_destructor_test",
     srcs = ["no_destructor_test.cc"],

absl/base/CMakeLists.txt

@@ -417,6 +417,19 @@ absl_cc_test(
     GTest::gtest_main
 )
 
+absl_cc_test(
+  NAME
+    casts_test
+  SRCS
+    "casts_test.cc"
+  COPTS
+    ${ABSL_TEST_COPTS}
+  DEPS
+    absl::base
+    absl::core_headers
+    GTest::gtest_main
+)
+
 absl_cc_test(
   NAME
     errno_saver_test

absl/base/casts.h

@@ -33,6 +33,7 @@
 #include <bit>  // For std::bit_cast.
 #endif  // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
 
+#include "absl/base/attributes.h"
 #include "absl/base/macros.h"
 #include "absl/meta/type_traits.h"
 
@@ -89,9 +90,26 @@ ABSL_NAMESPACE_BEGIN
 //
 // Such implicit cast chaining may be useful within template logic.
 template <typename To>
-constexpr To implicit_cast(typename absl::type_identity_t<To> to) {
+constexpr std::enable_if_t<
+    !type_traits_internal::IsView<std::enable_if_t<
+        !std::is_reference_v<To>, std::remove_cv_t<To>>>::value,
+    To>
+implicit_cast(absl::type_identity_t<To> to) {
   return to;
 }
+template <typename To>
+constexpr std::enable_if_t<
+    type_traits_internal::IsView<std::enable_if_t<!std::is_reference_v<To>,
+                                                  std::remove_cv_t<To>>>::value,
+    To>
+implicit_cast(absl::type_identity_t<To> to ABSL_ATTRIBUTE_LIFETIME_BOUND) {
+  return to;
+}
+template <typename To>
+constexpr std::enable_if_t<std::is_reference_v<To>, To> implicit_cast(
+    absl::type_identity_t<To> to ABSL_ATTRIBUTE_LIFETIME_BOUND) {
+  return std::forward<absl::type_identity_t<To>>(to);
+}
 
 // bit_cast()
 //

absl/base/casts_test.cc

@@ -0,0 +1,57 @@
+// Copyright 2025 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/casts.h"
+
+#include <type_traits>
+#include <utility>
+
+#include "gtest/gtest.h"
+
+namespace {
+
+struct Base {
+  explicit Base(int value) : x(value) {}
+  Base(const Base& other) = delete;
+  Base& operator=(const Base& other) = delete;
+  int x;
+};
+struct Derived : Base {
+  explicit Derived(int value) : Base(value) {}
+};
+
+static_assert(
+    std::is_same_v<
+        decltype(absl::implicit_cast<Base&>(std::declval<Derived&>())), Base&>);
+static_assert(std::is_same_v<decltype(absl::implicit_cast<const Base&>(
+                                 std::declval<Derived>())),
+                             const Base&>);
+
+TEST(ImplicitCastTest, LValueReference) {
+  Derived derived(5);
+  EXPECT_EQ(&absl::implicit_cast<Base&>(derived), &derived);
+  EXPECT_EQ(&absl::implicit_cast<const Base&>(derived), &derived);
+}
+
+TEST(ImplicitCastTest, RValueReference) {
+  Derived derived(5);
+  Base&& base = absl::implicit_cast<Base&&>(std::move(derived));
+  EXPECT_EQ(&base, &derived);
+
+  const Derived cderived(6);
+  const Base&& cbase = absl::implicit_cast<const Base&&>(std::move(cderived));
+  EXPECT_EQ(&cbase, &cderived);
+}
+
+}  // namespace