X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-c-bindings;a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fmain.rs;h=ce69294928af16714f3e7b645d34cbc2faa9f510;hp=f0c5db39982a7101cf82a459c07dbf8053d1f751;hb=ed6eb46f7b4e0d4c869ad08dffc600b4e93e2129;hpb=76087923a2131ecb054a0787b062443aa09ed0ae

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index f0c5db3..ce69294 100644
--- a/c-bindings-gen/src/main.rs
+++ b/c-bindings-gen/src/main.rs
@@ -25,12 +25,16 @@ use std::io::{Read, Write};
 use std::process;
 
 use proc_macro2::Span;
+use quote::format_ident;
+use syn::parse_quote;
 
 mod types;
 mod blocks;
 use types::*;
 use blocks::*;
 
+const DEFAULT_IMPORTS: &'static str = "\nuse std::str::FromStr;\nuse std::ffi::c_void;\nuse bitcoin::hashes::Hash;\nuse crate::c_types::*;\n";
+
 // *************************************
 // *** Manually-expanded conversions ***
 // *************************************
@@ -58,15 +62,13 @@ fn maybe_convert_trait_impl<W: std::io::Write>(w: &mut W, trait_path: &syn::Path
 		}
 
 		match &t as &str {
-			"util::ser::Writeable" => {
+			"lightning::util::ser::Writeable" => {
 				writeln!(w, "#[no_mangle]").unwrap();
 				writeln!(w, "/// Serialize the {} object into a byte array which can be read by {}_read", for_obj, for_obj).unwrap();
 				writeln!(w, "pub extern \"C\" fn {}_write(obj: &{}) -> crate::c_types::derived::CVec_u8Z {{", for_obj, full_obj_path).unwrap();
 
-				let ref_type = syn::Type::Reference(syn::TypeReference {
-					and_token: syn::Token!(&)(Span::call_site()), lifetime: None, mutability: None,
-					elem: Box::new(for_ty.clone()) });
-				assert!(!types.write_from_c_conversion_new_var(w, &syn::Ident::new("obj", Span::call_site()), &ref_type, Some(generics)));
+				let ref_type: syn::Type = syn::parse_quote!(&#for_ty);
+				assert!(!types.write_from_c_conversion_new_var(w, &format_ident!("obj"), &ref_type, Some(generics)));
 
 				write!(w, "\tcrate::c_types::serialize_obj(").unwrap();
 				types.write_from_c_conversion_prefix(w, &ref_type, Some(generics));
@@ -82,35 +84,16 @@ fn maybe_convert_trait_impl<W: std::io::Write>(w: &mut W, trait_path: &syn::Path
 					writeln!(w, "}}").unwrap();
 				}
 			},
-			"util::ser::Readable"|"util::ser::ReadableArgs" => {
+			"lightning::util::ser::Readable"|"lightning::util::ser::ReadableArgs" => {
 				// Create the Result<Object, DecodeError> syn::Type
-				let mut err_segs = syn::punctuated::Punctuated::new();
-				err_segs.push(syn::PathSegment { ident: syn::Ident::new("ln", Span::call_site()), arguments: syn::PathArguments::None });
-				err_segs.push(syn::PathSegment { ident: syn::Ident::new("msgs", Span::call_site()), arguments: syn::PathArguments::None });
-				err_segs.push(syn::PathSegment { ident: syn::Ident::new("DecodeError", Span::call_site()), arguments: syn::PathArguments::None });
-				let mut args = syn::punctuated::Punctuated::new();
-				args.push(syn::GenericArgument::Type(for_ty.clone()));
-				args.push(syn::GenericArgument::Type(syn::Type::Path(syn::TypePath {
-					qself: None, path: syn::Path {
-						leading_colon: Some(syn::Token![::](Span::call_site())), segments: err_segs,
-					}
-				})));
-				let mut res_segs = syn::punctuated::Punctuated::new();
-				res_segs.push(syn::PathSegment {
-					ident: syn::Ident::new("Result", Span::call_site()),
-					arguments: syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments {
-						colon2_token: None, lt_token: syn::Token![<](Span::call_site()), args, gt_token: syn::Token![>](Span::call_site()),
-					})
-				});
-				let res_ty = syn::Type::Path(syn::TypePath { qself: None, path: syn::Path {
-					leading_colon: None, segments: res_segs } });
+				let res_ty: syn::Type = parse_quote!(Result<#for_ty, ::ln::msgs::DecodeError>);
 
 				writeln!(w, "#[no_mangle]").unwrap();
 				writeln!(w, "/// Read a {} from a byte array, created by {}_write", for_obj, for_obj).unwrap();
 				write!(w, "pub extern \"C\" fn {}_read(ser: crate::c_types::u8slice", for_obj).unwrap();
 
 				let mut arg_conv = Vec::new();
-				if t == "util::ser::ReadableArgs" {
+				if t == "lightning::util::ser::ReadableArgs" {
 					write!(w, ", arg: ").unwrap();
 					assert!(trait_path.leading_colon.is_none());
 					let args_seg = trait_path.segments.iter().last().unwrap();
@@ -120,7 +103,7 @@ fn maybe_convert_trait_impl<W: std::io::Write>(w: &mut W, trait_path: &syn::Path
 						if let syn::GenericArgument::Type(args_ty) = args.args.iter().next().unwrap() {
 							types.write_c_type(w, args_ty, Some(generics), false);
 
-							assert!(!types.write_from_c_conversion_new_var(&mut arg_conv, &syn::Ident::new("arg", Span::call_site()), &args_ty, Some(generics)));
+							assert!(!types.write_from_c_conversion_new_var(&mut arg_conv, &format_ident!("arg"), &args_ty, Some(generics)));
 
 							write!(&mut arg_conv, "\tlet arg_conv = ").unwrap();
 							types.write_from_c_conversion_prefix(&mut arg_conv, &args_ty, Some(generics));
@@ -133,7 +116,7 @@ fn maybe_convert_trait_impl<W: std::io::Write>(w: &mut W, trait_path: &syn::Path
 				types.write_c_type(w, &res_ty, Some(generics), false);
 				writeln!(w, " {{").unwrap();
 
-				if t == "util::ser::ReadableArgs" {
+				if t == "lightning::util::ser::ReadableArgs" {
 					w.write(&arg_conv).unwrap();
 					write!(w, ";\n\tlet res: ").unwrap();
 					// At least in one case we need type annotations here, so provide them.
@@ -143,7 +126,7 @@ fn maybe_convert_trait_impl<W: std::io::Write>(w: &mut W, trait_path: &syn::Path
 					writeln!(w, "\tlet res = crate::c_types::deserialize_obj(ser);").unwrap();
 				}
 				write!(w, "\t").unwrap();
-				if types.write_to_c_conversion_new_var(w, &syn::Ident::new("res", Span::call_site()), &res_ty, Some(generics), false) {
+				if types.write_to_c_conversion_new_var(w, &format_ident!("res"), &res_ty, Some(generics), false) {
 					write!(w, "\n\t").unwrap();
 				}
 				types.write_to_c_conversion_inline_prefix(w, &res_ty, Some(generics), false);
@@ -162,7 +145,7 @@ fn maybe_convert_trait_impl<W: std::io::Write>(w: &mut W, trait_path: &syn::Path
 /// single function (eg for serialization).
 fn convert_trait_impl_field(trait_path: &str) -> (&'static str, String, &'static str) {
 	match trait_path {
-		"util::ser::Writeable" => ("Serialize the object into a byte array", "write".to_owned(), "crate::c_types::derived::CVec_u8Z"),
+		"lightning::util::ser::Writeable" => ("Serialize the object into a byte array", "write".to_owned(), "crate::c_types::derived::CVec_u8Z"),
 		_ => unimplemented!(),
 	}
 }
@@ -171,7 +154,7 @@ fn convert_trait_impl_field(trait_path: &str) -> (&'static str, String, &'static
 /// `for_obj` which implements the the trait at `trait_path`.
 fn write_trait_impl_field_assign<W: std::io::Write>(w: &mut W, trait_path: &str, for_obj: &syn::Ident) {
 	match trait_path {
-		"util::ser::Writeable" => {
+		"lightning::util::ser::Writeable" => {
 			writeln!(w, "\t\twrite: {}_write_void,", for_obj).unwrap();
 		},
 		_ => unimplemented!(),
@@ -182,8 +165,8 @@ fn write_trait_impl_field_assign<W: std::io::Write>(w: &mut W, trait_path: &str,
 fn do_write_impl_trait<W: std::io::Write>(w: &mut W, trait_path: &str, _trait_name: &syn::Ident, for_obj: &str) {
 eprintln!("{}", trait_path);
 	match trait_path {
-		"util::ser::Writeable" => {
-			writeln!(w, "impl lightning::{} for {} {{", trait_path, for_obj).unwrap();
+		"lightning::util::ser::Writeable" => {
+			writeln!(w, "impl {} for {} {{", trait_path, for_obj).unwrap();
 			writeln!(w, "\tfn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {{").unwrap();
 			writeln!(w, "\t\tlet vec = (self.write)(self.this_arg);").unwrap();
 			writeln!(w, "\t\tw.write_all(vec.as_slice())").unwrap();
@@ -197,7 +180,7 @@ eprintln!("{}", trait_path);
 // *** Per-Type Printing Logic ***
 // *******************************
 
-macro_rules! walk_supertraits { ($t: expr, $types: expr, ($( $pat: pat => $e: expr),*) ) => { {
+macro_rules! walk_supertraits { ($t: expr, $types: expr, ($( $($pat: pat)|* => $e: expr),*) ) => { {
 	if $t.colon_token.is_some() {
 		for st in $t.supertraits.iter() {
 			match st {
@@ -211,14 +194,14 @@ macro_rules! walk_supertraits { ($t: expr, $types: expr, ($( $pat: pat => $e: ex
 					if let Some(types) = types_opt {
 						if let Some(path) = types.maybe_resolve_path(&supertrait.path, None) {
 							match (&path as &str, &supertrait.path.segments.iter().last().unwrap().ident) {
-								$( $pat => $e, )*
+								$( $($pat)|* => $e, )*
 							}
 							continue;
 						}
 					}
 					if let Some(ident) = supertrait.path.get_ident() {
 						match (&format!("{}", ident) as &str, &ident) {
-							$( $pat => $e, )*
+							$( $($pat)|* => $e, )*
 						}
 					} else if types_opt.is_some() {
 						panic!("Supertrait unresolvable and not single-ident");
@@ -238,13 +221,15 @@ macro_rules! walk_supertraits { ($t: expr, $types: expr, ($( $pat: pat => $e: ex
 /// a concrete Deref to the Rust trait.
 fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, types: &mut TypeResolver<'b, 'a>, extra_headers: &mut File, cpp_headers: &mut File) {
 	let trait_name = format!("{}", t.ident);
+	let implementable;
 	match export_status(&t.attrs) {
-		ExportStatus::Export => {},
+		ExportStatus::Export => { implementable = true; }
+		ExportStatus::NotImplementable => { implementable = false; },
 		ExportStatus::NoExport|ExportStatus::TestOnly => return,
 	}
 	writeln_docs(w, &t.attrs, "");
 
-	let mut gen_types = GenericTypes::new();
+	let mut gen_types = GenericTypes::new(None);
 	assert!(gen_types.learn_generics(&t.generics, types));
 	gen_types.learn_associated_types(&t, types);
 
@@ -252,7 +237,9 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 	writeln!(w, "\t/// An opaque pointer which is passed to your function implementations as an argument.").unwrap();
 	writeln!(w, "\t/// This has no meaning in the LDK, and can be NULL or any other value.").unwrap();
 	writeln!(w, "\tpub this_arg: *mut c_void,").unwrap();
-	let mut generated_fields = Vec::new(); // Every field's (name, is_clonable) except this_arg, used in Clone generation
+	// We store every field's (name, Option<clone_fn>, docs) except this_arg, used in Clone generation
+	// docs is only set if its a function which should be callable on the object itself in C++
+	let mut generated_fields = Vec::new();
 	for item in t.items.iter() {
 		match item {
 			&syn::TraitItem::Method(ref m) => {
@@ -264,13 +251,14 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 					},
 					ExportStatus::Export => {},
 					ExportStatus::TestOnly => continue,
+					ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
 				}
 				if m.default.is_some() { unimplemented!(); }
 
 				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");
+				writeln_fn_docs(w, &m.attrs, "\t", types, Some(&meth_gen_types), m.sig.inputs.iter(), &m.sig.output);
 
 				if let syn::ReturnType::Type(_, rtype) = &m.sig.output {
 					if let syn::Type::Reference(r) = &**rtype {
@@ -285,19 +273,18 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 						// happen) as well as provide an Option<>al function pointer which is
 						// 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));
+						generated_fields.push((format!("{}", m.sig.ident), None, None));
 						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();
 						writeln!(w, "\t/// This function pointer may be NULL if {} is filled in when this object is created and never needs updating.", m.sig.ident).unwrap();
 						writeln!(w, "\tpub set_{}: Option<extern \"C\" fn(&{})>,", m.sig.ident, trait_name).unwrap();
-						generated_fields.push((format!("set_{}", m.sig.ident), true));
+						generated_fields.push((format!("set_{}", m.sig.ident), None, None));
 						// Note that cbindgen will now generate
-						// typedef struct Thing {..., set_thing: (const Thing*), ...} Thing;
+						// typedef struct Thing {..., set_thing: (const struct Thing*), ...} Thing;
 						// 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();
 						continue;
 					}
 					// Sadly, this currently doesn't do what we want, but it should be easy to get
@@ -305,8 +292,12 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 					writeln!(w, "\t#[must_use]").unwrap();
 				}
 
+				let mut cpp_docs = Vec::new();
+				writeln_fn_docs(&mut cpp_docs, &m.attrs, "\t * ", types, Some(&meth_gen_types), m.sig.inputs.iter(), &m.sig.output);
+				let docs_string = "\t/**\n".to_owned() + &String::from_utf8(cpp_docs).unwrap().replace("///", "") + "\t */\n";
+
 				write!(w, "\tpub {}: extern \"C\" fn (", m.sig.ident).unwrap();
-				generated_fields.push((format!("{}", m.sig.ident), true));
+				generated_fields.push((format!("{}", m.sig.ident), None, Some(docs_string)));
 				write_method_params(w, &m.sig, "c_void", types, Some(&meth_gen_types), true, false);
 				writeln!(w, ",").unwrap();
 			},
@@ -315,56 +306,53 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 		}
 	}
 	// Add functions which may be required for supertrait implementations.
-	let mut requires_clone = false;
-	walk_supertraits!(t, Some(&types), (
-		("Clone", _) => requires_clone = true,
-		(_, _) => {}
-	) );
 	walk_supertraits!(t, Some(&types), (
 		("Clone", _) => {
-			writeln!(w, "\t/// Creates a copy of the object pointed to by this_arg, for a copy of this {}.", trait_name).unwrap();
-			writeln!(w, "\t/// Note that the ultimate copy of the {} will have all function pointers the same as the original.", trait_name).unwrap();
-			writeln!(w, "\t/// May be NULL if no action needs to be taken, the this_arg pointer will be copied into the new {}.", trait_name).unwrap();
-			writeln!(w, "\tpub clone: Option<extern \"C\" fn (this_arg: *const c_void) -> *mut c_void>,").unwrap();
-			generated_fields.push(("clone".to_owned(), true));
+			writeln!(w, "\t/// Called, if set, after this {} has been cloned into a duplicate object.", trait_name).unwrap();
+			writeln!(w, "\t/// The new {} is provided, and should be mutated as needed to perform a", trait_name).unwrap();
+			writeln!(w, "\t/// deep copy of the object pointed to by this_arg or avoid any double-freeing.").unwrap();
+			writeln!(w, "\tpub cloned: Option<extern \"C\" fn (new_{}: &mut {})>,", trait_name, trait_name).unwrap();
+			generated_fields.push(("cloned".to_owned(), None, None));
 		},
-		("std::cmp::Eq", _) => {
-			writeln!(w, "\t/// Checks if two objects are equal given this object's this_arg pointer and another object.").unwrap();
+		("std::cmp::Eq", _)|("core::cmp::Eq", _) => {
+			let eq_docs = "Checks if two objects are equal given this object's this_arg pointer and another object.";
+			writeln!(w, "\t/// {}", eq_docs).unwrap();
 			writeln!(w, "\tpub eq: extern \"C\" fn (this_arg: *const c_void, other_arg: &{}) -> bool,", trait_name).unwrap();
-			writeln!(extra_headers, "typedef struct LDK{} LDK{};", trait_name, trait_name).unwrap();
-			generated_fields.push(("eq".to_owned(), true));
+			generated_fields.push(("eq".to_owned(), None, Some(format!("\t/** {} */\n", eq_docs))));
 		},
-		("std::hash::Hash", _) => {
-			writeln!(w, "\t/// Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.").unwrap();
-			writeln!(w, "\t/// This is used, for example, for inclusion of this object in a hash map.").unwrap();
+		("std::hash::Hash", _)|("core::hash::Hash", _) => {
+			let hash_docs_a = "Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.";
+			let hash_docs_b = "This is used, for example, for inclusion of this object in a hash map.";
+			writeln!(w, "\t/// {}", hash_docs_a).unwrap();
+			writeln!(w, "\t/// {}", hash_docs_b).unwrap();
 			writeln!(w, "\tpub hash: extern \"C\" fn (this_arg: *const c_void) -> u64,").unwrap();
-			generated_fields.push(("hash".to_owned(), true));
+			generated_fields.push(("hash".to_owned(), None,
+				Some(format!("\t/**\n\t * {}\n\t * {}\n\t */\n", hash_docs_a, hash_docs_b))));
 		},
 		("Send", _) => {}, ("Sync", _) => {},
 		(s, i) => {
+			// TODO: Both of the below should expose supertrait methods in C++, but doing so is
+			// nontrivial.
 			generated_fields.push(if types.crate_types.traits.get(s).is_none() {
 				let (docs, name, ret) = convert_trait_impl_field(s);
 				writeln!(w, "\t/// {}", docs).unwrap();
 				writeln!(w, "\tpub {}: extern \"C\" fn (this_arg: *const c_void) -> {},", name, ret).unwrap();
-				(name, true) // Assume clonable
+				(name, None, None) // Assume clonable
 			} else {
 				// For in-crate supertraits, just store a C-mapped copy of the supertrait as a member.
 				writeln!(w, "\t/// Implementation of {} for this object.", i).unwrap();
-				writeln!(w, "\tpub {}: crate::{},", i, s).unwrap();
 				let is_clonable = types.is_clonable(s);
-				if !is_clonable && requires_clone {
-					writeln!(w, "\t/// Creates a copy of the {}, for a copy of this {}.", i, trait_name).unwrap();
-					writeln!(w, "\t/// Because {} doesn't natively support copying itself, you have to provide a full copy implementation here.", i).unwrap();
-					writeln!(w, "\tpub {}_clone: extern \"C\" fn (orig_{}: &{}) -> {},", i, i, i, i).unwrap();
-				}
-				(format!("{}", i), is_clonable)
+				writeln!(w, "\tpub {}: crate::{},", i, s).unwrap();
+				(format!("{}", i), if !is_clonable {
+					Some(format!("crate::{}_clone_fields", s))
+				} else { None }, None)
 			});
 		}
 	) );
 	writeln!(w, "\t/// Frees any resources associated with this object given its this_arg pointer.").unwrap();
 	writeln!(w, "\t/// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.").unwrap();
 	writeln!(w, "\tpub free: Option<extern \"C\" fn(this_arg: *mut c_void)>,").unwrap();
-	generated_fields.push(("free".to_owned(), true));
+	generated_fields.push(("free".to_owned(), None, None));
 	writeln!(w, "}}").unwrap();
 
 	macro_rules! impl_trait_for_c {
@@ -405,7 +393,7 @@ 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 $type_resolver.skip_arg(&*arg.ty, Some(&meth_gen_types)) { "_" } else { "" }, ident.ident).unwrap();
+											write!(w, ", mut {}{}: ", if $type_resolver.skip_arg(&*arg.ty, Some(&meth_gen_types)) { "_" } else { "" }, ident.ident).unwrap();
 										}
 										_ => unimplemented!(),
 									}
@@ -443,7 +431,9 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 						}
 						write_method_var_decl_body(w, &m.sig, "\t", $type_resolver, Some(&meth_gen_types), true);
 						write!(w, "(self{}.{})(", $impl_accessor, m.sig.ident).unwrap();
-						write_method_call_params(w, &m.sig, "\t", $type_resolver, Some(&meth_gen_types), "", true);
+						let mut args = Vec::new();
+						write_method_call_params(&mut args, &m.sig, "\t", $type_resolver, Some(&meth_gen_types), "", true);
+						w.write_all(String::from_utf8(args).unwrap().replace("self", &format!("self{}", $impl_accessor)).as_bytes()).unwrap();
 
 						writeln!(w, "\n\t}}").unwrap();
 					},
@@ -464,35 +454,42 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 		}
 	}
 
+	writeln!(w, "unsafe impl Send for {} {{}}", trait_name).unwrap();
+	writeln!(w, "unsafe impl Sync for {} {{}}", trait_name).unwrap();
+
+	writeln!(w, "#[no_mangle]").unwrap();
+	writeln!(w, "pub(crate) extern \"C\" fn {}_clone_fields(orig: &{}) -> {} {{", trait_name, trait_name, trait_name).unwrap();
+	writeln!(w, "\t{} {{", trait_name).unwrap();
+	writeln!(w, "\t\tthis_arg: orig.this_arg,").unwrap();
+	for (field, clone_fn, _) in generated_fields.iter() {
+		if let Some(f) = clone_fn {
+			// If the field isn't clonable, blindly assume its a trait and hope for the best.
+			writeln!(w, "\t\t{}: {}(&orig.{}),", field, f, field).unwrap();
+		} else {
+			writeln!(w, "\t\t{}: Clone::clone(&orig.{}),", field, field).unwrap();
+		}
+	}
+	writeln!(w, "\t}}\n}}").unwrap();
 
 	// Implement supertraits for the C-mapped struct.
 	walk_supertraits!(t, Some(&types), (
-		("Send", _) => writeln!(w, "unsafe impl Send for {} {{}}", trait_name).unwrap(),
-		("Sync", _) => writeln!(w, "unsafe impl Sync for {} {{}}", trait_name).unwrap(),
-		("std::cmp::Eq", _) => {
+		("std::cmp::Eq", _)|("core::cmp::Eq", _) => {
 			writeln!(w, "impl std::cmp::Eq for {} {{}}", trait_name).unwrap();
 			writeln!(w, "impl std::cmp::PartialEq for {} {{", trait_name).unwrap();
 			writeln!(w, "\tfn eq(&self, o: &Self) -> bool {{ (self.eq)(self.this_arg, o) }}\n}}").unwrap();
 		},
-		("std::hash::Hash", _) => {
+		("std::hash::Hash", _)|("core::hash::Hash", _) => {
 			writeln!(w, "impl std::hash::Hash for {} {{", trait_name).unwrap();
 			writeln!(w, "\tfn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {{ hasher.write_u64((self.hash)(self.this_arg)) }}\n}}").unwrap();
 		},
+		("Send", _) => {}, ("Sync", _) => {},
 		("Clone", _) => {
 			writeln!(w, "#[no_mangle]").unwrap();
 			writeln!(w, "/// Creates a copy of a {}", trait_name).unwrap();
 			writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{", trait_name, trait_name, trait_name).unwrap();
-			writeln!(w, "\t{} {{", trait_name).unwrap();
-			writeln!(w, "\t\tthis_arg: if let Some(f) = orig.clone {{ (f)(orig.this_arg) }} else {{ orig.this_arg }},").unwrap();
-			for (field, clonable) in generated_fields.iter() {
-				if *clonable {
-					writeln!(w, "\t\t{}: Clone::clone(&orig.{}),", field, field).unwrap();
-				} else {
-					writeln!(w, "\t\t{}: (orig.{}_clone)(&orig.{}),", field, field, field).unwrap();
-					writeln!(w, "\t\t{}_clone: orig.{}_clone,", field, field).unwrap();
-				}
-			}
-			writeln!(w, "\t}}\n}}").unwrap();
+			writeln!(w, "\tlet mut res = {}_clone_fields(orig);", trait_name).unwrap();
+			writeln!(w, "\tif let Some(f) = orig.cloned {{ (f)(&mut res) }};").unwrap();
+			writeln!(w, "\tres\n}}").unwrap();
 			writeln!(w, "impl Clone for {} {{", trait_name).unwrap();
 			writeln!(w, "\tfn clone(&self) -> Self {{").unwrap();
 			writeln!(w, "\t\t{}_clone(self)", trait_name).unwrap();
@@ -503,16 +500,12 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 				let mut module_iter = s.rsplitn(2, "::");
 				module_iter.next().unwrap();
 				let supertrait_module = module_iter.next().unwrap();
-				let imports = ImportResolver::new(supertrait_module, &types.crate_types.lib_ast.modules.get(supertrait_module).unwrap().items);
-				let resolver = TypeResolver::new("lightning", &supertrait_module, imports, types.crate_types); // TODO: Drop hard-coded crate name here
-				writeln!(w, "impl lightning::{} for {} {{", s, trait_name).unwrap(); // TODO: Drop hard-coded crate name here
+				let imports = ImportResolver::new(supertrait_module.splitn(2, "::").next().unwrap(), &types.crate_types.lib_ast.dependencies,
+					supertrait_module, &types.crate_types.lib_ast.modules.get(supertrait_module).unwrap().items);
+				let resolver = TypeResolver::new(&supertrait_module, imports, types.crate_types);
+				writeln!(w, "impl {} for {} {{", s, trait_name).unwrap();
 				impl_trait_for_c!(supertrait, format!(".{}", i), &resolver);
 				writeln!(w, "}}").unwrap();
-				walk_supertraits!(supertrait, Some(&types), (
-					("Send", _) => writeln!(w, "unsafe impl Send for {} {{}}", trait_name).unwrap(),
-					("Sync", _) => writeln!(w, "unsafe impl Sync for {} {{}}", trait_name).unwrap(),
-					_ => unimplemented!()
-				) );
 			} else {
 				do_write_impl_trait(w, s, i, &trait_name);
 			}
@@ -520,16 +513,18 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 	) );
 
 	// Finally, implement the original Rust trait for the newly created mapped trait.
-	writeln!(w, "\nuse {}::{}::{} as rust{};", types.orig_crate, types.module_path, t.ident, trait_name).unwrap();
-	write!(w, "impl rust{}", t.ident).unwrap();
-	maybe_write_generics(w, &t.generics, types, false);
-	writeln!(w, " for {} {{", trait_name).unwrap();
-	impl_trait_for_c!(t, "", types);
-	writeln!(w, "}}\n").unwrap();
-	writeln!(w, "// We're essentially a pointer already, or at least a set of pointers, so allow us to be used").unwrap();
-	writeln!(w, "// directly as a Deref trait in higher-level structs:").unwrap();
-	writeln!(w, "impl std::ops::Deref for {} {{\n\ttype Target = Self;", trait_name).unwrap();
-	writeln!(w, "\tfn deref(&self) -> &Self {{\n\t\tself\n\t}}\n}}").unwrap();
+	writeln!(w, "\nuse {}::{} as rust{};", types.module_path, t.ident, trait_name).unwrap();
+	if implementable {
+		write!(w, "impl rust{}", t.ident).unwrap();
+		maybe_write_generics(w, &t.generics, types, false);
+		writeln!(w, " for {} {{", trait_name).unwrap();
+		impl_trait_for_c!(t, "", types);
+		writeln!(w, "}}\n").unwrap();
+		writeln!(w, "// We're essentially a pointer already, or at least a set of pointers, so allow us to be used").unwrap();
+		writeln!(w, "// directly as a Deref trait in higher-level structs:").unwrap();
+		writeln!(w, "impl std::ops::Deref for {} {{\n\ttype Target = Self;", trait_name).unwrap();
+		writeln!(w, "\tfn deref(&self) -> &Self {{\n\t\tself\n\t}}\n}}").unwrap();
+	}
 
 	writeln!(w, "/// Calls the free function if one is set").unwrap();
 	writeln!(w, "#[no_mangle]\npub extern \"C\" fn {}_free(this_ptr: {}) {{ }}", trait_name, trait_name).unwrap();
@@ -539,7 +534,8 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 	writeln!(w, "\t\t\tf(self.this_arg);").unwrap();
 	writeln!(w, "\t\t}}\n\t}}\n}}").unwrap();
 
-	write_cpp_wrapper(cpp_headers, &trait_name, true);
+	write_cpp_wrapper(cpp_headers, &trait_name, true, Some(generated_fields.drain(..)
+		.filter_map(|(name, _, docs)| if let Some(docs) = docs { Some((name, docs)) } else { None }).collect()));
 }
 
 /// Write out a simple "opaque" type (eg structs) which contain a pointer to the native Rust type
@@ -550,7 +546,7 @@ fn writeln_opaque<W: std::io::Write>(w: &mut W, ident: &syn::Ident, struct_name:
 	// If we directly read the original type by its original name, cbindgen hits
 	// https://github.com/eqrion/cbindgen/issues/286 Thus, instead, we import it as a temporary
 	// name and then reference it by that name, which works around the issue.
-	write!(w, "\nuse {}::{}::{} as native{}Import;\ntype native{} = native{}Import", types.orig_crate, types.module_path, ident, ident, ident, ident).unwrap();
+	write!(w, "\nuse {}::{} as native{}Import;\ntype native{} = native{}Import", types.module_path, ident, ident, ident, ident).unwrap();
 	maybe_write_generics(w, &generics, &types, true);
 	writeln!(w, ";\n").unwrap();
 	writeln!(extra_headers, "struct native{}Opaque;\ntypedef struct native{}Opaque LDKnative{};", ident, ident, ident).unwrap();
@@ -567,7 +563,7 @@ fn writeln_opaque<W: std::io::Write>(w: &mut W, ident: &syn::Ident, struct_name:
 	writeln!(w, "}}\n").unwrap();
 	writeln!(w, "impl Drop for {} {{\n\tfn drop(&mut self) {{", struct_name).unwrap();
 	writeln!(w, "\t\tif self.is_owned && !<*mut native{}>::is_null(self.inner) {{", ident).unwrap();
-	writeln!(w, "\t\t\tlet _ = unsafe {{ Box::from_raw(self.inner) }};\n\t\t}}\n\t}}\n}}").unwrap();
+	writeln!(w, "\t\t\tlet _ = unsafe {{ Box::from_raw(ObjOps::untweak_ptr(self.inner)) }};\n\t\t}}\n\t}}\n}}").unwrap();
 	writeln!(w, "/// Frees any resources used by the {}, if is_owned is set and inner is non-NULL.", struct_name).unwrap();
 	writeln!(w, "#[no_mangle]\npub extern \"C\" fn {}_free(this_obj: {}) {{ }}", struct_name, struct_name).unwrap();
 	writeln!(w, "#[allow(unused)]").unwrap();
@@ -575,16 +571,22 @@ fn writeln_opaque<W: std::io::Write>(w: &mut W, ident: &syn::Ident, struct_name:
 	writeln!(w, "extern \"C\" fn {}_free_void(this_ptr: *mut c_void) {{", struct_name).unwrap();
 	writeln!(w, "\tunsafe {{ let _ = Box::from_raw(this_ptr as *mut native{}); }}\n}}", struct_name).unwrap();
 	writeln!(w, "#[allow(unused)]").unwrap();
-	writeln!(w, "/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy").unwrap();
 	writeln!(w, "impl {} {{", struct_name).unwrap();
+	writeln!(w, "\tpub(crate) fn get_native_ref(&self) -> &'static native{} {{", struct_name).unwrap();
+	writeln!(w, "\t\tunsafe {{ &*ObjOps::untweak_ptr(self.inner) }}").unwrap();
+	writeln!(w, "\t}}").unwrap();
+	writeln!(w, "\tpub(crate) fn get_native_mut_ref(&self) -> &'static mut native{} {{", struct_name).unwrap();
+	writeln!(w, "\t\tunsafe {{ &mut *ObjOps::untweak_ptr(self.inner) }}").unwrap();
+	writeln!(w, "\t}}").unwrap();
+	writeln!(w, "\t/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy").unwrap();
 	writeln!(w, "\tpub(crate) fn take_inner(mut self) -> *mut native{} {{", struct_name).unwrap();
 	writeln!(w, "\t\tassert!(self.is_owned);").unwrap();
-	writeln!(w, "\t\tlet ret = self.inner;").unwrap();
+	writeln!(w, "\t\tlet ret = ObjOps::untweak_ptr(self.inner);").unwrap();
 	writeln!(w, "\t\tself.inner = std::ptr::null_mut();").unwrap();
 	writeln!(w, "\t\tret").unwrap();
 	writeln!(w, "\t}}\n}}").unwrap();
 
-	write_cpp_wrapper(cpp_headers, &format!("{}", ident), true);
+	write_cpp_wrapper(cpp_headers, &format!("{}", ident), true, None);
 }
 
 /// Writes out all the relevant mappings for a Rust struct, deferring to writeln_opaque to generate
@@ -597,7 +599,10 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct,
 	writeln_opaque(w, &s.ident, struct_name, &s.generics, &s.attrs, types, extra_headers, cpp_headers);
 
 	if let syn::Fields::Named(fields) = &s.fields {
-		let mut gen_types = GenericTypes::new();
+		let mut self_path_segs = syn::punctuated::Punctuated::new();
+		self_path_segs.push(s.ident.clone().into());
+		let self_path = syn::Path { leading_colon: None, segments: self_path_segs};
+		let mut gen_types = GenericTypes::new(Some((types.resolve_path(&self_path, None), &self_path)));
 		assert!(gen_types.learn_generics(&s.generics, types));
 
 		let mut all_fields_settable = true;
@@ -610,6 +615,7 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct,
 						all_fields_settable = false;
 						continue
 					},
+					ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
 				}
 
 				if let Some(ident) = &field.ident {
@@ -617,30 +623,26 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct,
 						and_token: syn::Token!(&)(Span::call_site()), lifetime: None, mutability: None,
 						elem: Box::new(field.ty.clone()) });
 					if types.understood_c_type(&ref_type, Some(&gen_types)) {
-						writeln_docs(w, &field.attrs, "");
+						writeln_arg_docs(w, &field.attrs, "", types, Some(&gen_types), vec![].drain(..), Some(&ref_type));
 						write!(w, "#[no_mangle]\npub extern \"C\" fn {}_get_{}(this_ptr: &{}) -> ", struct_name, ident, struct_name).unwrap();
 						types.write_c_type(w, &ref_type, Some(&gen_types), true);
-						write!(w, " {{\n\tlet mut inner_val = &mut unsafe {{ &mut *this_ptr.inner }}.{};\n\t", ident).unwrap();
-						let local_var = types.write_to_c_conversion_new_var(w, &syn::Ident::new("inner_val", Span::call_site()), &ref_type, Some(&gen_types), true);
+						write!(w, " {{\n\tlet mut inner_val = &mut this_ptr.get_native_mut_ref().{};\n\t", ident).unwrap();
+						let local_var = types.write_to_c_conversion_new_var(w, &format_ident!("inner_val"), &ref_type, Some(&gen_types), true);
 						if local_var { write!(w, "\n\t").unwrap(); }
 						types.write_to_c_conversion_inline_prefix(w, &ref_type, Some(&gen_types), true);
-						if local_var {
-							write!(w, "inner_val").unwrap();
-						} else {
-							write!(w, "(*inner_val)").unwrap();
-						}
+						write!(w, "inner_val").unwrap();
 						types.write_to_c_conversion_inline_suffix(w, &ref_type, Some(&gen_types), true);
 						writeln!(w, "\n}}").unwrap();
 					}
 
 					if types.understood_c_type(&field.ty, Some(&gen_types)) {
-						writeln_docs(w, &field.attrs, "");
+						writeln_arg_docs(w, &field.attrs, "", types, Some(&gen_types), vec![("val".to_owned(), &field.ty)].drain(..), None);
 						write!(w, "#[no_mangle]\npub extern \"C\" fn {}_set_{}(this_ptr: &mut {}, mut val: ", struct_name, ident, struct_name).unwrap();
 						types.write_c_type(w, &field.ty, Some(&gen_types), false);
 						write!(w, ") {{\n\t").unwrap();
-						let local_var = types.write_from_c_conversion_new_var(w, &syn::Ident::new("val", Span::call_site()), &field.ty, Some(&gen_types));
+						let local_var = types.write_from_c_conversion_new_var(w, &format_ident!("val"), &field.ty, Some(&gen_types));
 						if local_var { write!(w, "\n\t").unwrap(); }
-						write!(w, "unsafe {{ &mut *this_ptr.inner }}.{} = ", ident).unwrap();
+						write!(w, "unsafe {{ &mut *ObjOps::untweak_ptr(this_ptr.inner) }}.{} = ", ident).unwrap();
 						types.write_from_c_conversion_prefix(w, &field.ty, Some(&gen_types));
 						write!(w, "val").unwrap();
 						types.write_from_c_conversion_suffix(w, &field.ty, Some(&gen_types));
@@ -661,12 +663,12 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct,
 			}
 			write!(w, ") -> {} {{\n\t", struct_name).unwrap();
 			for field in fields.named.iter() {
-				let field_name = format!("{}_arg", field.ident.as_ref().unwrap());
-				if types.write_from_c_conversion_new_var(w, &syn::Ident::new(&field_name, Span::call_site()), &field.ty, Some(&gen_types)) {
+				let field_ident = format_ident!("{}_arg", field.ident.as_ref().unwrap());
+				if types.write_from_c_conversion_new_var(w, &field_ident, &field.ty, Some(&gen_types)) {
 					write!(w, "\n\t").unwrap();
 				}
 			}
-			writeln!(w, "{} {{ inner: Box::into_raw(Box::new(native{} {{", struct_name, s.ident).unwrap();
+			writeln!(w, "{} {{ inner: ObjOps::heap_alloc(native{} {{", struct_name, s.ident).unwrap();
 			for field in fields.named.iter() {
 				write!(w, "\t\t{}: ", field.ident.as_ref().unwrap()).unwrap();
 				types.write_from_c_conversion_prefix(w, &field.ty, Some(&gen_types));
@@ -674,7 +676,7 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct,
 				types.write_from_c_conversion_suffix(w, &field.ty, Some(&gen_types));
 				writeln!(w, ",").unwrap();
 			}
-			writeln!(w, "\t}})), is_owned: true }}\n}}").unwrap();
+			writeln!(w, "\t}}), is_owned: true }}\n}}").unwrap();
 		}
 	}
 }
@@ -692,11 +694,12 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 	match export_status(&i.attrs) {
 		ExportStatus::Export => {},
 		ExportStatus::NoExport|ExportStatus::TestOnly => return,
+		ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
 	}
 
 	if let syn::Type::Tuple(_) = &*i.self_ty {
 		if types.understood_c_type(&*i.self_ty, None) {
-			let mut gen_types = GenericTypes::new();
+			let mut gen_types = GenericTypes::new(None);
 			if !gen_types.learn_generics(&i.generics, types) {
 				eprintln!("Not implementing anything for `impl (..)` due to not understood generics");
 				return;
@@ -723,7 +726,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 		if p.qself.is_some() { unimplemented!(); }
 		if let Some(ident) = single_ident_generic_path_to_ident(&p.path) {
 			if let Some(resolved_path) = types.maybe_resolve_non_ignored_ident(&ident) {
-				let mut gen_types = GenericTypes::new();
+				let mut gen_types = GenericTypes::new(Some((resolved_path.clone(), &p.path)));
 				if !gen_types.learn_generics(&i.generics, types) {
 					eprintln!("Not implementing anything for impl {} due to not understood generics", ident);
 					return;
@@ -756,7 +759,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 
 						let export = export_status(&trait_obj.attrs);
 						match export {
-							ExportStatus::Export => {},
+							ExportStatus::Export|ExportStatus::NotImplementable => {},
 							ExportStatus::NoExport|ExportStatus::TestOnly => return,
 						}
 
@@ -767,7 +770,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 						// type-conversion logic without actually knowing the concrete native type.
 						writeln!(w, "impl From<native{}> for crate::{} {{", ident, full_trait_path).unwrap();
 						writeln!(w, "\tfn from(obj: native{}) -> Self {{", ident).unwrap();
-						writeln!(w, "\t\tlet mut rust_obj = {} {{ inner: Box::into_raw(Box::new(obj)), is_owned: true }};", ident).unwrap();
+						writeln!(w, "\t\tlet mut rust_obj = {} {{ inner: ObjOps::heap_alloc(obj), is_owned: true }};", ident).unwrap();
 						writeln!(w, "\t\tlet mut ret = {}_as_{}(&rust_obj);", ident, trait_obj.ident).unwrap();
 						writeln!(w, "\t\t// We want to free rust_obj when ret gets drop()'d, not rust_obj, so wipe rust_obj's pointer and set ret's free() fn").unwrap();
 						writeln!(w, "\t\trust_obj.inner = std::ptr::null_mut();").unwrap();
@@ -778,7 +781,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 						writeln!(w, "/// This copies the `inner` pointer in this_arg and thus the returned {} must be freed before this_arg is", trait_obj.ident).unwrap();
 						write!(w, "#[no_mangle]\npub extern \"C\" fn {}_as_{}(this_arg: &{}) -> crate::{} {{\n", ident, trait_obj.ident, ident, full_trait_path).unwrap();
 						writeln!(w, "\tcrate::{} {{", full_trait_path).unwrap();
-						writeln!(w, "\t\tthis_arg: unsafe {{ (*this_arg).inner as *mut c_void }},").unwrap();
+						writeln!(w, "\t\tthis_arg: unsafe {{ ObjOps::untweak_ptr((*this_arg).inner) as *mut c_void }},").unwrap();
 						writeln!(w, "\t\tfree: None,").unwrap();
 
 						macro_rules! write_meth {
@@ -793,6 +796,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 										continue;
 									},
 									ExportStatus::TestOnly => continue,
+									ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
 								}
 
 								let mut printed = false;
@@ -818,20 +822,17 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 							}
 						}
 						let mut requires_clone = false;
-						walk_supertraits!(trait_obj, Some(&types), (
-							("Clone", _) => requires_clone = true,
-							(_, _) => {}
-						) );
 						walk_supertraits!(trait_obj, Some(&types), (
 							("Clone", _) => {
-								writeln!(w, "\t\tclone: Some({}_clone_void),", ident).unwrap();
+								requires_clone = true;
+								writeln!(w, "\t\tcloned: Some({}_{}_cloned),", trait_obj.ident, ident).unwrap();
 							},
 							("Sync", _) => {}, ("Send", _) => {},
 							("std::marker::Sync", _) => {}, ("std::marker::Send", _) => {},
 							(s, t) => {
 								if let Some(supertrait_obj) = types.crate_types.traits.get(s) {
 									writeln!(w, "\t\t{}: crate::{} {{", t, s).unwrap();
-									writeln!(w, "\t\t\tthis_arg: unsafe {{ (*this_arg).inner as *mut c_void }},").unwrap();
+									writeln!(w, "\t\t\tthis_arg: unsafe {{ ObjOps::untweak_ptr((*this_arg).inner) as *mut c_void }},").unwrap();
 									writeln!(w, "\t\t\tfree: None,").unwrap();
 									for item in supertrait_obj.items.iter() {
 										match item {
@@ -842,9 +843,6 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 										}
 									}
 									write!(w, "\t\t}},\n").unwrap();
-									if !types.is_clonable(s) && requires_clone {
-										writeln!(w, "\t\t{}_clone: {}_{}_clone,", t, ident, t).unwrap();
-									}
 								} else {
 									write_trait_impl_field_assign(w, s, ident);
 								}
@@ -860,6 +858,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 								match export_status(&trait_method.attrs) {
 									ExportStatus::Export => {},
 									ExportStatus::NoExport|ExportStatus::TestOnly => continue,
+									ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
 								}
 
 								if let syn::ReturnType::Type(_, _) = &$m.sig.output {
@@ -884,9 +883,9 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 									t_gen_args += "_"
 								}
 								if takes_self {
-									write!(w, "<native{} as {}::{}<{}>>::{}(unsafe {{ &mut *(this_arg as *mut native{}) }}, ", ident, types.orig_crate, $trait_path, t_gen_args, $m.sig.ident, ident).unwrap();
+									write!(w, "<native{} as {}<{}>>::{}(unsafe {{ &mut *(this_arg as *mut native{}) }}, ", ident, $trait_path, t_gen_args, $m.sig.ident, ident).unwrap();
 								} else {
-									write!(w, "<native{} as {}::{}<{}>>::{}(", ident, types.orig_crate, $trait_path, t_gen_args, $m.sig.ident).unwrap();
+									write!(w, "<native{} as {}<{}>>::{}(", ident, $trait_path, t_gen_args, $m.sig.ident).unwrap();
 								}
 
 								let mut real_type = "".to_string();
@@ -928,42 +927,82 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 								_ => unimplemented!(),
 							}
 						}
-						walk_supertraits!(trait_obj, Some(&types), (
-							(s, t) => {
-								if let Some(supertrait_obj) = types.crate_types.traits.get(s) {
-									if !types.is_clonable(s) && requires_clone {
-										writeln!(w, "extern \"C\" fn {}_{}_clone(orig: &crate::{}) -> crate::{} {{", ident, t, s, s).unwrap();
-										writeln!(w, "\tcrate::{} {{", s).unwrap();
-										writeln!(w, "\t\tthis_arg: orig.this_arg,").unwrap();
-										writeln!(w, "\t\tfree: None,").unwrap();
-										for item in supertrait_obj.items.iter() {
-											match item {
-												syn::TraitItem::Method(m) => {
-													write_meth!(m, supertrait_obj, "");
-												},
-												_ => {},
-											}
-										}
-										write!(w, "\t}}\n}}\n").unwrap();
+						if requires_clone {
+							writeln!(w, "extern \"C\" fn {}_{}_cloned(new_obj: &mut crate::{}) {{", trait_obj.ident, ident, full_trait_path).unwrap();
+							writeln!(w, "\tnew_obj.this_arg = {}_clone_void(new_obj.this_arg);", ident).unwrap();
+							writeln!(w, "\tnew_obj.free = Some({}_free_void);", ident).unwrap();
+							walk_supertraits!(trait_obj, Some(&types), (
+								(s, t) => {
+									if types.crate_types.traits.get(s).is_some() {
+										assert!(!types.is_clonable(s)); // We don't currently support cloning with a clonable supertrait
+										writeln!(w, "\tnew_obj.{}.this_arg = new_obj.this_arg;", t).unwrap();
+										writeln!(w, "\tnew_obj.{}.free = None;", t).unwrap();
 									}
 								}
-							}
-						) );
+							) );
+							writeln!(w, "}}").unwrap();
+						}
 						write!(w, "\n").unwrap();
 					} else if path_matches_nongeneric(&trait_path.1, &["From"]) {
 					} else if path_matches_nongeneric(&trait_path.1, &["Default"]) {
 						writeln!(w, "/// Creates a \"default\" {}. See struct and individual field documentaiton for details on which values are used.", ident).unwrap();
 						write!(w, "#[must_use]\n#[no_mangle]\npub extern \"C\" fn {}_default() -> {} {{\n", ident, ident).unwrap();
-						write!(w, "\t{} {{ inner: Box::into_raw(Box::new(Default::default())), is_owned: true }}\n", ident).unwrap();
+						write!(w, "\t{} {{ inner: ObjOps::heap_alloc(Default::default()), is_owned: true }}\n", ident).unwrap();
 						write!(w, "}}\n").unwrap();
 					} else if path_matches_nongeneric(&trait_path.1, &["core", "cmp", "PartialEq"]) {
+					} else if path_matches_nongeneric(&trait_path.1, &["core", "cmp", "Eq"]) {
+						writeln!(w, "/// Checks if two {}s contain equal inner contents.", ident).unwrap();
+						writeln!(w, "/// This ignores pointers and is_owned flags and looks at the values in fields.").unwrap();
+						if types.c_type_has_inner_from_path(&resolved_path) {
+							writeln!(w, "/// Two objects with NULL inner values will be considered \"equal\" here.").unwrap();
+						}
+						write!(w, "#[no_mangle]\npub extern \"C\" fn {}_eq(a: &{}, b: &{}) -> bool {{\n", ident, ident, ident).unwrap();
+						if types.c_type_has_inner_from_path(&resolved_path) {
+							write!(w, "\tif a.inner == b.inner {{ return true; }}\n").unwrap();
+							write!(w, "\tif a.inner.is_null() || b.inner.is_null() {{ return false; }}\n").unwrap();
+						}
+
+						let path = &p.path;
+						let ref_type: syn::Type = syn::parse_quote!(&#path);
+						assert!(!types.write_to_c_conversion_new_var(w, &format_ident!("a"), &*i.self_ty, Some(&gen_types), false), "We don't support new var conversions when comparing equality");
+
+						write!(w, "\tif ").unwrap();
+						types.write_from_c_conversion_prefix(w, &ref_type, Some(&gen_types));
+						write!(w, "a").unwrap();
+						types.write_from_c_conversion_suffix(w, &ref_type, Some(&gen_types));
+						write!(w, " == ").unwrap();
+						types.write_from_c_conversion_prefix(w, &ref_type, Some(&gen_types));
+						write!(w, "b").unwrap();
+						types.write_from_c_conversion_suffix(w, &ref_type, Some(&gen_types));
+
+						writeln!(w, " {{ true }} else {{ false }}\n}}").unwrap();
+					} else if path_matches_nongeneric(&trait_path.1, &["core", "hash", "Hash"]) {
+						writeln!(w, "/// Checks if two {}s contain equal inner contents.", ident).unwrap();
+						write!(w, "#[no_mangle]\npub extern \"C\" fn {}_hash(o: &{}) -> u64 {{\n", ident, ident).unwrap();
+						if types.c_type_has_inner_from_path(&resolved_path) {
+							write!(w, "\tif o.inner.is_null() {{ return 0; }}\n").unwrap();
+						}
+
+						let path = &p.path;
+						let ref_type: syn::Type = syn::parse_quote!(&#path);
+						assert!(!types.write_to_c_conversion_new_var(w, &format_ident!("a"), &*i.self_ty, Some(&gen_types), false), "We don't support new var conversions when comparing equality");
+
+						writeln!(w, "\t// Note that we'd love to use std::collections::hash_map::DefaultHasher but it's not in core").unwrap();
+						writeln!(w, "\t#[allow(deprecated)]").unwrap();
+						writeln!(w, "\tlet mut hasher = core::hash::SipHasher::new();").unwrap();
+						write!(w, "\tstd::hash::Hash::hash(").unwrap();
+						types.write_from_c_conversion_prefix(w, &ref_type, Some(&gen_types));
+						write!(w, "o").unwrap();
+						types.write_from_c_conversion_suffix(w, &ref_type, Some(&gen_types));
+						writeln!(w, ", &mut hasher);").unwrap();
+						writeln!(w, "\tstd::hash::Hasher::finish(&hasher)\n}}").unwrap();
 					} else if (path_matches_nongeneric(&trait_path.1, &["core", "clone", "Clone"]) || path_matches_nongeneric(&trait_path.1, &["Clone"])) &&
 							types.c_type_has_inner_from_path(&resolved_path) {
 						writeln!(w, "impl Clone for {} {{", ident).unwrap();
 						writeln!(w, "\tfn clone(&self) -> Self {{").unwrap();
 						writeln!(w, "\t\tSelf {{").unwrap();
 						writeln!(w, "\t\t\tinner: if <*mut native{}>::is_null(self.inner) {{ std::ptr::null_mut() }} else {{", ident).unwrap();
-						writeln!(w, "\t\t\t\tBox::into_raw(Box::new(unsafe {{ &*self.inner }}.clone())) }},").unwrap();
+						writeln!(w, "\t\t\t\tObjOps::heap_alloc(unsafe {{ &*ObjOps::untweak_ptr(self.inner) }}.clone()) }},").unwrap();
 						writeln!(w, "\t\t\tis_owned: true,").unwrap();
 						writeln!(w, "\t\t}}\n\t}}\n}}").unwrap();
 						writeln!(w, "#[allow(unused)]").unwrap();
@@ -975,6 +1014,39 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 						writeln!(w, "/// Creates a copy of the {}", ident).unwrap();
 						writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{", ident, ident, ident).unwrap();
 						writeln!(w, "\torig.clone()").unwrap();
+						writeln!(w, "}}").unwrap();
+					} else if path_matches_nongeneric(&trait_path.1, &["FromStr"]) {
+						if let Some(container) = types.get_c_mangled_container_type(
+								vec![&*i.self_ty, &syn::Type::Tuple(syn::TypeTuple { paren_token: Default::default(), elems: syn::punctuated::Punctuated::new() })],
+								Some(&gen_types), "Result") {
+							writeln!(w, "#[no_mangle]").unwrap();
+							writeln!(w, "/// Read a {} object from a string", ident).unwrap();
+							writeln!(w, "pub extern \"C\" fn {}_from_str(s: crate::c_types::Str) -> {} {{", ident, container).unwrap();
+							writeln!(w, "\tmatch {}::from_str(s.into_str()) {{", resolved_path).unwrap();
+							writeln!(w, "\t\tOk(r) => {{").unwrap();
+							let new_var = types.write_to_c_conversion_new_var(w, &format_ident!("r"), &*i.self_ty, Some(&gen_types), false);
+							write!(w, "\t\t\tcrate::c_types::CResultTempl::ok(\n\t\t\t\t").unwrap();
+							types.write_to_c_conversion_inline_prefix(w, &*i.self_ty, Some(&gen_types), false);
+							write!(w, "{}r", if new_var { "local_" } else { "" }).unwrap();
+							types.write_to_c_conversion_inline_suffix(w, &*i.self_ty, Some(&gen_types), false);
+							writeln!(w, "\n\t\t\t)\n\t\t}},").unwrap();
+							writeln!(w, "\t\tErr(e) => crate::c_types::CResultTempl::err(()),").unwrap();
+							writeln!(w, "\t}}.into()\n}}").unwrap();
+						}
+					} else if path_matches_nongeneric(&trait_path.1, &["Display"]) {
+						writeln!(w, "#[no_mangle]").unwrap();
+						writeln!(w, "/// Get the string representation of a {} object", ident).unwrap();
+						writeln!(w, "pub extern \"C\" fn {}_to_str(o: &crate::{}) -> Str {{", ident, resolved_path).unwrap();
+
+						let self_ty = &i.self_ty;
+						let ref_type: syn::Type = syn::parse_quote!(&#self_ty);
+						let new_var = types.write_from_c_conversion_new_var(w, &format_ident!("o"), &ref_type, Some(&gen_types));
+						write!(w, "\tformat!(\"{{}}\", ").unwrap();
+						types.write_from_c_conversion_prefix(w, &ref_type, Some(&gen_types));
+						write!(w, "{}o", if new_var { "local_" } else { "" }).unwrap();
+						types.write_from_c_conversion_suffix(w, &ref_type, Some(&gen_types));
+						writeln!(w, ").into()").unwrap();
+
 						writeln!(w, "}}").unwrap();
 					} else {
 						//XXX: implement for other things like ToString
@@ -990,9 +1062,12 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 									match export_status(&m.attrs) {
 										ExportStatus::Export => {},
 										ExportStatus::NoExport|ExportStatus::TestOnly => continue,
+										ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
 									}
+									let mut meth_gen_types = gen_types.push_ctx();
+									assert!(meth_gen_types.learn_generics(&m.sig.generics, types));
 									if m.defaultness.is_some() { unimplemented!(); }
-									writeln_docs(w, &m.attrs, "");
+									writeln_fn_docs(w, &m.attrs, "", types, Some(&meth_gen_types), m.sig.inputs.iter(), &m.sig.output);
 									if let syn::ReturnType::Type(_, _) = &m.sig.output {
 										writeln!(w, "#[must_use]").unwrap();
 									}
@@ -1002,25 +1077,35 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 										DeclType::StructImported => format!("{}", ident),
 										_ => unimplemented!(),
 									};
-									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(&meth_gen_types), false);
 									let mut takes_self = false;
 									let mut takes_mut_self = false;
+									let mut takes_owned_self = false;
 									for inp in m.sig.inputs.iter() {
 										if let syn::FnArg::Receiver(r) = inp {
 											takes_self = true;
 											if r.mutability.is_some() { takes_mut_self = true; }
+											if r.reference.is_none() { takes_owned_self = true; }
 										}
 									}
-									if takes_mut_self {
-										write!(w, "unsafe {{ &mut (*(this_arg.inner as *mut native{})) }}.{}(", ident, m.sig.ident).unwrap();
-									} else if takes_self {
-										write!(w, "unsafe {{ &*this_arg.inner }}.{}(", m.sig.ident).unwrap();
+									if !takes_mut_self && !takes_self {
+										write!(w, "{}::{}(", resolved_path, m.sig.ident).unwrap();
 									} else {
-										write!(w, "{}::{}::{}(", types.orig_crate, resolved_path, m.sig.ident).unwrap();
+										match &declared_type {
+											DeclType::MirroredEnum => write!(w, "this_arg.to_native().{}(", m.sig.ident).unwrap(),
+											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 {
+													write!(w, "unsafe {{ &mut (*ObjOps::untweak_ptr(this_arg.inner as *mut native{})) }}.{}(", ident, m.sig.ident).unwrap();
+												} else {
+													write!(w, "unsafe {{ &*ObjOps::untweak_ptr(this_arg.inner) }}.{}(", m.sig.ident).unwrap();
+												}
+											},
+											_ => unimplemented!(),
+										}
 									}
 									write_method_call_params(w, &m.sig, "", types, Some(&meth_gen_types), &ret_type, false);
 									writeln!(w, "\n}}\n").unwrap();
@@ -1091,6 +1176,23 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 	}
 }
 
+/// Replaces upper case charachters with underscore followed by lower case except the first
+/// charachter and repeated upper case characthers (which are only made lower case).
+fn camel_to_snake_case(camel: &str) -> String {
+	let mut res = "".to_string();
+	let mut last_upper = -1;
+	for (idx, c) in camel.chars().enumerate() {
+		if c.is_uppercase() {
+			if last_upper != idx as isize - 1 { res.push('_'); }
+			res.push(c.to_lowercase().next().unwrap());
+			last_upper = idx as isize;
+		} else {
+			res.push(c);
+		}
+	}
+	res
+}
+
 
 /// Print a mapping of an enum. If all of the enum's fields are C-mapped in some form (or the enum
 /// is unitary), we generate an equivalent enum with all types replaced with their C mapped
@@ -1100,6 +1202,7 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 	match export_status(&e.attrs) {
 		ExportStatus::Export => {},
 		ExportStatus::NoExport|ExportStatus::TestOnly => return,
+		ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
 	}
 
 	if is_enum_opaque(e) {
@@ -1109,50 +1212,88 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 	}
 	writeln_docs(w, &e.attrs, "");
 
-	if e.generics.lt_token.is_some() {
-		unimplemented!();
-	}
+	let mut gen_types = GenericTypes::new(None);
+	assert!(gen_types.learn_generics(&e.generics, types));
 
 	let mut needs_free = false;
+	let mut constr = Vec::new();
 
 	writeln!(w, "#[must_use]\n#[derive(Clone)]\n#[repr(C)]\npub enum {} {{", e.ident).unwrap();
 	for var in e.variants.iter() {
 		assert_eq!(export_status(&var.attrs), ExportStatus::Export); // We can't partially-export a mirrored enum
 		writeln_docs(w, &var.attrs, "\t");
 		write!(w, "\t{}", var.ident).unwrap();
+		writeln!(&mut constr, "#[no_mangle]\n/// Utility method to constructs a new {}-variant {}", var.ident, e.ident).unwrap();
+		let constr_name = camel_to_snake_case(&format!("{}", var.ident));
+		write!(&mut constr, "pub extern \"C\" fn {}_{}(", e.ident, constr_name).unwrap();
+		let mut empty_tuple_variant = false;
 		if let syn::Fields::Named(fields) = &var.fields {
 			needs_free = true;
 			writeln!(w, " {{").unwrap();
-			for field in fields.named.iter() {
+			for (idx, field) in fields.named.iter().enumerate() {
 				if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
-				writeln_docs(w, &field.attrs, "\t\t");
+				writeln_field_docs(w, &field.attrs, "\t\t", types, Some(&gen_types), &field.ty);
 				write!(w, "\t\t{}: ", field.ident.as_ref().unwrap()).unwrap();
-				types.write_c_type(w, &field.ty, None, false);
+				write!(&mut constr, "{}{}: ", if idx != 0 { ", " } else { "" }, field.ident.as_ref().unwrap()).unwrap();
+				types.write_c_type(w, &field.ty, Some(&gen_types), false);
+				types.write_c_type(&mut constr, &field.ty, Some(&gen_types), false);
 				writeln!(w, ",").unwrap();
 			}
 			write!(w, "\t}}").unwrap();
 		} else if let syn::Fields::Unnamed(fields) = &var.fields {
-			needs_free = true;
-			write!(w, "(").unwrap();
-			for (idx, field) in fields.unnamed.iter().enumerate() {
-				if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
-				types.write_c_type(w, &field.ty, None, false);
-				if idx != fields.unnamed.len() - 1 {
-					write!(w, ",").unwrap();
+			if fields.unnamed.len() == 1 {
+				let mut empty_check = Vec::new();
+				types.write_c_type(&mut empty_check, &fields.unnamed[0].ty, Some(&gen_types), false);
+				if empty_check.is_empty() {
+					empty_tuple_variant = true;
 				}
 			}
-			write!(w, ")").unwrap();
+			if !empty_tuple_variant {
+				needs_free = true;
+				write!(w, "(").unwrap();
+				for (idx, field) in fields.unnamed.iter().enumerate() {
+					if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
+					write!(&mut constr, "{}: ", ('a' as u8 + idx as u8) as char).unwrap();
+					types.write_c_type(w, &field.ty, Some(&gen_types), false);
+					types.write_c_type(&mut constr, &field.ty, Some(&gen_types), false);
+					if idx != fields.unnamed.len() - 1 {
+						write!(w, ",").unwrap();
+						write!(&mut constr, ",").unwrap();
+					}
+				}
+				write!(w, ")").unwrap();
+			}
 		}
 		if var.discriminant.is_some() { unimplemented!(); }
+		write!(&mut constr, ") -> {} {{\n\t{}::{}", e.ident, e.ident, var.ident).unwrap();
+		if let syn::Fields::Named(fields) = &var.fields {
+			writeln!(&mut constr, " {{").unwrap();
+			for field in fields.named.iter() {
+				writeln!(&mut constr, "\t\t{},", field.ident.as_ref().unwrap()).unwrap();
+			}
+			writeln!(&mut constr, "\t}}").unwrap();
+		} else if let syn::Fields::Unnamed(fields) = &var.fields {
+			if !empty_tuple_variant {
+				write!(&mut constr, "(").unwrap();
+				for idx in 0..fields.unnamed.len() {
+					write!(&mut constr, "{}, ", ('a' as u8 + idx as u8) as char).unwrap();
+				}
+				writeln!(&mut constr, ")").unwrap();
+			} else {
+				writeln!(&mut constr, "").unwrap();
+			}
+		}
+		writeln!(&mut constr, "}}").unwrap();
 		writeln!(w, ",").unwrap();
 	}
-	writeln!(w, "}}\nuse {}::{}::{} as native{};\nimpl {} {{", types.orig_crate, types.module_path, e.ident, e.ident, e.ident).unwrap();
+	writeln!(w, "}}\nuse {}::{} as native{};\nimpl {} {{", types.module_path, e.ident, e.ident, e.ident).unwrap();
 
 	macro_rules! write_conv {
 		($fn_sig: expr, $to_c: expr, $ref: expr) => {
 			writeln!(w, "\t#[allow(unused)]\n\tpub(crate) fn {} {{\n\t\tmatch {} {{", $fn_sig, if $to_c { "native" } else { "self" }).unwrap();
 			for var in e.variants.iter() {
 				write!(w, "\t\t\t{}{}::{} ", if $to_c { "native" } else { "" }, e.ident, var.ident).unwrap();
+				let mut empty_tuple_variant = false;
 				if let syn::Fields::Named(fields) = &var.fields {
 					write!(w, "{{").unwrap();
 					for field in fields.named.iter() {
@@ -1161,12 +1302,21 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 					}
 					write!(w, "}} ").unwrap();
 				} else if let syn::Fields::Unnamed(fields) = &var.fields {
-					write!(w, "(").unwrap();
-					for (idx, field) in fields.unnamed.iter().enumerate() {
-						if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
-						write!(w, "{}{}, ", if $ref { "ref " } else { "mut " }, ('a' as u8 + idx as u8) as char).unwrap();
+					if fields.unnamed.len() == 1 {
+						let mut empty_check = Vec::new();
+						types.write_c_type(&mut empty_check, &fields.unnamed[0].ty, Some(&gen_types), false);
+						if empty_check.is_empty() {
+							empty_tuple_variant = true;
+						}
+					}
+					if !empty_tuple_variant || $to_c {
+						write!(w, "(").unwrap();
+						for (idx, field) in fields.unnamed.iter().enumerate() {
+							if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
+							write!(w, "{}{}, ", if $ref { "ref " } else { "mut " }, ('a' as u8 + idx as u8) as char).unwrap();
+						}
+						write!(w, ") ").unwrap();
 					}
-					write!(w, ") ").unwrap();
 				}
 				write!(w, "=>").unwrap();
 
@@ -1176,19 +1326,19 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 						let mut sink = ::std::io::sink();
 						let mut out: &mut dyn std::io::Write = if $ref { &mut sink } else { w };
 						let new_var = if $to_c {
-							types.write_to_c_conversion_new_var(&mut out, $field_ident, &$field.ty, None, false)
+							types.write_to_c_conversion_new_var(&mut out, $field_ident, &$field.ty, Some(&gen_types), false)
 						} else {
-							types.write_from_c_conversion_new_var(&mut out, $field_ident, &$field.ty, None)
+							types.write_from_c_conversion_new_var(&mut out, $field_ident, &$field.ty, Some(&gen_types))
 						};
 						if $ref || new_var {
 							if $ref {
 								write!(w, "let mut {}_nonref = (*{}).clone();\n\t\t\t\t", $field_ident, $field_ident).unwrap();
 								if new_var {
-									let nonref_ident = syn::Ident::new(&format!("{}_nonref", $field_ident), Span::call_site());
+									let nonref_ident = format_ident!("{}_nonref", $field_ident);
 									if $to_c {
-										types.write_to_c_conversion_new_var(w, &nonref_ident, &$field.ty, None, false);
+										types.write_to_c_conversion_new_var(w, &nonref_ident, &$field.ty, Some(&gen_types), false);
 									} else {
-										types.write_from_c_conversion_new_var(w, &nonref_ident, &$field.ty, None);
+										types.write_from_c_conversion_new_var(w, &nonref_ident, &$field.ty, Some(&gen_types));
 									}
 									write!(w, "\n\t\t\t\t").unwrap();
 								}
@@ -1206,7 +1356,9 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 				} else if let syn::Fields::Unnamed(fields) = &var.fields {
 					write!(w, " {{\n\t\t\t\t").unwrap();
 					for (idx, field) in fields.unnamed.iter().enumerate() {
-						handle_field_a!(field, &syn::Ident::new(&(('a' as u8 + idx as u8) as char).to_string(), Span::call_site()));
+						if !empty_tuple_variant {
+							handle_field_a!(field, &format_ident!("{}", ('a' as u8 + idx as u8) as char));
+						}
 					}
 				} else { write!(w, " ").unwrap(); }
 
@@ -1216,16 +1368,16 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 					($field: expr, $field_ident: expr) => { {
 						if export_status(&$field.attrs) == ExportStatus::TestOnly { continue; }
 						if $to_c {
-							types.write_to_c_conversion_inline_prefix(w, &$field.ty, None, false);
+							types.write_to_c_conversion_inline_prefix(w, &$field.ty, Some(&gen_types), false);
 						} else {
-							types.write_from_c_conversion_prefix(w, &$field.ty, None);
+							types.write_from_c_conversion_prefix(w, &$field.ty, Some(&gen_types));
 						}
 						write!(w, "{}{}", $field_ident,
 							if $ref { "_nonref" } else { "" }).unwrap();
 						if $to_c {
-							types.write_to_c_conversion_inline_suffix(w, &$field.ty, None, false);
+							types.write_to_c_conversion_inline_suffix(w, &$field.ty, Some(&gen_types), false);
 						} else {
-							types.write_from_c_conversion_suffix(w, &$field.ty, None);
+							types.write_from_c_conversion_suffix(w, &$field.ty, Some(&gen_types));
 						}
 						write!(w, ",").unwrap();
 					} }
@@ -1241,12 +1393,14 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 					writeln!(w, "\n\t\t\t\t}}").unwrap();
 					write!(w, "\t\t\t}}").unwrap();
 				} else if let syn::Fields::Unnamed(fields) = &var.fields {
-					write!(w, " (").unwrap();
-					for (idx, field) in fields.unnamed.iter().enumerate() {
-						write!(w, "\n\t\t\t\t\t").unwrap();
-						handle_field_b!(field, &syn::Ident::new(&(('a' as u8 + idx as u8) as char).to_string(), Span::call_site()));
+					if !empty_tuple_variant || !$to_c {
+						write!(w, " (").unwrap();
+						for (idx, field) in fields.unnamed.iter().enumerate() {
+							write!(w, "\n\t\t\t\t\t").unwrap();
+							handle_field_b!(field, &format_ident!("{}", ('a' as u8 + idx as u8) as char));
+						}
+						writeln!(w, "\n\t\t\t\t)").unwrap();
 					}
-					writeln!(w, "\n\t\t\t\t)").unwrap();
 					write!(w, "\t\t\t}}").unwrap();
 				}
 				writeln!(w, ",").unwrap();
@@ -1270,24 +1424,26 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 	writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{", e.ident, e.ident, e.ident).unwrap();
 	writeln!(w, "\torig.clone()").unwrap();
 	writeln!(w, "}}").unwrap();
-	write_cpp_wrapper(cpp_headers, &format!("{}", e.ident), needs_free);
+	w.write_all(&constr).unwrap();
+	write_cpp_wrapper(cpp_headers, &format!("{}", e.ident), needs_free, None);
 }
 
 fn writeln_fn<'a, 'b, W: std::io::Write>(w: &mut W, f: &'a syn::ItemFn, types: &mut TypeResolver<'b, 'a>) {
 	match export_status(&f.attrs) {
 		ExportStatus::Export => {},
 		ExportStatus::NoExport|ExportStatus::TestOnly => return,
+		ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
 	}
-	writeln_docs(w, &f.attrs, "");
-
-	let mut gen_types = GenericTypes::new();
+	let mut gen_types = GenericTypes::new(None);
 	if !gen_types.learn_generics(&f.sig.generics, types) { return; }
 
+	writeln_fn_docs(w, &f.attrs, "", types, Some(&gen_types), f.sig.inputs.iter(), &f.sig.output);
+
 	write!(w, "#[no_mangle]\npub extern \"C\" fn {}(", f.sig.ident).unwrap();
 	write_method_params(w, &f.sig, "", types, Some(&gen_types), false, true);
 	write!(w, " {{\n\t").unwrap();
 	write_method_var_decl_body(w, &f.sig, "", types, Some(&gen_types), false);
-	write!(w, "{}::{}::{}(", types.orig_crate, types.module_path, f.sig.ident).unwrap();
+	write!(w, "{}::{}(", types.module_path, f.sig.ident).unwrap();
 	write_method_call_params(w, &f.sig, "", types, Some(&gen_types), "", false);
 	writeln!(w, "\n}}\n").unwrap();
 }
@@ -1296,11 +1452,41 @@ fn writeln_fn<'a, 'b, W: std::io::Write>(w: &mut W, f: &'a syn::ItemFn, types: &
 // *** File/Crate Walking Logic ***
 // ********************************
 
+fn convert_priv_mod<'a, 'b: 'a, W: std::io::Write>(w: &mut W, libast: &'b FullLibraryAST, crate_types: &CrateTypes<'b>, out_dir: &str, mod_path: &str, module: &'b syn::ItemMod) {
+	// We want to ignore all items declared in this module (as they are not pub), but we still need
+	// to give the ImportResolver any use statements, so we copy them here.
+	let mut use_items = Vec::new();
+	for item in module.content.as_ref().unwrap().1.iter() {
+		if let syn::Item::Use(_) = item {
+			use_items.push(item);
+		}
+	}
+	let import_resolver = ImportResolver::from_borrowed_items(mod_path.splitn(2, "::").next().unwrap(), &libast.dependencies, mod_path, &use_items);
+	let mut types = TypeResolver::new(mod_path, import_resolver, crate_types);
+
+	writeln!(w, "mod {} {{\n{}", module.ident, DEFAULT_IMPORTS).unwrap();
+	for item in module.content.as_ref().unwrap().1.iter() {
+		match item {
+			syn::Item::Mod(m) => convert_priv_mod(w, libast, crate_types, out_dir, &format!("{}::{}", mod_path, module.ident), m),
+			syn::Item::Impl(i) => {
+				if let &syn::Type::Path(ref p) = &*i.self_ty {
+					if p.path.get_ident().is_some() {
+						writeln_impl(w, i, &mut types);
+					}
+				}
+			},
+			_ => {},
+		}
+	}
+	writeln!(w, "}}").unwrap();
+}
+
 /// Do the Real Work of mapping an original file to C-callable wrappers. Creates a new file at
 /// `out_path` and fills it with wrapper structs/functions to allow calling the things in the AST
 /// at `module` from C.
-fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &CrateTypes<'a>, out_dir: &str, orig_crate: &str, header_file: &mut File, cpp_header_file: &mut File) {
+fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &CrateTypes<'a>, out_dir: &str, header_file: &mut File, cpp_header_file: &mut File) {
 	for (module, astmod) in libast.modules.iter() {
+		let orig_crate = module.splitn(2, "::").next().unwrap();
 		let ASTModule { ref attrs, ref items, ref submods } = astmod;
 		assert_eq!(export_status(&attrs), ExportStatus::Export);
 
@@ -1329,6 +1515,7 @@ fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &CrateTypes<'a>
 		if module == "" {
 			// Special-case the top-level lib.rs with various lint allows and a pointer to the c_types
 			// and bitcoin hand-written modules.
+			writeln!(out, "//! C Bindings").unwrap();
 			writeln!(out, "#![allow(unknown_lints)]").unwrap();
 			writeln!(out, "#![allow(non_camel_case_types)]").unwrap();
 			writeln!(out, "#![allow(non_snake_case)]").unwrap();
@@ -1338,11 +1525,13 @@ fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &CrateTypes<'a>
 			writeln!(out, "#![allow(unused_parens)]").unwrap();
 			writeln!(out, "#![allow(unused_unsafe)]").unwrap();
 			writeln!(out, "#![allow(unused_braces)]").unwrap();
-			writeln!(out, "#![deny(missing_docs)]").unwrap();
+			// TODO: We need to map deny(missing_docs) in the source crate(s)
+			//writeln!(out, "#![deny(missing_docs)]").unwrap();
+			writeln!(out, "pub mod version;").unwrap();
 			writeln!(out, "pub mod c_types;").unwrap();
 			writeln!(out, "pub mod bitcoin;").unwrap();
 		} else {
-			writeln!(out, "\nuse std::ffi::c_void;\nuse bitcoin::hashes::Hash;\nuse crate::c_types::*;\n").unwrap();
+			writeln!(out, "{}", DEFAULT_IMPORTS).unwrap();
 		}
 
 		for m in submods {
@@ -1351,8 +1540,8 @@ fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &CrateTypes<'a>
 
 		eprintln!("Converting {} entries...", module);
 
-		let import_resolver = ImportResolver::new(module, items);
-		let mut type_resolver = TypeResolver::new(orig_crate, module, import_resolver, crate_types);
+		let import_resolver = ImportResolver::new(orig_crate, &libast.dependencies, module, items);
+		let mut type_resolver = TypeResolver::new(module, import_resolver, crate_types);
 
 		for item in items.iter() {
 			match item {
@@ -1376,16 +1565,18 @@ fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &CrateTypes<'a>
 						writeln_trait(&mut out, &t, &mut type_resolver, header_file, cpp_header_file);
 					}
 				},
-				syn::Item::Mod(_) => {}, // We don't have to do anything - the top loop handles these.
+				syn::Item::Mod(m) => {
+					convert_priv_mod(&mut out, libast, crate_types, out_dir, &format!("{}::{}", module, m.ident), m);
+				},
 				syn::Item::Const(c) => {
 					// Re-export any primitive-type constants.
 					if let syn::Visibility::Public(_) = c.vis {
 						if let syn::Type::Path(p) = &*c.ty {
 							let resolved_path = type_resolver.resolve_path(&p.path, None);
 							if type_resolver.is_primitive(&resolved_path) {
-								writeln_docs(&mut out, &c.attrs, "");
+								writeln_field_docs(&mut out, &c.attrs, "", &mut type_resolver, None, &*c.ty);
 								writeln!(out, "\n#[no_mangle]").unwrap();
-								writeln!(out, "pub static {}: {} = {}::{}::{};", c.ident, resolved_path, orig_crate, module, c.ident).unwrap();
+								writeln!(out, "pub static {}: {} = {}::{};", c.ident, resolved_path, module, c.ident).unwrap();
 							}
 						}
 					}
@@ -1395,6 +1586,7 @@ fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &CrateTypes<'a>
 						match export_status(&t.attrs) {
 							ExportStatus::Export => {},
 							ExportStatus::NoExport|ExportStatus::TestOnly => continue,
+							ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
 						}
 
 						let mut process_alias = true;
@@ -1427,11 +1619,11 @@ fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &CrateTypes<'a>
 	}
 }
 
-fn walk_private_mod<'a>(module: String, items: &'a syn::ItemMod, crate_types: &mut CrateTypes<'a>) {
-	let import_resolver = ImportResolver::new(&module, &items.content.as_ref().unwrap().1);
+fn walk_private_mod<'a>(ast_storage: &'a FullLibraryAST, orig_crate: &str, module: String, items: &'a syn::ItemMod, crate_types: &mut CrateTypes<'a>) {
+	let import_resolver = ImportResolver::new(orig_crate, &ast_storage.dependencies, &module, &items.content.as_ref().unwrap().1);
 	for item in items.content.as_ref().unwrap().1.iter() {
 		match item {
-			syn::Item::Mod(m) => walk_private_mod(format!("{}::{}", module, m.ident), m, crate_types),
+			syn::Item::Mod(m) => walk_private_mod(ast_storage, orig_crate, format!("{}::{}", module, m.ident), m, crate_types),
 			syn::Item::Impl(i) => {
 				if let &syn::Type::Path(ref p) = &*i.self_ty {
 					if let Some(trait_path) = i.trait_.as_ref() {
@@ -1456,7 +1648,8 @@ fn walk_ast<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a
 	for (module, astmod) in ast_storage.modules.iter() {
 		let ASTModule { ref attrs, ref items, submods: _ } = astmod;
 		assert_eq!(export_status(&attrs), ExportStatus::Export);
-		let import_resolver = ImportResolver::new(module, items);
+		let orig_crate = module.splitn(2, "::").next().unwrap();
+		let import_resolver = ImportResolver::new(orig_crate, &ast_storage.dependencies, module, items);
 
 		for item in items.iter() {
 			match item {
@@ -1465,6 +1658,7 @@ fn walk_ast<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a
 						match export_status(&s.attrs) {
 							ExportStatus::Export => {},
 							ExportStatus::NoExport|ExportStatus::TestOnly => continue,
+							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);
@@ -1473,7 +1667,7 @@ fn walk_ast<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a
 				syn::Item::Trait(t) => {
 					if let syn::Visibility::Public(_) = t.vis {
 						match export_status(&t.attrs) {
-							ExportStatus::Export => {},
+							ExportStatus::Export|ExportStatus::NotImplementable => {},
 							ExportStatus::NoExport|ExportStatus::TestOnly => continue,
 						}
 						let trait_path = format!("{}::{}", module, t.ident);
@@ -1491,6 +1685,7 @@ fn walk_ast<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a
 						match export_status(&t.attrs) {
 							ExportStatus::Export => {},
 							ExportStatus::NoExport|ExportStatus::TestOnly => continue,
+							ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
 						}
 						let type_path = format!("{}::{}", module, t.ident);
 						let mut process_alias = true;
@@ -1501,20 +1696,17 @@ fn walk_ast<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a
 						if process_alias {
 							match &*t.ty {
 								syn::Type::Path(p) => {
+									let t_ident = &t.ident;
+
 									// If its a path with no generics, assume we don't map the aliased type and map it opaque
-									let mut segments = syn::punctuated::Punctuated::new();
-									segments.push(syn::PathSegment {
-										ident: t.ident.clone(),
-										arguments: syn::PathArguments::None,
-									});
-									let path_obj = syn::Path { leading_colon: None, segments };
+									let path_obj = parse_quote!(#t_ident);
 									let args_obj = p.path.segments.last().unwrap().arguments.clone();
 									match crate_types.reverse_alias_map.entry(import_resolver.maybe_resolve_path(&p.path, None).unwrap()) {
 										hash_map::Entry::Occupied(mut e) => { e.get_mut().push((path_obj, args_obj)); },
 										hash_map::Entry::Vacant(e) => { e.insert(vec![(path_obj, args_obj)]); },
 									}
 
-									crate_types.opaques.insert(type_path.clone(), &t.ident);
+									crate_types.opaques.insert(type_path, t_ident);
 								},
 								_ => {
 									crate_types.type_aliases.insert(type_path, import_resolver.resolve_imported_refs((*t.ty).clone()));
@@ -1528,6 +1720,7 @@ fn walk_ast<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a
 						match export_status(&e.attrs) {
 							ExportStatus::Export => {},
 							ExportStatus::NoExport|ExportStatus::TestOnly => continue,
+							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);
@@ -1538,6 +1731,7 @@ fn walk_ast<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a
 						match export_status(&e.attrs) {
 							ExportStatus::Export => {},
 							ExportStatus::NoExport|ExportStatus::TestOnly => continue,
+							ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
 						}
 						let enum_path = format!("{}::{}", module, e.ident);
 						crate_types.mirrored_enums.insert(enum_path, &e);
@@ -1562,7 +1756,7 @@ fn walk_ast<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a
 						}
 					}
 				},
-				syn::Item::Mod(m) => walk_private_mod(format!("{}::{}", module, m.ident), m, crate_types),
+				syn::Item::Mod(m) => walk_private_mod(ast_storage, orig_crate, format!("{}::{}", module, m.ident), m, crate_types),
 				_ => {},
 			}
 		}
@@ -1571,17 +1765,17 @@ fn walk_ast<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a
 
 fn main() {
 	let args: Vec<String> = env::args().collect();
-	if args.len() != 6 {
-		eprintln!("Usage: target/dir source_crate_name derived_templates.rs extra/includes.h extra/cpp/includes.hpp");
+	if args.len() != 5 {
+		eprintln!("Usage: target/dir derived_templates.rs extra/includes.h extra/cpp/includes.hpp");
 		process::exit(1);
 	}
 
 	let mut derived_templates = std::fs::OpenOptions::new().write(true).create(true).truncate(true)
-		.open(&args[3]).expect("Unable to open new header file");
+		.open(&args[2]).expect("Unable to open new header file");
 	let mut header_file = std::fs::OpenOptions::new().write(true).create(true).truncate(true)
-		.open(&args[4]).expect("Unable to open new header file");
+		.open(&args[3]).expect("Unable to open new header file");
 	let mut cpp_header_file = std::fs::OpenOptions::new().write(true).create(true).truncate(true)
-		.open(&args[5]).expect("Unable to open new header file");
+		.open(&args[4]).expect("Unable to open new header file");
 
 	writeln!(header_file, "#if defined(__GNUC__)").unwrap();
 	writeln!(header_file, "#define MUST_USE_STRUCT __attribute__((warn_unused))").unwrap();
@@ -1610,12 +1804,12 @@ fn main() {
 	walk_ast(&libast, &mut libtypes);
 
 	// ... finally, do the actual file conversion/mapping, writing out types as we go.
-	convert_file(&libast, &libtypes, &args[1], &args[2], &mut header_file, &mut cpp_header_file);
+	convert_file(&libast, &libtypes, &args[1], &mut header_file, &mut cpp_header_file);
 
 	// For container templates which we created while walking the crate, make sure we add C++
 	// mapped types so that C++ users can utilize the auto-destructors available.
 	for (ty, has_destructor) in libtypes.templates_defined.borrow().iter() {
-		write_cpp_wrapper(&mut cpp_header_file, ty, *has_destructor);
+		write_cpp_wrapper(&mut cpp_header_file, ty, *has_destructor, None);
 	}
 	writeln!(cpp_header_file, "}}").unwrap();