X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Ftypes.rs;h=ad21b4c6bca53917685979c846021a03cdb45d7e;hb=c42ea50cc703f03465d52b5fccfc4a90466d9fea;hp=e3ae3bdef4f9012fd2b7014466f419b7080c8e19;hpb=c7ddcd3867757c74d8a3a2997604edf52aa0a536;p=rust-lightning

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index e3ae3bde..ad21b4c6 100644
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -1,8 +1,10 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::fs::File;
 use std::io::Write;
 use std::hash;
 
+use crate::blocks::*;
+
 use proc_macro2::{TokenTree, Span};
 
 // The following utils are used purely to build our known types maps - they break down all the
@@ -39,6 +41,15 @@ pub fn single_ident_generic_path_to_ident(p: &syn::Path) -> Option<&syn::Ident>
 	} else { None }
 }
 
+pub fn path_matches_nongeneric(p: &syn::Path, exp: &[&str]) -> bool {
+	if p.segments.len() != exp.len() { return false; }
+	for (seg, e) in p.segments.iter().zip(exp.iter()) {
+		if seg.arguments != syn::PathArguments::None { return false; }
+		if &format!("{}", seg.ident) != *e { return false; }
+	}
+	true
+}
+
 #[derive(Debug, PartialEq)]
 pub enum ExportStatus {
 	Export,
@@ -99,6 +110,29 @@ pub fn assert_simple_bound(bound: &syn::TraitBound) {
 	if let syn::TraitBoundModifier::Maybe(_) = bound.modifier { unimplemented!(); }
 }
 
+/// Returns true if the enum will be mapped as an opaue (ie struct with a pointer to the underlying
+/// type), otherwise it is mapped into a transparent, C-compatible version of itself.
+pub fn is_enum_opaque(e: &syn::ItemEnum) -> bool {
+	for var in e.variants.iter() {
+		if let syn::Fields::Named(fields) = &var.fields {
+			for field in fields.named.iter() {
+				match export_status(&field.attrs) {
+					ExportStatus::Export|ExportStatus::TestOnly => {},
+					ExportStatus::NoExport => return true,
+				}
+			}
+		} else if let syn::Fields::Unnamed(fields) = &var.fields {
+			for field in fields.unnamed.iter() {
+				match export_status(&field.attrs) {
+					ExportStatus::Export|ExportStatus::TestOnly => {},
+					ExportStatus::NoExport => return true,
+				}
+			}
+		}
+	}
+	false
+}
+
 /// A stack of sets of generic resolutions.
 ///
 /// This tracks the template parameters for a function, struct, or trait, allowing resolution into
@@ -139,6 +173,7 @@ impl<'a> GenericTypes<'a> {
 							if let Some(ident) = single_ident_generic_path_to_ident(&trait_bound.path) {
 								match &format!("{}", ident) as &str { "Send" => continue, "Sync" => continue, _ => {} }
 							}
+							if path_matches_nongeneric(&trait_bound.path, &["core", "clone", "Clone"]) { continue; }
 
 							assert_simple_bound(&trait_bound);
 							if let Some(mut path) = types.maybe_resolve_path(&trait_bound.path, None) {
@@ -267,12 +302,225 @@ pub enum DeclType<'a> {
 	EnumIgnored,
 }
 
+pub struct ImportResolver<'mod_lifetime, 'crate_lft: 'mod_lifetime> {
+	module_path: &'mod_lifetime str,
+	imports: HashMap<syn::Ident, (String, syn::Path)>,
+	declared: HashMap<syn::Ident, DeclType<'crate_lft>>,
+	priv_modules: HashSet<syn::Ident>,
+}
+impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'crate_lft> {
+	fn process_use_intern(imports: &mut HashMap<syn::Ident, (String, syn::Path)>, u: &syn::UseTree, partial_path: &str, mut path: syn::punctuated::Punctuated<syn::PathSegment, syn::token::Colon2>) {
+		match u {
+			syn::UseTree::Path(p) => {
+				let new_path = format!("{}{}::", partial_path, p.ident);
+				path.push(syn::PathSegment { ident: p.ident.clone(), arguments: syn::PathArguments::None });
+				Self::process_use_intern(imports, &p.tree, &new_path, path);
+			},
+			syn::UseTree::Name(n) => {
+				let full_path = format!("{}{}", partial_path, n.ident);
+				path.push(syn::PathSegment { ident: n.ident.clone(), arguments: syn::PathArguments::None });
+				imports.insert(n.ident.clone(), (full_path, syn::Path { leading_colon: Some(syn::Token![::](Span::call_site())), segments: path }));
+			},
+			syn::UseTree::Group(g) => {
+				for i in g.items.iter() {
+					Self::process_use_intern(imports, i, partial_path, path.clone());
+				}
+			},
+			syn::UseTree::Rename(r) => {
+				let full_path = format!("{}{}", partial_path, r.ident);
+				path.push(syn::PathSegment { ident: r.ident.clone(), arguments: syn::PathArguments::None });
+				imports.insert(r.rename.clone(), (full_path, syn::Path { leading_colon: Some(syn::Token![::](Span::call_site())), segments: path }));
+			},
+			syn::UseTree::Glob(_) => {
+				eprintln!("Ignoring * use for {} - this may result in resolution failures", partial_path);
+			},
+		}
+	}
+
+	fn process_use(imports: &mut HashMap<syn::Ident, (String, syn::Path)>, u: &syn::ItemUse) {
+		if let syn::Visibility::Public(_) = u.vis {
+			// We actually only use these for #[cfg(fuzztarget)]
+			eprintln!("Ignoring pub(use) tree!");
+			return;
+		}
+		if u.leading_colon.is_some() { eprintln!("Ignoring leading-colon use!"); return; }
+		Self::process_use_intern(imports, &u.tree, "", syn::punctuated::Punctuated::new());
+	}
+
+	fn insert_primitive(imports: &mut HashMap<syn::Ident, (String, syn::Path)>, id: &str) {
+		let ident = syn::Ident::new(id, Span::call_site());
+		let mut path = syn::punctuated::Punctuated::new();
+		path.push(syn::PathSegment { ident: ident.clone(), arguments: syn::PathArguments::None });
+		imports.insert(ident, (id.to_owned(), syn::Path { leading_colon: Some(syn::Token![::](Span::call_site())), segments: path }));
+	}
+
+	pub fn new(module_path: &'mod_lifetime str, contents: &'crate_lft [syn::Item]) -> Self {
+		let mut imports = HashMap::new();
+		// Add primitives to the "imports" list:
+		Self::insert_primitive(&mut imports, "bool");
+		Self::insert_primitive(&mut imports, "u64");
+		Self::insert_primitive(&mut imports, "u32");
+		Self::insert_primitive(&mut imports, "u16");
+		Self::insert_primitive(&mut imports, "u8");
+		Self::insert_primitive(&mut imports, "usize");
+		Self::insert_primitive(&mut imports, "str");
+		Self::insert_primitive(&mut imports, "String");
+
+		// These are here to allow us to print native Rust types in trait fn impls even if we don't
+		// have C mappings:
+		Self::insert_primitive(&mut imports, "Result");
+		Self::insert_primitive(&mut imports, "Vec");
+		Self::insert_primitive(&mut imports, "Option");
+
+		let mut declared = HashMap::new();
+		let mut priv_modules = HashSet::new();
+
+		for item in contents.iter() {
+			match item {
+				syn::Item::Use(u) => Self::process_use(&mut imports, &u),
+				syn::Item::Struct(s) => {
+					if let syn::Visibility::Public(_) = s.vis {
+						match export_status(&s.attrs) {
+							ExportStatus::Export => { declared.insert(s.ident.clone(), DeclType::StructImported); },
+							ExportStatus::NoExport => { declared.insert(s.ident.clone(), DeclType::StructIgnored); },
+							ExportStatus::TestOnly => continue,
+						}
+					}
+				},
+				syn::Item::Type(t) if export_status(&t.attrs) == ExportStatus::Export => {
+					if let syn::Visibility::Public(_) = t.vis {
+						let mut process_alias = true;
+						for tok in t.generics.params.iter() {
+							if let syn::GenericParam::Lifetime(_) = tok {}
+							else { process_alias = false; }
+						}
+						if process_alias {
+							match &*t.ty {
+								syn::Type::Path(_) => { declared.insert(t.ident.clone(), DeclType::StructImported); },
+								_ => {},
+							}
+						}
+					}
+				},
+				syn::Item::Enum(e) => {
+					if let syn::Visibility::Public(_) = e.vis {
+						match export_status(&e.attrs) {
+							ExportStatus::Export if is_enum_opaque(e) => { declared.insert(e.ident.clone(), DeclType::EnumIgnored); },
+							ExportStatus::Export => { declared.insert(e.ident.clone(), DeclType::MirroredEnum); },
+							_ => continue,
+						}
+					}
+				},
+				syn::Item::Trait(t) if export_status(&t.attrs) == ExportStatus::Export => {
+					if let syn::Visibility::Public(_) = t.vis {
+						declared.insert(t.ident.clone(), DeclType::Trait(t));
+					}
+				},
+				syn::Item::Mod(m) => {
+					priv_modules.insert(m.ident.clone());
+				},
+				_ => {},
+			}
+		}
+
+		Self { module_path, imports, declared, priv_modules }
+	}
+
+	pub fn get_declared_type(&self, ident: &syn::Ident) -> Option<&DeclType<'crate_lft>> {
+		self.declared.get(ident)
+	}
+
+	pub fn maybe_resolve_declared(&self, id: &syn::Ident) -> Option<&DeclType<'crate_lft>> {
+		self.declared.get(id)
+	}
+
+	pub fn maybe_resolve_ident(&self, id: &syn::Ident) -> Option<String> {
+		if let Some((imp, _)) = self.imports.get(id) {
+			Some(imp.clone())
+		} else if self.declared.get(id).is_some() {
+			Some(self.module_path.to_string() + "::" + &format!("{}", id))
+		} else { None }
+	}
+
+	pub fn maybe_resolve_non_ignored_ident(&self, id: &syn::Ident) -> Option<String> {
+		if let Some((imp, _)) = self.imports.get(id) {
+			Some(imp.clone())
+		} else if let Some(decl_type) = self.declared.get(id) {
+			match decl_type {
+				DeclType::StructIgnored => None,
+				_ => Some(self.module_path.to_string() + "::" + &format!("{}", id)),
+			}
+		} else { None }
+	}
+
+	pub fn maybe_resolve_path(&self, p_arg: &syn::Path, generics: Option<&GenericTypes>) -> Option<String> {
+		let p = if let Some(gen_types) = generics {
+			if let Some((_, synpath)) = gen_types.maybe_resolve_path(p_arg) {
+				synpath
+			} else { p_arg }
+		} else { p_arg };
+
+		if p.leading_colon.is_some() {
+			Some(p.segments.iter().enumerate().map(|(idx, seg)| {
+				format!("{}{}", if idx == 0 { "" } else { "::" }, seg.ident)
+			}).collect())
+		} else if let Some(id) = p.get_ident() {
+			self.maybe_resolve_ident(id)
+		} else {
+			if p.segments.len() == 1 {
+				let seg = p.segments.iter().next().unwrap();
+				return self.maybe_resolve_ident(&seg.ident);
+			}
+			let mut seg_iter = p.segments.iter();
+			let first_seg = seg_iter.next().unwrap();
+			let remaining: String = seg_iter.map(|seg| {
+				format!("::{}", seg.ident)
+			}).collect();
+			if let Some((imp, _)) = self.imports.get(&first_seg.ident) {
+				if remaining != "" {
+					Some(imp.clone() + &remaining)
+				} else {
+					Some(imp.clone())
+				}
+			} else if let Some(_) = self.priv_modules.get(&first_seg.ident) {
+				Some(format!("{}::{}{}", self.module_path, first_seg.ident, remaining))
+			} else { None }
+		}
+	}
+
+	/// Map all the Paths in a Type into absolute paths given a set of imports (generated via process_use_intern)
+	pub fn resolve_imported_refs(&self, mut ty: syn::Type) -> syn::Type {
+		match &mut ty {
+			syn::Type::Path(p) => {
+				if let Some(ident) = p.path.get_ident() {
+					if let Some((_, newpath)) = self.imports.get(ident) {
+						p.path = newpath.clone();
+					}
+				} else { unimplemented!(); }
+			},
+			syn::Type::Reference(r) => {
+				r.elem = Box::new(self.resolve_imported_refs((*r.elem).clone()));
+			},
+			syn::Type::Slice(s) => {
+				s.elem = Box::new(self.resolve_imported_refs((*s.elem).clone()));
+			},
+			syn::Type::Tuple(t) => {
+				for e in t.elems.iter_mut() {
+					*e = self.resolve_imported_refs(e.clone());
+				}
+			},
+			_ => unimplemented!(),
+		}
+		ty
+	}
+}
+
 // templates_defined is walked to write the C++ header, so if we use the default hashing it get
 // reordered on each genbindings run. Instead, we use SipHasher (which defaults to 0-keys) so that
 // the sorting is stable across runs. It is deprecated, but the "replacement" doesn't actually
 // accomplish the same goals, so we just ignore it.
 #[allow(deprecated)]
