Refactor ffi_11 crate to use newtypes.

Previously when we could be confident a C++ and Rust type matched in bit
width, it would be a type alias in ffi_11. Relying on aliases is
problematic for the rmeta interface (aliases don't exist at the MIR
level). Instead, use wrapper structs so our ffi types are considered
distinct at the MIR level.

PiperOrigin-RevId: 830498336

Author: thunderseethe

cc_bindings_from_rs/generate_bindings/format_type.rs

@@ -503,7 +503,7 @@ pub fn format_ty_for_cc<'tcx>(
             };
 
             check_fn_sig(&sig)?;
-            is_thunk_required(&sig).context("Function pointers can't have a thunk")?;
+            is_thunk_required(tcx, &sig).context("Function pointers can't have a thunk")?;
 
             // `is_thunk_required` check above implies `extern "C"` (or `"C-unwind"`).
             // This assertion reinforces that the generated C++ code doesn't need

cc_bindings_from_rs/generate_bindings/generate_function.rs

@@ -121,6 +121,7 @@ fn cc_param_to_c_abi<'tcx>(
     includes: &mut BTreeSet<CcInclude>,
     statements: &mut TokenStream,
 ) -> Result<TokenStream> {
+    let tcx = db.tcx();
     Ok(if let Some(bridged_type) = is_bridged_type(db, ty.mid())? {
         match bridged_type {
             BridgedType::Legacy { cpp_type, .. } => {
@@ -146,7 +147,7 @@ fn cc_param_to_c_abi<'tcx>(
                 quote! { #buffer_name }
             }
         }
-    } else if is_c_abi_compatible_by_value(ty.mid()) {
+    } else if is_c_abi_compatible_by_value(tcx, ty.mid()) {
         quote! { #cc_ident }
     } else if let Some(tuple_tys) = ty.as_tuple(db) {
         let n = tuple_tys.len();
@@ -243,7 +244,11 @@ fn cc_return_value_from_c_abi<'tcx>(
     storage_statements: &mut TokenStream,
     recursive: bool,
 ) -> Result<ReturnConversion> {
+    let tcx = db.tcx();
     let storage_name = &expect_format_cc_ident(&format!("__{ident}_storage"));
+    // TODO: b/459482188 - The order of this check must align with the order in `generate_thunk_decl`.
+    // We should centralize this logic so that the order exists in a singular location used by both
+    // places.
     if let Some(bridged_type) = is_bridged_type(db, ty.mid())? {
         match bridged_type {
             BridgedType::Legacy { cpp_type, .. } => {
@@ -286,7 +291,7 @@ fn cc_return_value_from_c_abi<'tcx>(
                 })
             }
         }
-    } else if is_c_abi_compatible_by_value(ty.mid()) {
+    } else if is_c_abi_compatible_by_value(tcx, ty.mid()) {
         let cc_type = &format_ty_for_cc_amending_prereqs(db, ty, prereqs)?;
         let local_name = &expect_format_cc_ident(&format!("__{ident}_ret_val_holder"));
         storage_statements.extend(quote! {
@@ -493,6 +498,7 @@ pub(crate) fn generate_thunk_call<'tcx>(
     has_self_param: bool,
     params: &[Param<'tcx>],
 ) -> Result<CcSnippet> {
+    let tcx = db.tcx();
     let mut prereqs = CcPrerequisites::default();
     let mut tokens = TokenStream::new();
 
@@ -514,7 +520,6 @@ pub(crate) fn generate_thunk_call<'tcx>(
                     tokens.extend(quote! { auto&& #cc_name = *this; });
                 }
             }
-            let tcx = db.tcx();
             cc_param_to_c_abi(
                 db,
                 cc_name.clone(),
@@ -552,7 +557,7 @@ pub(crate) fn generate_thunk_call<'tcx>(
     }
 
     let return_body = if is_bridged_type(db, rs_return_type.mid())?.is_none()
-        && is_c_abi_compatible_by_value(rs_return_type.mid())
+        && is_c_abi_compatible_by_value(tcx, rs_return_type.mid())
     {
         // C++ compilers can emit diagnostics if a function marked [[noreturn]] looks like it
         // might return. In this scenario, we just call the (also [[noreturn]]) thunk.
@@ -601,7 +606,8 @@ pub fn generate_function(db: &dyn BindingsGenerator<'_>, def_id: DefId) -> Resul
     // TODO(b/262904507): Don't require thunks for mangled extern "C" functions.
     let (export_name, has_no_mangle) = export_name_and_no_mangle_attrs_of(tcx, def_id);
     let has_export_name = export_name.is_some();
-    let needs_thunk = is_thunk_required(&sig_mid).is_err() || (!has_no_mangle && !has_export_name);
+    let needs_thunk =
+        is_thunk_required(tcx, &sig_mid).is_err() || (!has_no_mangle && !has_export_name);
     let thunk_name = thunk_name(db, def_id, export_name, needs_thunk);
 
     let unqualified_fn_name = db

cc_bindings_from_rs/generate_bindings/generate_function_thunk.rs

@@ -86,6 +86,7 @@ pub fn generate_thunk_decl<'tcx>(
     thunk_name: &Ident,
     has_self_param: bool,
 ) -> Result<CcSnippet> {
+    let tcx = db.tcx();
     let mut prereqs = CcPrerequisites::default();
     let main_api_ret_type = format_ret_ty_for_cc(db, sig_mid, sig_hir)?.into_tokens(&mut prereqs);
 
@@ -110,7 +111,7 @@ pub fn generate_thunk_decl<'tcx>(
                         }
                         BridgedType::Composable(_) => Ok(quote! { unsigned char* }),
                     }
-                } else if is_c_abi_compatible_by_value(ty) {
+                } else if is_c_abi_compatible_by_value(tcx, ty) {
                     Ok(quote! { #cpp_type })
                 } else if let Some(tuple_abi) = tuple_c_abi_c_type(ty) {
                     Ok(tuple_abi)
@@ -130,22 +131,32 @@ pub fn generate_thunk_decl<'tcx>(
     };
 
     // Types which are not C-ABI compatible by-value are returned via out-pointer parameters.
-    let thunk_ret_type: TokenStream;
-    if is_c_abi_compatible_by_value(sig_mid.output()) {
-        thunk_ret_type = main_api_ret_type;
+    // TODO: b/ 459482188 - The order of this check must align with the order in `cc_return_value_from_c_abi`.
+    // We should centralize this logic so that the order exists in a singular location used by both
+    // places.
+    let thunk_ret_type = if let Some(briging) = is_bridged_type(db, sig_mid.output())? {
+        match briging {
+            BridgedType::Legacy { .. } => {
+                thunk_params.push(quote! { #main_api_ret_type* __ret_ptr });
+                quote! { void }
+            }
+            BridgedType::Composable(_) => {
+                thunk_params.push(quote! { unsigned char * __ret_ptr });
+                quote! { void }
+            }
+        }
+    } else if is_c_abi_compatible_by_value(tcx, sig_mid.output()) {
+        main_api_ret_type
     } else if let Some(tuple_abi) = tuple_c_abi_c_type(sig_mid.output()) {
-        thunk_ret_type = quote! { void };
         thunk_params.push(quote! { #tuple_abi __ret_ptr });
+        quote! { void }
     } else if let ty::TyKind::Array(inner_ty, _) = sig_mid.output().kind() {
         let c_type = array_c_abi_c_type(db.tcx(), *inner_ty)?;
-        thunk_ret_type = quote! { void };
         thunk_params.push(quote! { #c_type __ret_ptr });
-    } else if let Some(BridgedType::Composable(_)) = is_bridged_type(db, sig_mid.output())? {
-        thunk_ret_type = quote! { void };
-        thunk_params.push(quote! { unsigned char * __ret_ptr });
+        quote! { void }
     } else {
-        thunk_ret_type = quote! { void };
         thunk_params.push(quote! { #main_api_ret_type* __ret_ptr });
+        quote! { void }
     };
 
     let mut attributes = vec![];
@@ -266,7 +277,8 @@ fn convert_value_from_c_abi_to_rust<'tcx>(
             extern_c_decls,
         );
     }
-    if is_c_abi_compatible_by_value(ty) {
+    let tcx = db.tcx();
+    if is_c_abi_compatible_by_value(tcx, ty) {
         return Ok(quote! {});
     }
     if let ty::TyKind::Tuple(tuple_tys) = ty.kind() {
@@ -281,12 +293,13 @@ fn c_abi_for_param_type<'tcx>(
     db: &dyn BindingsGenerator<'tcx>,
     ty: ty::Ty<'tcx>,
 ) -> Result<TokenStream> {
+    let tcx = db.tcx();
     if let Some(bridged) = is_bridged_type(db, ty)? {
         match bridged {
             BridgedType::Legacy { .. } => Ok(quote! { *const core::ffi::c_void }),
             BridgedType::Composable(_) => Ok(quote! { *const core::ffi::c_uchar }),
         }
-    } else if is_c_abi_compatible_by_value(ty) {
+    } else if is_c_abi_compatible_by_value(tcx, ty) {
         let rs_type = db.format_ty_for_rs(ty)?;
         Ok(quote! { #rs_type })
     } else if let Some(tuple_abi) = tuple_c_abi_rs_type(ty) {
@@ -375,6 +388,7 @@ fn write_rs_value_to_c_abi_ptr<'tcx>(
         let rs_type_tokens = db.format_ty_for_rs(rs_type)?;
         Ok(quote! { (#c_ptr as *mut #rs_type_tokens).write(#rs_value); })
     };
+    let tcx = db.tcx();
     Ok(if let Some(bridged_type) = is_bridged_type(db, rs_type)? {
         match bridged_type {
             BridgedType::Legacy { conversion_info, .. } => match conversion_info {
@@ -412,7 +426,7 @@ fn write_rs_value_to_c_abi_ptr<'tcx>(
                 }
             }
         }
-    } else if is_c_abi_compatible_by_value(rs_type) {
+    } else if is_c_abi_compatible_by_value(tcx, rs_type) {
         write_directly()?
     } else if let ty::TyKind::Tuple(tuple_tys) = rs_type.kind() {
         let num_elements = tuple_tys.len();
@@ -525,7 +539,7 @@ pub fn generate_thunk_impl<'tcx>(
 
     let thunk_return_type;
     let thunk_return_expression;
-    if output_is_bridged.is_none() && is_c_abi_compatible_by_value(sig.output()) {
+    if output_is_bridged.is_none() && is_c_abi_compatible_by_value(tcx, sig.output()) {
         // The output is not bridged and is C ABI compatible by-value, so we can just return
         // the result directly, and no out-param is needed.
         thunk_return_type = db.format_ty_for_rs(sig.output())?;
@@ -576,7 +590,7 @@ pub fn generate_thunk_impl<'tcx>(
 
 /// Returns `Ok(())` if no thunk is required.
 /// Otherwise returns an error the describes why the thunk is needed.
-pub fn is_thunk_required(sig: &ty::FnSig) -> Result<()> {
+pub fn is_thunk_required(tcx: TyCtxt<'_>, sig: &ty::FnSig) -> Result<()> {
     match sig.abi {
         // "C" ABI is okay: since https://rust-lang.github.io/rfcs/2945-c-unwind-abi.html has been
         // accepted, a Rust panic that "escapes" a "C" ABI function is a defined crash. See
@@ -594,9 +608,12 @@ pub fn is_thunk_required(sig: &ty::FnSig) -> Result<()> {
         _ => bail!("Any calling convention other than `extern \"C\"` requires a thunk"),
     };
 
-    ensure!(is_c_abi_compatible_by_value(sig.output()), "Return type requires a thunk");
+    ensure!(is_c_abi_compatible_by_value(tcx, sig.output()), "Return type requires a thunk");
     for (i, param_ty) in sig.inputs().iter().enumerate() {
-        ensure!(is_c_abi_compatible_by_value(*param_ty), "Type of parameter #{i} requires a thunk");
+        ensure!(
+            is_c_abi_compatible_by_value(tcx, *param_ty),
+            "Type of parameter #{i} requires a thunk"
+        );
     }
 
     Ok(())

cc_bindings_from_rs/generate_bindings/query_compiler.rs

@@ -32,17 +32,17 @@ use std::rc::Rc;
 
 /// Whether functions using `extern "C"` ABI can safely handle values of type
 /// `ty` (e.g. when passing by value arguments or return values of such type).
-pub fn is_c_abi_compatible_by_value(ty: Ty) -> bool {
+pub fn is_c_abi_compatible_by_value(tcx: TyCtxt<'_>, ty: Ty) -> bool {
     match ty.kind() {
         // `improper_ctypes_definitions` warning doesn't complain about the following types:
-        ty::TyKind::Bool |
-        ty::TyKind::Float{..} |
-        ty::TyKind::Int{..} |
-        ty::TyKind::Uint{..} |
-        ty::TyKind::Never |
-        ty::TyKind::RawPtr{..} |
-        ty::TyKind::Ref{..} |
-        ty::TyKind::FnPtr{..} => true,
+        ty::TyKind::Bool
+        | ty::TyKind::Float { .. }
+        | ty::TyKind::Int { .. }
+        | ty::TyKind::Uint { .. }
+        | ty::TyKind::Never
+        | ty::TyKind::RawPtr { .. }
+        | ty::TyKind::Ref { .. }
+        | ty::TyKind::FnPtr { .. } => true,
         ty::TyKind::Tuple(types) if types.is_empty() => true,
 
         // Crubit assumes that `char` is compatible with a certain `extern "C"` ABI.
@@ -55,7 +55,7 @@ pub fn is_c_abi_compatible_by_value(ty: Ty) -> bool {
         // - In general `TyKind::Ref` should have the same ABI as `TyKind::RawPtr`
         // - References to slices (`&[T]`) or strings (`&str`) rely on assumptions
         //   spelled out in `rust_builtin_type_abi_assumptions.md`.
-        ty::TyKind::Slice{..} => false,
+        ty::TyKind::Slice { .. } => false,
 
         // Crubit's C++ bindings for tuples, structs, and other ADTs may not preserve
         // their ABI (even if they *do* preserve their memory layout).  For example:
@@ -70,13 +70,23 @@ pub fn is_c_abi_compatible_by_value(ty: Ty) -> bool {
         // returning `true` in a few limited cases (this may require additional complexity to
         // ensure that `generate_adt` never injects explicit padding into such structs):
         // - `#[repr(C)]` structs and unions,
-        // - `#[repr(transparent)]` struct that wraps an ABI-safe type,
         // - Discriminant-only enums (b/259984090).
-        ty::TyKind::Tuple{..} |  // An empty tuple (`()` - the unit type) is handled above.
-        ty::TyKind::Adt{..} => false,
+        ty::TyKind::Tuple { .. } => false, // An empty tuple (`()` - the unit type) is handled above.
+        ty::TyKind::Adt(adt, _) => {
+            if !adt.repr().transparent() {
+                // If our adt is not transparent, it is not abi compatible by value.
+                return false;
+            }
+            let Some(field) = adt.all_fields().next() else {
+                // TODO: b/258259459 - Support zero sized types.
+                return false;
+            };
+            is_c_abi_compatible_by_value(tcx, tcx.type_of(field.did).instantiate_identity())
+        }
 
         // Arrays are explicitly not ABI-compatible (though they are layout-compatible).
-        ty::TyKind::Array{..} => false,
+        ty::TyKind::Array { .. } => false,
+        ty::TyKind::Alias { .. } => false,
 
         // These kinds of reference-related types are not implemented yet - `is_c_abi_compatible_by_value`
         // should never need to handle them, because `format_ty_for_cc` fails for such types.
@@ -85,7 +95,7 @@ pub fn is_c_abi_compatible_by_value(ty: Ty) -> bool {
         // `format_ty_for_cc` is expected to fail for other kinds of types
         // and therefore `is_c_abi_compatible_by_value` should never be called for
         // these other types
-        _ => unimplemented!(),
+        ty => panic!("unsupported type kind: {ty:?}"),
     }
 }