Add support for references inside bridge types

Additionally, this CL:
* adds an operator==/!= impl for SliceRef in order to simplify testing.
* fixes a bug where substs in composable bridged types were lowered
  using the TypeLocation of the parent type rather than TypeLocation::NestedBridgable

PiperOrigin-RevId: 872574800

Author: cramertj

cc_bindings_from_rs/generate_bindings/format_type.rs

@@ -293,13 +293,15 @@ pub fn format_ty_for_cc<'tcx>(
                     BridgedType::Composable(mut composable) => {
                         // The existance of crubit_abi_type implies that the type can fully
                         // composably bridge.
-
                         let mut tokens = composable.cpp_type.to_token_stream();
-
                         if !substs.is_empty() {
                             let mut generic_types_tokens = Vec::with_capacity(substs.len());
                             for subst in *substs {
-                                let snippet = format_ty_for_cc(db, subst.expect_ty(), location)?;
+                                let snippet = format_ty_for_cc(
+                                    db,
+                                    subst.expect_ty(),
+                                    TypeLocation::NestedBridgeable,
+                                )?;
                                 generic_types_tokens
                                     .push(snippet.into_tokens(&mut composable.prereqs));
                             }
@@ -990,21 +992,27 @@ pub fn crubit_abi_type_from_ty<'tcx>(
             }
             // Do we need to confirm that pointee is layout compatible?
             let rust_type = db.format_ty_for_rs(pointee)?;
-            let cpp_type_with_prereqs = db.format_ty_for_cc(pointee, TypeLocation::Other)?;
+            let CcSnippet { tokens: cpp_type, prereqs } =
+                db.format_ty_for_cc(pointee, TypeLocation::Other)?;
 
             return Ok(CrubitAbiTypeWithCcPrereqs {
                 crubit_abi_type: CrubitAbiType::Ptr {
                     is_const: mutability.is_not(),
                     is_rust_slice,
                     rust_type,
-                    cpp_type: cpp_type_with_prereqs.tokens,
+                    cpp_type,
                 },
-                prereqs: cpp_type_with_prereqs.prereqs,
+                prereqs,
             });
         }
-        ty::TyKind::Ref(_region, _inner, _mutability) => {
-            // TODO(okabayashi): Support &str and &[T], and possibly other reference types.
-            bail!("Reference types are not yet supported in bridging");
+        ty::TyKind::Ref(_, _, _) => {
+            let rust_type = db.format_ty_for_rs(ty)?;
+            let CcSnippet { tokens: cpp_type, prereqs } =
+                db.format_ty_for_cc(ty, TypeLocation::Other)?;
+            return Ok(CrubitAbiTypeWithCcPrereqs {
+                crubit_abi_type: CrubitAbiType::Transmute { rust_type, cpp_type },
+                prereqs,
+            });
         }
         _ => bail!("Unsupported bridge type: {ty:?}"),
     }))

cc_bindings_from_rs/test/bridging/composable/composable_bridging.rs

@@ -30,6 +30,18 @@ pub fn assert_some_some_5(x: Option<Option<i32>>) {
     assert_eq!(x, Some(Some(5)));
 }
 
+pub fn option_slice_without_first(x: Option<&[i32]>) -> Option<&[i32]> {
+    let (_first, rest) = x?.split_first()?;
+    Some(rest)
+}
+
+pub fn option_adds_one_to_ref(x: Option<&mut i32>) -> Option<&mut i32> {
+    x.map(|x| {
+        *x += 1;
+        x
+    })
+}
+
 #[crubit_annotate::cpp_bridge(
     cpp_type = "std::optional",
     bridge_abi_cpp = "crubit::OptionalAbi",

cc_bindings_from_rs/test/bridging/composable/composable_bridging_test.cc

@@ -12,6 +12,8 @@
 namespace crubit {
 namespace {
 
+using ::rs_std::SliceRef;
+
 TEST(ComposableBridging, MaybeInt) {
   std::optional<int> maybe_int = composable_bridging::maybe_int();
   ASSERT_TRUE(maybe_int.has_value());
@@ -43,5 +45,24 @@ TEST(ComposableBridging, Parameters) {
       std::make_optional(std::make_optional(5)));
 }
 
+TEST(ComposableBridging, NestedSlices) {
+  using ::composable_bridging::option_slice_without_first;
+  EXPECT_EQ(option_slice_without_first(std::nullopt), std::nullopt);
+  EXPECT_EQ(option_slice_without_first(
+                std::make_optional<SliceRef<const int>>({1, 2, 3})),
+            std::make_optional<SliceRef<const int>>({2, 3}));
+}
+
+TEST(ComposableBridging, NestedRefs) {
+  using ::composable_bridging::option_adds_one_to_ref;
+  EXPECT_EQ(option_adds_one_to_ref(std::nullopt), std::nullopt);
+  int x = 5;
+  std::optional<int* crubit_nonnull> y =
+      option_adds_one_to_ref(std::make_optional(&x));
+  ASSERT_TRUE(y.has_value());
+  EXPECT_EQ(*y.value(), 6);
+  EXPECT_EQ(x, 6);
+}
+
 }  // namespace
 }  // namespace crubit