-type NonRandomHash = hash::BuildHasherDefault<hash::SipHasher>;
+pub type NonRandomHash = hash::BuildHasherDefault<hash::SipHasher>;
 
 /// Top-level struct tracking everything which has been defined while walking the crate.
 pub struct CrateTypes<'a> {
@@ -285,6 +533,8 @@ pub struct CrateTypes<'a> {
 	pub traits: HashMap<String, &'a syn::ItemTrait>,
 	/// Aliases from paths to some other Type
 	pub type_aliases: HashMap<String, syn::Type>,
+	/// Value is an alias to Key (maybe with some generics)
+	pub reverse_alias_map: HashMap<String, Vec<(syn::Path, syn::PathArguments)>>,
 	/// Template continer types defined, map from mangled type name -> whether a destructor fn
 	/// exists.
 	///
@@ -293,6 +543,10 @@ pub struct CrateTypes<'a> {
 	/// The output file for any created template container types, written to as we find new
 	/// template containers which need to be defined.
 	pub template_file: &'a mut File,
+	/// Set of containers which are clonable
+	pub clonable_types: HashSet<String>,
+	/// Key impls Value
+	pub trait_impls: HashMap<String, Vec<String>>,
 }
 
 /// A struct which tracks resolving rust types into C-mapped equivalents, exists for one specific
