Track generic param count and print types in ptr-conversion

This will allow rustc to prevent an issue where we accidentally
map `&&Object as *const _` to get a `*const Object`, instead
getting a pointer to a pointer.

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index 51f67f750678fe9cfb6e0328c1ef0234b843153e..1bcc8f19731f435fb5e91a8e57625d4adff3f759 100644 (file)
--- a/c-bindings-gen/src/main.rs
+++ b/c-bindings-gen/src/main.rs
@@ -1259,7 +1259,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
                                                                        write!(w, "#[no_mangle]\npub extern \"C\" fn {}_{}(", ident, m.sig.ident).unwrap();
                                                                        let ret_type = match &declared_type {
                                                                                DeclType::MirroredEnum => format!("{}", ident),
-                                                                               DeclType::StructImported => format!("{}", ident),
+                                                                               DeclType::StructImported {..} => format!("{}", ident),
                                                                                _ => unimplemented!(),
                                                                        };
                                                                        write_method_params(w, &m.sig, &ret_type, types, Some(&meth_gen_types), false, true);
@@ -1280,7 +1280,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
                                                                        } else {
                                                                                match &declared_type {
                                                                                        DeclType::MirroredEnum => write!(w, "this_arg.to_native().{}(", m.sig.ident).unwrap(),
-                                                                                       DeclType::StructImported => {
+                                                                                       DeclType::StructImported {..} => {
                                                                                                if takes_owned_self {
                                                                                                        write!(w, "(*unsafe {{ Box::from_raw(this_arg.take_inner()) }}).{}(", m.sig.ident).unwrap();
                                                                                                } else if takes_mut_self {
@@ -1846,7 +1846,7 @@ fn walk_ast<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a
                                                        ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
                                                }
                                                let struct_path = format!("{}::{}", module, s.ident);
-                                               crate_types.opaques.insert(struct_path, &s.ident);
+                                               crate_types.opaques.insert(struct_path, (&s.ident, &s.generics));
                                        }
                                },
                                syn::Item::Trait(t) => {
@@ -1891,7 +1891,7 @@ fn walk_ast<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a
                                                                                hash_map::Entry::Vacant(e) => { e.insert(vec![(path_obj, args_obj)]); },
                                                                        }
 
-                                                                       crate_types.opaques.insert(type_path, t_ident);
+                                                                       crate_types.opaques.insert(type_path, (t_ident, &t.generics));
                                                                },
                                                                _ => {
                                                                        crate_types.type_aliases.insert(type_path, import_resolver.resolve_imported_refs((*t.ty).clone()));
@@ -1908,7 +1908,7 @@ fn walk_ast<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a
                                                        ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
                                                }
                                                let enum_path = format!("{}::{}", module, e.ident);
-                                               crate_types.opaques.insert(enum_path, &e.ident);
+                                               crate_types.opaques.insert(enum_path, (&e.ident, &e.generics));
                                        }
                                },
                                syn::Item::Enum(e) => {

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index 18f6a0c051671b374e1a60ae87e3449855bd024b..fc832f8ef7f212e5e18dd3f07a92ab521bf26297 100644 (file)
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -381,9 +381,9 @@ impl<'a, 'b, 'c: 'a + 'b> ResolveType<'c> for Option<&GenericTypes<'a, 'b>> {
 pub enum DeclType<'a> {
        MirroredEnum,
        Trait(&'a syn::ItemTrait),
-       StructImported,
+       StructImported { generic_param_count: usize },
        StructIgnored,
-       EnumIgnored,
+       EnumIgnored { generic_param_count: usize },
 }
 
 pub struct ImportResolver<'mod_lifetime, 'crate_lft: 'mod_lifetime> {
@@ -495,7 +495,7 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr
                                syn::Item::Struct(s) => {
                                        if let syn::Visibility::Public(_) = s.vis {
                                                match export_status(&s.attrs) {
-                                                       ExportStatus::Export => { declared.insert(s.ident.clone(), DeclType::StructImported); },
+                                                       ExportStatus::Export => { declared.insert(s.ident.clone(), DeclType::StructImported { generic_param_count: s.generics.params.len() }); },
                                                        ExportStatus::NoExport => { declared.insert(s.ident.clone(), DeclType::StructIgnored); },
                                                        ExportStatus::TestOnly => continue,
                                                        ExportStatus::NotImplementable => panic!("(C-not implementable) should only appear on traits!"),
@@ -510,14 +510,14 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr
                                                        else { process_alias = false; }
                                                }
                                                if process_alias {
-                                                       declared.insert(t.ident.clone(), DeclType::StructImported);
+                                                       declared.insert(t.ident.clone(), DeclType::StructImported { generic_param_count: t.generics.params.len() });
                                                }
                                        }
                                },
                                syn::Item::Enum(e) => {
                                        if let syn::Visibility::Public(_) = e.vis {
                                                match export_status(&e.attrs) {
-                                                       ExportStatus::Export if is_enum_opaque(e) => { declared.insert(e.ident.clone(), DeclType::EnumIgnored); },
+                                                       ExportStatus::Export if is_enum_opaque(e) => { declared.insert(e.ident.clone(), DeclType::EnumIgnored { generic_param_count: e.generics.params.len() }); },
                                                        ExportStatus::Export => { declared.insert(e.ident.clone(), DeclType::MirroredEnum); },
                                                        ExportStatus::NotImplementable => panic!("(C-not implementable) should only appear on traits!"),
                                                        _ => continue,
@@ -728,7 +728,7 @@ fn initial_clonable_types() -> HashSet<String> {
 pub struct CrateTypes<'a> {
        /// This may contain structs or enums, but only when either is mapped as
        /// struct X { inner: *mut originalX, .. }
-       pub opaques: HashMap<String, &'a syn::Ident>,
+       pub opaques: HashMap<String, (&'a syn::Ident, &'a syn::Generics)>,
        /// Enums which are mapped as C enums with conversion functions
        pub mirrored_enums: HashMap<String, &'a syn::ItemEnum>,
        /// Traits which are mapped as a pointer + jump table
@@ -1853,8 +1853,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                        }
                                } else if let Some(c_type) = path_lookup(&resolved_path, is_ref, ptr_for_ref) {
                                        write!(w, "{}", c_type).unwrap();
-                               } else if self.crate_types.opaques.get(&resolved_path).is_some() {
-                                       decl_lookup(w, &DeclType::StructImported, &resolved_path, is_ref, is_mut);
+                               } else if let Some((_, generics)) = self.crate_types.opaques.get(&resolved_path) {
+                                       decl_lookup(w, &DeclType::StructImported { generic_param_count: generics.params.len() }, &resolved_path, is_ref, is_mut);
                                } else if self.crate_types.mirrored_enums.get(&resolved_path).is_some() {
                                        decl_lookup(w, &DeclType::MirroredEnum, &resolved_path, is_ref, is_mut);
                                } else if let Some(t) = self.crate_types.traits.get(&resolved_path) {
@@ -1941,15 +1941,15 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                                DeclType::MirroredEnum if is_ref && ptr_for_ref => write!(w, "crate::{}::from_native(", decl_path).unwrap(),
                                                DeclType::MirroredEnum if is_ref => write!(w, "&crate::{}::from_native(", decl_path).unwrap(),
                                                DeclType::MirroredEnum => write!(w, "crate::{}::native_into(", decl_path).unwrap(),
-                                               DeclType::EnumIgnored|DeclType::StructImported if is_ref && ptr_for_ref && from_ptr =>
+                                               DeclType::EnumIgnored {..}|DeclType::StructImported {..} if is_ref && ptr_for_ref && from_ptr =>
                                                        write!(w, "crate::{} {{ inner: unsafe {{ (", decl_path).unwrap(),
-                                               DeclType::EnumIgnored|DeclType::StructImported if is_ref => {
+                                               DeclType::EnumIgnored {..}|DeclType::StructImported {..} if is_ref => {
                                                        if !ptr_for_ref { write!(w, "&").unwrap(); }
                                                        write!(w, "crate::{} {{ inner: unsafe {{ ObjOps::nonnull_ptr_to_inner((", decl_path).unwrap()
                                                },
-                                               DeclType::EnumIgnored|DeclType::StructImported if !is_ref && from_ptr =>
+                                               DeclType::EnumIgnored {..}|DeclType::StructImported {..} if !is_ref && from_ptr =>
                                                        write!(w, "crate::{} {{ inner: ", decl_path).unwrap(),
-                                               DeclType::EnumIgnored|DeclType::StructImported if !is_ref =>
+                                               DeclType::EnumIgnored {..}|DeclType::StructImported {..} if !is_ref =>
                                                        write!(w, "crate::{} {{ inner: ObjOps::heap_alloc(", decl_path).unwrap(),
                                                DeclType::Trait(_) if is_ref => write!(w, "").unwrap(),
                                                DeclType::Trait(_) if !is_ref => write!(w, "Into::into(").unwrap(),
@@ -1963,15 +1963,20 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
        fn write_to_c_conversion_inline_suffix_inner<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, is_ref: bool, ptr_for_ref: bool, from_ptr: bool) {
                self.write_conversion_inline_intern(w, t, generics, is_ref, false, ptr_for_ref, "*/", false, |_, _| ".into()".to_owned(),
                                |a, b, c| self.to_c_conversion_inline_suffix_from_path(a, b, c),
-                               |w, decl_type, _full_path, is_ref, _is_mut| match decl_type {
+                               |w, decl_type, full_path, is_ref, _is_mut| match decl_type {
                                        DeclType::MirroredEnum => write!(w, ")").unwrap(),
-                                       DeclType::EnumIgnored|DeclType::StructImported if is_ref && ptr_for_ref && from_ptr =>
-                                               write!(w, " as *const _) as *mut _ }}, is_owned: false }}").unwrap(),
-                                       DeclType::EnumIgnored|DeclType::StructImported if is_ref =>
-                                               write!(w, " as *const _) as *mut _) }}, is_owned: false }}").unwrap(),
-                                       DeclType::EnumIgnored|DeclType::StructImported if !is_ref && from_ptr =>
+                                       DeclType::EnumIgnored { generic_param_count }|DeclType::StructImported { generic_param_count } if is_ref => {
+                                               write!(w, " as *const {}<", full_path).unwrap();
+                                               for _ in 0..*generic_param_count { write!(w, "_, ").unwrap(); }
+                                               if ptr_for_ref && from_ptr {
+                                                       write!(w, ">) as *mut _ }}, is_owned: false }}").unwrap();
+                                               } else {
+                                                       write!(w, ">) as *mut _) }}, is_owned: false }}").unwrap();
+                                               }
+                                       },
+                                       DeclType::EnumIgnored {..}|DeclType::StructImported {..} if !is_ref && from_ptr =>
                                                write!(w, ", is_owned: true }}").unwrap(),
-                                       DeclType::EnumIgnored|DeclType::StructImported if !is_ref => write!(w, "), is_owned: true }}").unwrap(),
+                                       DeclType::EnumIgnored {..}|DeclType::StructImported {..} if !is_ref => write!(w, "), is_owned: true }}").unwrap(),
                                        DeclType::Trait(_) if is_ref => {},
                                        DeclType::Trait(_) => {
                                                // This is used when we're converting a concrete Rust type into a C trait
@@ -1991,8 +1996,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                self.write_conversion_inline_intern(w, t, generics, is_ref, false, false, "() /*", true, |_, _| "&local_".to_owned(),
                                |a, b, _c| self.from_c_conversion_prefix_from_path(a, b),
                                |w, decl_type, _full_path, is_ref, _is_mut| match decl_type {
-                                       DeclType::StructImported if is_ref => write!(w, "").unwrap(),
-                                       DeclType::StructImported if !is_ref => write!(w, "*unsafe {{ Box::from_raw(").unwrap(),
+                                       DeclType::StructImported {..} if is_ref => write!(w, "").unwrap(),
+                                       DeclType::StructImported {..} if !is_ref => write!(w, "*unsafe {{ Box::from_raw(").unwrap(),
                                        DeclType::MirroredEnum if is_ref => write!(w, "&").unwrap(),
                                        DeclType::MirroredEnum => {},
                                        DeclType::Trait(_) => {},
@@ -2012,10 +2017,10 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                },
                                |a, b, _c| self.from_c_conversion_suffix_from_path(a, b),
                                |w, decl_type, _full_path, is_ref, is_mut| match decl_type {
-                                       DeclType::StructImported if is_ref && ptr_for_ref => write!(w, "XXX unimplemented").unwrap(),
-                                       DeclType::StructImported if is_mut && is_ref => write!(w, ".get_native_mut_ref()").unwrap(),
-                                       DeclType::StructImported if is_ref => write!(w, ".get_native_ref()").unwrap(),
-                                       DeclType::StructImported if !is_ref => write!(w, ".take_inner()) }}").unwrap(),
+                                       DeclType::StructImported {..} if is_ref && ptr_for_ref => write!(w, "XXX unimplemented").unwrap(),
+                                       DeclType::StructImported {..} if is_mut && is_ref => write!(w, ".get_native_mut_ref()").unwrap(),
+                                       DeclType::StructImported {..} if is_ref => write!(w, ".get_native_ref()").unwrap(),
+                                       DeclType::StructImported {..} if !is_ref => write!(w, ".take_inner()) }}").unwrap(),
                                        DeclType::MirroredEnum if is_ref => write!(w, ".to_native()").unwrap(),
                                        DeclType::MirroredEnum => write!(w, ".into_native()").unwrap(),
                                        DeclType::Trait(_) => {},
@@ -2035,7 +2040,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                        } else { None }
                                },
                                |w, decl_type, _full_path, is_ref, _is_mut| match decl_type {
-                                       DeclType::StructImported if !is_ref => write!(w, "").unwrap(),
+                                       DeclType::StructImported {..} if !is_ref => write!(w, "").unwrap(),
                                        _ => unimplemented!(),
                                });
        }
@@ -2049,7 +2054,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                },
                                |a, b, _c| self.from_c_conversion_suffix_from_path(a, b),
                                |w, decl_type, _full_path, is_ref, _is_mut| match decl_type {
-                                       DeclType::StructImported if !is_ref => write!(w, ".get_native_ref()").unwrap(),
+                                       DeclType::StructImported {..} if !is_ref => write!(w, ".get_native_ref()").unwrap(),
                                        _ => unimplemented!(),
                                });
        }
@@ -2682,7 +2687,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                        if let syn::Type::Path(p) = &*r.elem {
                                                // Slices with "real types" inside are mapped as the equivalent non-ref Vec
                                                let resolved = self.resolve_path(&p.path, generics);
-                                               let mangled_container = if let Some(ident) = self.crate_types.opaques.get(&resolved) {
+                                               let mangled_container = if let Some((ident, _)) = self.crate_types.opaques.get(&resolved) {
                                                        format!("CVec_{}Z", ident)
                                                } else if let Some(en) = self.crate_types.mirrored_enums.get(&resolved) {
                                                        format!("CVec_{}Z", en.ident)
@@ -2696,7 +2701,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                                        if let syn::Type::Path(p) = &*r2.elem {
                                                                // Slices with slices with opaque types (with is_owned flags) are mapped as non-ref Vecs
                                                                let resolved = self.resolve_path(&p.path, generics);
-                                                               let mangled_container = if let Some(ident) = self.crate_types.opaques.get(&resolved) {
+                                                               let mangled_container = if let Some((ident, _)) = self.crate_types.opaques.get(&resolved) {
                                                                        format!("CVec_CVec_{}ZZ", ident)
                                                                } else { return false; };
                                                                write!(w, "{}::{}", Self::generated_container_path(), mangled_container).unwrap();