cc_bindings_from_rs/test/golden/composable_bridging.rs

@@ -21,6 +21,18 @@ pub fn option_increments(x: Option<i32>) -> Option<i32> {
     x.map(|x| x + 1)
 }
 
+pub fn option_slice_without_first(x: Option<&[i32]>) -> Option<&[i32]> {
+    let (_first, rest) = x?.split_first()?;
+    Some(rest)
+}
+
+pub fn option_adds_one_to_ref(x: Option<&mut i32>) -> Option<&mut i32> {
+    x.map(|x| {
+        *x += 1;
+        x
+    })
+}
+
 ///CRUBIT_ANNOTATE: cpp_type=std::optional
 ///CRUBIT_ANNOTATE: bridge_abi_cpp=crubit::OptionalAbi
 ///CRUBIT_ANNOTATE: bridge_abi_rust=MyOptionRustAbi

cc_bindings_from_rs/test/golden/composable_bridging_cc_api.h

@@ -13,7 +13,9 @@
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+#include "support/annotations_internal.h"
 #include "support/bridge.h"
+#include "support/lifetime_annotations.h"
 #include "support/rs_std/slice_ref.h"
 
 #include <cstdint>
@@ -23,27 +25,37 @@ namespace composable_bridging_rust {
 
 // Error generating bindings for `composable_bridging_rust_golden::MyOptionRust`
 // defined at
-// cc_bindings_from_rs/test/golden/composable_bridging.rs;l=27:
+// cc_bindings_from_rs/test/golden/composable_bridging.rs;l=39:
 // Type bindings for composable_bridging_rust_golden::MyOptionRust suppressed
 // due to being mapped to an existing C++ type (std::optional)
 
 // Error generating bindings for
 // `composable_bridging_rust_golden::MyOptionRustAbi` defined at
-// cc_bindings_from_rs/test/golden/composable_bridging.rs;l=38:
+// cc_bindings_from_rs/test/golden/composable_bridging.rs;l=50:
 // Generic types are not supported yet (b/259749095)
 
 // Generated from:
-// cc_bindings_from_rs/test/golden/composable_bridging.rs;l=29
+// cc_bindings_from_rs/test/golden/composable_bridging.rs;l=41
 std::optional<std::int32_t> make_my_option_rust();
 
 // Generated from:
-// cc_bindings_from_rs/test/golden/composable_bridging.rs;l=33
+// cc_bindings_from_rs/test/golden/composable_bridging.rs;l=45
 std::optional<rs_std::SliceRef<const std::int32_t>> maybe_int_slice();
 
+// Generated from:
+// cc_bindings_from_rs/test/golden/composable_bridging.rs;l=29
+std::optional<std::int32_t* $(__anon1) crubit_nonnull> option_adds_one_to_ref(
+    std::optional<std::int32_t* $(__anon1) crubit_nonnull> x);
+
 // Generated from:
 // cc_bindings_from_rs/test/golden/composable_bridging.rs;l=20
 std::optional<std::int32_t> option_increments(std::optional<std::int32_t> x);
 
+// Generated from:
+// cc_bindings_from_rs/test/golden/composable_bridging.rs;l=24
+std::optional<rs_std::SliceRef<const std::int32_t>> option_slice_without_first(
+    std::optional<rs_std::SliceRef<const std::int32_t>> x);
+
 // Generated from:
 // cc_bindings_from_rs/test/golden/composable_bridging.rs;l=12
 std::optional<std::int32_t> returns_no_int();
@@ -86,6 +98,33 @@ inline std::optional<rs_std::SliceRef<const std::int32_t>> maybe_int_slice() {
       __return_value_storage);
 }
 