@@ -300,10 +554,8 @@ pub struct CrateTypes<'a> {
 pub struct TypeResolver<'mod_lifetime, 'crate_lft: 'mod_lifetime> {
 	pub orig_crate: &'mod_lifetime str,
 	pub module_path: &'mod_lifetime str,
-	imports: HashMap<syn::Ident, String>,
-	// ident -> is-mirrored-enum
-	declared: HashMap<syn::Ident, DeclType<'crate_lft>>,
 	pub crate_types: &'mod_lifetime mut CrateTypes<'crate_lft>,
+	types: ImportResolver<'mod_lifetime, 'crate_lft>,
 }
 
 /// Returned by write_empty_rust_val_check_suffix to indicate what type of dereferencing needs to
@@ -318,24 +570,8 @@ enum EmptyValExpectedTy {
 }
 
 impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
-	pub fn new(orig_crate: &'a str, module_path: &'a str, crate_types: &'a mut CrateTypes<'c>) -> Self {
-		let mut imports = HashMap::new();
-		// Add primitives to the "imports" list:
-		imports.insert(syn::Ident::new("bool", Span::call_site()), "bool".to_string());
-		imports.insert(syn::Ident::new("u64", Span::call_site()), "u64".to_string());
-		imports.insert(syn::Ident::new("u32", Span::call_site()), "u32".to_string());
-		imports.insert(syn::Ident::new("u16", Span::call_site()), "u16".to_string());
-		imports.insert(syn::Ident::new("u8", Span::call_site()), "u8".to_string());
-		imports.insert(syn::Ident::new("usize", Span::call_site()), "usize".to_string());
-		imports.insert(syn::Ident::new("str", Span::call_site()), "str".to_string());
-		imports.insert(syn::Ident::new("String", Span::call_site()), "String".to_string());
-
-		// These are here to allow us to print native Rust types in trait fn impls even if we don't
-		// have C mappings:
-		imports.insert(syn::Ident::new("Result", Span::call_site()), "Result".to_string());
-		imports.insert(syn::Ident::new("Vec", Span::call_site()), "Vec".to_string());
-		imports.insert(syn::Ident::new("Option", Span::call_site()), "Option".to_string());
-		Self { orig_crate, module_path, imports, declared: HashMap::new(), crate_types }
+	pub fn new(orig_crate: &'a str, module_path: &'a str, types: ImportResolver<'a, 'c>, crate_types: &'a mut CrateTypes<'c>) -> Self {
+		Self { orig_crate, module_path, types, crate_types }
 	}
 
 	// *************************************************
@@ -351,7 +587,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 	/// Returns true we if can just skip passing this to C entirely
 	fn no_arg_path_to_rust(&self, full_path: &str) -> &str {
 		if full_path == "bitcoin::secp256k1::Secp256k1" {
-			"&bitcoin::secp256k1::Secp256k1::new()"
+			"secp256k1::SECP256K1"
 		} else { unimplemented!(); }
 	}
 
@@ -368,9 +604,19 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			_ => false,
 		}
 	}
+	pub fn is_clonable(&self, ty: &str) -> bool {
+		if self.crate_types.clonable_types.contains(ty) { return true; }
+		if self.is_primitive(ty) { return true; }
+		match ty {
+			"()" => true,
+			"crate::c_types::Signature" => true,
+			"crate::c_types::TxOut" => true,
+			_ => false,
+		}
+	}
 	/// Gets the C-mapped type for types which are outside of the crate, or which are manually
 	/// ignored by for some reason need mapping anyway.
-	fn c_type_from_path<'b>(&self, full_path: &'b str, is_ref: bool, ptr_for_ref: bool) -> Option<&'b str> {
+	fn c_type_from_path<'b>(&self, full_path: &'b str, is_ref: bool, _ptr_for_ref: bool) -> Option<&'b str> {
 		if self.is_primitive(full_path) {
 			return Some(full_path);
 		}
@@ -424,14 +670,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			// Override the default since Records contain an fmt with a lifetime:
 			"util::logger::Record" => Some("*const std::os::raw::c_char"),
 
-			// List of structs we map that aren't detected:
-			"ln::features::InitFeatures" if is_ref && ptr_for_ref => Some("crate::ln::features::InitFeatures"),
-			"ln::features::InitFeatures" if is_ref => Some("*const crate::ln::features::InitFeatures"),
-			"ln::features::InitFeatures" => Some("crate::ln::features::InitFeatures"),
-			_ => {
-				eprintln!("    Type {} (ref: {}) unresolvable in C", full_path, is_ref);
-				None
-			},
+			_ => None,
 		}
 	}
 
@@ -490,16 +729,10 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			"ln::channelmanager::PaymentPreimage" if is_ref => Some("&::lightning::ln::channelmanager::PaymentPreimage(unsafe { *"),
 			"ln::channelmanager::PaymentSecret" => Some("::lightning::ln::channelmanager::PaymentSecret("),
 
-			// List of structs we map (possibly during processing of other files):
-			"ln::features::InitFeatures" if !is_ref => Some("*unsafe { Box::from_raw("),
-
 			// List of traits we map (possibly during processing of other files):
 			"crate::util::logger::Logger" => Some(""),
 
-			_ => {
-				eprintln!("    Type {} unconvertable from C", full_path);
-				None
-			},
+			_ => None,
 		}.map(|s| s.to_owned())
 	}
 	fn from_c_conversion_suffix_from_path<'b>(&self, full_path: &str, is_ref: bool) -> Option<String> {
@@ -548,17 +781,10 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			"ln::channelmanager::PaymentPreimage" if is_ref => Some(" })"),
 			"ln::channelmanager::PaymentSecret" => Some(".data)"),
 
-			// List of structs we map (possibly during processing of other files):
-			"ln::features::InitFeatures" if is_ref => Some(".inner) }"),
-			"ln::features::InitFeatures" if !is_ref => Some(".take_inner()) }"),
-
 			// List of traits we map (possibly during processing of other files):
 			"crate::util::logger::Logger" => Some(""),
 
-			_ => {
-				eprintln!("    Type {} unconvertable from C", full_path);
-				None
-			},
+			_ => None,
 		}.map(|s| s.to_owned())
 	}
 
@@ -582,7 +808,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			_ => None,
 		}.map(|s| s.to_owned())
 	}
