Support accepting non-Rust movable C++ types as constructors in Rust functions.

PiperOrigin-RevId: 910223861

Author: Googler

cc_bindings_from_rs/generate_bindings/format_type.rs

@@ -145,6 +145,16 @@ pub fn format_ty_for_cc<'tcx>(
     location: TypeLocation,
 ) -> Result<CcSnippet<'tcx>> {
     let tcx = db.tcx();
+
+    // Normalize the type to resolve projections (associated types).
+    let ty = query_compiler::try_normalize(
+        tcx,
+        ty::PseudoCanonicalInput {
+            typing_env: rustc_middle::ty::TypingEnv::fully_monomorphized(),
+            value: ty,
+        },
+    )
+    .unwrap_or(ty);
     fn cstdint<'tcx>(tokens: TokenStream) -> CcSnippet<'tcx> {
         CcSnippet::with_include(tokens, CcInclude::cstdint())
     }
@@ -270,6 +280,15 @@ pub fn format_ty_for_cc<'tcx>(
         }
 
         ty::TyKind::Adt(adt, substs) => {
+            if matches_qualified_name(db, adt.did(), &["ctor", "RvalueReference"]) {
+                let referent = substs[1].expect_ty();
+                return format_pointer_or_reference_ty_for_cc(
+                    db,
+                    referent,
+                    Mutability::Mut,
+                    quote! { && },
+                );
+            }
             let def_id = adt.did();
             let mut prereqs = CcPrerequisites::default();
 
@@ -766,8 +785,9 @@ pub fn format_ty_for_rs<'tcx>(db: &BindingsGenerator<'tcx>, ty: Ty<'tcx>) -> Res
             let has_composable_bridging =
                 matches!(is_bridged_type(db, ty)?, Some(BridgedType::Composable(_)));
             // We support generics if they're for `std::option::Option` or `std::result::Result`.
-            let is_supported_generic_type =
-                BridgedBuiltin::new(db, adt).is_some() || !has_non_lifetime_substs(substs);
+            let is_supported_generic_type = BridgedBuiltin::new(db, adt).is_some()
+                || !has_non_lifetime_substs(substs)
+                || matches_qualified_name(db, adt.did(), &["ctor", "RvalueReference"]);
             ensure!(
                 has_cpp_type || is_supported_generic_type || has_composable_bridging,
                 "Generic types without composable bridging are not supported yet (b/259749095)"

cc_bindings_from_rs/generate_bindings/generate_bindings_test.rs

@@ -2146,7 +2146,7 @@ fn test_format_item_unsupported_type_without_direct_existence() {
         "#;
     test_format_item(test_src, "EvilAlias", |result| {
         let err = result.unwrap_err();
-        assert_eq!(err, "The following Rust type is not supported yet: <i64 as Evil>::Type");
+        assert_eq!(err, "Not a public or a supported reexported type (b/262052635).");
     });
 }
 

cc_bindings_from_rs/generate_bindings/generate_function.rs

@@ -185,7 +185,16 @@ fn cc_param_to_c_abi<'tcx>(
             }
         }
     } else if is_c_abi_compatible_by_value(tcx, ty) {
-        quote! { #cc_ident }
+        if let ty::TyKind::Adt(adt, _) = ty.kind() {
+            if crate::matches_qualified_name(db, adt.did(), &["ctor", "RvalueReference"]) {
+                includes.insert(code_gen_utils::CcInclude::utility());
+                quote! { ::std::move(#cc_ident) }
+            } else {
+                quote! { #cc_ident }
+            }
+        } else {
+            quote! { #cc_ident }
+        }
     } else if let ty::TyKind::Tuple(tuple_tys) = ty.kind() {
         let n = tuple_tys.len();
         let c_abi_names = ident_for_each(&format!("{cc_ident}_cabi"), n);

cc_bindings_from_rs/generate_bindings/generate_function_test.rs

@@ -1032,9 +1032,7 @@ fn test_format_item_unsupported_fn_async() {
         let err = result.unwrap_err();
         assert_eq!(
             err,
-            "Error formatting function return type `impl std::future::Future<Output = ()>`: \
-                         The following Rust type is not supported yet: \
-                         impl std::future::Future<Output = ()>"
+            "Error formatting function return type `impl std::future::Future<Output = ()>`: The following Rust type is not supported yet: {async fn body of async_function()}"
         );
     });
 }

cc_bindings_from_rs/generate_bindings/get_generic_args.rs

@@ -2,14 +2,14 @@
 // Exceptions. See /LICENSE for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-use crate::liberate_and_deanonymize_late_bound_regions;
+use crate::{liberate_and_deanonymize_late_bound_regions, matches_qualified_name};
 use arc_anyhow::{anyhow, bail, ensure, Result};
 use database::BindingsGenerator;
 use rustc_infer::infer::{InferCtxt, RegionVariableOrigin};
 use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_span::def_id::DefId;
-use rustc_span::symbol::sym;
+use rustc_span::symbol::{sym, Symbol};
 use rustc_trait_selection::infer::canonical::ir::TypingMode;
 use rustc_trait_selection::infer::TyCtxtInferExt;
 use rustc_trait_selection::traits::ObligationCtxt;
@@ -36,6 +36,15 @@ pub fn get_generic_args<'tcx>(
         finder.generic_param_indices
     };
 
+    let params_used_in_return_type = {
+        let mut finder = GenericParamsFinder::default();
+        let fn_sig = tcx.fn_sig(fn_def_id).instantiate_identity();
+        let fn_sig = liberate_and_deanonymize_late_bound_regions(tcx, fn_sig, fn_def_id);
+        use rustc_type_ir::TypeVisitable;
+        fn_sig.output().visit_with(&mut finder);
+        finder.generic_param_indices
+    };
+
     let replacements: HashMap<usize, ty::GenericArg<'tcx>> = (0..generics.count())
         .map(|idx| {
             let param_def = generics.param_at(idx, tcx);
@@ -50,14 +59,20 @@ pub fn get_generic_args<'tcx>(
                         "No support for replacing an _unused_ generic type param: `{}`",
                         param_def.name,
                     );
-                    get_replacement_for_generic_type_param(tcx, fn_def_id, predicates, param_def)
-                        .map(|ty| ty.into())
-                        .ok_or_else(|| {
-                            anyhow!(
-                                "No valid non-generic replacement for generic type param `{}`",
-                                param_def.name,
-                            )
-                        })?
+                    get_replacement_for_generic_type_param(
+                        db,
+                        fn_def_id,
+                        predicates,
+                        param_def,
+                        params_used_in_return_type.contains(&param_def.index),
+                    )
+                    .map(|ty| ty.into())
+                    .ok_or_else(|| {
+                        anyhow!(
+                            "No valid non-generic replacement for generic type param `{}`",
+                            param_def.name,
+                        )
+                    })?
                 }
             };
             Ok((idx, replacement))
@@ -79,32 +94,97 @@ pub fn get_generic_args<'tcx>(
 /// If the returned type needs to use a new anonymous lifetime, then it will be generated
 /// using the given `def_id` as its scope.
 fn get_replacement_for_trait_predicate<'tcx>(
-    tcx: TyCtxt<'tcx>,
+    db: &BindingsGenerator<'tcx>,
     trait_predicate: ty::TraitPredicate<'tcx>,
+    predicates: ty::GenericPredicates<'tcx>,
     new_anon_lifetime: impl Fn() -> ty::Region<'tcx>,
+    is_used_in_return_type: bool,
 ) -> Option<Ty<'tcx>> {
+    let tcx = db.tcx();
     if trait_predicate.polarity != ty::PredicatePolarity::Positive {
         return None;
     }
     let trait_ref = trait_predicate.trait_ref;
 
     // `args[0]` is `Self` / `T`.  And when working with `Into<U>`, `AsRef<U>`, etc.
     // we typically want the first and only other generic argument - `U`.
-    let ty1 = trait_ref.args.get(1).and_then(|generic_arg| generic_arg.as_type())?;
+    let ty1 = trait_ref.args.get(1).and_then(|generic_arg| generic_arg.as_type());
 
     // `T: Into<U>` => `U`
     if tcx.is_diagnostic_item(sym::Into, trait_ref.def_id) {
-        return Some(ty1);
+        return ty1;
     }
 
     // `T: AsRef<U>` => `&U`
     if tcx.is_diagnostic_item(sym::AsRef, trait_ref.def_id) {
-        return Some(Ty::new_imm_ref(tcx, new_anon_lifetime(), ty1));
+        return Some(Ty::new_imm_ref(tcx, new_anon_lifetime(), ty1?));
     }
 
     // `T: AsMut<U>` => `&mut U`
     if tcx.is_diagnostic_item(sym::AsMut, trait_ref.def_id) {
-        return Some(Ty::new_mut_ref(tcx, new_anon_lifetime(), ty1));
+        return Some(Ty::new_mut_ref(tcx, new_anon_lifetime(), ty1?));
+    }
+
+    // Support for Ctor trait (b/489315162)
+    if matches_qualified_name(db, trait_ref.def_id, &["ctor", "Ctor"]) {
+        if is_used_in_return_type {
+            return None;
+        }
+        // 1. Find the `DefId` of the `Output` associated type in the `Ctor` trait.
+        let ctor_output_def_id = tcx
+            .associated_items(trait_ref.def_id)
+            .in_definition_order()
+            .find(|item| {
+                item.name() == sym::Output && matches!(item.kind, ty::AssocKind::Type { .. })
+            })
+            .map(|item| item.def_id)?;
+
+        // 2. Iterate over the predicates and look for projections.
+        let output_ty = predicates
+            .predicates
+            .iter()
+            .filter_map(|(clause, _)| {
+                if let ty::ClauseKind::Projection(projection_predicate) =
+                    clause.kind().skip_binder()
+                {
+                    let projection_term = projection_predicate.projection_term;
+                    if projection_term.def_id == ctor_output_def_id
+                        && projection_term.self_ty() == trait_ref.self_ty()
+                    {
+                        return projection_predicate.term.as_type();
+                    }
+                }
+                None
+            })
+            .next()?;
+
+        // 3. Find DefIds for CtorNew and RvalueReference
+        let ctor_crate = trait_ref.def_id.krate;
+        let public_paths = db.public_paths_by_def_id(ctor_crate);
+        let find_by_name = |name: &str| {
+            let target_symbol = Symbol::intern(name);
+            public_paths.iter().find_map(|(def_id, paths)| {
+                if paths.canonical().name == target_symbol {
+                    Some(*def_id)
+                } else {
+                    None
+                }
+            })
+        };
+        let _ctor_new_def_id = find_by_name("CtorNew")?;
+        let rvalue_ref_def_id = find_by_name("RvalueReference")?;
+
+        // 4. Construct RvalueReference<'_, Output>
+        let anon_region = new_anon_lifetime();
+        let rvalue_ref_ty = Ty::new_adt(
+            tcx,
+            tcx.adt_def(rvalue_ref_def_id),
+            tcx.mk_args(&[anon_region.into(), output_ty.into()]),
+        );
+
+        // TODO(b/489315162): Verify Output: CtorNew<RvalueReference<'_, Output>>
+
+        return Some(rvalue_ref_ty);
     }
 
     // TODO(b/281542952): Implement other replacements as needed.
@@ -146,11 +226,13 @@ fn is_valid_replacement_for_generic_type_param<'tcx>(
 /// that may be constraining `T`.  When multiple answers are possible, returns
 /// the first one.
 fn get_replacement_for_generic_type_param<'tcx>(
-    tcx: TyCtxt<'tcx>,
+    db: &BindingsGenerator<'tcx>,
     def_id: DefId,
     predicates: ty::GenericPredicates<'tcx>,
     generic_type_param: &ty::GenericParamDef,
+    is_used_in_return_type: bool,
 ) -> Option<Ty<'tcx>> {
