Disable bindings for ADTs with non-'static lifetimes in cc_bindings_from_rs.

PiperOrigin-RevId: 910588993

Author: Googler

cc_bindings_from_rs/generate_bindings/format_type.rs

@@ -273,6 +273,10 @@ pub fn format_ty_for_cc<'tcx>(
             let def_id = adt.did();
             let mut prereqs = CcPrerequisites::default();
 
+            if has_non_static_lifetime_in_adt(tcx, ty) {
+                bail!("Types with non-'static lifetimes are not supported yet (b/500486197)");
+            }
+
             if location.is_bridgeable() && is_c_abi_compatible_by_value(tcx, ty) {
                 ensure!(
                     db.has_move_ctor_and_assignment_operator(
@@ -608,6 +612,35 @@ pub fn region_is_elided<'tcx>(tcx: TyCtxt<'tcx>, region: ty::Region<'tcx>) -> bo
     }
 }
 
+pub(crate) fn has_non_static_lifetime_in_adt<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
+    use core::ops::ControlFlow;
+    use rustc_middle::ty::{Ty, TyCtxt, TypeVisitor};
+    use ty::TypeSuperVisitable;
+
+    struct HasNonStaticLifetimeInAdt;
+    struct Searcher<'tcx> {
+        tcx: TyCtxt<'tcx>,
+    }
+    impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for Searcher<'tcx> {
+        type Result = ControlFlow<HasNonStaticLifetimeInAdt>;
+        fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<HasNonStaticLifetimeInAdt> {
+            if let ty::TyKind::Adt(adt, substs) = ty.kind() {
+                if self.tcx.item_name(adt.did()).as_str() == "LossyFormatter" {
+                    return ty.super_visit_with(self);
+                }
+                if substs.iter().any(|subst| subst.as_region().is_some_and(|r| !r.is_static())) {
+                    return ControlFlow::Break(HasNonStaticLifetimeInAdt);
+                }
+            }
+            ty.super_visit_with(self)
+        }
+    }
+    match (Searcher { tcx }).visit_ty(ty) {
+        ControlFlow::Break(HasNonStaticLifetimeInAdt) => true,
+        ControlFlow::Continue(()) => false,
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct CcParamTy<'tcx> {
     pub snippet: CcSnippet<'tcx>,

cc_bindings_from_rs/generate_bindings/format_type_test.rs

@@ -304,6 +304,12 @@ fn test_format_ty_for_cc_successes() {
             cc: "::rs::core::cmp::Ordering",
             includes: ["\"fake_bindings_for_unittests/core_cc_api.h\""]
         ),
+        case!(
+            rs: "LifetimeGenericStruct<'static>",
+            cc: "::rust_out::LifetimeGenericStruct",
+            includes: [],
+            prereq_def: "LifetimeGenericStruct"
+        ),
     ];
     let preamble = quote! {
         #![allow(unused_parens)]
@@ -323,6 +329,10 @@ fn test_format_ty_for_cc_successes() {
             pub y: i32,
         }
 
+        pub struct LifetimeGenericStruct<'a> {
+            pub reference: &'a u8,
+        }
+
         #[allow(unused)]
         type Identity<T> = T;
     };
@@ -466,6 +476,14 @@ fn test_format_ty_for_cc_failures() {
             "Failed to format type for the definition of `std::alloc::LayoutError`: \
              Zero-sized types (ZSTs) are not supported (b/258259459)",
         ),
+        (
+            "LifetimeGenericStruct<'_>",
+            "Types with non-'static lifetimes are not supported yet (b/500486197)",
+        ),
+        (
+            "Option<LifetimeGenericStruct<'_>>",
+            "Types with non-'static lifetimes are not supported yet (b/500486197)",
+        ),
     ];
     let preamble = quote! {
         #![feature(never_type)]
@@ -483,6 +501,10 @@ fn test_format_ty_for_cc_failures() {
         pub struct TypeGenericStruct<T = u8> {
             pub t: T,
         }
+
+        pub struct LifetimeGenericStruct<'a> {
+            pub reference: &'a u8,
+        }
     };
     test_ty(
         TypeLocation::FnParam { is_self_param: false, elided_is_output: false },

cc_bindings_from_rs/generate_bindings/generate_struct_and_union.rs

@@ -1001,10 +1001,15 @@ pub fn generate_adt_core<'tcx>(
     // present. We want to generate bindings for functions regardless of their lifetime bounds, as
     // C++ cannot special-case the availability of a function based on lifetimes.
     #[rustversion::before(2026-04-19)]
-    let self_ty = erase_regions(tcx, tcx.type_of(def_id).instantiate_identity());
+    let original_self_ty = tcx.type_of(def_id).instantiate_identity();
     #[rustversion::since(2026-04-19)]
-    let self_ty =
-        erase_regions(tcx, crate::normalize_ty(tcx, tcx.type_of(def_id).instantiate_identity()));
+    let original_self_ty = crate::normalize_ty(tcx, tcx.type_of(def_id).instantiate_identity());
+
+    if crate::format_type::has_non_static_lifetime_in_adt(tcx, original_self_ty) {
+        bail!("Types with non-'static lifetimes are not supported yet (b/500486197)");
+    }
+
+    let self_ty = erase_regions(tcx, original_self_ty);
     assert!(self_ty.is_adt());
     assert!(db.symbol_canonical_name(def_id).is_some(), "Caller should verify");