From: Matt Corallo Date: Mon, 1 Nov 2021 17:55:20 +0000 (+0000) Subject: Track generic param count and print types in ptr-conversion X-Git-Tag: v0.0.103.0^2~7 X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=commitdiff_plain;h=6728a81b78cec348a99084e841b055424425e27a;p=ldk-c-bindings 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 51f67f7..1bcc8f1 100644 --- a/c-bindings-gen/src/main.rs +++ b/c-bindings-gen/src/main.rs @@ -1259,7 +1259,7 @@ fn writeln_impl(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: &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 18f6a0c..fc832f8 100644 --- 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 { 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, + pub opaques: HashMap, /// Enums which are mapped as C enums with conversion functions pub mirrored_enums: HashMap, /// 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(&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();