Refactoring: deduplication: `format_param_types_for_cc`.
Quite similar code was used by both `format_fn` and `format_thunk_decl`
to format function parameters. The duplication would get somewhat worse
after adding support for function pointers (which adds a 3rd place where
parameter types need to be formatted + requires formatting them with
a future/new TypeLocation).
Because of the above, this CL extracts the shared code into
`format_param_types_for_cc`.
PiperOrigin-RevId: 524116023
diff --git a/cc_bindings_from_rs/bindings.rs b/cc_bindings_from_rs/bindings.rs
index 1765130..465f673 100644
--- a/cc_bindings_from_rs/bindings.rs
+++ b/cc_bindings_from_rs/bindings.rs
@@ -505,6 +505,20 @@
.context("Error formatting function return type")
}
+fn format_param_types_for_cc<'tcx>(
+ input: &Input<'tcx>,
+ sig: &ty::FnSig<'tcx>,
+) -> Result<Vec<CcSnippet>> {
+ sig.inputs()
+ .iter()
+ .enumerate()
+ .map(|(i, &ty)| {
+ Ok(format_ty_for_cc(input, ty, TypeLocation::Other)
+ .with_context(|| format!("Error handling parameter #{i}"))?)
+ })
+ .collect()
+}
+
/// Formats `ty` for Rust - to be used in `..._cc_api_impl.rs` (e.g. as a type
/// of a parameter in a Rust thunk). Because `..._cc_api_impl.rs` is a
/// distinct, separate crate, the returned `TokenStream` uses crate-qualified
@@ -600,26 +614,29 @@
let sig = get_fn_sig(tcx, fn_def_id)?;
let main_api_ret_type = format_ret_ty_for_cc(input, &sig)?.into_tokens(&mut prereqs);
- let mut thunk_params = sig
- .inputs()
- .iter()
- .map(|&ty| -> Result<TokenStream> {
- let cc_type = format_ty_for_cc(input, ty, TypeLocation::Other)?.into_tokens(&mut prereqs);
- if is_c_abi_compatible_by_value(ty) {
- Ok(quote! { #cc_type })
- } else {
- // Rust thunk will move a value via memcpy - we need to `ensure` that
- // invoking the C++ destructor (on the moved-away value) is safe.
- // TODO(b/259749095): Support generic structs (with non-empty ParamEnv).
- ensure!(
- !ty.needs_drop(tcx, ty::ParamEnv::empty()),
- "Only trivially-movable and trivially-destructible types \
- may be passed by value over the FFI boundary"
- );
- Ok(quote! { #cc_type* })
- }
- })
- .collect::<Result<Vec<_>>>()?;
+ let mut thunk_params = {
+ let cc_types = format_param_types_for_cc(input, &sig)?;
+ sig.inputs()
+ .iter()
+ .zip(cc_types.into_iter())
+ .map(|(&ty, cc_type)| -> Result<TokenStream> {
+ let cc_type = cc_type.into_tokens(&mut prereqs);
+ if is_c_abi_compatible_by_value(ty) {
+ Ok(quote! { #cc_type })
+ } else {
+ // Rust thunk will move a value via memcpy - we need to `ensure` that
+ // invoking the C++ destructor (on the moved-away value) is safe.
+ // TODO(b/259749095): Support generic structs (with non-empty ParamEnv).
+ ensure!(
+ !ty.needs_drop(tcx, ty::ParamEnv::empty()),
+ "Only trivially-movable and trivially-destructible types \
+ may be passed by value over the FFI boundary"
+ );
+ Ok(quote! { #cc_type* })
+ }
+ })
+ .collect::<Result<Vec<_>>>()?
+ };
let thunk_ret_type: TokenStream;
if is_c_abi_compatible_by_value(sig.output()) {
@@ -814,19 +831,18 @@
}
let params = {
let names = tcx.fn_arg_names(def_id).iter();
- let types = sig.inputs().iter();
+ let cc_types = format_param_types_for_cc(input, &sig)?;
names
- .zip(types)
.enumerate()
- .map(|(i, (name, &ty))| -> Result<Param> {
+ .zip(sig.inputs().iter())
+ .zip(cc_types.into_iter())
+ .map(|(((i, name), &ty), cc_type)| {
let cc_name = format_cc_ident(name.as_str())
.unwrap_or_else(|_err| format_cc_ident(&format!("__param_{i}")).unwrap());
- let cc_type = format_ty_for_cc(input, ty, TypeLocation::Other)?.into_tokens(&mut main_api_prereqs);
- Ok(Param { cc_name, cc_type, ty })
+ let cc_type = cc_type.into_tokens(&mut main_api_prereqs);
+ Param { cc_name, cc_type, ty }
})
- .enumerate()
- .map(|(i, result)| result.with_context(|| format!("Error handling parameter #{i}")))
- .collect::<Result<Vec<_>>>()?
+ .collect_vec()
};
let main_api_params = params
.iter()
