X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Ftypes.rs;h=f8ecc7ca843d275e53a33b2e30ebf3873f629151;hb=5d83aff2dd572685d7f76406422167e12c836b0e;hp=835e6c02323a92eff2d2df0f070b04b21e7ebadc;hpb=1f9a169c7e376baad24015ecf775e1adcf9d5967;p=ldk-c-bindings

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index 835e6c0..f8ecc7c 100644
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -164,19 +164,20 @@ pub fn is_enum_opaque(e: &syn::ItemEnum) -> bool {
 /// concrete C container struct, etc).
 #[must_use]
 pub struct GenericTypes<'a, 'b> {
+	self_ty: Option<(String, &'a syn::Path)>,
 	parent: Option<&'b GenericTypes<'b, 'b>>,
 	typed_generics: HashMap<&'a syn::Ident, (String, Option<&'a syn::Path>)>,
 }
 impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
-	pub fn new() -> Self {
-		Self { parent: None, typed_generics: HashMap::new(), }
+	pub fn new(self_ty: Option<(String, &'a syn::Path)>) -> Self {
+		Self { self_ty, 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<'c>(&'c self) -> GenericTypes<'a, 'c> {
-		GenericTypes { parent: Some(self), typed_generics: HashMap::new(), }
+		GenericTypes { self_ty: None, parent: Some(self), typed_generics: HashMap::new(), }
 	}
 
 	/// Learn the generics in generics in the current context, given a TypeResolver.
@@ -281,6 +282,11 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
 
 	/// 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> {
+		if let Some(ty) = &self.self_ty {
+			if format!("{}", ident) == "Self" {
+				return Some(&ty.0);
+			}
+		}
 		if let Some(res) = self.typed_generics.get(ident).map(|(a, _)| a) {
 			return Some(res);
 		}
@@ -294,6 +300,11 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
 	/// 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() {
+			if let Some(ty) = &self.self_ty {
+				if format!("{}", ident) == "Self" {
+					return Some((&ty.0, ty.1));
+				}
+			}
 			if let Some(res) = self.typed_generics.get(ident).map(|(a, b)| (a, b.unwrap())) {
 				return Some(res);
 			}
@@ -2340,6 +2351,13 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 		}
 		self.write_c_mangled_container_path_intern(w, args, generics, ident, is_ref, is_mut, ptr_for_ref, false)
 	}
+	pub fn get_c_mangled_container_type(&self, args: Vec<&syn::Type>, generics: Option<&GenericTypes>, template_name: &str) -> Option<String> {
+		let mut out = Vec::new();
+		if !self.write_c_mangled_container_path(&mut out, args, generics, template_name, false, false, false) {
+			return None;
+		}
+		Some(String::from_utf8(out).unwrap())
+	}
 
 	// **********************************
 	// *** C Type Equivalent Printing ***