From: Matt Corallo Date: Mon, 12 Apr 2021 21:10:17 +0000 (-0400) Subject: Make GenericTypes stack pushes RAII, giving borrowck knowledge of diff ImportResolver... X-Git-Tag: v0.0.98~16^2~5 X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=commitdiff_plain;h=ede0077a0c4567b93fbc135b6159403017958fc4;p=ldk-c-bindings Make GenericTypes stack pushes RAII, giving borrowck knowledge of diff ImportResolver lifetimes --- diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs index 44e74b9..a1c5a74 100644 --- a/c-bindings-gen/src/main.rs +++ b/c-bindings-gen/src/main.rs @@ -267,8 +267,8 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty } if m.default.is_some() { unimplemented!(); } - gen_types.push_ctx(); - assert!(gen_types.learn_generics(&m.sig.generics, types)); + let mut meth_gen_types = gen_types.push_ctx(); + assert!(meth_gen_types.learn_generics(&m.sig.generics, types)); writeln_docs(w, &m.attrs, "\t"); @@ -286,7 +286,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty // called when the trait method is called which allows updating on the fly. write!(w, "\tpub {}: ", m.sig.ident).unwrap(); generated_fields.push((format!("{}", m.sig.ident), true)); - types.write_c_type(w, &*r.elem, Some(&gen_types), false); + types.write_c_type(w, &*r.elem, Some(&meth_gen_types), false); writeln!(w, ",").unwrap(); writeln!(w, "\t/// Fill in the {} field as a reference to it will be given to Rust after this returns", m.sig.ident).unwrap(); writeln!(w, "\t/// Note that this takes a pointer to this object, not the this_ptr like other methods do").unwrap(); @@ -298,7 +298,6 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty // which does not compile since Thing is not defined before it is used. writeln!(extra_headers, "struct LDK{};", trait_name).unwrap(); writeln!(extra_headers, "typedef struct LDK{} LDK{};", trait_name, trait_name).unwrap(); - gen_types.pop_ctx(); continue; } // Sadly, this currently doesn't do what we want, but it should be easy to get @@ -308,10 +307,8 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty write!(w, "\tpub {}: extern \"C\" fn (", m.sig.ident).unwrap(); generated_fields.push((format!("{}", m.sig.ident), true)); - write_method_params(w, &m.sig, "c_void", types, Some(&gen_types), true, false); + write_method_params(w, &m.sig, "c_void", types, Some(&meth_gen_types), true, false); writeln!(w, ",").unwrap(); - - gen_types.pop_ctx(); }, &syn::TraitItem::Type(_) => {}, _ => unimplemented!(), @@ -381,10 +378,10 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty m.sig.abi.is_some() || m.sig.variadic.is_some() { unimplemented!(); } - gen_types.push_ctx(); - assert!(gen_types.learn_generics(&m.sig.generics, types)); + let mut meth_gen_types = gen_types.push_ctx(); + assert!(meth_gen_types.learn_generics(&m.sig.generics, types)); write!(w, "\tfn {}", m.sig.ident).unwrap(); - types.write_rust_generic_param(w, Some(&gen_types), m.sig.generics.params.iter()); + types.write_rust_generic_param(w, Some(&meth_gen_types), m.sig.generics.params.iter()); write!(w, "(").unwrap(); for inp in m.sig.inputs.iter() { match inp { @@ -408,11 +405,11 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty ident.mutability.is_some() || ident.subpat.is_some() { unimplemented!(); } - write!(w, ", {}{}: ", if types.skip_arg(&*arg.ty, Some(&gen_types)) { "_" } else { "" }, ident.ident).unwrap(); + write!(w, ", {}{}: ", if types.skip_arg(&*arg.ty, Some(&meth_gen_types)) { "_" } else { "" }, ident.ident).unwrap(); } _ => unimplemented!(), } - types.write_rust_type(w, Some(&gen_types), &*arg.ty); + types.write_rust_type(w, Some(&meth_gen_types), &*arg.ty); } } } @@ -420,7 +417,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty match &m.sig.output { syn::ReturnType::Type(_, rtype) => { write!(w, " -> ").unwrap(); - types.write_rust_type(w, Some(&gen_types), &*rtype) + types.write_rust_type(w, Some(&meth_gen_types), &*rtype) }, _ => {}, } @@ -437,20 +434,18 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty writeln!(w, "if let Some(f) = self{}.set_{} {{", $impl_accessor, m.sig.ident).unwrap(); writeln!(w, "\t\t\t(f)(&self{});", $impl_accessor).unwrap(); write!(w, "\t\t}}\n\t\t").unwrap(); - types.write_from_c_conversion_to_ref_prefix(w, &*r.elem, Some(&gen_types)); + types.write_from_c_conversion_to_ref_prefix(w, &*r.elem, Some(&meth_gen_types)); write!(w, "self{}.{}", $impl_accessor, m.sig.ident).unwrap(); - types.write_from_c_conversion_to_ref_suffix(w, &*r.elem, Some(&gen_types)); + types.write_from_c_conversion_to_ref_suffix(w, &*r.elem, Some(&meth_gen_types)); writeln!(w, "\n\t}}").unwrap(); - gen_types.pop_ctx(); continue; } } - write_method_var_decl_body(w, &m.sig, "\t", types, Some(&gen_types), true); + write_method_var_decl_body(w, &m.sig, "\t", types, Some(&meth_gen_types), true); write!(w, "(self{}.{})(", $impl_accessor, m.sig.ident).unwrap(); - write_method_call_params(w, &m.sig, "\t", types, Some(&gen_types), "", true); + write_method_call_params(w, &m.sig, "\t", types, Some(&meth_gen_types), "", true); writeln!(w, "\n\t}}").unwrap(); - gen_types.pop_ctx(); }, &syn::TraitItem::Type(ref t) => { if t.default.is_some() || t.generics.lt_token.is_some() { unimplemented!(); } @@ -866,11 +861,11 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ writeln!(w, "#[must_use]").unwrap(); } write!(w, "extern \"C\" fn {}_{}_{}(", ident, $trait.ident, $m.sig.ident).unwrap(); - gen_types.push_ctx(); - assert!(gen_types.learn_generics(&$m.sig.generics, types)); - write_method_params(w, &$m.sig, "c_void", types, Some(&gen_types), true, true); + let mut meth_gen_types = gen_types.push_ctx(); + assert!(meth_gen_types.learn_generics(&$m.sig.generics, types)); + write_method_params(w, &$m.sig, "c_void", types, Some(&meth_gen_types), true, true); write!(w, " {{\n\t").unwrap(); - write_method_var_decl_body(w, &$m.sig, "", types, Some(&gen_types), false); + write_method_var_decl_body(w, &$m.sig, "", types, Some(&meth_gen_types), false); let mut takes_self = false; for inp in $m.sig.inputs.iter() { if let syn::FnArg::Receiver(_) = inp { @@ -900,8 +895,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ }, _ => {}, } - write_method_call_params(w, &$m.sig, "", types, Some(&gen_types), &real_type, false); - gen_types.pop_ctx(); + write_method_call_params(w, &$m.sig, "", types, Some(&meth_gen_types), &real_type, false); write!(w, "\n}}\n").unwrap(); if let syn::ReturnType::Type(_, rtype) = &$m.sig.output { if let syn::Type::Reference(r) = &**rtype { @@ -910,7 +904,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ writeln!(w, "\t// This is a bit race-y in the general case, but for our specific use-cases today, we're safe").unwrap(); writeln!(w, "\t// Specifically, we must ensure that the first time we're called it can never be in parallel").unwrap(); write!(w, "\tif ").unwrap(); - types.write_empty_rust_val_check(Some(&gen_types), w, &*r.elem, &format!("trait_self_arg.{}", $m.sig.ident)); + types.write_empty_rust_val_check(Some(&meth_gen_types), w, &*r.elem, &format!("trait_self_arg.{}", $m.sig.ident)); writeln!(w, " {{").unwrap(); writeln!(w, "\t\tunsafe {{ &mut *(trait_self_arg as *const {} as *mut {}) }}.{} = {}_{}_{}(trait_self_arg.this_arg);", $trait.ident, $trait.ident, $m.sig.ident, ident, $trait.ident, $m.sig.ident).unwrap(); writeln!(w, "\t}}").unwrap(); @@ -1003,11 +997,11 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ DeclType::StructImported => format!("{}", ident), _ => unimplemented!(), }; - gen_types.push_ctx(); - assert!(gen_types.learn_generics(&m.sig.generics, types)); - write_method_params(w, &m.sig, &ret_type, types, Some(&gen_types), false, true); + let mut meth_gen_types = gen_types.push_ctx(); + assert!(meth_gen_types.learn_generics(&m.sig.generics, types)); + write_method_params(w, &m.sig, &ret_type, types, Some(&meth_gen_types), false, true); write!(w, " {{\n\t").unwrap(); - write_method_var_decl_body(w, &m.sig, "", types, Some(&gen_types), false); + write_method_var_decl_body(w, &m.sig, "", types, Some(&meth_gen_types), false); let mut takes_self = false; let mut takes_mut_self = false; for inp in m.sig.inputs.iter() { @@ -1023,8 +1017,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ } else { write!(w, "{}::{}::{}(", types.orig_crate, resolved_path, m.sig.ident).unwrap(); } - write_method_call_params(w, &m.sig, "", types, Some(&gen_types), &ret_type, false); - gen_types.pop_ctx(); + write_method_call_params(w, &m.sig, "", types, Some(&meth_gen_types), &ret_type, false); writeln!(w, "\n}}\n").unwrap(); } }, diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs index e0ce8ac..92da872 100644 --- a/c-bindings-gen/src/types.rs +++ b/c-bindings-gen/src/types.rs @@ -160,23 +160,21 @@ pub fn is_enum_opaque(e: &syn::ItemEnum) -> bool { /// It maps both direct types as well as Deref, mapping them via the provided /// TypeResolver's resolve_path function (ie traits map to the concrete jump table, structs to the /// concrete C container struct, etc). -pub struct GenericTypes<'a> { - typed_generics: Vec)>>, +#[must_use] +pub struct GenericTypes<'a, 'b> { + parent: Option<&'b GenericTypes<'b, 'b>>, + typed_generics: HashMap<&'a syn::Ident, (String, Option<&'a syn::Path>)>, } -impl<'a> GenericTypes<'a> { +impl<'a, 'p: 'a> GenericTypes<'a, 'p> { pub fn new() -> Self { - Self { typed_generics: vec![HashMap::new()], } + Self { parent: None, typed_generics: HashMap::new(), } } /// push a new context onto the stack, allowing for a new set of generics to be learned which /// will override any lower contexts, but which will still fall back to resoltion via lower /// contexts. - pub fn push_ctx(&mut self) { - self.typed_generics.push(HashMap::new()); - } - /// pop the latest context off the stack. - pub fn pop_ctx(&mut self) { - self.typed_generics.pop(); + pub fn push_ctx<'c>(&'c self) -> GenericTypes<'a, 'c> { + GenericTypes { parent: Some(self), typed_generics: HashMap::new(), } } /// Learn the generics in generics in the current context, given a TypeResolver. @@ -202,7 +200,7 @@ impl<'a> GenericTypes<'a> { path = "crate::".to_string() + &path; Some(&trait_bound.path) } else { None }; - self.typed_generics.last_mut().unwrap().insert(&type_param.ident, (path, new_ident)); + self.typed_generics.insert(&type_param.ident, (path, new_ident)); } else { return false; } } } @@ -218,7 +216,7 @@ impl<'a> GenericTypes<'a> { if p.qself.is_some() { return false; } if p.path.leading_colon.is_some() { return false; } let mut p_iter = p.path.segments.iter(); - if let Some(gen) = self.typed_generics.last_mut().unwrap().get_mut(&p_iter.next().unwrap().ident) { + if let Some(gen) = self.typed_generics.get_mut(&p_iter.next().unwrap().ident) { if gen.0 != "std::ops::Deref" { return false; } if &format!("{}", p_iter.next().unwrap().ident) != "Target" { return false; } @@ -237,7 +235,7 @@ impl<'a> GenericTypes<'a> { } } } - for (_, (_, ident)) in self.typed_generics.last().unwrap().iter() { + for (_, (_, ident)) in self.typed_generics.iter() { if ident.is_none() { return false; } } true @@ -263,7 +261,7 @@ impl<'a> GenericTypes<'a> { path = "crate::".to_string() + &path; Some(&tr.path) } else { None }; - self.typed_generics.last_mut().unwrap().insert(&t.ident, (path, new_ident)); + self.typed_generics.insert(&t.ident, (path, new_ident)); } else { unimplemented!(); } }, _ => unimplemented!(), @@ -277,21 +275,21 @@ impl<'a> GenericTypes<'a> { /// Attempt to resolve an Ident as a generic parameter and return the full path. pub fn maybe_resolve_ident<'b>(&'b self, ident: &syn::Ident) -> Option<&'b String> { - for gen in self.typed_generics.iter().rev() { - if let Some(res) = gen.get(ident).map(|(a, _)| a) { - return Some(res); - } + if let Some(res) = self.typed_generics.get(ident).map(|(a, _)| a) { + return Some(res); + } + if let Some(parent) = self.parent { + parent.maybe_resolve_ident(ident) + } else { + None } - None } /// Attempt to resolve a Path as a generic parameter and return the full path. as both a string /// and syn::Path. pub fn maybe_resolve_path<'b>(&'b self, path: &syn::Path) -> Option<(&'b String, &'a syn::Path)> { if let Some(ident) = path.get_ident() { - for gen in self.typed_generics.iter().rev() { - if let Some(res) = gen.get(ident).map(|(a, b)| (a, b.unwrap())) { - return Some(res); - } + if let Some(res) = self.typed_generics.get(ident).map(|(a, b)| (a, b.unwrap())) { + return Some(res); } } else { // Associated types are usually specified as "Self::Generic", so we check for that @@ -299,14 +297,16 @@ impl<'a> GenericTypes<'a> { let mut it = path.segments.iter(); if path.segments.len() == 2 && format!("{}", it.next().unwrap().ident) == "Self" { let ident = &it.next().unwrap().ident; - for gen in self.typed_generics.iter().rev() { - if let Some(res) = gen.get(ident).map(|(a, b)| (a, b.unwrap())) { - return Some(res); - } + if let Some(res) = self.typed_generics.get(ident).map(|(a, b)| (a, b.unwrap())) { + return Some(res); } } } - None + if let Some(parent) = self.parent { + parent.maybe_resolve_path(path) + } else { + None + } } }