+namespace __crubit_internal {
+extern "C" void __crubit_thunk_option_uadds_uone_uto_uref(
+    unsigned char*, unsigned char* __ret_ptr);
+}
+inline std::optional<std::int32_t* $(__anon1) crubit_nonnull>
+option_adds_one_to_ref(
+    std::optional<std::int32_t* $(__anon1) crubit_nonnull> x) {
+  unsigned char x_buffer[::crubit::OptionAbi<
+      ::crubit::TransmuteAbi<std::int32_t* $(__anon1) crubit_nonnull>>::kSize];
+  ::crubit::internal::Encode<::crubit::OptionAbi<
+      ::crubit::TransmuteAbi<std::int32_t* $(__anon1) crubit_nonnull>>>(
+      ::crubit::OptionAbi<
+          ::crubit::TransmuteAbi<std::int32_t* $(__anon1) crubit_nonnull>>(
+          ::crubit::TransmuteAbi<std::int32_t* $(__anon1) crubit_nonnull>()),
+      x_buffer, x);
+  unsigned char __return_value_storage[::crubit::OptionAbi<
+      ::crubit::TransmuteAbi<std::int32_t* $(__anon1) crubit_nonnull>>::kSize];
+  __crubit_internal::__crubit_thunk_option_uadds_uone_uto_uref(
+      x_buffer, __return_value_storage);
+  return ::crubit::internal::Decode<::crubit::OptionAbi<
+      ::crubit::TransmuteAbi<std::int32_t* $(__anon1) crubit_nonnull>>>(
+      ::crubit::OptionAbi<
+          ::crubit::TransmuteAbi<std::int32_t* $(__anon1) crubit_nonnull>>(
+          ::crubit::TransmuteAbi<std::int32_t* $(__anon1) crubit_nonnull>()),
+      __return_value_storage);
+}
+
 namespace __crubit_internal {
 extern "C" void __crubit_thunk_option_uincrements(unsigned char*,
                                                   unsigned char* __ret_ptr);
@@ -110,6 +149,33 @@ inline std::optional<std::int32_t> option_increments(
       __return_value_storage);
 }
 
+namespace __crubit_internal {
+extern "C" void __crubit_thunk_option_uslice_uwithout_ufirst(
+    unsigned char*, unsigned char* __ret_ptr);
+}
+inline std::optional<rs_std::SliceRef<const std::int32_t>>
+option_slice_without_first(
+    std::optional<rs_std::SliceRef<const std::int32_t>> x) {
+  unsigned char x_buffer[::crubit::OptionAbi<
+      ::crubit::TransmuteAbi<rs_std::SliceRef<const std::int32_t>>>::kSize];
+  ::crubit::internal::Encode<::crubit::OptionAbi<
+      ::crubit::TransmuteAbi<rs_std::SliceRef<const std::int32_t>>>>(
+      ::crubit::OptionAbi<
+          ::crubit::TransmuteAbi<rs_std::SliceRef<const std::int32_t>>>(
+          ::crubit::TransmuteAbi<rs_std::SliceRef<const std::int32_t>>()),
+      x_buffer, x);
+  unsigned char __return_value_storage[::crubit::OptionAbi<
+      ::crubit::TransmuteAbi<rs_std::SliceRef<const std::int32_t>>>::kSize];
+  __crubit_internal::__crubit_thunk_option_uslice_uwithout_ufirst(
+      x_buffer, __return_value_storage);
+  return ::crubit::internal::Decode<::crubit::OptionAbi<
+      ::crubit::TransmuteAbi<rs_std::SliceRef<const std::int32_t>>>>(
+      ::crubit::OptionAbi<
+          ::crubit::TransmuteAbi<rs_std::SliceRef<const std::int32_t>>>(
+          ::crubit::TransmuteAbi<rs_std::SliceRef<const std::int32_t>>()),
+      __return_value_storage);
+}
+
 namespace __crubit_internal {
 extern "C" void __crubit_thunk_returns_uno_uint(unsigned char* __ret_ptr);
 }

cc_bindings_from_rs/test/golden/composable_bridging_cc_api_impl.rs

@@ -41,6 +41,28 @@ unsafe extern "C" fn __crubit_thunk_maybe_uint_uslice(__ret_ptr: *mut core::ffi:
     }
 }
 #[unsafe(no_mangle)]
