X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Ftypes.rs;h=483c1d9b9d12821b427cf8e0e143a56abb9a2400;hb=32abba7201f4045d31bc7c7df43683028989b4aa;hp=973d1909ef9215287baef561fb6cf139fb13052c;hpb=35e48cf479b8ec03ddf574e2c74d1c2b6d76143e;p=rust-lightning diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs index 973d1909..483c1d9b 100644 --- a/c-bindings-gen/src/types.rs +++ b/c-bindings-gen/src/types.rs @@ -1,6 +1,7 @@ use std::collections::HashMap; use std::fs::File; use std::io::Write; +use std::hash; use proc_macro2::{TokenTree, Span}; @@ -225,6 +226,13 @@ pub enum DeclType<'a> { EnumIgnored, } +// templates_defined is walked to write the C++ header, so if we use the default hashing it get +// reordered on each genbindings run. Instead, we use SipHasher (which defaults to 0-keys) so that +// the sorting is stable across runs. It is deprecated, but the "replacement" doesn't actually +// accomplish the same goals, so we just ignore it. +#[allow(deprecated)] +type NonRandomHash = hash::BuildHasherDefault; + /// Top-level struct tracking everything which has been defined while walking the crate. pub struct CrateTypes<'a> { /// This may contain structs or enums, but only when either is mapped as @@ -240,7 +248,7 @@ pub struct CrateTypes<'a> { /// exists. /// /// This is used at the end of processing to make C++ wrapper classes - pub templates_defined: HashMap, + pub templates_defined: HashMap, /// The output file for any created template container types, written to as we find new /// template containers which need to be defined. pub template_file: &'a mut File, @@ -924,19 +932,34 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // *** Original Rust Type Printing *** // *********************************** - fn write_rust_path(&self, w: &mut W, path: &syn::Path) { - if let Some(resolved) = self.maybe_resolve_path(&path, None) { + fn in_rust_prelude(resolved_path: &str) -> bool { + match resolved_path { + "Vec" => true, + "Result" => true, + "Option" => true, + _ => false, + } + } + + fn write_rust_path(&self, w: &mut W, generics_resolver: Option<&GenericTypes>, path: &syn::Path) { + if let Some(resolved) = self.maybe_resolve_path(&path, generics_resolver) { if self.is_primitive(&resolved) { write!(w, "{}", path.get_ident().unwrap()).unwrap(); } else { - if resolved.starts_with("ln::") || resolved.starts_with("chain::") || resolved.starts_with("util::") { - write!(w, "lightning::{}", resolved).unwrap(); + // TODO: We should have a generic "is from a dependency" check here instead of + // checking for "bitcoin" explicitly. + if resolved.starts_with("bitcoin::") || Self::in_rust_prelude(&resolved) { + write!(w, "{}", resolved).unwrap(); + // If we're printing a generic argument, it needs to reference the crate, otherwise + // the original crate: + } else if self.maybe_resolve_path(&path, None).as_ref() == Some(&resolved) { + write!(w, "{}::{}", self.orig_crate, resolved).unwrap(); } else { - write!(w, "{}", resolved).unwrap(); // XXX: Probably doens't work, get_ident().unwrap() + write!(w, "crate::{}", resolved).unwrap(); } } if let syn::PathArguments::AngleBracketed(args) = &path.segments.iter().last().unwrap().arguments { - self.write_rust_generic_arg(w, args.args.iter()); + self.write_rust_generic_arg(w, generics_resolver, args.args.iter()); } } else { if path.leading_colon.is_some() { @@ -946,12 +969,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { if idx != 0 { write!(w, "::").unwrap(); } write!(w, "{}", seg.ident).unwrap(); if let syn::PathArguments::AngleBracketed(args) = &seg.arguments { - self.write_rust_generic_arg(w, args.args.iter()); + self.write_rust_generic_arg(w, generics_resolver, args.args.iter()); } } } } - pub fn write_rust_generic_param<'b, W: std::io::Write>(&self, w: &mut W, generics: impl Iterator) { + pub fn write_rust_generic_param<'b, W: std::io::Write>(&self, w: &mut W, generics_resolver: Option<&GenericTypes>, generics: impl Iterator) { let mut had_params = false; for (idx, arg) in generics.enumerate() { if idx != 0 { write!(w, ", ").unwrap(); } else { write!(w, "<").unwrap(); } @@ -966,7 +989,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { match bound { syn::TypeParamBound::Trait(tb) => { if tb.paren_token.is_some() || tb.lifetimes.is_some() { unimplemented!(); } - self.write_rust_path(w, &tb.path); + self.write_rust_path(w, generics_resolver, &tb.path); }, _ => unimplemented!(), } @@ -979,24 +1002,24 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { if had_params { write!(w, ">").unwrap(); } } - pub fn write_rust_generic_arg<'b, W: std::io::Write>(&self, w: &mut W, generics: impl Iterator) { + pub fn write_rust_generic_arg<'b, W: std::io::Write>(&self, w: &mut W, generics_resolver: Option<&GenericTypes>, generics: impl Iterator) { write!(w, "<").unwrap(); for (idx, arg) in generics.enumerate() { if idx != 0 { write!(w, ", ").unwrap(); } match arg { - syn::GenericArgument::Type(t) => self.write_rust_type(w, t), + syn::GenericArgument::Type(t) => self.write_rust_type(w, generics_resolver, t), _ => unimplemented!(), } } write!(w, ">").unwrap(); } - pub fn write_rust_type(&self, w: &mut W, t: &syn::Type) { + pub fn write_rust_type(&self, w: &mut W, generics: Option<&GenericTypes>, t: &syn::Type) { match t { syn::Type::Path(p) => { if p.qself.is_some() || p.path.leading_colon.is_some() { unimplemented!(); } - self.write_rust_path(w, &p.path); + self.write_rust_path(w, generics, &p.path); }, syn::Type::Reference(r) => { write!(w, "&").unwrap(); @@ -1006,11 +1029,11 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { if r.mutability.is_some() { write!(w, "mut ").unwrap(); } - self.write_rust_type(w, &*r.elem); + self.write_rust_type(w, generics, &*r.elem); }, syn::Type::Array(a) => { write!(w, "[").unwrap(); - self.write_rust_type(w, &a.elem); + self.write_rust_type(w, generics, &a.elem); if let syn::Expr::Lit(l) = &a.len { if let syn::Lit::Int(i) = &l.lit { write!(w, "; {}]", i).unwrap(); @@ -1019,14 +1042,14 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } syn::Type::Slice(s) => { write!(w, "[").unwrap(); - self.write_rust_type(w, &s.elem); + self.write_rust_type(w, generics, &s.elem); write!(w, "]").unwrap(); }, syn::Type::Tuple(s) => { write!(w, "(").unwrap(); for (idx, t) in s.elems.iter().enumerate() { if idx != 0 { write!(w, ", ").unwrap(); } - self.write_rust_type(w, &t); + self.write_rust_type(w, generics, &t); } write!(w, ")").unwrap(); }, @@ -1689,11 +1712,11 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { assert!(self.write_c_type_intern(w, gen, None, false, false, false)); } writeln!(w, ") -> {} {{", mangled_container).unwrap(); - writeln!(w, "\t{} {{", mangled_container).unwrap(); + write!(w, "\t{} {{ ", mangled_container).unwrap(); for idx in 0..args.len() { - writeln!(w, "\t\t{}: Box::into_raw(Box::new({})),", ('a' as u8 + idx as u8) as char, ('a' as u8 + idx as u8) as char).unwrap(); + write!(w, "{}, ", ('a' as u8 + idx as u8) as char).unwrap(); } - writeln!(w, "\t}}\n}}\n").unwrap(); + writeln!(w, "}}\n}}\n").unwrap(); } else { writeln!(w, "").unwrap(); } @@ -1735,7 +1758,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } else if in_crate { write!(w, "{}", c_type).unwrap(); } else { - self.write_rust_type(w, &t); + self.write_rust_type(w, None, &t); } } else { // If we just write out resolved_generic, it may mostly work, however for