Make GenericTypes stack pushes RAII, giving borrowck knowledge of diff ImportResolver...

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index 44e74b9ebdc0676372f911361c718648688509c1..a1c5a746edd2527118cca86b5fdb03262ea13235 100644 (file)
--- 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: std::io::Write>(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: std::io::Write>(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: std::io::Write>(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: std::io::Write>(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: std::io::Write>(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 e0ce8ac449e4cf6f0e6addc59ebb650f8c7da152..92da8727929bd1f0ef43b245fc2895b05bc95aa0 100644 (file)
--- 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<Target = X>, 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<HashMap<&'a syn::Ident, (String, Option<&'a syn::Path>)>>,
+#[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
+               }
        }
 }