+unsafe extern "C" fn __crubit_thunk_option_uadds_uone_uto_uref(
+    x: *const core::ffi::c_uchar,
+    __ret_ptr: *mut core::ffi::c_uchar,
+) -> () {
+    unsafe {
+        let x = unsafe {
+            ::bridge_rust::internal::decode(
+                ::bridge_rust::OptionAbi(::bridge_rust::transmute_abi::<&'static mut i32>()),
+                x,
+            )
+        };
+        let __rs_return_value = ::composable_bridging_rust_golden::option_adds_one_to_ref(x);
+        unsafe {
+            ::bridge_rust::internal::encode(
+                ::bridge_rust::OptionAbi(::bridge_rust::transmute_abi::<&'static mut i32>()),
+                __ret_ptr as *mut core::ffi::c_uchar,
+                __rs_return_value,
+            );
+        }
+    }
+}
+#[unsafe(no_mangle)]
 unsafe extern "C" fn __crubit_thunk_option_uincrements(
     x: *const core::ffi::c_uchar,
     __ret_ptr: *mut core::ffi::c_uchar,
@@ -63,6 +85,28 @@ unsafe extern "C" fn __crubit_thunk_option_uincrements(
     }
 }
 #[unsafe(no_mangle)]
+unsafe extern "C" fn __crubit_thunk_option_uslice_uwithout_ufirst(
+    x: *const core::ffi::c_uchar,
+    __ret_ptr: *mut core::ffi::c_uchar,
+) -> () {
+    unsafe {
+        let x = unsafe {
+            ::bridge_rust::internal::decode(
+                ::bridge_rust::OptionAbi(::bridge_rust::transmute_abi::<&'static [i32]>()),
+                x,
+            )
+        };
+        let __rs_return_value = ::composable_bridging_rust_golden::option_slice_without_first(x);
+        unsafe {
+            ::bridge_rust::internal::encode(
+                ::bridge_rust::OptionAbi(::bridge_rust::transmute_abi::<&'static [i32]>()),
+                __ret_ptr as *mut core::ffi::c_uchar,
+                __rs_return_value,
+            );
+        }
+    }
+}
+#[unsafe(no_mangle)]
 unsafe extern "C" fn __crubit_thunk_returns_uno_uint(__ret_ptr: *mut core::ffi::c_uchar) -> () {
     unsafe {
         let __rs_return_value = ::composable_bridging_rust_golden::returns_no_int();

support/rs_std/slice_ref.h

@@ -99,6 +99,61 @@ class CRUBIT_INTERNAL_RUST_TYPE("&[]")
   size_t size_;
 };
 
+namespace internal {
+template <typename T>
+constexpr bool EqualImpl(SliceRef<const T> a, SliceRef<const T> b) {
+  absl::Span<const T> a_span = a.to_span();
+  absl::Span<const T> b_span = b.to_span();
+  return std::equal(a_span.begin(), a_span.end(), b_span.begin(), b_span.end());
+}
+}  // namespace internal
+
+template <typename T>
+constexpr bool operator==(SliceRef<T> a, SliceRef<T> b) {
+  return internal::EqualImpl(a, b);
+}
+template <typename T>
+constexpr bool operator==(SliceRef<const T> a, SliceRef<T> b) {
+  return internal::EqualImpl(a, b);
+}
+template <typename T>
+constexpr bool operator==(SliceRef<T> a, SliceRef<const T> b) {
+  return internal::EqualImpl(a, b);
+}
+template <typename T, typename U>
+  requires(std::convertible_to<U, SliceRef<const T>>)
+constexpr bool operator==(const U& a, SliceRef<T> b) {
+  return internal::EqualImpl(a, b);
+}
+template <typename T, typename U>
+  requires(std::convertible_to<U, SliceRef<const T>>)
+constexpr bool operator==(SliceRef<T> a, const U& b) {
+  return internal::EqualImpl(a, b);
+}
+
+template <typename T>
+constexpr bool operator!=(SliceRef<T> a, SliceRef<T> b) {
+  return !(a == b);
+}
+template <typename T>
+constexpr bool operator!=(SliceRef<const T> a, SliceRef<T> b) {
+  return !(a == b);
+}
+template <typename T>
+constexpr bool operator!=(SliceRef<T> a, SliceRef<const T> b) {
+  return !(a == b);
+}
+template <typename T, typename U>
+  requires(std::convertible_to<U, SliceRef<const T>>)
+constexpr bool operator!=(const U& a, SliceRef<T> b) {
+  return !(a == b);
+}
+template <typename T, typename U>
+  requires(std::convertible_to<U, SliceRef<const T>>)
+constexpr bool operator!=(SliceRef<T> a, const U& b) {
+  return !(a == b);
+}
+
 }  // namespace rs_std
 
 namespace crubit::internal {