-	fn to_c_conversion_inline_prefix_from_path(&self, full_path: &str, is_ref: bool, ptr_for_ref: bool) -> Option<String> {
+	fn to_c_conversion_inline_prefix_from_path(&self, full_path: &str, is_ref: bool, _ptr_for_ref: bool) -> Option<String> {
 		if self.is_primitive(full_path) {
 			return Some("".to_owned());
 		}
@@ -616,6 +842,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			"bitcoin::blockdata::transaction::Transaction" => Some("crate::c_types::Transaction::from_vec(local_"),
 			"bitcoin::blockdata::transaction::OutPoint" => Some("crate::c_types::bitcoin_to_C_outpoint("),
 			"bitcoin::blockdata::transaction::TxOut" if !is_ref => Some("crate::c_types::TxOut::from_rust("),
+			"bitcoin::network::constants::Network" => Some("crate::bitcoin::network::Network::from_bitcoin("),
 			"bitcoin::blockdata::block::BlockHeader" if is_ref => Some("&local_"),
 			"bitcoin::blockdata::block::Block" if is_ref => Some("crate::c_types::u8slice::from_slice(&local_"),
 
@@ -635,18 +862,10 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			// Override the default since Records contain an fmt with a lifetime:
 			"util::logger::Record" => Some("local_"),
 
-			// List of structs we map (possibly during processing of other files):
-			"ln::features::InitFeatures" if is_ref && ptr_for_ref => Some("crate::ln::features::InitFeatures { inner: &mut "),
-			"ln::features::InitFeatures" if is_ref => Some("Box::into_raw(Box::new(crate::ln::features::InitFeatures { inner: &mut "),
-			"ln::features::InitFeatures" if !is_ref => Some("crate::ln::features::InitFeatures { inner: Box::into_raw(Box::new("),
-
-			_ => {
-				eprintln!("    Type {} (is_ref: {}) unconvertable to C", full_path, is_ref);
-				None
-			},
+			_ => None,
 		}.map(|s| s.to_owned())
 	}
-	fn to_c_conversion_inline_suffix_from_path(&self, full_path: &str, is_ref: bool, ptr_for_ref: bool) -> Option<String> {
+	fn to_c_conversion_inline_suffix_from_path(&self, full_path: &str, is_ref: bool, _ptr_for_ref: bool) -> Option<String> {
 		if self.is_primitive(full_path) {
 			return Some("".to_owned());
 		}
@@ -681,6 +900,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			"bitcoin::blockdata::transaction::Transaction" => Some(")"),
 			"bitcoin::blockdata::transaction::OutPoint" => Some(")"),
 			"bitcoin::blockdata::transaction::TxOut" if !is_ref => Some(")"),
+			"bitcoin::network::constants::Network" => Some(")"),
 			"bitcoin::blockdata::block::BlockHeader" if is_ref => Some(""),
 			"bitcoin::blockdata::block::Block" if is_ref => Some(")"),
 
@@ -700,15 +920,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			// Override the default since Records contain an fmt with a lifetime:
 			"util::logger::Record" => Some(".as_ptr()"),
 
-			// List of structs we map (possibly during processing of other files):
-			"ln::features::InitFeatures" if is_ref && ptr_for_ref => Some(", is_owned: false }"),
-			"ln::features::InitFeatures" if is_ref => Some(", is_owned: false }))"),
-			"ln::features::InitFeatures" => Some(")), is_owned: true }"),
-
-			_ => {
-				eprintln!("    Type {} unconvertable to C", full_path);
-				None
-			},
+			_ => None,
 		}.map(|s| s.to_owned())
 	}
 
@@ -727,7 +939,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
 	/// Returns the module path in the generated mapping crate to the containers which we generate
 	/// when writing to CrateTypes::template_file.
-	fn generated_container_path() -> &'static str {
+	pub fn generated_container_path() -> &'static str {
 		"crate::c_types::derived"
 	}
 	/// Returns the module path in the generated mapping crate to the container templates, which
