Support for type aliases in extern "Rust" section.

anforowicz · anforowicz · commit 8dbb7b288893 · 2025-07-25T19:15:31.000Z
Fixes https://crbug.com/433254489
diff --git a/book/package-lock.json b/book/package-lock.json
diff --git a/book/src/extern-rust.md b/book/src/extern-rust.md
@@ -163,3 +163,46 @@ mod ffi {
 
 Bounds on a lifetime (like `<'a, 'b: 'a>`) are not currently supported. Nor are
 type parameters or where-clauses.
+
+## Reusing existing binding types
+
+Extern Rust types support a syntax for declaring that a C++ binding of the
+given Rust type already exists outside of the current bridge module. This
+avoids generating a separate binding which would clash with the first one
+(e.g. one possible error is: "conflicting implementations of trait `RustType`").
+
+The snippet below illustrates how to unify references to a Rust type
+across bridges:
+
+```rs
+// file1.rs
+#[cxx::bridge(namespace = "example")]
+pub mod ffi {
+    extern "Rust" {
+        type Demo;
+
+        fn create_demo() -> Box<Demo>;
+    }
+}
+
+pub struct Demo;
+
+pub fn create_demo() -> Box<Demo> { todo!() }
+```
+
+```rs
+// file2.rs
+#[cxx::bridge(namespace = "example")]
+pub mod ffi {
+    extern "C++" {
+        include!("file1.rs.h");
+    }
+    extern "Rust" {
+        type Demo = crate::file1::Demo;
+
+        fn take_ref_demo(demo: &Demo);
+    }
+}
+
+pub fn take_ref_demo(demo: &crate::file1::Demo) { todo!() }
+```
diff --git a/macro/src/expand.rs b/macro/src/expand.rs
@@ -1270,26 +1270,37 @@ fn expand_type_alias(alias: &TypeAlias) -> TokenStream {
 fn expand_type_alias_verify(alias: &TypeAlias, types: &Types) -> TokenStream {
     let attrs = &alias.attrs;
     let ident = &alias.name.rust;
-    let type_id = type_id(&alias.name);
     let begin_span = alias.type_token.span;
     let end_span = alias.semi_token.span;
-    let begin = quote_spanned!(begin_span=> ::cxx::private::verify_extern_type::<);
     let end = quote_spanned!(end_span=> >);
 
-    let mut verify = quote! {
-        #attrs
-        const _: fn() = #begin #ident, #type_id #end;
-    };
+    match alias.lang {
+        Lang::Cxx | Lang::CxxUnwind => {
+            let type_id = type_id(&alias.name);
+            let begin = quote_spanned!(begin_span=> ::cxx::private::verify_extern_type::<);
+            let mut verify = quote! {
+                #attrs
+                const _: fn() = #begin #ident, #type_id #end;
+            };
 
-    if types.required_trivial.contains_key(&alias.name.rust) {
-        let begin = quote_spanned!(begin_span=> ::cxx::private::verify_extern_kind::<);
-        verify.extend(quote! {
-            #attrs
-            const _: fn() = #begin #ident, ::cxx::kind::Trivial #end;
-        });
-    }
+            if types.required_trivial.contains_key(&alias.name.rust) {
+                let begin = quote_spanned!(begin_span=> ::cxx::private::verify_extern_kind::<);
+                verify.extend(quote! {
+                    #attrs
+                    const _: fn() = #begin #ident, ::cxx::kind::Trivial #end;
+                });
+            }
 
-    verify
+            verify
+        }
+        Lang::Rust => {
+            let begin = quote_spanned!(begin_span=> ::cxx::private::verify_rust_type::<);
+            quote! {
+                #attrs
+                const _: fn() = #begin #ident #end;
+            }
+        }
+    }
 }
 
 fn type_id(name: &Pair) -> TokenStream {
diff --git a/src/lib.rs b/src/lib.rs
@@ -503,7 +503,7 @@ pub mod private {
     pub use crate::rust_str::RustStr;
     #[cfg(feature = "alloc")]
     pub use crate::rust_string::RustString;
-    pub use crate::rust_type::{ImplBox, ImplVec, RustType};
+    pub use crate::rust_type::{verify_rust_type, ImplBox, ImplVec, RustType};
     #[cfg(feature = "alloc")]
     pub use crate::rust_vec::RustVec;
     pub use crate::shared_ptr::SharedPtrTarget;
diff --git a/src/rust_type.rs b/src/rust_type.rs
@@ -3,3 +3,6 @@
 pub unsafe trait RustType {}
 pub unsafe trait ImplBox {}
 pub unsafe trait ImplVec {}
+
+#[doc(hidden)]
+pub fn verify_rust_type<T: RustType>() {}
diff --git a/syntax/check.rs b/syntax/check.rs
@@ -710,7 +710,9 @@ fn describe(cx: &mut Check, ty: &Type) -> String {
             } else if cx.types.enums.contains_key(&ident.rust) {
                 "enum".to_owned()
             } else if cx.types.cxx_aliases.contains_key(&ident.rust) {
-                "C++ type".to_owned()
+                "aliased C++ type".to_owned()
+            } else if cx.types.rust_aliases.contains_key(&ident.rust) {
+                "aliased Rust type".to_owned()
             } else if cx.types.cxx.contains(&ident.rust) {
                 "opaque C++ type".to_owned()
             } else if cx.types.rust.contains(&ident.rust) {
diff --git a/syntax/mod.rs b/syntax/mod.rs
@@ -170,6 +170,7 @@ pub(crate) struct ExternFn {
 pub(crate) struct TypeAlias {
     #[allow(dead_code)] // only used by cxx-build, not cxxbridge-macro
     pub cfg: CfgExpr,
+    pub lang: Lang,
     #[allow(dead_code)] // only used by cxxbridge-macro, not cxx-build
     pub doc: Doc,
     pub derives: Vec<Derive>,
diff --git a/syntax/parse.rs b/syntax/parse.rs
@@ -870,17 +870,12 @@ fn parse_type_alias(
         },
     ));
 
-    if lang == Lang::Rust {
-        let span = quote!(#type_token #semi_token);
-        let msg = "type alias in extern \"Rust\" block is not supported";
-        return Err(Error::new_spanned(span, msg));
-    }
-
     let visibility = visibility_pub(&visibility, type_token.span);
     let name = pair(namespace, &ident, cxx_name, rust_name);
 
     Ok(Api::TypeAlias(TypeAlias {
         cfg,
+        lang,
         doc,
         derives,
         attrs,
diff --git a/syntax/types.rs b/syntax/types.rs
@@ -7,7 +7,8 @@ use crate::syntax::set::{OrderedSet, UnorderedSet};
 use crate::syntax::trivial::{self, TrivialReason};
 use crate::syntax::visit::{self, Visit};
 use crate::syntax::{
-    toposort, Api, Atom, Enum, EnumRepr, ExternType, Impl, Lifetimes, Pair, Struct, Type, TypeAlias,
+    toposort, Api, Atom, Enum, EnumRepr, ExternType, Impl, Lang, Lifetimes, Pair, Struct, Type,
+    TypeAlias,
 };
 use proc_macro2::Ident;
 use quote::ToTokens;
@@ -20,6 +21,8 @@ pub(crate) struct Types<'a> {
     pub rust: UnorderedSet<&'a Ident>,
     /// Type aliases defined in the `extern "C++"` section of `#[cxx::bridge]`.
     pub cxx_aliases: UnorderedMap<&'a Ident, &'a TypeAlias>,
+    /// Type aliases defined in the `extern "Rust"` section of `#[cxx::bridge]`.
+    pub rust_aliases: UnorderedMap<&'a Ident, &'a TypeAlias>,
     pub untrusted: UnorderedMap<&'a Ident, &'a ExternType>,
     pub required_trivial: UnorderedMap<&'a Ident, Vec<TrivialReason<'a>>>,
     pub impls: OrderedMap<ImplKey<'a>, Option<&'a Impl>>,
@@ -36,6 +39,7 @@ impl<'a> Types<'a> {
         let mut cxx = UnorderedSet::new();
         let mut rust = UnorderedSet::new();
         let mut cxx_aliases = UnorderedMap::new();
+        let mut rust_aliases = UnorderedMap::new();
         let mut untrusted = UnorderedMap::new();
         let mut impls = OrderedMap::new();
         let mut resolutions = UnorderedMap::new();
@@ -158,8 +162,16 @@ impl<'a> Types<'a> {
                     if !type_names.insert(ident) {
                         duplicate_name(cx, alias, ident);
                     }
-                    cxx.insert(ident);
-                    cxx_aliases.insert(ident, alias);
+                    match alias.lang {
+                        Lang::Cxx | Lang::CxxUnwind => {
+                            cxx.insert(ident);
+                            cxx_aliases.insert(ident, alias);
+                        }
+                        Lang::Rust => {
+                            rust.insert(ident);
+                            rust_aliases.insert(ident, alias);
+                        }
+                    }
                     add_resolution(&alias.name, &alias.generics);
                 }
                 Api::Impl(imp) => {
@@ -182,7 +194,9 @@ impl<'a> Types<'a> {
                 | ImplKey::SharedPtr(ident)
                 | ImplKey::WeakPtr(ident)
                 | ImplKey::CxxVector(ident) => {
-                    Atom::from(ident.rust).is_none() && !cxx_aliases.contains_key(ident.rust)
+                    Atom::from(ident.rust).is_none()
+                        && !cxx_aliases.contains_key(ident.rust)
+                        && !rust_aliases.contains_key(ident.rust)
                 }
             };
             if implicit_impl && !impls.contains_key(&impl_key) {
@@ -204,6 +218,7 @@ impl<'a> Types<'a> {
             cxx,
             rust,
             cxx_aliases,
+            rust_aliases,
             untrusted,
             required_trivial,
             impls,
@@ -310,4 +325,19 @@ mod test {
         let types = collect_types(&apis).unwrap();
         assert!(types.cxx_aliases.contains_key(&format_ident!("Alias")));
     }
+
+    #[test]
+    fn test_parsing_of_rust_type_aliases() {
+        let apis = parse_apis(quote! {
+            #[cxx::bridge]
+            mod ffi {
+                extern "Rust" {
+                    type Alias = crate::another_module::Foo;
+                }
+            }
+        })
+        .unwrap();
+        let types = collect_types(&apis).unwrap();
+        assert!(types.rust_aliases.contains_key(&format_ident!("Alias")));
+    }
 }
diff --git a/tests/ffi/lib.rs b/tests/ffi/lib.rs
@@ -342,6 +342,13 @@ pub mod ffi {
 
     impl Box<Shared> {}
     impl CxxVector<SharedString> {}
+
+    extern "Rust" {
+        type CrossModuleRustType = crate::module::CrossModuleRustType;
+        fn r_get_value_from_cross_module_rust_type(
+            value: &CrossModuleRustType,
+        ) -> i32;
+    }
 }
 
 mod other {
@@ -659,3 +666,9 @@ fn r_try_return_mutsliceu8(slice: &mut [u8]) -> Result<&mut [u8], Error> {
 fn r_aliased_function(x: i32) -> String {
     x.to_string()
 }
+
+fn r_get_value_from_cross_module_rust_type(
+    value: &crate::module::CrossModuleRustType,
+) -> i32 {
+    value.0
+}
diff --git a/tests/ffi/module.rs b/tests/ffi/module.rs
@@ -78,3 +78,24 @@ pub mod ffi2 {
     impl UniquePtr<F> {}
     impl UniquePtr<G> {}
 }
+
+#[cxx::bridge(namespace = "tests")]
+pub mod ffi3 {
+    extern "Rust" {
+        type CrossModuleRustType;
+
+        #[allow(clippy::unnecessary_box_returns)]
+        fn r_boxed_cross_module_rust_type(
+            value: i32,
+        ) -> Box<CrossModuleRustType>;
+    }
+}
+
+pub struct CrossModuleRustType(pub i32);
+
+#[allow(clippy::unnecessary_box_returns)]
+fn r_boxed_cross_module_rust_type(
+    value: i32,
+) -> Box<CrossModuleRustType> {
+    Box::new(CrossModuleRustType(value))
+}
diff --git a/tests/ffi/tests.cc b/tests/ffi/tests.cc
@@ -980,6 +980,9 @@ extern "C" const char *cxx_run_test() noexcept {
   (void)rust::Vec<size_t>();
   (void)rust::Vec<rust::isize>();
 
+  ASSERT(123 == r_get_value_from_cross_module_rust_type(
+      *r_boxed_cross_module_rust_type(123)));
+
   cxx_test_suite_set_correct();
   return nullptr;
 }
diff --git a/tests/ui/type_alias_rust.rs b/tests/ui/type_alias_rust.rs
diff --git a/tests/ui/type_alias_rust.stderr b/tests/ui/type_alias_rust.stderr