+    let tcx = db.tcx();
     // Look only at trait predicates involving this param (e.g. `T: SomeTrait`).
     let trait_predicates_for_this_generic_param = predicates
         .predicates
@@ -171,7 +253,13 @@ fn get_replacement_for_generic_type_param<'tcx>(
     // Find the first replacement that fits all the constraints.
     trait_predicates_for_this_generic_param
         .filter_map(|trait_predicate| {
-            get_replacement_for_trait_predicate(tcx, trait_predicate, new_anon_lifetime)
+            get_replacement_for_trait_predicate(
+                db,
+                trait_predicate,
+                predicates,
+                new_anon_lifetime,
+                is_used_in_return_type,
+            )
         })
         .find(|new_ty| {
             is_valid_replacement_for_generic_type_param(

cc_bindings_from_rs/test/functions/BUILD

@@ -24,6 +24,9 @@ rust_library(
     aspect_hints = [
         "//features:experimental",
     ],
+    deps = [
+        "//support:ctor",
+    ],
 )
 
 cc_bindings_from_rust(

cc_bindings_from_rs/test/functions/functions.rs

@@ -274,4 +274,34 @@ pub mod generic_fn_tests {
             }
         }
     }
+
+    pub mod ctor_trait_tests {
+        use ctor::Ctor;
+        use std::marker::PhantomPinned;
+
+        pub struct NonMovable {
+            pub value: i32,
+            _pinned: PhantomPinned,
+        }
+
+        impl NonMovable {
+            pub fn new(value: i32) -> Self {
+                NonMovable { value, _pinned: PhantomPinned }
+            }
+        }
+
+        impl<'a> ::ctor::CtorNew<::ctor::RvalueReference<'a, Self>> for NonMovable {
+            type CtorType = ::ctor::RvalueReference<'a, Self>;
+            type Error = i32;
+            fn ctor_new(
+                args: ::ctor::RvalueReference<'a, Self>,
+            ) -> ::ctor::RvalueReference<'a, Self> {
+                args
+            }
+        }
+
+        pub fn accept_ctor(_c: impl Ctor<Output = NonMovable>) -> i32 {
+            42
+        }
+    }
 }