@@ -753,11 +965,11 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			"Result" if !is_ref => {
 				Some(("match ",
 						vec![(" { Ok(mut o) => crate::c_types::CResultTempl::ok(".to_string(), "o".to_string()),
-							("), Err(mut e) => crate::c_types::CResultTempl::err(".to_string(), "e".to_string())],
-						") }"))
+							(").into(), Err(mut e) => crate::c_types::CResultTempl::err(".to_string(), "e".to_string())],
+						").into() }"))
 			},
 			"Vec" if !is_ref => {
-				Some(("Vec::new(); for item in ", vec![(format!(".drain(..) {{ local_{}.push(", var_name), "item".to_string())], "); }"))
+				Some(("Vec::new(); for mut item in ", vec![(format!(".drain(..) {{ local_{}.push(", var_name), "item".to_string())], "); }"))
 			},
 			"Slice" => {
 				Some(("Vec::new(); for item in ", vec![(format!(".iter() {{ local_{}.push(", var_name), "**item".to_string())], "); }"))
@@ -798,8 +1010,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 		match full_path {
 			"Result" if !is_ref => {
 				Some(("match ",
-						vec![(".result_ok { true => Ok(".to_string(), format!("(*unsafe {{ Box::from_raw(<*mut _>::take_ptr(&mut {}.contents.result)) }})", var_name)),
-						     ("), false => Err(".to_string(), format!("(*unsafe {{ Box::from_raw(<*mut _>::take_ptr(&mut {}.contents.err)) }})", var_name))],
+						vec![(".result_ok { true => Ok(".to_string(), format!("(*unsafe {{ Box::from_raw(<*mut _>::take_ptr(&mut {}.contents.result)) }})", var_access)),
+						     ("), false => Err(".to_string(), format!("(*unsafe {{ Box::from_raw(<*mut _>::take_ptr(&mut {}.contents.err)) }})", var_access))],
 						")}"))
 			},
 			"Vec"|"Slice" if !is_ref => {
@@ -812,9 +1024,9 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 				if let Some(syn::Type::Path(p)) = single_contained {
 					if self.c_type_has_inner_from_path(&self.resolve_path(&p.path, generics)) {
 						if is_ref {
-							return Some(("if ", vec![(".inner.is_null() { None } else { Some((*".to_string(), format!("{}", var_name))], ").clone()) }"))
+							return Some(("if ", vec![(".inner.is_null() { None } else { Some((*".to_string(), format!("{}", var_access))], ").clone()) }"))
 						} else {
-							return Some(("if ", vec![(".inner.is_null() { None } else { Some(".to_string(), format!("{}", var_name))], ") }"));
+							return Some(("if ", vec![(".inner.is_null() { None } else { Some(".to_string(), format!("{}", var_access))], ") }"));
 						}
 					}
 				}
@@ -847,127 +1059,24 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 	// *** Type definition during main.rs processing ***
 	// *************************************************
 
-	fn process_use_intern<W: std::io::Write>(&mut self, w: &mut W, u: &syn::UseTree, partial_path: &str) {
-		match u {
-			syn::UseTree::Path(p) => {
-				let new_path = format!("{}::{}", partial_path, p.ident);
-				self.process_use_intern(w, &p.tree, &new_path);
-			},
-			syn::UseTree::Name(n) => {
-				let full_path = format!("{}::{}", partial_path, n.ident);
-				self.imports.insert(n.ident.clone(), full_path);
-			},
-			syn::UseTree::Group(g) => {
-				for i in g.items.iter() {
-					self.process_use_intern(w, i, partial_path);
-				}
-			},
-			syn::UseTree::Rename(r) => {
-				let full_path = format!("{}::{}", partial_path, r.ident);
-				self.imports.insert(r.rename.clone(), full_path);
-			},
-			syn::UseTree::Glob(_) => {
-				eprintln!("Ignoring * use for {} - this may result in resolution failures", partial_path);
-			},
-		}
-	}
-	pub fn process_use<W: std::io::Write>(&mut self, w: &mut W, u: &syn::ItemUse) {
-		if let syn::Visibility::Public(_) = u.vis {
-			// We actually only use these for #[cfg(fuzztarget)]
-			eprintln!("Ignoring pub(use) tree!");
-			return;
-		}
-		match &u.tree {
-			syn::UseTree::Path(p) => {
-				let new_path = format!("{}", p.ident);
-				self.process_use_intern(w, &p.tree, &new_path);
-			},
-			syn::UseTree::Name(n) => {
-				let full_path = format!("{}", n.ident);
-				self.imports.insert(n.ident.clone(), full_path);
-			},
-			_ => unimplemented!(),
-		}
-		if u.leading_colon.is_some() { unimplemented!() }
-	}
-
-	pub fn mirrored_enum_declared(&mut self, ident: &syn::Ident) {
-		eprintln!("{} mirrored", ident);
-		self.declared.insert(ident.clone(), DeclType::MirroredEnum);
-	}
-	pub fn enum_ignored(&mut self, ident: &'c syn::Ident) {
-		self.declared.insert(ident.clone(), DeclType::EnumIgnored);
-	}
-	pub fn struct_imported(&mut self, ident: &'c syn::Ident, named: String) {
-		eprintln!("Imported {} as {}", ident, named);
-		self.declared.insert(ident.clone(), DeclType::StructImported);
-	}
-	pub fn struct_ignored(&mut self, ident: &syn::Ident) {
-		eprintln!("Not importing {}", ident);
-		self.declared.insert(ident.clone(), DeclType::StructIgnored);
-	}
-	pub fn trait_declared(&mut self, ident: &syn::Ident, t: &'c syn::ItemTrait) {
-		eprintln!("Trait {} created", ident);
-		self.declared.insert(ident.clone(), DeclType::Trait(t));
-	}
 	pub fn get_declared_type(&'a self, ident: &syn::Ident) -> Option<&'a DeclType<'c>> {
-		self.declared.get(ident)
+		self.types.get_declared_type(ident)
 	}
 	/// Returns true if the object at the given path is mapped as X { inner: *mut origX, .. }.
-	fn c_type_has_inner_from_path(&self, full_path: &str) -> bool{
+	pub fn c_type_has_inner_from_path(&self, full_path: &str) -> bool{
 		self.crate_types.opaques.get(full_path).is_some()
 	}
 
 	pub fn maybe_resolve_ident(&self, id: &syn::Ident) -> Option<String> {
-		if let Some(imp) = self.imports.get(id) {
-			Some(imp.clone())
-		} else if self.declared.get(id).is_some() {
-			Some(self.module_path.to_string() + "::" + &format!("{}", id))
-		} else { None }
+		self.types.maybe_resolve_ident(id)
 	}
 
 	pub fn maybe_resolve_non_ignored_ident(&self, id: &syn::Ident) -> Option<String> {
-		if let Some(imp) = self.imports.get(id) {
-			Some(imp.clone())
-		} else if let Some(decl_type) = self.declared.get(id) {
-			match decl_type {
-				DeclType::StructIgnored => None,
-				_ => Some(self.module_path.to_string() + "::" + &format!("{}", id)),
-			}
-		} else { None }
+		self.types.maybe_resolve_non_ignored_ident(id)
 	}
 
 	pub fn maybe_resolve_path(&self, p_arg: &syn::Path, generics: Option<&GenericTypes>) -> Option<String> {
-		let p = if let Some(gen_types) = generics {
-			if let Some((_, synpath)) = gen_types.maybe_resolve_path(p_arg) {
-				synpath
-			} else { p_arg }
-		} else { p_arg };
-
-		if p.leading_colon.is_some() {
-			Some(p.segments.iter().enumerate().map(|(idx, seg)| {
-				format!("{}{}", if idx == 0 { "" } else { "::" }, seg.ident)
-			}).collect())
-		} else if let Some(id) = p.get_ident() {
-			self.maybe_resolve_ident(id)
-		} else {
-			if p.segments.len() == 1 {
-				let seg = p.segments.iter().next().unwrap();
-				return self.maybe_resolve_ident(&seg.ident);
-			}
-			let mut seg_iter = p.segments.iter();
-			let first_seg = seg_iter.next().unwrap();
-			let remaining: String = seg_iter.map(|seg| {
-				format!("::{}", seg.ident)
-			}).collect();
-			if let Some(imp) = self.imports.get(&first_seg.ident) {
-				if remaining != "" {
-					Some(imp.clone() + &remaining)
-				} else {
-					Some(imp.clone())
-				}
-			} else { None }
-		}
+		self.types.maybe_resolve_path(p_arg, generics)
 	}
 	pub fn resolve_path(&self, p: &syn::Path, generics: Option<&GenericTypes>) -> String {
 		self.maybe_resolve_path(p, generics).unwrap()
@@ -1061,7 +1170,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 	pub fn write_rust_type<W: std::io::Write>(&self, w: &mut W, generics: Option<&GenericTypes>, t: &syn::Type) {
 		match t {
 			syn::Type::Path(p) => {
-				if p.qself.is_some() || p.path.leading_colon.is_some() {
+				if p.qself.is_some() {
 					unimplemented!();
 				}
 				self.write_rust_path(w, generics, &p.path);
@@ -1257,10 +1366,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 				} else if let Some(t) = self.crate_types.traits.get(&resolved_path) {
 					decl_lookup(w, &DeclType::Trait(t), &resolved_path, is_ref, is_mut);
 				} else if let Some(ident) = single_ident_generic_path_to_ident(&p.path) {
-					if let Some(_) = self.imports.get(ident) {
-						// crate_types lookup has to have succeeded:
-						panic!("Failed to print inline conversion for {}", ident);
-					} else if let Some(decl_type) = self.declared.get(ident) {
+					if let Some(decl_type) = self.types.maybe_resolve_declared(ident) {
 						decl_lookup(w, decl_type, &self.maybe_resolve_ident(ident).unwrap(), is_ref, is_mut);
 					} else { unimplemented!(); }
 				} else { unimplemented!(); }
@@ -1585,7 +1691,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 					if let Some((prefix, suffix)) = path_lookup(&resolved_path, is_ref) {
 						write!(w, "let mut local_{} = {}{}{};", ident, prefix, var, suffix).unwrap();
 						true
-					} else if self.declared.get(ty_ident).is_some() {
+					} else if self.types.maybe_resolve_declared(ty_ident).is_some() {
 						false
 					} else { false }
 				} else { false }
@@ -1720,155 +1826,96 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 	// *** C Container Type Equivalent and alias Printing ***
 	// ******************************************************
 
-	fn write_template_constructor<W: std::io::Write>(&mut self, w: &mut W, container_type: &str, mangled_container: &str, args: &Vec<&syn::Type>, generics: Option<&GenericTypes>, is_ref: bool) {
-		if container_type == "Result" {
-			assert_eq!(args.len(), 2);
-			macro_rules! write_fn {
-				($call: expr) => { {
-					writeln!(w, "#[no_mangle]\npub extern \"C\" fn {}_{}() -> {} {{", mangled_container, $call, mangled_container).unwrap();
-					writeln!(w, "\t{}::CResultTempl::{}(0)\n}}\n", Self::container_templ_path(), $call).unwrap();
-				} }
-			}
-			macro_rules! write_alias {
-				($call: expr, $item: expr) => { {
-					write!(w, "#[no_mangle]\npub static {}_{}: extern \"C\" fn (", mangled_container, $call).unwrap();
-					if let syn::Type::Path(syn::TypePath { path, .. }) = $item {
-						let resolved = self.resolve_path(path, generics);
-						if self.is_known_container(&resolved, is_ref) || self.is_transparent_container(&resolved, is_ref) {
-							self.write_c_mangled_container_path_intern(w, Self::path_to_generic_args(path), generics,
-								&format!("{}", single_ident_generic_path_to_ident(path).unwrap()), is_ref, false, false, false);
-						} else {
-							self.write_template_generics(w, &mut [$item].iter().map(|t| *t), generics, is_ref, true);
-						}
-					} else if let syn::Type::Tuple(syn::TypeTuple { elems, .. }) = $item {
-						self.write_c_mangled_container_path_intern(w, elems.iter().collect(), generics,
-							&format!("{}Tuple", elems.len()), is_ref, false, false, false);
-					} else { unimplemented!(); }
-					write!(w, ") -> {} =\n\t{}::CResultTempl::<", mangled_container, Self::container_templ_path()).unwrap();
-					self.write_template_generics(w, &mut args.iter().map(|t| *t), generics, is_ref, true);
-					writeln!(w, ">::{};\n", $call).unwrap();
-				} }
-			}
-			match args[0] {
-				syn::Type::Tuple(t) if t.elems.is_empty() => write_fn!("ok"),
-				_ => write_alias!("ok", args[0]),
-			}
-			match args[1] {
-				syn::Type::Tuple(t) if t.elems.is_empty() => write_fn!("err"),
-				_ => write_alias!("err", args[1]),
-			}
-		} else if container_type.ends_with("Tuple") {
-			write!(w, "#[no_mangle]\npub extern \"C\" fn {}_new(", mangled_container).unwrap();
-			for (idx, gen) in args.iter().enumerate() {
-				write!(w, "{}{}: ", if idx != 0 { ", " } else { "" }, ('a' as u8 + idx as u8) as char).unwrap();
-				assert!(self.write_c_type_intern(w, gen, None, false, false, false));
-			}
-			writeln!(w, ") -> {} {{", mangled_container).unwrap();
-			write!(w, "\t{} {{ ", mangled_container).unwrap();
-			for idx in 0..args.len() {
-				write!(w, "{}, ", ('a' as u8 + idx as u8) as char).unwrap();
-			}
-			writeln!(w, "}}\n}}\n").unwrap();
-		} else {
-			writeln!(w, "").unwrap();
-		}
-	}
-
-	fn write_template_generics<'b, W: std::io::Write>(&self, w: &mut W, args: &mut dyn Iterator<Item=&'b syn::Type>, generics: Option<&GenericTypes>, is_ref: bool, in_crate: bool) {
+	fn write_template_generics<'b, W: std::io::Write>(&mut self, w: &mut W, args: &mut dyn Iterator<Item=&'b syn::Type>, generics: Option<&GenericTypes>, is_ref: bool) -> bool {
+		assert!(!is_ref); // We don't currently support outer reference types
 		for (idx, t) in args.enumerate() {
 			if idx != 0 {
 				write!(w, ", ").unwrap();
 			}
-			if let syn::Type::Tuple(tup) = t {
-				if tup.elems.is_empty() {
-					write!(w, "u8").unwrap();
-				} else {
-					write!(w, "{}::C{}TupleTempl<", Self::container_templ_path(), tup.elems.len()).unwrap();
-					self.write_template_generics(w, &mut tup.elems.iter(), generics, is_ref, in_crate);
-					write!(w, ">").unwrap();
-				}
-			} else if let syn::Type::Path(p_arg) = t {
-				let resolved_generic = self.resolve_path(&p_arg.path, generics);
-				if self.is_primitive(&resolved_generic) {
-					write!(w, "{}", resolved_generic).unwrap();
-				} else if let Some(c_type) = self.c_type_from_path(&resolved_generic, is_ref, false) {
-					if self.is_known_container(&resolved_generic, is_ref) {
-							write!(w, "{}::C{}Templ<", Self::container_templ_path(), single_ident_generic_path_to_ident(&p_arg.path).unwrap()).unwrap();
-						assert_eq!(p_arg.path.segments.len(), 1);
-						if let syn::PathArguments::AngleBracketed(args) = &p_arg.path.segments.iter().next().unwrap().arguments {
-							self.write_template_generics(w, &mut args.args.iter().map(|gen|
-								if let syn::GenericArgument::Type(t) = gen { t } else { unimplemented!() }),
-								generics, is_ref, in_crate);
-						} else { unimplemented!(); }
-						write!(w, ">").unwrap();
-					} else if resolved_generic == "Option" {
-						if let syn::PathArguments::AngleBracketed(args) = &p_arg.path.segments.iter().next().unwrap().arguments {
-							self.write_template_generics(w, &mut args.args.iter().map(|gen|
-								if let syn::GenericArgument::Type(t) = gen { t } else { unimplemented!() }),
-								generics, is_ref, in_crate);
-						} else { unimplemented!(); }
-					} else if in_crate {
-						write!(w, "{}", c_type).unwrap();
-					} else {
-						self.write_rust_type(w, generics, &t);
-					}
-				} else {
-					// If we just write out resolved_generic, it may mostly work, however for
-					// original types which are generic, we need the template args. We could
-					// figure them out and write them out, too, but its much easier to just
-					// reference the native{} type alias which exists at least for opaque types.
-					if in_crate {
-						write!(w, "crate::{}", resolved_generic).unwrap();
-					} else {
-						let path_name: Vec<&str> = resolved_generic.rsplitn(2, "::").collect();
-						if path_name.len() > 1 {
-							write!(w, "crate::{}::native{}", path_name[1], path_name[0]).unwrap();
-						} else {
-							write!(w, "crate::native{}", path_name[0]).unwrap();
-						}
-					}
-				}
-			} else if let syn::Type::Reference(r_arg) = t {
+			if let syn::Type::Reference(r_arg) = t {
+				if !self.write_c_type_intern(w, &*r_arg.elem, generics, false, false, false) { return false; }
+
+				// While write_c_type_intern, above is correct, we don't want to blindly convert a
+				// reference to something stupid, so check that the container is either opaque or a
+				// predefined type (currently only Transaction).
 				if let syn::Type::Path(p_arg) = &*r_arg.elem {
 					let resolved = self.resolve_path(&p_arg.path, generics);
-					if self.crate_types.opaques.get(&resolved).is_some() {
-						write!(w, "crate::{}", resolved).unwrap();
-					} else {
-						let cty = self.c_type_from_path(&resolved, true, true).expect("Template generics should be opaque or have a predefined mapping");
-						w.write(cty.as_bytes()).unwrap();
-					}
+					assert!(self.crate_types.opaques.get(&resolved).is_some() ||
+							self.c_type_from_path(&resolved, true, true).is_some(), "Template generics should be opaque or have a predefined mapping");
 				} else { unimplemented!(); }
-			} else if let syn::Type::Array(a_arg) = t {
-				if let syn::Type::Path(p_arg) = &*a_arg.elem {
-					let resolved = self.resolve_path(&p_arg.path, generics);
-					assert!(self.is_primitive(&resolved));
-					if let syn::Expr::Lit(syn::ExprLit { lit: syn::Lit::Int(len), .. }) = &a_arg.len {
-						write!(w, "{}",
-							self.c_type_from_path(&format!("[{}; {}]", resolved, len.base10_digits()), is_ref, false).unwrap()).unwrap();
-					}
-				}
+			} else {
+				if !self.write_c_type_intern(w, t, generics, false, false, false) { return false; }
 			}
 		}
+		true
 	}
-	fn check_create_container(&mut self, mangled_container: String, container_type: &str, args: Vec<&syn::Type>, generics: Option<&GenericTypes>, is_ref: bool) {
+	fn check_create_container(&mut self, mangled_container: String, container_type: &str, args: Vec<&syn::Type>, generics: Option<&GenericTypes>, is_ref: bool) -> bool {
 		if !self.crate_types.templates_defined.get(&mangled_container).is_some() {
-			self.crate_types.templates_defined.insert(mangled_container.clone(), true);
 			let mut created_container: Vec<u8> = Vec::new();
 
-			write!(&mut created_container, "pub type {} = ", mangled_container).unwrap();
-			write!(&mut created_container, "{}::C{}Templ<", Self::container_templ_path(), container_type).unwrap();
-			self.write_template_generics(&mut created_container, &mut args.iter().map(|t| *t), generics, is_ref, true);
-			writeln!(&mut created_container, ">;").unwrap();
+			if container_type == "Result" {
+				let mut a_ty: Vec<u8> = Vec::new();
+				if let syn::Type::Tuple(tup) = args.iter().next().unwrap() {
+					if tup.elems.is_empty() {
+						write!(&mut a_ty, "()").unwrap();
+					} else {
+						if !self.write_template_generics(&mut a_ty, &mut args.iter().map(|t| *t).take(1), generics, is_ref) { return false; }
+					}
+				} else {
+					if !self.write_template_generics(&mut a_ty, &mut args.iter().map(|t| *t).take(1), generics, is_ref) { return false; }
+				}
 
-			write!(&mut created_container, "#[no_mangle]\npub static {}_free: extern \"C\" fn({}) = ", mangled_container, mangled_container).unwrap();
-			write!(&mut created_container, "{}::C{}Templ_free::<", Self::container_templ_path(), container_type).unwrap();
-			self.write_template_generics(&mut created_container, &mut args.iter().map(|t| *t), generics, is_ref, true);
-			writeln!(&mut created_container, ">;").unwrap();
+				let mut b_ty: Vec<u8> = Vec::new();
+				if let syn::Type::Tuple(tup) = args.iter().skip(1).next().unwrap() {
+					if tup.elems.is_empty() {
+						write!(&mut b_ty, "()").unwrap();
+					} else {
+						if !self.write_template_generics(&mut b_ty, &mut args.iter().map(|t| *t).skip(1), generics, is_ref) { return false; }
+					}
+				} else {
+					if !self.write_template_generics(&mut b_ty, &mut args.iter().map(|t| *t).skip(1), generics, is_ref) { return false; }
+				}
 
-			self.write_template_constructor(&mut created_container, container_type, &mangled_container, &args, generics, is_ref);
+				let ok_str = String::from_utf8(a_ty).unwrap();
+				let err_str = String::from_utf8(b_ty).unwrap();
+				let is_clonable = self.is_clonable(&ok_str) && self.is_clonable(&err_str);
+				write_result_block(&mut created_container, &mangled_container, &ok_str, &err_str, is_clonable);
+				if is_clonable {
+					self.crate_types.clonable_types.insert(Self::generated_container_path().to_owned() + "::" + &mangled_container);
+				}
+			} else if container_type == "Vec" {
+				let mut a_ty: Vec<u8> = Vec::new();
+				if !self.write_template_generics(&mut a_ty, &mut args.iter().map(|t| *t), generics, is_ref) { return false; }
+				let ty = String::from_utf8(a_ty).unwrap();
+				let is_clonable = self.is_clonable(&ty);
+				write_vec_block(&mut created_container, &mangled_container, &ty, is_clonable);
+				if is_clonable {
+					self.crate_types.clonable_types.insert(Self::generated_container_path().to_owned() + "::" + &mangled_container);
+				}
+			} else if container_type.ends_with("Tuple") {
+				let mut tuple_args = Vec::new();
+				let mut is_clonable = true;
+				for arg in args.iter() {
+					let mut ty: Vec<u8> = Vec::new();
+					if !self.write_template_generics(&mut ty, &mut [arg].iter().map(|t| **t), generics, is_ref) { return false; }
+					let ty_str = String::from_utf8(ty).unwrap();
+					if !self.is_clonable(&ty_str) {
+						is_clonable = false;
+					}
+					tuple_args.push(ty_str);
+				}
+				write_tuple_block(&mut created_container, &mangled_container, &tuple_args, is_clonable);
+				if is_clonable {
+					self.crate_types.clonable_types.insert(Self::generated_container_path().to_owned() + "::" + &mangled_container);
+				}
+			} else {
+				unreachable!();
+			}
+			self.crate_types.templates_defined.insert(mangled_container.clone(), true);
 
 			self.crate_types.template_file.write(&created_container).unwrap();
 		}
+		true
 	}
 	fn path_to_generic_args(path: &syn::Path) -> Vec<&syn::Type> {
 		if let syn::PathArguments::AngleBracketed(args) = &path.segments.iter().next().unwrap().arguments {
@@ -1885,45 +1932,42 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 		for arg in args.iter() {
 			macro_rules! write_path {
 				($p_arg: expr, $extra_write: expr) => {
-					let subtype = self.resolve_path(&$p_arg.path, generics);
-					if self.is_transparent_container(ident, is_ref) {
-						// We dont (yet) support primitives or containers inside transparent
-						// containers, so check for that first:
-						if self.is_primitive(&subtype) { return false; }
-						if self.is_known_container(&subtype, is_ref) { return false; }
-						if !in_type {
-							if self.c_type_has_inner_from_path(&subtype) {
-								if !self.write_c_path_intern(w, &$p_arg.path, generics, is_ref, is_mut, ptr_for_ref) { return false; }
+					if let Some(subtype) = self.maybe_resolve_path(&$p_arg.path, generics) {
+						if self.is_transparent_container(ident, is_ref) {
+							// We dont (yet) support primitives or containers inside transparent
+							// containers, so check for that first:
+							if self.is_primitive(&subtype) { return false; }
+							if self.is_known_container(&subtype, is_ref) { return false; }
+							if !in_type {
+								if self.c_type_has_inner_from_path(&subtype) {
+									if !self.write_c_path_intern(w, &$p_arg.path, generics, is_ref, is_mut, ptr_for_ref) { return false; }
+								} else {
+									// Option<T> needs to be converted to a *mut T, ie mut ptr-for-ref
+									if !self.write_c_path_intern(w, &$p_arg.path, generics, true, true, true) { return false; }
+								}
 							} else {
-								// Option<T> needs to be converted to a *mut T, ie mut ptr-for-ref
-								if !self.write_c_path_intern(w, &$p_arg.path, generics, true, true, true) { return false; }
+								write!(w, "{}", $p_arg.path.segments.last().unwrap().ident).unwrap();
 							}
-						} else {
-							if $p_arg.path.segments.len() == 1 {
-								write!(w, "{}", $p_arg.path.segments.iter().next().unwrap().ident).unwrap();
-							} else {
+						} else if self.is_known_container(&subtype, is_ref) || self.is_transparent_container(&subtype, is_ref) {
+							if !self.write_c_mangled_container_path_intern(w, Self::path_to_generic_args(&$p_arg.path), generics,
+									&subtype, is_ref, is_mut, ptr_for_ref, true) {
 								return false;
 							}
-						}
-					} else if self.is_known_container(&subtype, is_ref) || self.is_transparent_container(&subtype, is_ref) {
-						if !self.write_c_mangled_container_path_intern(w, Self::path_to_generic_args(&$p_arg.path), generics,
-								&subtype, is_ref, is_mut, ptr_for_ref, true) {
-							return false;
-						}
-						self.write_c_mangled_container_path_intern(&mut mangled_type, Self::path_to_generic_args(&$p_arg.path),
-							generics, &subtype, is_ref, is_mut, ptr_for_ref, true);
-						if let Some(w2) = $extra_write as Option<&mut Vec<u8>> {
-							self.write_c_mangled_container_path_intern(w2, Self::path_to_generic_args(&$p_arg.path),
+							self.write_c_mangled_container_path_intern(&mut mangled_type, Self::path_to_generic_args(&$p_arg.path),
 								generics, &subtype, is_ref, is_mut, ptr_for_ref, true);
+							if let Some(w2) = $extra_write as Option<&mut Vec<u8>> {
+								self.write_c_mangled_container_path_intern(w2, Self::path_to_generic_args(&$p_arg.path),
+									generics, &subtype, is_ref, is_mut, ptr_for_ref, true);
+							}
+						} else {
+							let id = subtype.rsplitn(2, ':').next().unwrap(); // Get the "Base" name of the resolved type
+							write!(w, "{}", id).unwrap();
+							write!(mangled_type, "{}", id).unwrap();
+							if let Some(w2) = $extra_write as Option<&mut Vec<u8>> {
+								write!(w2, "{}", id).unwrap();
+							}
 						}
-					} else {
-						let id = &&$p_arg.path.segments.iter().rev().next().unwrap().ident;
-						write!(w, "{}", id).unwrap();
-						write!(mangled_type, "{}", id).unwrap();
-						if let Some(w2) = $extra_write as Option<&mut Vec<u8>> {
-							write!(w2, "{}", id).unwrap();
-						}
-					}
+					} else { return false; }
 				}
 			}
 			if let syn::Type::Tuple(tuple) = arg {
@@ -1952,13 +1996,14 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 					write!(w, "Z").unwrap();
 					write!(mangled_type, "Z").unwrap();
 					write!(mangled_tuple_type, "Z").unwrap();
-					self.check_create_container(String::from_utf8(mangled_tuple_type).unwrap(),
-						&format!("{}Tuple", tuple.elems.len()), tuple.elems.iter().collect(), generics, is_ref);
+					if !self.check_create_container(String::from_utf8(mangled_tuple_type).unwrap(),
+							&format!("{}Tuple", tuple.elems.len()), tuple.elems.iter().collect(), generics, is_ref) {
+						return false;
+					}
 				}
 			} else if let syn::Type::Path(p_arg) = arg {
 				write_path!(p_arg, None);
 			} else if let syn::Type::Reference(refty) = arg {
-				if args.len() != 1 { return false; }
 				if let syn::Type::Path(p_arg) = &*refty.elem {
 					write_path!(p_arg, None);
 				} else if let syn::Type::Slice(_) = &*refty.elem {
@@ -1966,6 +2011,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 					// make it a pointer so that its an option. Note that we cannot always convert
 					// the Vec-as-slice (ie non-ref types) containers, so sometimes need to be able
 					// to edit it, hence we use *mut here instead of *const.
+					if args.len() != 1 { return false; }
 					write!(w, "*mut ").unwrap();
 					self.write_c_type(w, arg, None, true);
 				} else { return false; }
@@ -1987,8 +2033,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 		write!(mangled_type, "Z").unwrap();
 
 		// Make sure the type is actually defined:
-		self.check_create_container(String::from_utf8(mangled_type).unwrap(), ident, args, generics, is_ref);
-		true
+		self.check_create_container(String::from_utf8(mangled_type).unwrap(), ident, args, generics, is_ref)
 	}
 	fn write_c_mangled_container_path<W: std::io::Write>(&mut self, w: &mut W, args: Vec<&syn::Type>, generics: Option<&GenericTypes>, ident: &str, is_ref: bool, is_mut: bool, ptr_for_ref: bool) -> bool {
 		if !self.is_transparent_container(ident, is_ref) {
@@ -2098,8 +2143,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 							format!("CVec_{}Z", id)
 						} else { return false; };
 						write!(w, "{}::{}", Self::generated_container_path(), mangled_container).unwrap();
-						self.check_create_container(mangled_container, "Vec", vec![&*r.elem], generics, false);
-						true
+						self.check_create_container(mangled_container, "Vec", vec![&*r.elem], generics, false)
 					} else { false }
 				} else if let syn::Type::Tuple(_) = &*s.elem {
 					let mut args = syn::punctuated::Punctuated::new();