diff --git a/engine/src/ast_discoverer.rs b/engine/src/ast_discoverer.rs
index 8840899..f555419 100644
--- a/engine/src/ast_discoverer.rs
+++ b/engine/src/ast_discoverer.rs
@@ -14,12 +14,13 @@
 };
 use itertools::Itertools;
 use proc_macro2::Ident;
+use syn::visit_mut::{visit_type_mut, VisitMut};
 use syn::{
-    parse_quote, punctuated::Punctuated, Attribute, Binding, Expr, ExprAssign, ExprAssignOp,
-    ExprAwait, ExprBinary, ExprBox, ExprBreak, ExprCast, ExprField, ExprGroup, ExprLet, ExprParen,
-    ExprReference, ExprTry, ExprType, ExprUnary, ImplItem, Item, ItemEnum, ItemStruct, Pat, PatBox,
-    PatReference, PatSlice, PatTuple, Path, Receiver, ReturnType, Signature, Stmt, TraitItem, Type,
-    TypeArray, TypeGroup, TypeParamBound, TypeParen, TypePtr, TypeReference, TypeSlice,
+    parse_quote, punctuated::Punctuated, AssocConst, AssocType, Attribute, Expr, ExprAssign,
+    ExprAwait, ExprBinary, ExprBlock, ExprBreak, ExprCast, ExprConst, ExprField, ExprGroup,
+    ExprLet, ExprParen, ExprReference, ExprTry, ExprUnary, ImplItem, Item, ItemEnum, ItemStruct,
+    LocalInit, Pat, PatReference, PatSlice, PatTuple, Path, ReturnType, Signature, Stmt, TraitItem,
+    Type, TypeArray, TypeGroup, TypeParamBound, TypeParen, TypePtr, TypeReference, TypeSlice,
 };
 use thiserror::Error;
 
@@ -34,8 +35,6 @@
 pub enum DiscoveryErr {
     #[error("#[extern_rust_function] was attached to a method in an impl block that was too complex for autocxx. autocxx supports only \"impl X {{...}}\" where X is a single identifier, not a path or more complex type.")]
     FoundExternRustFunOnTypeWithoutClearReceiver,
-    #[error("#[extern_rust_function] was attached to a method taking no parameters.")]
-    NonReferenceReceiver,
     #[error("#[extern_rust_function] was attached to a method taking a receiver by value.")]
     NoParameterOnMethod,
     #[error("#[extern_rust_function] was in an impl block nested wihtin another block. This is only supported in the outermost mod of a file, alongside the include_cpp!.")]
@@ -103,7 +102,7 @@
                     self.discoveries.extern_rust_funs.push(RustFun {
                         path: self.deeper_path(&fun.sig.ident),
                         sig: fun.sig.clone(),
-                        receiver: None,
+                        has_receiver: false,
                     });
                 }
             }
@@ -178,7 +177,7 @@
     }
 
     fn search_trait_item(&mut self, itm: &TraitItem) -> Result<(), DiscoveryErr> {
-        if let TraitItem::Method(itm) = itm {
+        if let TraitItem::Fn(itm) = itm {
             if let Some(block) = &itm.default {
                 self.search_stmts(block.stmts.iter())?
             }
@@ -199,13 +198,14 @@
     fn search_stmt(&mut self, stmt: &Stmt) -> Result<(), DiscoveryErr> {
         match stmt {
             Stmt::Local(lcl) => {
-                if let Some((_, expr)) = &lcl.init {
+                if let Some(LocalInit { expr, .. }) = &lcl.init {
                     self.search_expr(expr)?
                 }
                 self.search_pat(&lcl.pat)
             }
             Stmt::Item(itm) => self.search_item(itm),
-            Stmt::Expr(exp) | Stmt::Semi(exp, _) => self.search_expr(exp),
+            Stmt::Expr(exp, _) => self.search_expr(exp),
+            Stmt::Macro(_) => Ok(()),
         }
     }
 
@@ -214,10 +214,9 @@
             Expr::Path(exp) => {
                 self.search_path(&exp.path)?;
             }
-            Expr::Macro(_) => {}
+            Expr::Macro(_) | Expr::Infer(_) => {}
             Expr::Array(array) => self.search_exprs(array.elems.iter())?,
             Expr::Assign(ExprAssign { left, right, .. })
-            | Expr::AssignOp(ExprAssignOp { left, right, .. })
             | Expr::Binary(ExprBinary { left, right, .. }) => {
                 self.search_expr(left)?;
                 self.search_expr(right)?;
@@ -226,9 +225,10 @@
             Expr::Await(ExprAwait { base, .. }) | Expr::Field(ExprField { base, .. }) => {
                 self.search_expr(base)?
             }
-            Expr::Block(blck) => self.search_stmts(blck.block.stmts.iter())?,
-            Expr::Box(ExprBox { expr, .. })
-            | Expr::Break(ExprBreak {
+            Expr::Block(ExprBlock { block, .. }) | Expr::Const(ExprConst { block, .. }) => {
+                self.search_stmts(block.stmts.iter())?
+            }
+            Expr::Break(ExprBreak {
                 expr: Some(expr), ..
             })
             | Expr::Cast(ExprCast { expr, .. })
@@ -236,7 +236,6 @@
             | Expr::Paren(ExprParen { expr, .. })
             | Expr::Reference(ExprReference { expr, .. })
             | Expr::Try(ExprTry { expr, .. })
-            | Expr::Type(ExprType { expr, .. })
             | Expr::Unary(ExprUnary { expr, .. }) => self.search_expr(expr)?,
             Expr::Call(exc) => {
                 self.search_expr(&exc.func)?;
@@ -281,8 +280,8 @@
                 self.search_exprs(mtc.args.iter())?;
             }
             Expr::Range(exr) => {
-                self.search_option_expr(&exr.from)?;
-                self.search_option_expr(&exr.to)?;
+                self.search_option_expr(&exr.start)?;
+                self.search_option_expr(&exr.end)?;
             }
             Expr::Repeat(exr) => {
                 self.search_expr(&exr.expr)?;
@@ -334,7 +333,7 @@
         impl_item: &ImplItem,
         receiver: Option<&RustPath>,
     ) -> Result<(), DiscoveryErr> {
-        if let ImplItem::Method(itm) = impl_item {
+        if let ImplItem::Fn(itm) = impl_item {
             if Self::has_attr(&itm.attrs, EXTERN_RUST_FUN) {
                 if self.mod_path.is_some() {
                     return Err(DiscoveryErr::FoundExternRustFunWithinMod);
@@ -347,7 +346,7 @@
                     self.discoveries.extern_rust_funs.push(RustFun {
                         path: self.deeper_path(&itm.sig.ident),
                         sig,
-                        receiver: Some(receiver.get_final_ident().clone()),
+                        has_receiver: true,
                     });
                     self.discoveries.extern_rust_types.push(receiver.clone())
                 } else {
@@ -363,10 +362,15 @@
 
     fn search_pat(&mut self, pat: &Pat) -> Result<(), DiscoveryErr> {
         match pat {
-            Pat::Box(PatBox { pat, .. }) | Pat::Reference(PatReference { pat, .. }) => {
-                self.search_pat(pat)
+            Pat::Const(const_) => {
+                for stmt in &const_.block.stmts {
+                    self.search_stmt(stmt)?
+                }
+                Ok(())
             }
+            Pat::Reference(PatReference { pat, .. }) => self.search_pat(pat),
             Pat::Ident(_) | Pat::Lit(_) | Pat::Macro(_) | Pat::Range(_) | Pat::Rest(_) => Ok(()),
+            Pat::Paren(paren) => self.search_pat(&paren.pat),
             Pat::Or(pator) => {
                 for case in &pator.cases {
                     self.search_pat(case)?;
@@ -389,7 +393,7 @@
             }
             Pat::TupleStruct(tps) => {
                 self.search_path(&tps.path)?;
-                for f in &tps.pat.elems {
+                for f in &tps.elems {
                     self.search_pat(f)?;
                 }
                 Ok(())
@@ -398,6 +402,7 @@
                 self.search_pat(&pt.pat)?;
                 self.search_type(&pt.ty)
             }
+            Pat::Verbatim(_) | Pat::Wild(_) => Ok(()),
             _ => Ok(()),
         }
     }
@@ -438,7 +443,7 @@
 
     fn search_type_param_bounds(
         &mut self,
-        bounds: &Punctuated<TypeParamBound, syn::token::Add>,
+        bounds: &Punctuated<TypeParamBound, syn::token::Plus>,
     ) -> Result<(), DiscoveryErr> {
         for b in bounds {
             if let syn::TypeParamBound::Trait(tpbt) = b {
@@ -467,13 +472,17 @@
                     match arg {
                         syn::GenericArgument::Lifetime(_) => {}
                         syn::GenericArgument::Type(ty)
-                        | syn::GenericArgument::Binding(Binding { ty, .. }) => {
+                        | syn::GenericArgument::AssocType(AssocType { ty, .. }) => {
                             self.search_type(ty)?
                         }
                         syn::GenericArgument::Constraint(c) => {
                             self.search_type_param_bounds(&c.bounds)?
                         }
-                        syn::GenericArgument::Const(c) => self.search_expr(c)?,
+                        syn::GenericArgument::Const(value)
+                        | syn::GenericArgument::AssocConst(AssocConst { value, .. }) => {
+                            self.search_expr(value)?
+                        }
+                        _ => {}
                     }
                 }
             }
@@ -489,7 +498,7 @@
 
     fn has_attr(attrs: &[Attribute], attr_name: &str) -> bool {
         attrs.iter().any(|attr| {
-            attr.path
+            attr.path()
                 .segments
                 .last()
                 .map(|seg| seg.ident == attr_name)
@@ -498,6 +507,24 @@
     }
 }
 
+struct SelfSubstituter<'a> {
+    self_ty: &'a Ident,
+}
+
+impl<'a> SelfSubstituter<'a> {
+    pub fn new(self_ty: &'a Ident) -> Self {
+        Self { self_ty }
+    }
+}
+
+impl<'a> VisitMut for SelfSubstituter<'a> {
+    fn visit_type_path_mut(&mut self, i: &mut syn::TypePath) {
+        if i.qself.is_none() && i.path.is_ident("Self") {
+            i.path = Path::from(self.self_ty.clone());
+        }
+    }
+}
+
 /// Take a method signature that may be `fn a(&self)`
 /// and turn it into `fn a(self: &A)` which is what we will
 /// need to specify to cxx.
@@ -505,25 +532,19 @@
     let mut sig = sig.clone();
     match sig.inputs.iter_mut().next() {
         Some(first_arg) => match first_arg {
-            syn::FnArg::Receiver(Receiver {
-                reference: Some(_),
-                mutability: Some(_),
-                ..
-            }) => {
+            syn::FnArg::Receiver(rec_arg) => {
+                let mut substituted_type = rec_arg.ty.clone();
+                visit_type_mut(&mut SelfSubstituter::new(receiver), &mut substituted_type);
                 *first_arg = parse_quote! {
-                    self: &mut #receiver
+                        qelf: #substituted_type
+                };
+                if let syn::FnArg::Typed(ref mut pat_type) = *first_arg {
+                    if let syn::Pat::Ident(ref mut pat_ident) = *pat_type.pat {
+                        assert_eq!(pat_ident.ident.to_string(), "qelf");
+                        pat_ident.ident = Ident::new("self", pat_ident.ident.span());
+                    }
                 }
             }
-            syn::FnArg::Receiver(Receiver {
-                reference: Some(_),
-                mutability: None,
-                ..
-            }) => {
-                *first_arg = parse_quote! {
-                    self: &#receiver
-                }
-            }
-            syn::FnArg::Receiver(..) => return Err(DiscoveryErr::NonReferenceReceiver),
             syn::FnArg::Typed(_) => {}
         },
         None => return Err(DiscoveryErr::NoParameterOnMethod),
@@ -534,7 +555,7 @@
 #[cfg(test)]
 mod tests {
     use quote::{quote, ToTokens};
-    use syn::{parse_quote, ImplItemMethod};
+    use syn::{parse_quote, ImplItemFn};
 
     use crate::{ast_discoverer::add_receiver, types::make_ident};
 
@@ -690,7 +711,7 @@
 
     #[test]
     fn test_add_receiver() {
-        let meth: ImplItemMethod = parse_quote! {
+        let meth: ImplItemFn = parse_quote! {
             fn a(&self) {}
         };
         let a = make_ident("A");
@@ -702,7 +723,7 @@
             quote! { fn a(self: &A) }.to_string()
         );
 
-        let meth: ImplItemMethod = parse_quote! {
+        let meth: ImplItemFn = parse_quote! {
             fn a(&mut self, b: u32) -> Foo {}
         };
         assert_eq!(
@@ -713,12 +734,7 @@
             quote! { fn a(self: &mut A, b: u32) -> Foo }.to_string()
         );
 
-        let meth: ImplItemMethod = parse_quote! {
-            fn a(self) {}
-        };
-        assert!(add_receiver(&meth.sig, &a).is_err());
-
-        let meth: ImplItemMethod = parse_quote! {
+        let meth: ImplItemFn = parse_quote! {
             fn a() {}
         };
         assert!(add_receiver(&meth.sig, &a).is_err());
diff --git a/engine/src/builder.rs b/engine/src/builder.rs
index d0b5199..064056e 100644
--- a/engine/src/builder.rs
+++ b/engine/src/builder.rs
@@ -10,8 +10,8 @@
 use miette::Diagnostic;
 use thiserror::Error;
 
-use crate::generate_rs_single;
-use crate::{strip_system_headers, CppCodegenOptions, ParseError, RebuildDependencyRecorder};
+use crate::{generate_rs_single, CodegenOptions};
+use crate::{get_cxx_header_bytes, CppCodegenOptions, ParseError, RebuildDependencyRecorder};
 use std::ffi::OsStr;
 use std::ffi::OsString;
 use std::fs::File;
@@ -63,8 +63,16 @@
 
 /// An object to allow building of bindings from a `build.rs` file.
 ///
-/// It would be unusual to use this directly - see the `autocxx_build` or
+/// It would be unusual to create this directly - see the `autocxx_build` or
 /// `autocxx_gen` crates.
+///
+/// Once you've got one of these objects, you may set some configuration
+/// options but then you're likely to want to call the [`build`] method.
+///
+/// # Setting C++ version
+///
+/// Ensure you use [`extra_clang_args`] as well as giving an appropriate
+/// option to the [`cc::Build`] which you receive from the [`build`] function.
 #[cfg_attr(feature = "nightly", doc(cfg(feature = "build")))]
 pub struct Builder<'a, BuilderContext> {
     rs_file: PathBuf,
@@ -73,7 +81,7 @@
     dependency_recorder: Option<Box<dyn RebuildDependencyRecorder>>,
     custom_gendir: Option<PathBuf>,
     auto_allowlist: bool,
-    cpp_codegen_options: CppCodegenOptions<'a>,
+    codegen_options: CodegenOptions<'a>,
     // This member is to ensure that this type is parameterized
     // by a BuilderContext. The goal is to balance three needs:
     // (1) have most of the functionality over in autocxx_engine,
@@ -108,12 +116,14 @@
             dependency_recorder: CTX::get_dependency_recorder(),
             custom_gendir: None,
             auto_allowlist: false,
-            cpp_codegen_options: CppCodegenOptions::default(),
+            codegen_options: CodegenOptions::default(),
             ctx: PhantomData,
         }
     }
 
-    /// Specify extra arguments for clang.
+    /// Specify extra arguments for clang. These are used when parsing
+    /// C++ headers. For example, you might want to provide
+    /// `-std=c++17` to specify C++17.
     pub fn extra_clang_args(mut self, extra_clang_args: &[&str]) -> Self {
         self.extra_clang_args = extra_clang_args.iter().map(|s| s.to_string()).collect();
         self
@@ -130,7 +140,7 @@
     where
         F: FnOnce(&mut CppCodegenOptions),
     {
-        modifier(&mut self.cpp_codegen_options);
+        modifier(&mut self.codegen_options.cpp_codegen_options);
         self
     }
 
@@ -152,20 +162,33 @@
         self
     }
 
+    #[doc(hidden)]
+    /// Whether to force autocxx always to generate extra Rust and C++
+    /// side shims. This is only used by the integration test suite to
+    /// exercise more code paths - don't use it!
+    pub fn force_wrapper_generation(mut self, do_it: bool) -> Self {
+        self.codegen_options.force_wrapper_gen = do_it;
+        self
+    }
+
     /// Whether to suppress inclusion of system headers (`memory`, `string` etc.)
     /// from generated C++ bindings code. This should not normally be used,
     /// but can occasionally be useful if you're reducing a test case and you
     /// have a preprocessed header file which already contains absolutely everything
     /// that the bindings could ever need.
     pub fn suppress_system_headers(mut self, do_it: bool) -> Self {
-        self.cpp_codegen_options.suppress_system_headers = do_it;
+        self.codegen_options
+            .cpp_codegen_options
+            .suppress_system_headers = do_it;
         self
     }
 
     /// An annotation optionally to include on each C++ function.
     /// For example to export the symbol from a library.
     pub fn cxx_impl_annotations(mut self, cxx_impl_annotations: Option<String>) -> Self {
-        self.cpp_codegen_options.cxx_impl_annotations = cxx_impl_annotations;
+        self.codegen_options
+            .cpp_codegen_options
+            .cxx_impl_annotations = cxx_impl_annotations;
         self
     }
 
@@ -176,6 +199,17 @@
     /// so if you use the `miette` crate and its `fancy` feature, then simply
     /// return a `miette::Result` from your main function, you should get nicely
     /// printed diagnostics.
+    ///
+    /// As this is a [`cc::Build`] there are lots of options you can apply to
+    /// the resulting options, but please bear in mind that these only apply
+    /// to the build process for the generated code - such options will not
+    /// influence autocxx's process for parsing header files.
+    ///
+    /// For example, if you wish to set the C++ version to C++17, you might
+    /// be tempted to use [`cc::Build::flag_if_supported`] to add the
+    /// `-std=c++17` flag. However, this won't affect the header parsing which
+    /// autocxx does internally (by means of bindgen) so you _additionally_
+    /// should call [`extra_clang_args`] with that same option.
     pub fn build(self) -> Result<BuilderBuild, BuilderError> {
         self.build_listing_files().map(|r| r.0)
     }
@@ -208,7 +242,11 @@
         write_to_file(
             &incdir,
             "cxx.h",
-            &Self::get_cxx_header_bytes(self.cpp_codegen_options.suppress_system_headers),
+            &get_cxx_header_bytes(
+                self.codegen_options
+                    .cpp_codegen_options
+                    .suppress_system_headers,
+            ),
         )?;
 
         let autocxx_inc = build_autocxx_inc(self.autocxx_incs, &incdir);
@@ -221,7 +259,7 @@
                 autocxx_inc,
                 clang_args,
                 self.dependency_recorder,
-                &self.cpp_codegen_options,
+                &self.codegen_options,
             )
             .map_err(BuilderError::ParseError)?;
         let mut counter = 0;
@@ -235,10 +273,10 @@
         builder.includes(parsed_file.include_dirs());
         for include_cpp in parsed_file.get_cpp_buildables() {
             let generated_code = include_cpp
-                .generate_h_and_cxx(&self.cpp_codegen_options)
+                .generate_h_and_cxx(&self.codegen_options.cpp_codegen_options)
                 .map_err(BuilderError::InvalidCxx)?;
             for filepair in generated_code.0 {
-                let fname = format!("gen{}.cxx", counter);
+                let fname = format!("gen{counter}.cxx");
                 counter += 1;
                 if let Some(implementation) = &filepair.implementation {
                     let gen_cxx_path = write_to_file(&cxxdir, &fname, implementation)?;
@@ -260,10 +298,6 @@
             Ok(BuilderSuccess(builder, generated_rs, generated_cpp))
         }
     }
-
-    fn get_cxx_header_bytes(suppress_system_headers: bool) -> Vec<u8> {
-        strip_system_headers(crate::HEADER.as_bytes().to_vec(), suppress_system_headers)
-    }
 }
 
 fn ensure_created(dir: &Path) -> Result<(), BuilderError> {
@@ -285,6 +319,13 @@
 
 fn write_to_file(dir: &Path, filename: &str, content: &[u8]) -> Result<PathBuf, BuilderError> {
     let path = dir.join(filename);
+    if let Ok(existing_contents) = std::fs::read(&path) {
+        // Avoid altering timestamps on disk if the file already exists,
+        // to stop downstream build steps recurring.
+        if existing_contents == content {
+            return Ok(path);
+        }
+    }
     try_write_to_file(&path, content).map_err(|e| BuilderError::FileWriteFail(e, path.clone()))?;
     Ok(path)
 }
diff --git a/engine/src/conversion/analysis/abstract_types.rs b/engine/src/conversion/analysis/abstract_types.rs
index dac9684..884cbd0 100644
--- a/engine/src/conversion/analysis/abstract_types.rs
+++ b/engine/src/conversion/analysis/abstract_types.rs
@@ -6,6 +6,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use indexmap::map::IndexMap as HashMap;
+use syn::{punctuated::Punctuated, token::Comma, FnArg};
+
 use super::{
     fun::{
         FnAnalysis, FnKind, FnPhase, FnPrePhase2, MethodKind, PodAndConstructorAnalysis,
@@ -13,106 +16,164 @@
     },
     pod::PodAnalysis,
 };
-use crate::conversion::{api::Api, apivec::ApiVec};
 use crate::conversion::{
-    api::TypeKind,
+    analysis::{depth_first::fields_and_bases_first, fun::ReceiverMutability},
+    api::{ApiName, TypeKind},
     error_reporter::{convert_apis, convert_item_apis},
-    ConvertError,
+    ConvertErrorFromCpp,
+};
+use crate::{
+    conversion::{api::Api, apivec::ApiVec},
+    types::QualifiedName,
 };
 use indexmap::set::IndexSet as HashSet;
 
+#[derive(Hash, PartialEq, Eq, Clone, Debug)]
+struct Signature {
+    name: String,
+    args: Vec<syn::Type>,
+    constness: ReceiverMutability,
+}
+
+impl Signature {
+    fn new(
+        name: &ApiName,
+        params: &Punctuated<FnArg, Comma>,
+        constness: ReceiverMutability,
+    ) -> Self {
+        Signature {
+            name: name.cpp_name(),
+            args: params
+                .iter()
+                .skip(1) // skip `this` implicit argument
+                .filter_map(|p| {
+                    if let FnArg::Typed(t) = p {
+                        Some((*t.ty).clone())
+                    } else {
+                        None
+                    }
+                })
+                .collect(),
+            constness,
+        }
+    }
+}
+
 /// Spot types with pure virtual functions and mark them abstract.
-pub(crate) fn mark_types_abstract(mut apis: ApiVec<FnPrePhase2>) -> ApiVec<FnPrePhase2> {
-    let mut abstract_types: HashSet<_> = apis
-        .iter()
-        .filter_map(|api| match &api {
-            Api::Function {
-                analysis:
-                    FnAnalysis {
-                        kind:
-                            FnKind::Method {
-                                impl_for: self_ty_name,
-                                method_kind: MethodKind::PureVirtual(_),
-                                ..
-                            },
-                        ..
-                    },
-                ..
-            } => Some(self_ty_name.clone()),
-            _ => None,
+pub(crate) fn mark_types_abstract(apis: ApiVec<FnPrePhase2>) -> ApiVec<FnPrePhase2> {
+    #[derive(Default, Debug, Clone)]
+    struct ClassAbstractState {
+        undefined: HashSet<Signature>,
+        defined: HashSet<Signature>,
+    }
+    let mut class_states: HashMap<QualifiedName, ClassAbstractState> = HashMap::new();
+    let mut abstract_classes = HashSet::new();
+
+    for api in apis.iter() {
+        if let Api::Function {
+            name,
+            analysis:
+                FnAnalysis {
+                    kind:
+                        FnKind::Method {
+                            impl_for: self_ty_name,
+                            method_kind,
+                            ..
+                        },
+                    params,
+                    ..
+                },
+            ..
+        } = api
+        {
+            match method_kind {
+                MethodKind::PureVirtual(constness) => {
+                    class_states
+                        .entry(self_ty_name.clone())
+                        .or_default()
+                        .undefined
+                        .insert(Signature::new(name, params, *constness));
+                }
+                MethodKind::Virtual(constness) => {
+                    class_states
+                        .entry(self_ty_name.clone())
+                        .or_default()
+                        .defined
+                        .insert(Signature::new(name, params, *constness));
+                }
+                _ => {}
+            }
+        }
+    }
+
+    for api in fields_and_bases_first(apis.iter()) {
+        if let Api::Struct {
+            analysis:
+                PodAndConstructorAnalysis {
+                    pod:
+                        PodAnalysis {
+                            bases,
+                            kind: TypeKind::Pod | TypeKind::NonPod,
+                            ..
+                        },
+                    ..
+                },
+            name,
+            ..
+        } = api
+        {
+            // resolve virtuals for a class: start with new pure virtuals in this class
+            let mut self_cs = class_states.get(&name.name).cloned().unwrap_or_default();
+
+            // then add pure virtuals of bases
+            for base in bases.iter() {
+                if let Some(base_cs) = class_states.get(base) {
+                    self_cs.undefined.extend(base_cs.undefined.iter().cloned());
+                }
+            }
+
+            // then remove virtuals defined in this class
+            self_cs
+                .undefined
+                .retain(|und| !self_cs.defined.contains(und));
+
+            // if there are undefined functions, mark as virtual
+            if !self_cs.undefined.is_empty() {
+                abstract_classes.insert(name.name.clone());
+            }
+
+            // store it back so child classes can read it properly
+            *class_states.entry(name.name.clone()).or_default() = self_cs;
+        }
+    }
+
+    // mark abstract types as abstract
+    let mut apis: ApiVec<_> = apis
+        .into_iter()
+        .map(|mut api| {
+            if let Api::Struct { name, analysis, .. } = &mut api {
+                if abstract_classes.contains(&name.name) {
+                    analysis.pod.kind = TypeKind::Abstract;
+                }
+            }
+            api
         })
         .collect();
 
-    // Spot any derived classes (recursively). Also, any types which have a base
-    // class that's not on the allowlist are presumed to be abstract, because we
-    // have no way of knowing (as they're not on the allowlist, there will be
-    // no methods associated so we won't be able to spot pure virtual methods).
-    let mut iterate = true;
-    while iterate {
-        iterate = false;
-        apis = apis
-            .into_iter()
-            .map(|api| {
-                match api {
-                    Api::Struct {
-                        analysis:
-                            PodAndConstructorAnalysis {
-                                pod:
-                                    PodAnalysis {
-                                        bases,
-                                        kind: TypeKind::Pod | TypeKind::NonPod,
-                                        castable_bases,
-                                        field_deps,
-                                        field_info,
-                                        is_generic,
-                                        in_anonymous_namespace,
-                                    },
-                                constructors,
-                            },
-                        name,
-                        details,
-                    } if abstract_types.contains(&name.name)
-                        || !abstract_types.is_disjoint(&bases) =>
-                    {
-                        abstract_types.insert(name.name.clone());
-                        // Recurse in case there are further dependent types
-                        iterate = true;
-                        Api::Struct {
-                            analysis: PodAndConstructorAnalysis {
-                                pod: PodAnalysis {
-                                    bases,
-                                    kind: TypeKind::Abstract,
-                                    castable_bases,
-                                    field_deps,
-                                    field_info,
-                                    is_generic,
-                                    in_anonymous_namespace,
-                                },
-                                constructors,
-                            },
-                            name,
-                            details,
-                        }
-                    }
-                    _ => api,
-                }
-            })
-            .collect()
-    }
-
     // We also need to remove any constructors belonging to these
     // abstract types.
     apis.retain(|api| {
         !matches!(&api,
-        Api::Function {
-            analysis:
-                FnAnalysis {
-                    kind: FnKind::Method{impl_for: self_ty, method_kind: MethodKind::Constructor{..}, ..}
-                        | FnKind::TraitMethod{ kind: TraitMethodKind::CopyConstructor | TraitMethodKind::MoveConstructor, impl_for: self_ty, ..},
+            Api::Function {
+                analysis:
+                    FnAnalysis {
+                        kind: FnKind::Method{impl_for: self_ty, method_kind: MethodKind::Constructor{..}, ..}
+                            | FnKind::TraitMethod{ kind: TraitMethodKind::CopyConstructor | TraitMethodKind::MoveConstructor, impl_for: self_ty, ..},
+                        ..
+                    },
                     ..
-                },
-                ..
-        } if abstract_types.contains(self_ty))
+            } if abstract_classes.contains(self_ty)
+        )
     });
 
     // Finally, if there are any types which are nested inside other types,
@@ -143,10 +204,11 @@
             .map(|n| n.contains("::"))
             .unwrap_or_default() =>
         {
-            Err(ConvertError::AbstractNestedType)
+            Err(ConvertErrorFromCpp::AbstractNestedType)
         }
         _ => Ok(Box::new(std::iter::once(api))),
     });
+
     results
 }
 
diff --git a/engine/src/conversion/analysis/allocators.rs b/engine/src/conversion/analysis/allocators.rs
index 3695de0..da25a77 100644
--- a/engine/src/conversion/analysis/allocators.rs
+++ b/engine/src/conversion/analysis/allocators.rs
@@ -12,9 +12,13 @@
 
 use crate::{
     conversion::{
-        api::{Api, ApiName, CppVisibility, FuncToConvert, Provenance, References, TraitSynthesis},
+        api::{
+            Api, ApiName, CppVisibility, DeletedOrDefaulted, FuncToConvert, Provenance, References,
+            TraitSynthesis,
+        },
         apivec::ApiVec,
     },
+    minisyn::minisynize_punctuated,
     types::{make_ident, QualifiedName},
 };
 
@@ -73,8 +77,8 @@
                 fun: Box::new(FuncToConvert {
                     ident,
                     doc_attrs: Vec::new(),
-                    inputs,
-                    output,
+                    inputs: minisynize_punctuated(inputs),
+                    output: output.into(),
                     vis: parse_quote! { pub },
                     virtualness: crate::conversion::api::Virtualness::None,
                     cpp_vis: CppVisibility::Public,
@@ -86,7 +90,7 @@
                     synthesized_this_type: None,
                     synthetic_cpp: Some((cpp_function_body, CppFunctionKind::Function)),
                     add_to_trait: Some(synthesis),
-                    is_deleted: false,
+                    is_deleted: DeletedOrDefaulted::Neither,
                     provenance: Provenance::SynthesizedOther,
                     variadic: false,
                 }),
diff --git a/engine/src/conversion/analysis/casts.rs b/engine/src/conversion/analysis/casts.rs
index 5f493f9..2426a50 100644
--- a/engine/src/conversion/analysis/casts.rs
+++ b/engine/src/conversion/analysis/casts.rs
@@ -6,13 +6,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use crate::minisyn::FnArg;
 use itertools::Itertools;
 use quote::quote;
-use syn::{parse_quote, FnArg};
+use syn::parse_quote;
 
 use crate::{
     conversion::{
-        api::{Api, ApiName, CastMutability, Provenance, References, TraitSynthesis},
+        api::{
+            Api, ApiName, CastMutability, DeletedOrDefaulted, Provenance, References,
+            TraitSynthesis,
+        },
         apivec::ApiVec,
     },
     types::{make_ident, QualifiedName},
@@ -112,7 +116,7 @@
                 mutable,
             }),
             synthetic_cpp: Some((CppFunctionBody::Cast, CppFunctionKind::Function)),
-            is_deleted: false,
+            is_deleted: DeletedOrDefaulted::Neither,
             provenance: Provenance::SynthesizedOther,
             variadic: false,
         }),
diff --git a/engine/src/conversion/analysis/ctypes.rs b/engine/src/conversion/analysis/ctypes.rs
index b2ce840..bc6f096 100644
--- a/engine/src/conversion/analysis/ctypes.rs
+++ b/engine/src/conversion/analysis/ctypes.rs
@@ -8,7 +8,7 @@
 
 use indexmap::map::IndexMap as HashMap;
 
-use syn::Ident;
+use crate::minisyn::Ident;
 
 use crate::conversion::api::ApiName;
 use crate::conversion::apivec::ApiVec;
diff --git a/engine/src/conversion/analysis/deps.rs b/engine/src/conversion/analysis/deps.rs
index 7aca96c..a301090 100644
--- a/engine/src/conversion/analysis/deps.rs
+++ b/engine/src/conversion/analysis/deps.rs
@@ -6,8 +6,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use itertools::Itertools;
-
 use crate::{
     conversion::api::{Api, TypeKind},
     types::QualifiedName,
@@ -22,10 +20,6 @@
 pub(crate) trait HasDependencies {
     fn name(&self) -> &QualifiedName;
     fn deps(&self) -> Box<dyn Iterator<Item = &QualifiedName> + '_>;
-
-    fn format_deps(&self) -> String {
-        self.deps().join(",")
-    }
 }
 
 impl HasDependencies for Api<FnPrePhase1> {
@@ -37,13 +31,9 @@
                 ..
             } => Box::new(old_tyname.iter().chain(deps.iter())),
             Api::Struct {
-                analysis:
-                    PodAnalysis {
-                        kind: TypeKind::Pod,
-                        bases,
-                        field_deps,
-                        ..
-                    },
+                analysis: PodAnalysis {
+                    bases, field_deps, ..
+                },
                 ..
             } => Box::new(field_deps.iter().chain(bases.iter())),
             Api::Function { analysis, .. } => Box::new(analysis.deps.iter()),
@@ -52,7 +42,7 @@
                 superclass,
             } => Box::new(std::iter::once(superclass)),
             Api::RustSubclassFn { details, .. } => Box::new(details.dependencies.iter()),
-            Api::RustFn { receiver, .. } => Box::new(receiver.iter()),
+            Api::RustFn { deps, .. } => Box::new(deps.iter()),
             _ => Box::new(std::iter::empty()),
         }
     }
@@ -105,7 +95,7 @@
                 superclass,
             } => Box::new(std::iter::once(superclass)),
             Api::RustSubclassFn { details, .. } => Box::new(details.dependencies.iter()),
-            Api::RustFn { receiver, .. } => Box::new(receiver.iter()),
+            Api::RustFn { deps, .. } => Box::new(deps.iter()),
             _ => Box::new(std::iter::empty()),
         }
     }
diff --git a/engine/src/conversion/analysis/depth_first.rs b/engine/src/conversion/analysis/depth_first.rs
index 02459e1..baadbd7 100644
--- a/engine/src/conversion/analysis/depth_first.rs
+++ b/engine/src/conversion/analysis/depth_first.rs
@@ -14,10 +14,20 @@
 
 use crate::types::QualifiedName;
 
-use super::deps::HasDependencies;
+/// A little like `HasDependencies` but accounts for only direct fiele
+/// and bases.
+pub(crate) trait HasFieldsAndBases {
+    fn name(&self) -> &QualifiedName;
+    /// Return field and base class dependencies of this item.
+    /// This should only include those items where a definition is required,
+    /// not merely a declaration. So if the field type is
+    /// `std::unique_ptr<A>`, this should only return `std::unique_ptr`.
+    fn field_and_base_deps(&self) -> Box<dyn Iterator<Item = &QualifiedName> + '_>;
+}
 
-/// Return APIs in a depth-first order, i.e. those with no dependencies first.
-pub(super) fn depth_first<'a, T: HasDependencies + Debug + 'a>(
+/// Iterate through APIs in an order such that later APIs have no fields or bases
+/// other than those whose types have already been processed.
+pub(super) fn fields_and_bases_first<'a, T: HasFieldsAndBases + Debug + 'a>(
     inputs: impl Iterator<Item = &'a T> + 'a,
 ) -> impl Iterator<Item = &'a T> {
     let queue: VecDeque<_> = inputs.collect();
@@ -25,18 +35,21 @@
     DepthFirstIter { queue, yet_to_do }
 }
 
-struct DepthFirstIter<'a, T: HasDependencies + Debug> {
+struct DepthFirstIter<'a, T: HasFieldsAndBases + Debug> {
     queue: VecDeque<&'a T>,
     yet_to_do: HashSet<&'a QualifiedName>,
 }
 
-impl<'a, T: HasDependencies + Debug> Iterator for DepthFirstIter<'a, T> {
+impl<'a, T: HasFieldsAndBases + Debug> Iterator for DepthFirstIter<'a, T> {
     type Item = &'a T;
 
     fn next(&mut self) -> Option<Self::Item> {
         let first_candidate = self.queue.get(0).map(|api| api.name());
         while let Some(candidate) = self.queue.pop_front() {
-            if !candidate.deps().any(|d| self.yet_to_do.contains(&d)) {
+            if !candidate
+                .field_and_base_deps()
+                .any(|d| self.yet_to_do.contains(&d))
+            {
                 self.yet_to_do.remove(candidate.name());
                 return Some(candidate);
             }
@@ -46,7 +59,11 @@
                     "Failed to find a candidate; there must be a circular dependency. Queue is {}",
                     self.queue
                         .iter()
-                        .map(|item| format!("{}: {}", item.name(), item.deps().join(",")))
+                        .map(|item| format!(
+                            "{}: {}",
+                            item.name(),
+                            item.field_and_base_deps().join(",")
+                        ))
                         .join("\n")
                 );
             }
@@ -59,17 +76,17 @@
 mod test {
     use crate::types::QualifiedName;
 
-    use super::{depth_first, HasDependencies};
+    use super::{fields_and_bases_first, HasFieldsAndBases};
 
     #[derive(Debug)]
     struct Thing(QualifiedName, Vec<QualifiedName>);
 
-    impl HasDependencies for Thing {
+    impl HasFieldsAndBases for Thing {
         fn name(&self) -> &QualifiedName {
             &self.0
         }
 
-        fn deps(&self) -> Box<dyn Iterator<Item = &QualifiedName> + '_> {
+        fn field_and_base_deps(&self) -> Box<dyn Iterator<Item = &QualifiedName> + '_> {
             Box::new(self.1.iter())
         }
     }
@@ -89,7 +106,7 @@
             vec![QualifiedName::new_from_cpp_name("a")],
         );
         let api_list = vec![a, b, c];
-        let mut it = depth_first(api_list.iter());
+        let mut it = fields_and_bases_first(api_list.iter());
         assert_eq!(it.next().unwrap().0, QualifiedName::new_from_cpp_name("a"));
         assert_eq!(it.next().unwrap().0, QualifiedName::new_from_cpp_name("c"));
         assert_eq!(it.next().unwrap().0, QualifiedName::new_from_cpp_name("b"));
diff --git a/engine/src/conversion/analysis/fun/bridge_name_tracker.rs b/engine/src/conversion/analysis/fun/bridge_name_tracker.rs
index 7e81c59..c98beaf 100644
--- a/engine/src/conversion/analysis/fun/bridge_name_tracker.rs
+++ b/engine/src/conversion/analysis/fun/bridge_name_tracker.rs
@@ -104,7 +104,7 @@
             *count += 1;
             prefix
         } else {
-            let r = format!("{}_autocxx{}", prefix, count);
+            let r = format!("{prefix}_autocxx{count}");
             *count += 1;
             r
         }
diff --git a/engine/src/conversion/analysis/fun/function_wrapper.rs b/engine/src/conversion/analysis/fun/function_wrapper.rs
index ab3b7d9..0495533 100644
--- a/engine/src/conversion/analysis/fun/function_wrapper.rs
+++ b/engine/src/conversion/analysis/fun/function_wrapper.rs
@@ -6,12 +6,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use crate::minisyn::Ident;
 use crate::{
-    conversion::api::SubclassName,
+    conversion::{api::SubclassName, type_helpers::extract_pinned_mutable_reference_type},
     types::{Namespace, QualifiedName},
 };
 use quote::ToTokens;
-use syn::{parse_quote, Ident, Type, TypeReference};
+use syn::{parse_quote, Type, TypeReference};
 
 #[derive(Clone, Debug)]
 pub(crate) enum CppConversionType {
@@ -85,9 +86,9 @@
 /// variant params. That would remove the possibility of various runtime
 /// panics by enforcing (for example) that conversion from a pointer always
 /// has a Type::Ptr.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct TypeConversionPolicy {
-    unwrapped_type: Type,
+    unwrapped_type: crate::minisyn::Type,
     pub(crate) cpp_conversion: CppConversionType,
     pub(crate) rust_conversion: RustConversionType,
 }
@@ -103,7 +104,7 @@
         rust_conversion: RustConversionType,
     ) -> Self {
         Self {
-            unwrapped_type: ty,
+            unwrapped_type: ty.into(),
             cpp_conversion,
             rust_conversion,
         }
@@ -118,7 +119,14 @@
             Type::Reference(TypeReference {
                 elem, mutability, ..
             }) => (*elem, mutability.is_some()),
-            _ => panic!("Not a ptr: {}", ty.to_token_stream()),
+            Type::Path(ref tp) => {
+                if let Some(unwrapped_type) = extract_pinned_mutable_reference_type(tp) {
+                    (unwrapped_type.clone(), true)
+                } else {
+                    panic!("Path was not a mutable reference: {}", ty.to_token_stream())
+                }
+            }
+            _ => panic!("Not a reference: {}", ty.to_token_stream()),
         };
         TypeConversionPolicy {
             unwrapped_type: if is_mut {
@@ -133,7 +141,7 @@
 
     pub(crate) fn new_to_unique_ptr(ty: Type) -> Self {
         TypeConversionPolicy {
-            unwrapped_type: ty,
+            unwrapped_type: ty.into(),
             cpp_conversion: CppConversionType::FromValueToUniquePtr,
             rust_conversion: RustConversionType::None,
         }
@@ -141,7 +149,7 @@
 
     pub(crate) fn new_for_placement_return(ty: Type) -> Self {
         TypeConversionPolicy {
-            unwrapped_type: ty,
+            unwrapped_type: ty.into(),
             cpp_conversion: CppConversionType::FromReturnValueToPlacementPtr,
             // Rust conversion is marked as none here, since this policy
             // will be applied to the return value, and the Rust-side
@@ -157,7 +165,7 @@
     pub(crate) fn unconverted_rust_type(&self) -> Type {
         match self.cpp_conversion {
             CppConversionType::FromValueToUniquePtr => self.make_unique_ptr_type(),
-            _ => self.unwrapped_type.clone(),
+            _ => self.unwrapped_type.clone().into(),
         }
     }
 
@@ -170,7 +178,7 @@
                     *mut #innerty
                 }
             }
-            _ => self.unwrapped_type.clone(),
+            _ => self.unwrapped_type.clone().into(),
         }
     }
 
@@ -222,7 +230,7 @@
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) enum CppFunctionBody {
     FunctionCall(Namespace, Ident),
     StaticMethodCall(Namespace, Ident, Ident),
@@ -234,7 +242,7 @@
     FreeUninitialized(QualifiedName),
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) enum CppFunctionKind {
     Function,
     Method,
@@ -243,10 +251,10 @@
     SynthesizedConstructor,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct CppFunction {
     pub(crate) payload: CppFunctionBody,
-    pub(crate) wrapper_function_name: Ident,
+    pub(crate) wrapper_function_name: crate::minisyn::Ident,
     pub(crate) original_cpp_name: String,
     pub(crate) return_conversion: Option<TypeConversionPolicy>,
     pub(crate) argument_conversion: Vec<TypeConversionPolicy>,
diff --git a/engine/src/conversion/analysis/fun/implicit_constructors.rs b/engine/src/conversion/analysis/fun/implicit_constructors.rs
index 469ed89..a1ebf27 100644
--- a/engine/src/conversion/analysis/fun/implicit_constructors.rs
+++ b/engine/src/conversion/analysis/fun/implicit_constructors.rs
@@ -11,13 +11,16 @@
 
 use syn::{Type, TypeArray};
 
+use crate::conversion::api::DeletedOrDefaulted;
 use crate::{
     conversion::{
-        analysis::{depth_first::depth_first, pod::PodAnalysis, type_converter::TypeKind},
+        analysis::{
+            depth_first::fields_and_bases_first, pod::PodAnalysis, type_converter::TypeKind,
+        },
         api::{Api, ApiName, CppVisibility, FuncToConvert, SpecialMemberKind},
         apivec::ApiVec,
         convert_error::ConvertErrorWithContext,
-        ConvertError,
+        ConvertErrorFromCpp,
     },
     known_types::{known_types, KnownTypeConstructorDetails},
     types::QualifiedName,
@@ -177,6 +180,13 @@
     apis: &ApiVec<FnPrePhase1>,
 ) -> HashMap<QualifiedName, ItemsFound> {
     let (explicits, unknown_types) = find_explicit_items(apis);
+    let enums: HashSet<QualifiedName> = apis
+        .iter()
+        .filter_map(|api| match api {
+            Api::Enum { name, .. } => Some(name.name.clone()),
+            _ => None,
+        })
+        .collect();
 
     // These contain all the classes we've seen so far with the relevant properties on their
     // constructors of each kind. We iterate via [`depth_first`], so analyzing later classes
@@ -189,7 +199,7 @@
     // These analyses include all bases and members of each class.
     let mut all_items_found: HashMap<QualifiedName, ItemsFound> = HashMap::new();
 
-    for api in depth_first(apis.iter()) {
+    for api in fields_and_bases_first(apis.iter()) {
         if let Api::Struct {
             name,
             analysis:
@@ -211,7 +221,17 @@
                 })
             };
             let get_items_found = |qn: &QualifiedName| -> Option<ItemsFound> {
-                if let Some(constructor_details) = known_types().get_constructor_details(qn) {
+                if enums.contains(qn) {
+                    Some(ItemsFound {
+                        default_constructor: SpecialMemberFound::NotPresent,
+                        destructor: SpecialMemberFound::Implicit,
+                        const_copy_constructor: SpecialMemberFound::Implicit,
+                        non_const_copy_constructor: SpecialMemberFound::NotPresent,
+                        move_constructor: SpecialMemberFound::Implicit,
+                        name: Some(name.clone()),
+                    })
+                } else if let Some(constructor_details) = known_types().get_constructor_details(qn)
+                {
                     Some(known_type_items_found(constructor_details))
                 } else {
                     all_items_found.get(qn).cloned()
@@ -539,8 +559,7 @@
                 all_items_found
                     .insert(name.name.clone(), items_found)
                     .is_none(),
-                "Duplicate struct: {:?}",
-                name
+                "Duplicate struct: {name:?}"
             );
         }
     }
@@ -556,7 +575,7 @@
         .entry(ExplicitType { ty, kind })
     {
         Entry::Vacant(entry) => {
-            entry.insert(if fun.is_deleted {
+            entry.insert(if matches!(fun.is_deleted, DeletedOrDefaulted::Deleted) {
                 ExplicitFound::Deleted
             } else {
                 ExplicitFound::UserDefined(fun.cpp_vis)
@@ -575,7 +594,8 @@
                         kind: FnKind::Method { impl_for, .. },
                         param_details,
                         ignore_reason:
-                            Ok(()) | Err(ConvertErrorWithContext(ConvertError::AssignmentOperator, _)),
+                            Ok(())
+                            | Err(ConvertErrorWithContext(ConvertErrorFromCpp::AssignmentOperator, _)),
                         ..
                     },
                 fun,
diff --git a/engine/src/conversion/analysis/fun/mod.rs b/engine/src/conversion/analysis/fun/mod.rs
index 7194746..415e40a 100644
--- a/engine/src/conversion/analysis/fun/mod.rs
+++ b/engine/src/conversion/analysis/fun/mod.rs
@@ -19,9 +19,9 @@
             type_converter::{self, add_analysis, TypeConversionContext, TypeConverter},
         },
         api::{
-            ApiName, CastMutability, CppVisibility, FuncToConvert, NullPhase, Provenance,
-            References, SpecialMemberKind, SubclassName, TraitImplSignature, TraitSynthesis,
-            UnsafetyNeeded, Virtualness,
+            ApiName, CastMutability, CppVisibility, DeletedOrDefaulted, FuncToConvert, NullPhase,
+            Provenance, References, SpecialMemberKind, SubclassName, TraitImplSignature,
+            TraitSynthesis, UnsafetyNeeded, Virtualness,
         },
         apivec::ApiVec,
         convert_error::ErrorContext,
@@ -29,6 +29,7 @@
         error_reporter::{convert_apis, report_any_error},
     },
     known_types::known_types,
+    minisyn::minisynize_punctuated,
     types::validate_ident_ok_for_rust,
 };
 use indexmap::map::IndexMap as HashMap;
@@ -40,14 +41,14 @@
 use proc_macro2::Span;
 use quote::quote;
 use syn::{
-    parse_quote, punctuated::Punctuated, token::Comma, FnArg, Ident, Pat, ReturnType, Type,
-    TypePath, TypePtr, TypeReference, Visibility,
+    parse_quote, punctuated::Punctuated, token::Comma, FnArg, Ident, Pat, PatType, ReturnType,
+    Type, TypePath, TypePtr, TypeReference, Visibility,
 };
 
 use crate::{
     conversion::{
         api::{AnalysisPhase, Api, TypeKind},
-        ConvertError,
+        ConvertErrorFromCpp,
     },
     types::{make_ident, validate_ident_ok_for_cxx, Namespace, QualifiedName},
 };
@@ -64,13 +65,14 @@
 };
 
 use super::{
+    depth_first::HasFieldsAndBases,
     doc_label::make_doc_attrs,
     pod::{PodAnalysis, PodPhase},
     tdef::TypedefAnalysis,
     type_converter::{Annotated, PointerTreatment},
 };
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub(crate) enum ReceiverMutability {
     Const,
     Mutable,
@@ -85,7 +87,7 @@
     PureVirtual(ReceiverMutability),
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) enum TraitMethodKind {
     CopyConstructor,
     MoveConstructor,
@@ -95,11 +97,11 @@
     Dealloc,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct TraitMethodDetails {
     pub(crate) trt: TraitImplSignature,
     pub(crate) avoid_self: bool,
-    pub(crate) method_name: Ident,
+    pub(crate) method_name: crate::minisyn::Ident,
     /// For traits, where we're trying to implement a specific existing
     /// interface, we may need to reorder the parameters to fit that
     /// interface.
@@ -109,7 +111,7 @@
     pub(crate) trait_call_is_unsafe: bool,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) enum FnKind {
     Function,
     Method {
@@ -129,31 +131,31 @@
 
 /// Strategy for ensuring that the final, callable, Rust name
 /// is what the user originally expected.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 
 pub(crate) enum RustRenameStrategy {
     /// cxx::bridge name matches user expectations
     None,
     /// Even the #[rust_name] attribute would cause conflicts, and we need
     /// to use a 'use XYZ as ABC'
-    RenameInOutputMod(Ident),
+    RenameInOutputMod(crate::minisyn::Ident),
     /// This function requires us to generate a Rust function to do
     /// parameter conversion.
     RenameUsingWrapperFunction,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct FnAnalysis {
     /// Each entry in the cxx::bridge needs to have a unique name, even if
     /// (from the perspective of Rust and C++) things are in different
     /// namespaces/mods.
-    pub(crate) cxxbridge_name: Ident,
+    pub(crate) cxxbridge_name: crate::minisyn::Ident,
     /// ... so record also the name under which we wish to expose it in Rust.
     pub(crate) rust_name: String,
     pub(crate) rust_rename_strategy: RustRenameStrategy,
     pub(crate) params: Punctuated<FnArg, Comma>,
     pub(crate) kind: FnKind,
-    pub(crate) ret_type: ReturnType,
+    pub(crate) ret_type: crate::minisyn::ReturnType,
     pub(crate) param_details: Vec<ArgumentAnalysis>,
     pub(crate) ret_conversion: Option<TypeConversionPolicy>,
     pub(crate) requires_unsafe: UnsafetyNeeded,
@@ -172,12 +174,13 @@
     pub(crate) rust_wrapper_needed: bool,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct ArgumentAnalysis {
     pub(crate) conversion: TypeConversionPolicy,
-    pub(crate) name: Pat,
+    pub(crate) name: crate::minisyn::Pat,
     pub(crate) self_type: Option<(QualifiedName, ReceiverMutability)>,
     pub(crate) has_lifetime: bool,
+    pub(crate) is_mutable_reference: bool,
     pub(crate) deps: HashSet<QualifiedName>,
     pub(crate) requires_unsafe: UnsafetyNeeded,
     pub(crate) is_placement_return_destination: bool,
@@ -187,6 +190,7 @@
     rt: ReturnType,
     conversion: Option<TypeConversionPolicy>,
     was_reference: bool,
+    was_mutable_reference: bool,
     deps: HashSet<QualifiedName>,
     placement_param_needed: Option<(FnArg, ArgumentAnalysis)>,
 }
@@ -197,12 +201,14 @@
             rt: parse_quote! {},
             conversion: None,
             was_reference: false,
+            was_mutable_reference: false,
             deps: Default::default(),
             placement_param_needed: None,
         }
     }
 }
 
+#[derive(std::fmt::Debug)]
 pub(crate) struct PodAndConstructorAnalysis {
     pub(crate) pod: PodAnalysis,
     pub(crate) constructors: PublicConstructors,
@@ -210,6 +216,7 @@
 
 /// An analysis phase where we've analyzed each function, but
 /// haven't yet determined which constructors/etc. belong to each type.
+#[derive(std::fmt::Debug)]
 pub(crate) struct FnPrePhase1;
 
 impl AnalysisPhase for FnPrePhase1 {
@@ -220,6 +227,7 @@
 
 /// An analysis phase where we've analyzed each function, and identified
 /// what implicit constructors/destructors are present in each type.
+#[derive(std::fmt::Debug)]
 pub(crate) struct FnPrePhase2;
 
 impl AnalysisPhase for FnPrePhase2 {
@@ -228,6 +236,7 @@
     type FunAnalysis = FnAnalysis;
 }
 
+#[derive(Debug)]
 pub(crate) struct PodAndDepAnalysis {
     pub(crate) pod: PodAnalysis,
     pub(crate) constructor_and_allocator_deps: Vec<QualifiedName>,
@@ -236,6 +245,7 @@
 
 /// Analysis phase after we've finished analyzing functions and determined
 /// which constructors etc. belong to them.
+#[derive(std::fmt::Debug)]
 pub(crate) struct FnPhase;
 
 /// Indicates which kinds of public constructors are known to exist for a type.
@@ -283,6 +293,7 @@
     generic_types: HashSet<QualifiedName>,
     types_in_anonymous_namespace: HashSet<QualifiedName>,
     existing_superclass_trait_api_names: HashSet<QualifiedName>,
+    force_wrapper_generation: bool,
 }
 
 impl<'a> FnAnalyzer<'a> {
@@ -290,6 +301,7 @@
         apis: ApiVec<PodPhase>,
         unsafe_policy: &'a UnsafePolicy,
         config: &'a IncludeCppConfig,
+        force_wrapper_generation: bool,
     ) -> ApiVec<FnPrePhase2> {
         let mut me = Self {
             unsafe_policy,
@@ -305,6 +317,7 @@
             generic_types: Self::build_generic_type_set(&apis),
             existing_superclass_trait_api_names: HashSet::new(),
             types_in_anonymous_namespace: Self::build_types_in_anonymous_namespace(&apis),
+            force_wrapper_generation,
         };
         let mut results = ApiVec::new();
         convert_apis(
@@ -427,7 +440,7 @@
         ty: Box<Type>,
         ns: &Namespace,
         pointer_treatment: PointerTreatment,
-    ) -> Result<Annotated<Box<Type>>, ConvertError> {
+    ) -> Result<Annotated<Box<Type>>, ConvertErrorFromCpp> {
         let ctx = TypeConversionContext::OuterType { pointer_treatment };
         let mut annotated = self.type_converter.convert_boxed_type(ty, ns, &ctx)?;
         self.extra_apis.append(&mut annotated.extra_apis);
@@ -513,7 +526,7 @@
                     **fun,
                     FuncToConvert {
                         special_member: Some(SpecialMemberKind::Destructor),
-                        is_deleted: false,
+                        is_deleted: DeletedOrDefaulted::Neither | DeletedOrDefaulted::Defaulted,
                         cpp_vis: CppVisibility::Public,
                         ..
                     }
@@ -741,6 +754,10 @@
                     sophistication,
                     false,
                 )
+                .map_err(|err| ConvertErrorFromCpp::Argument {
+                    arg: describe_arg(i),
+                    err: Box::new(err),
+                })
             })
             .partition(Result::is_ok);
         let (mut params, mut param_details): (Punctuated<_, Comma>, Vec<_>) =
@@ -775,7 +792,7 @@
                 if initial_rust_name.ends_with('_') {
                     initial_rust_name // case 2
                 } else if validate_ident_ok_for_rust(cpp_name).is_err() {
-                    format!("{}_", cpp_name) // case 5
+                    format!("{cpp_name}_") // case 5
                 } else {
                     cpp_name.to_string() // cases 3, 4, 6
                 }
@@ -829,7 +846,7 @@
                 let is_move =
                     matches!(fun.special_member, Some(SpecialMemberKind::MoveConstructor));
                 if let Some(constructor_suffix) = rust_name.strip_prefix(nested_type_ident) {
-                    rust_name = format!("new{}", constructor_suffix);
+                    rust_name = format!("new{constructor_suffix}");
                 }
                 rust_name = predetermined_rust_name
                     .unwrap_or_else(|| self.get_overload_name(ns, type_ident, rust_name));
@@ -868,7 +885,7 @@
                             impl_for: self_ty,
                             details: Box::new(TraitMethodDetails {
                                 trt: TraitImplSignature {
-                                    ty,
+                                    ty: ty.into(),
                                     trait_signature: parse_quote! {
                                         autocxx::moveit::new:: #trait_id
                                     },
@@ -904,7 +921,7 @@
                         impl_for: self_ty,
                         details: Box::new(TraitMethodDetails {
                             trt: TraitImplSignature {
-                                ty,
+                                ty: ty.into(),
                                 trait_signature: parse_quote! {
                                     Drop
                                 },
@@ -934,7 +951,7 @@
                     // fn make_unique(...args) -> UniquePtr<Type>
                     // If there are multiple constructors, bindgen generates
                     // new, new1, new2 etc. and we'll keep those suffixes.
-                    rust_name = format!("new{}", constructor_suffix);
+                    rust_name = format!("new{constructor_suffix}");
                     MethodKind::Constructor {
                         is_default: matches!(
                             fun.special_member,
@@ -1033,10 +1050,10 @@
                 ..
             } => {
                 if param_details.len() < 2 {
-                    set_ignore_reason(ConvertError::ConstructorWithOnlyOneParam);
+                    set_ignore_reason(ConvertErrorFromCpp::ConstructorWithOnlyOneParam);
                 }
                 if param_details.len() > 2 {
-                    set_ignore_reason(ConvertError::ConstructorWithMultipleParams);
+                    set_ignore_reason(ConvertErrorFromCpp::ConstructorWithMultipleParams);
                 }
                 self.reanalyze_parameter(
                     0,
@@ -1058,10 +1075,10 @@
                 ..
             } => {
                 if param_details.len() < 2 {
-                    set_ignore_reason(ConvertError::ConstructorWithOnlyOneParam);
+                    set_ignore_reason(ConvertErrorFromCpp::ConstructorWithOnlyOneParam);
                 }
                 if param_details.len() > 2 {
-                    set_ignore_reason(ConvertError::ConstructorWithMultipleParams);
+                    set_ignore_reason(ConvertErrorFromCpp::ConstructorWithMultipleParams);
                 }
                 self.reanalyze_parameter(
                     0,
@@ -1099,14 +1116,14 @@
         // or note whether the type is abstract.
         let externally_callable = match fun.cpp_vis {
             CppVisibility::Private => {
-                set_ignore_reason(ConvertError::PrivateMethod);
+                set_ignore_reason(ConvertErrorFromCpp::PrivateMethod);
                 false
             }
             CppVisibility::Protected => false,
             CppVisibility::Public => true,
         };
         if fun.variadic {
-            set_ignore_reason(ConvertError::Variadic);
+            set_ignore_reason(ConvertErrorFromCpp::Variadic);
         }
         if let Some(problem) = bads.into_iter().next() {
             match problem {
@@ -1116,7 +1133,7 @@
         } else if fun.unused_template_param {
             // This indicates that bindgen essentially flaked out because templates
             // were too complex.
-            set_ignore_reason(ConvertError::UnusedTemplateParam)
+            set_ignore_reason(ConvertErrorFromCpp::UnusedTemplateParam)
         } else if matches!(
             fun.special_member,
             Some(SpecialMemberKind::AssignmentOperator)
@@ -1124,11 +1141,11 @@
             // Be careful with the order of this if-else tree. Anything above here means we won't
             // treat it as an assignment operator, but anything below we still consider when
             // deciding which other C++ special member functions are implicitly defined.
-            set_ignore_reason(ConvertError::AssignmentOperator)
+            set_ignore_reason(ConvertErrorFromCpp::AssignmentOperator)
         } else if fun.references.rvalue_ref_return {
-            set_ignore_reason(ConvertError::RValueReturn)
-        } else if fun.is_deleted {
-            set_ignore_reason(ConvertError::Deleted)
+            set_ignore_reason(ConvertErrorFromCpp::RValueReturn)
+        } else if matches!(fun.is_deleted, DeletedOrDefaulted::Deleted) {
+            set_ignore_reason(ConvertErrorFromCpp::Deleted)
         } else {
             match kind {
                 FnKind::Method {
@@ -1140,21 +1157,21 @@
                         | MethodKind::Virtual(..),
                     ..
                 } if !known_types().is_cxx_acceptable_receiver(impl_for) => {
-                    set_ignore_reason(ConvertError::UnsupportedReceiver);
+                    set_ignore_reason(ConvertErrorFromCpp::UnsupportedReceiver);
                 }
                 FnKind::Method { ref impl_for, .. } if !self.is_on_allowlist(impl_for) => {
                     // Bindgen will output methods for types which have been encountered
                     // virally as arguments on other allowlisted types. But we don't want
                     // to generate methods unless the user has specifically asked us to.
                     // It may, for instance, be a private type.
-                    set_ignore_reason(ConvertError::MethodOfNonAllowlistedType);
+                    set_ignore_reason(ConvertErrorFromCpp::MethodOfNonAllowlistedType);
                 }
                 FnKind::Method { ref impl_for, .. } | FnKind::TraitMethod { ref impl_for, .. } => {
                     if self.is_generic_type(impl_for) {
-                        set_ignore_reason(ConvertError::MethodOfGenericType);
+                        set_ignore_reason(ConvertErrorFromCpp::MethodOfGenericType);
                     }
                     if self.types_in_anonymous_namespace.contains(impl_for) {
-                        set_ignore_reason(ConvertError::MethodInAnonymousNamespace);
+                        set_ignore_reason(ConvertErrorFromCpp::MethodInAnonymousNamespace);
                     }
                 }
                 _ => {}
@@ -1199,12 +1216,46 @@
 
         let requires_unsafe = self.should_be_unsafe(&param_details, &kind);
 
-        let num_input_references = param_details.iter().filter(|pd| pd.has_lifetime).count();
-        if num_input_references != 1 && return_analysis.was_reference {
+        // The following sections reject some types of function because of the arrangement
+        // of Rust references. We could lift these restrictions when/if we switch to using
+        // CppRef to represent C++ references.
+        if return_analysis.was_reference {
             // cxx only allows functions to return a reference if they take exactly
-            // one reference as a parameter. Let's see...
-            set_ignore_reason(ConvertError::NotOneInputReference(rust_name.clone()));
+            // one reference as a parameter. Let's see.
+            let num_input_references = param_details.iter().filter(|pd| pd.has_lifetime).count();
+            if num_input_references == 0 {
+                set_ignore_reason(ConvertErrorFromCpp::NoInputReference(rust_name.clone()));
+            }
+            if num_input_references > 1 {
+                set_ignore_reason(ConvertErrorFromCpp::MultipleInputReferences(
+                    rust_name.clone(),
+                ));
+            }
         }
+        if return_analysis.was_mutable_reference {
+            // This one's a bit more subtle. We can't have:
+            //    fn foo(thing: &Thing) -> &mut OtherThing
+            // because Rust doesn't allow it.
+            // We could probably allow:
+            //    fn foo(thing: &mut Thing, thing2: &mut OtherThing) -> &mut OtherThing
+            // but probably cxx doesn't allow that. (I haven't checked). Even if it did,
+            // there's ambiguity here so won't allow it.
+            let num_input_mutable_references = param_details
+                .iter()
+                .filter(|pd| pd.has_lifetime && pd.is_mutable_reference)
+                .count();
+            if num_input_mutable_references == 0 {
+                set_ignore_reason(ConvertErrorFromCpp::NoMutableInputReference(
+                    rust_name.clone(),
+                ));
+            }
+            if num_input_mutable_references > 1 {
+                set_ignore_reason(ConvertErrorFromCpp::MultipleMutableInputReferences(
+                    rust_name.clone(),
+                ));
+            }
+        }
+
         let mut ret_type = return_analysis.rt;
         let ret_type_conversion = return_analysis.conversion;
 
@@ -1248,19 +1299,23 @@
             _ if ret_type_conversion_needed => true,
             _ if cpp_name_incompatible_with_cxx => true,
             _ if fun.synthetic_cpp.is_some() => true,
+            _ if self.force_wrapper_generation => true,
             _ => false,
         };
 
         let cpp_wrapper = if wrapper_function_needed {
             // Generate a new layer of C++ code to wrap/unwrap parameters
             // and return values into/out of std::unique_ptrs.
-            let cpp_construction_ident = make_ident(&effective_cpp_name);
+            let cpp_construction_ident = make_ident(effective_cpp_name);
             let joiner = if cxxbridge_name.to_string().ends_with('_') {
                 ""
             } else {
                 "_"
             };
-            cxxbridge_name = make_ident(&format!("{}{}autocxx_wrapper", cxxbridge_name, joiner));
+            cxxbridge_name = make_ident(
+                self.config
+                    .uniquify_name_per_mod(&format!("{cxxbridge_name}{joiner}autocxx_wrapper")),
+            );
             let (payload, cpp_function_kind) = match fun.synthetic_cpp.as_ref().cloned() {
                 Some((payload, cpp_function_kind)) => (payload, cpp_function_kind),
                 None => match kind {
@@ -1321,10 +1376,10 @@
             params.clear();
             for pd in &param_details {
                 let type_name = pd.conversion.converted_rust_type();
-                let arg_name = if pd.self_type.is_some() {
+                let arg_name: syn::Pat = if pd.self_type.is_some() {
                     parse_quote!(autocxx_gen_this)
                 } else {
-                    pd.name.clone()
+                    pd.name.clone().into()
                 };
                 params.push(parse_quote!(
                     #arg_name: #type_name
@@ -1358,12 +1413,15 @@
             _ if any_param_needs_rust_conversion || return_needs_rust_conversion => true,
             FnKind::TraitMethod { .. } => true,
             FnKind::Method { .. } => cxxbridge_name != rust_name,
+            _ if self.force_wrapper_generation => true,
             _ => false,
         };
 
         // Naming, part two.
         // Work out our final naming strategy.
-        validate_ident_ok_for_cxx(&cxxbridge_name.to_string()).unwrap_or_else(set_ignore_reason);
+        validate_ident_ok_for_cxx(&cxxbridge_name.to_string())
+            .map_err(ConvertErrorFromCpp::InvalidIdent)
+            .unwrap_or_else(set_ignore_reason);
         let rust_name_ident = make_ident(&rust_name);
         let rust_rename_strategy = match kind {
             _ if rust_wrapper_needed => RustRenameStrategy::RenameUsingWrapperFunction,
@@ -1380,10 +1438,10 @@
             params,
             ret_conversion: ret_type_conversion,
             kind,
-            ret_type,
+            ret_type: ret_type.into(),
             param_details,
             requires_unsafe,
-            vis,
+            vis: vis.into(),
             cpp_wrapper,
             deps,
             ignore_reason,
@@ -1422,7 +1480,7 @@
         sophistication: TypeConversionSophistication,
         construct_into_self: bool,
         is_move_constructor: bool,
-    ) -> Result<(), ConvertError> {
+    ) -> Result<(), ConvertErrorFromCpp> {
         self.convert_fn_arg(
             fun.inputs.iter().nth(param_idx).unwrap(),
             ns,
@@ -1484,7 +1542,7 @@
                             AsRef < #to_type >
                         },
                         parse_quote! {
-                            &'a mut ::std::pin::Pin < &'a mut #from_type_path >
+                            &'a mut ::core::pin::Pin < &'a mut #from_type_path >
                         },
                         "as_ref",
                     ),
@@ -1493,7 +1551,7 @@
                             autocxx::PinMut < #to_type >
                         },
                         parse_quote! {
-                            ::std::pin::Pin < &'a mut #from_type_path >
+                            ::core::pin::Pin < &'a mut #from_type_path >
                         },
                         "pin_mut",
                     ),
@@ -1505,7 +1563,7 @@
                         impl_for: from_type.clone(),
                         details: Box::new(TraitMethodDetails {
                             trt: TraitImplSignature {
-                                ty,
+                                ty: ty.into(),
                                 trait_signature,
                                 unsafety: None,
                             },
@@ -1549,7 +1607,7 @@
                 impl_for: ty.clone(),
                 details: Box::new(TraitMethodDetails {
                     trt: TraitImplSignature {
-                        ty: Type::Path(typ),
+                        ty: Type::Path(typ).into(),
                         trait_signature: parse_quote! { autocxx::moveit::MakeCppStorage },
                         unsafety: Some(parse_quote! { unsafe }),
                     },
@@ -1590,7 +1648,7 @@
         force_rust_conversion: Option<RustConversionType>,
         sophistication: TypeConversionSophistication,
         construct_into_self: bool,
-    ) -> Result<(FnArg, ArgumentAnalysis), ConvertError> {
+    ) -> Result<(FnArg, ArgumentAnalysis), ConvertErrorFromCpp> {
         Ok(match arg {
             FnArg::Typed(pt) => {
                 let mut pt = pt.clone();
@@ -1627,12 +1685,11 @@
                                     };
                                     Ok((this_type, receiver_mutability))
                                 }
-                                _ => Err(ConvertError::UnexpectedThisType(QualifiedName::new(
-                                    ns,
-                                    make_ident(fn_name),
-                                ))),
+                                _ => Err(ConvertErrorFromCpp::UnexpectedThisType(
+                                    QualifiedName::new(ns, make_ident(fn_name)),
+                                )),
                             },
-                            _ => Err(ConvertError::UnexpectedThisType(QualifiedName::new(
+                            _ => Err(ConvertErrorFromCpp::UnexpectedThisType(QualifiedName::new(
                                 ns,
                                 make_ident(fn_name),
                             ))),
@@ -1646,8 +1703,9 @@
                         syn::Pat::Ident(pp)
                     }
                     syn::Pat::Ident(pp) => {
-                        validate_ident_ok_for_cxx(&pp.ident.to_string())?;
-                        pointer_treatment = references.param_treatment(&pp.ident);
+                        validate_ident_ok_for_cxx(&pp.ident.to_string())
+                            .map_err(ConvertErrorFromCpp::InvalidIdent)?;
+                        pointer_treatment = references.param_treatment(&pp.ident.clone().into());
                         syn::Pat::Ident(pp)
                     }
                     _ => old_pat,
@@ -1684,13 +1742,17 @@
                     FnArg::Typed(pt),
                     ArgumentAnalysis {
                         self_type,
-                        name: new_pat,
+                        name: new_pat.into(),
                         conversion,
                         has_lifetime: matches!(
                             annotated_type.kind,
                             type_converter::TypeKind::Reference
                                 | type_converter::TypeKind::MutableReference
                         ),
+                        is_mutable_reference: matches!(
+                            annotated_type.kind,
+                            type_converter::TypeKind::MutableReference
+                        ),
                         deps: annotated_type.types_encountered,
                         requires_unsafe,
                         is_placement_return_destination,
@@ -1859,7 +1921,7 @@
         ns: &Namespace,
         references: &References,
         sophistication: TypeConversionSophistication,
-    ) -> Result<ReturnTypeAnalysis, ConvertError> {
+    ) -> Result<ReturnTypeAnalysis, ConvertErrorFromCpp> {
         Ok(match rt {
             ReturnType::Default => ReturnTypeAnalysis::default(),
             ReturnType::Type(rarrow, boxed_type) => {
@@ -1902,9 +1964,9 @@
                                 conversion: Some(TypeConversionPolicy::new_for_placement_return(
                                     ty.clone(),
                                 )),
-                                was_reference: false,
                                 deps: annotated_type.types_encountered,
                                 placement_param_needed: Some((fnarg, analysis)),
+                                ..Default::default()
                             }
                         } else {
                             // There are some types which we can't currently represent within a moveit::new::New.
@@ -1917,14 +1979,18 @@
                             ReturnTypeAnalysis {
                                 rt: ReturnType::Type(*rarrow, boxed_type),
                                 conversion,
-                                was_reference: false,
                                 deps: annotated_type.types_encountered,
-                                placement_param_needed: None,
+                                ..Default::default()
                             }
                         }
                     }
                     _ => {
-                        let was_reference = references.ref_return;
+                        let was_mutable_reference = matches!(
+                            annotated_type.kind,
+                            type_converter::TypeKind::MutableReference
+                        );
+                        let was_reference = was_mutable_reference
+                            || matches!(annotated_type.kind, type_converter::TypeKind::Reference);
                         let conversion = Some(
                             if was_reference
                                 && matches!(
@@ -1941,6 +2007,7 @@
                             rt: ReturnType::Type(*rarrow, boxed_type),
                             conversion,
                             was_reference,
+                            was_mutable_reference,
                             deps: annotated_type.types_encountered,
                             placement_param_needed: None,
                         }
@@ -2091,9 +2158,12 @@
                     Box::new(FuncToConvert {
                         self_ty: Some(self_ty.clone()),
                         ident,
-                        doc_attrs: make_doc_attrs(format!("Synthesized {}.", special_member)),
-                        inputs,
-                        output: ReturnType::Default,
+                        doc_attrs: make_doc_attrs(format!("Synthesized {special_member}."))
+                            .into_iter()
+                            .map(Into::into)
+                            .collect(),
+                        inputs: minisynize_punctuated(inputs),
+                        output: ReturnType::Default.into(),
                         vis: parse_quote! { pub },
                         virtualness: Virtualness::None,
                         cpp_vis: CppVisibility::Public,
@@ -2102,7 +2172,7 @@
                         references,
                         original_name: None,
                         synthesized_this_type: None,
-                        is_deleted: false,
+                        is_deleted: DeletedOrDefaulted::Neither,
                         add_to_trait: None,
                         synthetic_cpp: None,
                         provenance: Provenance::SynthesizedOther,
@@ -2192,7 +2262,7 @@
         )
     }
 
-    pub(crate) fn cxxbridge_name(&self) -> Option<Ident> {
+    pub(crate) fn cxxbridge_name(&self) -> Option<crate::minisyn::Ident> {
         match self {
             Api::Function { ref analysis, .. } => Some(analysis.cxxbridge_name.clone()),
             Api::StringConstructor { .. }
@@ -2224,3 +2294,60 @@
         _ => panic!("did not find angle bracketed args"),
     }
 }
+
+impl HasFieldsAndBases for Api<FnPrePhase1> {
+    fn name(&self) -> &QualifiedName {
+        self.name()
+    }
+
+    fn field_and_base_deps(&self) -> Box<dyn Iterator<Item = &QualifiedName> + '_> {
+        match self {
+            Api::Struct {
+                analysis:
+                    PodAnalysis {
+                        field_definition_deps,
+                        bases,
+                        ..
+                    },
+                ..
+            } => Box::new(field_definition_deps.iter().chain(bases.iter())),
+            _ => Box::new(std::iter::empty()),
+        }
+    }
+}
+
+impl HasFieldsAndBases for Api<FnPrePhase2> {
+    fn name(&self) -> &QualifiedName {
+        self.name()
+    }
+
+    fn field_and_base_deps(&self) -> Box<dyn Iterator<Item = &QualifiedName> + '_> {
+        match self {
+            Api::Struct {
+                analysis:
+                    PodAndConstructorAnalysis {
+                        pod:
+                            PodAnalysis {
+                                field_definition_deps,
+                                bases,
+                                ..
+                            },
+                        ..
+                    },
+                ..
+            } => Box::new(field_definition_deps.iter().chain(bases.iter())),
+            _ => Box::new(std::iter::empty()),
+        }
+    }
+}
+
+/// Stringify a function argument for diagnostics
+fn describe_arg(arg: &FnArg) -> String {
+    match arg {
+        FnArg::Receiver(_) => "the function receiver (this/self paramter)".into(),
+        FnArg::Typed(PatType { pat, .. }) => match pat.as_ref() {
+            Pat::Ident(pti) => pti.ident.to_string(),
+            _ => "another argument we don't know how to describe".into(),
+        },
+    }
+}
diff --git a/engine/src/conversion/analysis/fun/overload_tracker.rs b/engine/src/conversion/analysis/fun/overload_tracker.rs
index 6fc532c..20165f5 100644
--- a/engine/src/conversion/analysis/fun/overload_tracker.rs
+++ b/engine/src/conversion/analysis/fun/overload_tracker.rs
@@ -49,7 +49,7 @@
         if this_offset == 0 {
             cpp_method_name
         } else {
-            format!("{}{}", cpp_method_name, this_offset)
+            format!("{cpp_method_name}{this_offset}")
         }
     }
 }
diff --git a/engine/src/conversion/analysis/fun/subclass.rs b/engine/src/conversion/analysis/fun/subclass.rs
index 6383d2c..8698539 100644
--- a/engine/src/conversion/analysis/fun/subclass.rs
+++ b/engine/src/conversion/analysis/fun/subclass.rs
@@ -6,6 +6,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::ops::DerefMut;
+
 use indexmap::map::IndexMap as HashMap;
 
 use syn::{parse_quote, FnArg, PatType, Type, TypePtr};
@@ -17,6 +19,7 @@
     SubclassName, SuperclassMethod, UnsafetyNeeded, Virtualness,
 };
 use crate::conversion::apivec::ApiVec;
+use crate::minisyn::minisynize_punctuated;
 use crate::{
     conversion::{
         analysis::fun::function_wrapper::{
@@ -85,6 +88,7 @@
         .param_details
         .iter()
         .map(|pd| pd.name.clone())
+        .map(Into::into)
         .collect();
     let requires_unsafe = if matches!(unsafe_policy, UnsafePolicy::AllFunctionsUnsafe) {
         UnsafetyNeeded::Always
@@ -95,10 +99,10 @@
         name,
         details: SuperclassMethod {
             name: make_ident(&analysis.rust_name),
-            params: analysis.params.clone(),
+            params: minisynize_punctuated(analysis.params.clone()),
             ret_type: analysis.ret_type.clone(),
             param_names,
-            receiver_mutability: receiver_mutability.clone(),
+            receiver_mutability: *receiver_mutability,
             requires_unsafe,
             is_pure_virtual,
             receiver,
@@ -122,10 +126,10 @@
         sub.0.name.get_final_item(),
         name.name.get_final_item()
     ));
-    let params = std::iter::once(parse_quote! {
+    let params = std::iter::once(crate::minisyn::FnArg(parse_quote! {
         me: & #holder_name
-    })
-    .chain(analysis.params.iter().skip(1).cloned())
+    }))
+    .chain(analysis.params.iter().skip(1).cloned().map(Into::into))
     .collect();
     let kind = if matches!(receiver_mutability, ReceiverMutability::Mutable) {
         CppFunctionKind::Method
@@ -161,7 +165,7 @@
                 qualification: Some(cpp),
             },
             superclass: superclass.clone(),
-            receiver_mutability: receiver_mutability.clone(),
+            receiver_mutability: *receiver_mutability,
             dependencies,
             requires_unsafe,
             is_pure_virtual: matches!(
@@ -213,7 +217,9 @@
     let subclass_constructor_name =
         make_ident(format!("{}_{}", cpp.get_final_item(), cpp.get_final_item()));
     let mut existing_params = fun.inputs.clone();
-    if let Some(FnArg::Typed(PatType { ty, .. })) = existing_params.first_mut() {
+    if let Some(FnArg::Typed(PatType { ty, .. })) =
+        existing_params.first_mut().map(DerefMut::deref_mut)
+    {
         if let Type::Ptr(TypePtr { elem, .. }) = &mut **ty {
             *elem = Box::new(Type::Path(sub.cpp().to_type_path()));
         } else {
@@ -229,7 +235,7 @@
     };
     let inputs = self_param
         .into_iter()
-        .chain(std::iter::once(boxed_holder_param))
+        .chain(std::iter::once(boxed_holder_param.into()))
         .chain(existing_params)
         .collect();
     let maybe_wrap = Box::new(FuncToConvert {
diff --git a/engine/src/conversion/analysis/name_check.rs b/engine/src/conversion/analysis/name_check.rs
index 7547c7c..38b8db4 100644
--- a/engine/src/conversion/analysis/name_check.rs
+++ b/engine/src/conversion/analysis/name_check.rs
@@ -8,14 +8,14 @@
 
 use indexmap::map::IndexMap as HashMap;
 
-use syn::Ident;
+use crate::minisyn::Ident;
 
 use crate::{
     conversion::{
         api::{Api, SubclassName},
         apivec::ApiVec,
         error_reporter::convert_item_apis,
-        ConvertError,
+        ConvertErrorFromCpp,
     },
     types::{validate_ident_ok_for_cxx, QualifiedName},
 };
@@ -92,7 +92,7 @@
         if let Some(name) = my_name {
             let symbols_for_this_name = names_found.entry(name).or_default();
             if symbols_for_this_name.len() > 1usize {
-                Err(ConvertError::DuplicateCxxBridgeName(
+                Err(ConvertErrorFromCpp::DuplicateCxxBridgeName(
                     symbols_for_this_name.clone(),
                 ))
             } else {
@@ -107,9 +107,9 @@
 
 fn validate_all_segments_ok_for_cxx(
     items: impl Iterator<Item = String>,
-) -> Result<(), ConvertError> {
+) -> Result<(), ConvertErrorFromCpp> {
     for seg in items {
-        validate_ident_ok_for_cxx(&seg)?;
+        validate_ident_ok_for_cxx(&seg).map_err(ConvertErrorFromCpp::InvalidIdent)?;
     }
     Ok(())
 }
diff --git a/engine/src/conversion/analysis/pod/byvalue_checker.rs b/engine/src/conversion/analysis/pod/byvalue_checker.rs
index de72eec..6e2e9b9 100644
--- a/engine/src/conversion/analysis/pod/byvalue_checker.rs
+++ b/engine/src/conversion/analysis/pod/byvalue_checker.rs
@@ -7,7 +7,7 @@
 // except according to those terms.
 
 use crate::conversion::apivec::ApiVec;
-use crate::{conversion::ConvertError, known_types::known_types};
+use crate::{conversion::ConvertErrorFromCpp, known_types::known_types};
 use crate::{
     conversion::{
         analysis::tdef::TypedefPhase,
@@ -48,6 +48,9 @@
 /// std::string contains a self-referential pointer.
 /// It is possible that this is duplicative of the information stored
 /// elsewhere in the `Api` list and could possibly be removed or simplified.
+/// In general this is one of the oldest parts of autocxx and
+/// the code here could quite possibly be simplified by reusing code
+/// elsewhere.
 pub struct ByValueChecker {
     // Mapping from type name to whether it is safe to be POD
     results: HashMap<QualifiedName, StructDetails>,
@@ -60,7 +63,7 @@
             let safety = if by_value_safe {
                 PodState::IsPod
             } else {
-                PodState::UnsafeToBePod(format!("type {} is not safe for POD", tn))
+                PodState::UnsafeToBePod(format!("type {tn} is not safe for POD"))
             };
             results.insert(tn.clone(), StructDetails::new(safety));
         }
@@ -72,7 +75,7 @@
     pub(crate) fn new_from_apis(
         apis: &ApiVec<TypedefPhase>,
         config: &IncludeCppConfig,
-    ) -> Result<ByValueChecker, ConvertError> {
+    ) -> Result<ByValueChecker, ConvertErrorFromCpp> {
         let mut byvalue_checker = ByValueChecker::new();
         for blocklisted in config.get_blocklist() {
             let tn = QualifiedName::new_from_cpp_name(blocklisted);
@@ -81,6 +84,11 @@
                 .results
                 .insert(tn, StructDetails::new(safety));
         }
+        // As we do this analysis, we need to be aware that structs
+        // may depend on other types. Ideally we'd use the depth first iterator
+        // but that's awkward given that our ApiPhase does not yet have a fixed
+        // list of field/base types. Instead, we'll iterate first over non-struct
+        // types and then over structs.
         for api in apis.iter() {
             match api {
                 Api::Typedef { analysis, .. } => {
@@ -94,7 +102,7 @@
                             _ => None,
                         },
                         TypedefKind::Use(_, ref ty) => match **ty {
-                            Type::Path(ref typ) => {
+                            crate::minisyn::Type(Type::Path(ref typ)) => {
                                 let target_tn = QualifiedName::from_type_path(typ);
                                 known_types().consider_substitution(&target_tn)
                             }
@@ -113,15 +121,7 @@
                         None => byvalue_checker.ingest_nonpod_type(name.clone()),
                     }
                 }
-                Api::Struct { details, .. } => {
-                    byvalue_checker.ingest_struct(&details.item, api.name().get_namespace())
-                }
-                Api::Enum { .. } => {
-                    byvalue_checker
-                        .results
-                        .insert(api.name().clone(), StructDetails::new(PodState::IsPod));
-                }
-                Api::ExternCppType { pod: true, .. } => {
+                Api::Enum { .. } | Api::ExternCppType { pod: true, .. } => {
                     byvalue_checker
                         .results
                         .insert(api.name().clone(), StructDetails::new(PodState::IsPod));
@@ -129,6 +129,11 @@
                 _ => {}
             }
         }
+        for api in apis.iter() {
+            if let Api::Struct { details, .. } = api {
+                byvalue_checker.ingest_struct(&details.item, api.name().get_namespace())
+            }
+        }
         let pod_requests = config
             .get_pod_requests()
             .iter()
@@ -136,27 +141,32 @@
             .collect();
         byvalue_checker
             .satisfy_requests(pod_requests)
-            .map_err(ConvertError::UnsafePodType)?;
+            .map_err(ConvertErrorFromCpp::UnsafePodType)?;
         Ok(byvalue_checker)
     }
 
     fn ingest_struct(&mut self, def: &ItemStruct, ns: &Namespace) {
         // For this struct, work out whether it _could_ be safe as a POD.
-        let tyname = QualifiedName::new(ns, def.ident.clone());
+        let tyname = QualifiedName::new(ns, def.ident.clone().into());
         let mut field_safety_problem = PodState::SafeToBePod;
         let fieldlist = Self::get_field_types(def);
         for ty_id in &fieldlist {
             match self.results.get(ty_id) {
+                None if ty_id.get_final_item() == "__BindgenUnionField" => {
+                    field_safety_problem = PodState::UnsafeToBePod(format!(
+                        "Type {tyname} could not be POD because it is a union"
+                    ));
+                    break;
+                }
                 None => {
                     field_safety_problem = PodState::UnsafeToBePod(format!(
-                        "Type {} could not be POD because its dependent type {} isn't known",
-                        tyname, ty_id
+                        "Type {tyname} could not be POD because its dependent type {ty_id} isn't known"
                     ));
                     break;
                 }
                 Some(deets) => {
                     if let PodState::UnsafeToBePod(reason) = &deets.state {
-                        let new_reason = format!("Type {} could not be POD because its dependent type {} isn't safe to be POD. Because: {}", tyname, ty_id, reason);
+                        let new_reason = format!("Type {tyname} could not be POD because its dependent type {ty_id} isn't safe to be POD. Because: {reason}");
                         field_safety_problem = PodState::UnsafeToBePod(new_reason);
                         break;
                     }
@@ -164,10 +174,8 @@
             }
         }
         if Self::has_vtable(def) {
-            let reason = format!(
-                "Type {} could not be POD because it has virtual functions.",
-                tyname
-            );
+            let reason =
+                format!("Type {tyname} could not be POD because it has virtual functions.");
             field_safety_problem = PodState::UnsafeToBePod(reason);
         }
         let mut my_details = StructDetails::new(field_safety_problem);
@@ -176,7 +184,7 @@
     }
 
     fn ingest_nonpod_type(&mut self, tyname: QualifiedName) {
-        let new_reason = format!("Type {} is a typedef to a complex type", tyname);
+        let new_reason = format!("Type {tyname} is a typedef to a complex type");
         self.results.insert(
             tyname,
             StructDetails::new(PodState::UnsafeToBePod(new_reason)),
@@ -191,8 +199,7 @@
             match deets {
                 None => {
                     return Err(format!(
-                        "Unable to make {} POD because we never saw a struct definition",
-                        ty_id
+                        "Unable to make {ty_id} POD because we never saw a struct definition"
                     ))
                 }
                 Some(deets) => match &deets.state {
@@ -236,6 +243,10 @@
         )
     }
 
+    /// This is a miniature version of the analysis in `super::get_struct_field_types`.
+    /// It would be nice to unify them. However, this version only cares about spotting
+    /// fields which may be non-POD, so can largely concern itself with just `Type::Path`
+    /// fields.
     fn get_field_types(def: &ItemStruct) -> Vec<QualifiedName> {
         let mut results = Vec::new();
         for f in &def.fields {
@@ -261,10 +272,11 @@
 #[cfg(test)]
 mod tests {
     use super::ByValueChecker;
+    use crate::minisyn::ItemStruct;
     use crate::types::{Namespace, QualifiedName};
-    use syn::{parse_quote, Ident, ItemStruct};
+    use syn::parse_quote;
 
-    fn ty_from_ident(id: &Ident) -> QualifiedName {
+    fn ty_from_ident(id: &syn::Ident) -> QualifiedName {
         QualifiedName::new_from_cpp_name(&id.to_string())
     }
 
diff --git a/engine/src/conversion/analysis/pod/mod.rs b/engine/src/conversion/analysis/pod/mod.rs
index eeb5051..2fafc95 100644
--- a/engine/src/conversion/analysis/pod/mod.rs
+++ b/engine/src/conversion/analysis/pod/mod.rs
@@ -13,7 +13,7 @@
 
 use autocxx_parser::IncludeCppConfig;
 use byvalue_checker::ByValueChecker;
-use syn::{ItemEnum, ItemStruct, Type, Visibility};
+use syn::{ItemStruct, Type, Visibility};
 
 use crate::{
     conversion::{
@@ -23,18 +23,21 @@
         convert_error::{ConvertErrorWithContext, ErrorContext},
         error_reporter::convert_apis,
         parse::BindgenSemanticAttributes,
-        ConvertError,
+        ConvertErrorFromCpp,
     },
     types::{Namespace, QualifiedName},
 };
 
 use super::tdef::{TypedefAnalysis, TypedefPhase};
 
+#[derive(std::fmt::Debug)]
+
 pub(crate) struct FieldInfo {
     pub(crate) ty: Type,
     pub(crate) type_kind: type_converter::TypeKind,
 }
 
+#[derive(std::fmt::Debug)]
 pub(crate) struct PodAnalysis {
     pub(crate) kind: TypeKind,
     pub(crate) bases: HashSet<QualifiedName>,
@@ -43,12 +46,18 @@
     /// because otherwise we don't know whether they're
     /// abstract or not.
     pub(crate) castable_bases: HashSet<QualifiedName>,
+    /// All field types. e.g. for std::unique_ptr<A>, this would include
+    /// both std::unique_ptr and A
     pub(crate) field_deps: HashSet<QualifiedName>,
+    /// Types within fields where we need a definition, e.g. for
+    /// std::unique_ptr<A> it would just be std::unique_ptr.
+    pub(crate) field_definition_deps: HashSet<QualifiedName>,
     pub(crate) field_info: Vec<FieldInfo>,
     pub(crate) is_generic: bool,
     pub(crate) in_anonymous_namespace: bool,
 }
 
+#[derive(std::fmt::Debug)]
 pub(crate) struct PodPhase;
 
 impl AnalysisPhase for PodPhase {
@@ -65,7 +74,7 @@
 pub(crate) fn analyze_pod_apis(
     apis: ApiVec<TypedefPhase>,
     config: &IncludeCppConfig,
-) -> Result<ApiVec<PodPhase>, ConvertError> {
+) -> Result<ApiVec<PodPhase>, ConvertErrorFromCpp> {
     // This next line will return an error if any of the 'generate_pod'
     // directives from the user can't be met because, for instance,
     // a type contains a std::string or some other type which can't be
@@ -118,7 +127,7 @@
 
 fn analyze_enum(
     name: ApiName,
-    mut item: ItemEnum,
+    mut item: crate::minisyn::ItemEnum,
 ) -> Result<Box<dyn Iterator<Item = Api<PodPhase>>>, ConvertErrorWithContext> {
     let metadata = BindgenSemanticAttributes::new_retaining_others(&mut item.attrs);
     metadata.check_for_fatal_attrs(&name.name.get_final_ident())?;
@@ -138,12 +147,14 @@
     metadata.check_for_fatal_attrs(&id)?;
     let bases = get_bases(&details.item);
     let mut field_deps = HashSet::new();
+    let mut field_definition_deps = HashSet::new();
     let mut field_info = Vec::new();
     let field_conversion_errors = get_struct_field_types(
         type_converter,
         name.name.get_namespace(),
         &details.item,
         &mut field_deps,
+        &mut field_definition_deps,
         &mut field_info,
         extra_apis,
     );
@@ -152,7 +163,7 @@
         // Let's not allow anything to be POD if it's got rvalue reference fields.
         if details.has_rvalue_reference_fields {
             return Err(ConvertErrorWithContext(
-                ConvertError::RValueReferenceField,
+                ConvertErrorFromCpp::RValueReferenceField,
                 Some(ErrorContext::new_for_item(id)),
             ));
         }
@@ -186,6 +197,7 @@
             bases: bases.into_keys().collect(),
             castable_bases,
             field_deps,
+            field_definition_deps,
             field_info,
             is_generic,
             in_anonymous_namespace,
@@ -198,9 +210,10 @@
     ns: &Namespace,
     s: &ItemStruct,
     field_deps: &mut HashSet<QualifiedName>,
+    field_definition_deps: &mut HashSet<QualifiedName>,
     field_info: &mut Vec<FieldInfo>,
     extra_apis: &mut ApiVec<NullPhase>,
-) -> Vec<ConvertError> {
+) -> Vec<ConvertErrorFromCpp> {
     let mut convert_errors = Vec::new();
     let struct_type_params = s
         .generics
@@ -225,6 +238,14 @@
                     .unwrap_or(false)
                 {
                     field_deps.extend(r.types_encountered);
+                    if let Type::Path(typ) = &r.ty {
+                        // Later analyses need to know about the field
+                        // types where we need full definitions, as opposed
+                        // to just declarations. That means just the outermost
+                        // type path.
+                        // TODO: consider arrays.
+                        field_definition_deps.insert(QualifiedName::from_type_path(typ));
+                    }
                     field_info.push(FieldInfo {
                         ty: r.ty,
                         type_kind: r.kind,
diff --git a/engine/src/conversion/analysis/remove_ignored.rs b/engine/src/conversion/analysis/remove_ignored.rs
index bd11b13..4ed4b9f 100644
--- a/engine/src/conversion/analysis/remove_ignored.rs
+++ b/engine/src/conversion/analysis/remove_ignored.rs
@@ -11,7 +11,7 @@
 use super::deps::HasDependencies;
 use super::fun::{FnAnalysis, FnKind, FnPhase};
 use crate::conversion::apivec::ApiVec;
-use crate::conversion::{convert_error::ErrorContext, ConvertError};
+use crate::conversion::{convert_error::ErrorContext, ConvertErrorFromCpp};
 use crate::{conversion::api::Api, known_types};
 
 /// Remove any APIs which depend on other items which have been ignored.
@@ -44,7 +44,10 @@
                 if !ignored_dependents.is_empty() {
                     iterate_again = true;
                     ignored_items.insert(api.name().clone());
-                    create_ignore_item(api, ConvertError::IgnoredDependent(ignored_dependents))
+                    create_ignore_item(
+                        api,
+                        ConvertErrorFromCpp::IgnoredDependent(ignored_dependents),
+                    )
                 } else {
                     let mut missing_deps = api.deps().filter(|dep| {
                         !valid_types.contains(*dep) && !known_types().is_known_type(dep)
@@ -52,7 +55,10 @@
                     let first = missing_deps.next();
                     std::mem::drop(missing_deps);
                     if let Some(missing_dep) = first.cloned() {
-                        create_ignore_item(api, ConvertError::UnknownDependentType(missing_dep))
+                        create_ignore_item(
+                            api,
+                            ConvertErrorFromCpp::UnknownDependentType(missing_dep),
+                        )
                     } else {
                         api
                     }
@@ -63,7 +69,7 @@
     apis
 }
 
-fn create_ignore_item(api: Api<FnPhase>, err: ConvertError) -> Api<FnPhase> {
+fn create_ignore_item(api: Api<FnPhase>, err: ConvertErrorFromCpp) -> Api<FnPhase> {
     let id = api.name().get_final_ident();
     log::info!("Marking as ignored: {} because {}", id.to_string(), err);
     Api::IgnoredItem {
diff --git a/engine/src/conversion/analysis/replace_hopeless_typedef_targets.rs b/engine/src/conversion/analysis/replace_hopeless_typedef_targets.rs
index 8d5d033..918fb8f 100644
--- a/engine/src/conversion/analysis/replace_hopeless_typedef_targets.rs
+++ b/engine/src/conversion/analysis/replace_hopeless_typedef_targets.rs
@@ -15,7 +15,7 @@
         api::Api,
         apivec::ApiVec,
         convert_error::{ConvertErrorWithContext, ErrorContext},
-        ConvertError,
+        ConvertErrorFromCpp,
     },
     types::QualifiedName,
 };
@@ -71,7 +71,7 @@
                 {
                     Api::IgnoredItem {
                         name: api.name_info().clone(),
-                        err: ConvertError::NestedOpaqueTypedef,
+                        err: ConvertErrorFromCpp::NestedOpaqueTypedef,
                         ctx: Some(ErrorContext::new_for_item(name_id)),
                     }
                 } else {
diff --git a/engine/src/conversion/analysis/tdef.rs b/engine/src/conversion/analysis/tdef.rs
index 5a635f8..1c414e8 100644
--- a/engine/src/conversion/analysis/tdef.rs
+++ b/engine/src/conversion/analysis/tdef.rs
@@ -19,11 +19,12 @@
         convert_error::{ConvertErrorWithContext, ErrorContext},
         error_reporter::convert_apis,
         parse::BindgenSemanticAttributes,
-        ConvertError,
+        ConvertErrorFromCpp,
     },
     types::QualifiedName,
 };
 
+#[derive(std::fmt::Debug)]
 pub(crate) struct TypedefAnalysis {
     pub(crate) kind: TypedefKind,
     pub(crate) deps: HashSet<QualifiedName>,
@@ -31,6 +32,7 @@
 
 /// Analysis phase where typedef analysis has been performed but no other
 /// analyses just yet.
+#[derive(std::fmt::Debug)]
 pub(crate) struct TypedefPhase;
 
 impl AnalysisPhase for TypedefPhase {
@@ -57,7 +59,7 @@
             Ok(Box::new(std::iter::once(match item {
                 TypedefKind::Type(ity) => get_replacement_typedef(
                     name,
-                    ity,
+                    ity.into(),
                     old_tyname,
                     &mut type_converter,
                     &mut extra_apis,
@@ -87,7 +89,7 @@
 ) -> Result<Api<TypedefPhase>, ConvertErrorWithContext> {
     if !ity.generics.params.is_empty() {
         return Err(ConvertErrorWithContext(
-            ConvertError::TypedefTakesGenericParameters,
+            ConvertErrorFromCpp::TypedefTakesGenericParameters,
             Some(ErrorContext::new_for_item(name.name.get_final_ident())),
         ));
     }
@@ -108,7 +110,7 @@
             ty: syn::Type::Path(ref typ),
             ..
         }) if QualifiedName::from_type_path(typ) == name.name => Err(ConvertErrorWithContext(
-            ConvertError::InfinitelyRecursiveTypedef(name.name.clone()),
+            ConvertErrorFromCpp::InfinitelyRecursiveTypedef(name.name.clone()),
             Some(ErrorContext::new_for_item(name.name.get_final_ident())),
         )),
         Ok(mut final_type) => {
@@ -116,10 +118,10 @@
             extra_apis.append(&mut final_type.extra_apis);
             Ok(Api::Typedef {
                 name,
-                item: TypedefKind::Type(ity),
+                item: TypedefKind::Type(ity.into()),
                 old_tyname,
                 analysis: TypedefAnalysis {
-                    kind: TypedefKind::Type(converted_type),
+                    kind: TypedefKind::Type(converted_type.into()),
                     deps: final_type.types_encountered,
                 },
             })
diff --git a/engine/src/conversion/analysis/type_converter.rs b/engine/src/conversion/analysis/type_converter.rs
index 7e2d2bd..63f7ae9 100644
--- a/engine/src/conversion/analysis/type_converter.rs
+++ b/engine/src/conversion/analysis/type_converter.rs
@@ -10,8 +10,8 @@
     conversion::{
         api::{AnalysisPhase, Api, ApiName, NullPhase, TypedefKind, UnanalyzedApi},
         apivec::ApiVec,
-        codegen_cpp::type_to_cpp::type_to_cpp,
-        ConvertError,
+        codegen_cpp::type_to_cpp::CppNameMap,
+        ConvertErrorFromCpp,
     },
     known_types::{known_types, CxxGenericType},
     types::{make_ident, Namespace, QualifiedName},
@@ -34,7 +34,7 @@
 pub(crate) enum TypeKind {
     Regular,
     Pointer,
-    SubclassHolder(Ident),
+    SubclassHolder(crate::minisyn::Ident),
     Reference,
     RValueReference,
     MutableReference,
@@ -109,14 +109,9 @@
         matches!(self, Self::WithinReference)
     }
     fn allowed_generic_type(&self, ident: &Ident) -> bool {
-        match self {
+        !matches!(self,
             Self::WithinStructField { struct_type_params }
-                if struct_type_params.contains(ident) =>
-            {
-                false
-            }
-            _ => true,
-        }
+                if struct_type_params.contains(ident))
     }
 }
 
@@ -135,6 +130,7 @@
     forward_declarations: HashSet<QualifiedName>,
     ignored_types: HashSet<QualifiedName>,
     config: &'a IncludeCppConfig,
+    original_name_map: CppNameMap,
 }
 
 impl<'a> TypeConverter<'a> {
@@ -149,6 +145,7 @@
             forward_declarations: Self::find_incomplete_types(apis),
             ignored_types: Self::find_ignored_types(apis),
             config,
+            original_name_map: CppNameMap::new_from_apis(apis),
         }
     }
 
@@ -157,7 +154,7 @@
         ty: Box<Type>,
         ns: &Namespace,
         ctx: &TypeConversionContext,
-    ) -> Result<Annotated<Box<Type>>, ConvertError> {
+    ) -> Result<Annotated<Box<Type>>, ConvertErrorFromCpp> {
         Ok(self.convert_type(*ty, ns, ctx)?.map(Box::new))
     }
 
@@ -166,7 +163,7 @@
         ty: Type,
         ns: &Namespace,
         ctx: &TypeConversionContext,
-    ) -> Result<Annotated<Type>, ConvertError> {
+    ) -> Result<Annotated<Type>, ConvertErrorFromCpp> {
         let result = match ty {
             Type::Path(p) => {
                 let newp = self.convert_type_path(p, ns, ctx)?;
@@ -175,7 +172,7 @@
                     if !ctx.allow_instantiation_of_forward_declaration()
                         && self.forward_declarations.contains(&qn)
                     {
-                        return Err(ConvertError::TypeContainingForwardDeclaration(qn));
+                        return Err(ConvertErrorFromCpp::TypeContainingForwardDeclaration(qn));
                     }
                     // Special handling because rust_Str (as emitted by bindgen)
                     // doesn't simply get renamed to a different type _identifier_.
@@ -220,7 +217,11 @@
                 )
             }
             Type::Ptr(ptr) => self.convert_ptr(ptr, ns, ctx.pointer_treatment())?,
-            _ => return Err(ConvertError::UnknownType(ty.to_token_stream().to_string())),
+            _ => {
+                return Err(ConvertErrorFromCpp::UnknownType(
+                    ty.to_token_stream().to_string(),
+                ))
+            }
         };
         Ok(result)
     }
@@ -230,7 +231,7 @@
         mut typ: TypePath,
         ns: &Namespace,
         ctx: &TypeConversionContext,
-    ) -> Result<Annotated<Type>, ConvertError> {
+    ) -> Result<Annotated<Type>, ConvertErrorFromCpp> {
         // First, qualify any unqualified paths.
         if typ.path.segments.iter().next().unwrap().ident != "root" {
             let ty = QualifiedName::from_type_path(&typ);
@@ -241,7 +242,7 @@
             if !known_types().is_known_type(&ty) {
                 let num_segments = typ.path.segments.len();
                 if num_segments > 1 {
-                    return Err(ConvertError::UnsupportedBuiltInType(ty));
+                    return Err(ConvertErrorFromCpp::UnsupportedBuiltInType(ty));
                 }
                 if !self.types_found.contains(&ty) {
                     typ.path.segments = std::iter::once(&"root".to_string())
@@ -257,9 +258,11 @@
         }
 
         let original_tn = QualifiedName::from_type_path(&typ);
-        original_tn.validate_ok_for_cxx()?;
+        original_tn
+            .validate_ok_for_cxx()
+            .map_err(ConvertErrorFromCpp::InvalidIdent)?;
         if self.config.is_on_blocklist(&original_tn.to_cpp_name()) {
-            return Err(ConvertError::Blocked(original_tn));
+            return Err(ConvertErrorFromCpp::Blocked(original_tn));
         }
         let mut deps = HashSet::new();
 
@@ -331,7 +334,9 @@
                     )?;
                     deps.extend(innerty.types_encountered.drain(..));
                 } else {
-                    return Err(ConvertError::TemplatedTypeContainingNonPathArg(tn.clone()));
+                    return Err(ConvertErrorFromCpp::TemplatedTypeContainingNonPathArg(
+                        tn.clone(),
+                    ));
                 }
             } else {
                 // Oh poop. It's a generic type which cxx won't be able to handle.
@@ -347,7 +352,9 @@
                                     if typ.path.segments.len() == 1
                                         && !ctx.allowed_generic_type(&seg.ident)
                                     {
-                                        return Err(ConvertError::ReferringToGenericTypeParam);
+                                        return Err(
+                                            ConvertErrorFromCpp::ReferringToGenericTypeParam,
+                                        );
                                     }
                                 }
                             }
@@ -361,7 +368,7 @@
                 // this a bit.
                 let qn = QualifiedName::from_type_path(&typ); // ignores generic params
                 if self.ignored_types.contains(&qn) {
-                    return Err(ConvertError::ConcreteVersionOfIgnoredTemplate);
+                    return Err(ConvertErrorFromCpp::ConcreteVersionOfIgnoredTemplate);
                 }
                 let (new_tn, api) = self.get_templated_typename(&Type::Path(typ))?;
                 extra_apis.extend(api.into_iter());
@@ -385,7 +392,7 @@
         pun: Punctuated<GenericArgument, P>,
         ns: &Namespace,
         ctx: &TypeConversionContext,
-    ) -> Result<Annotated<Punctuated<GenericArgument, P>>, ConvertError>
+    ) -> Result<Annotated<Punctuated<GenericArgument, P>>, ConvertErrorFromCpp>
     where
         P: Default,
     {
@@ -411,7 +418,10 @@
         ))
     }
 
-    fn resolve_typedef<'b>(&'b self, tn: &QualifiedName) -> Result<Option<&'b Type>, ConvertError> {
+    fn resolve_typedef<'b>(
+        &'b self,
+        tn: &QualifiedName,
+    ) -> Result<Option<&'b Type>, ConvertErrorFromCpp> {
         let mut encountered = HashSet::new();
         let mut tn = tn.clone();
         let mut previous_typ = None;
@@ -422,7 +432,7 @@
                     previous_typ = r;
                     let new_tn = QualifiedName::from_type_path(typ);
                     if encountered.contains(&new_tn) {
-                        return Err(ConvertError::InfinitelyRecursiveTypedef(tn.clone()));
+                        return Err(ConvertErrorFromCpp::InfinitelyRecursiveTypedef(tn.clone()));
                     }
                     if typ
                         .path
@@ -430,7 +440,7 @@
                         .iter()
                         .any(|seg| seg.ident.to_string().starts_with("_bindgen_mod"))
                     {
-                        return Err(ConvertError::TypedefToTypeInAnonymousNamespace);
+                        return Err(ConvertErrorFromCpp::TypedefToTypeInAnonymousNamespace);
                     }
                     encountered.insert(new_tn.clone());
                     tn = new_tn;
@@ -446,10 +456,10 @@
         mut ptr: TypePtr,
         ns: &Namespace,
         pointer_treatment: PointerTreatment,
-    ) -> Result<Annotated<Type>, ConvertError> {
+    ) -> Result<Annotated<Type>, ConvertErrorFromCpp> {
         match pointer_treatment {
             PointerTreatment::Pointer => {
-                crate::known_types::ensure_pointee_is_valid(&ptr)?;
+                Self::ensure_pointee_is_valid(&ptr)?;
                 let innerty =
                     self.convert_boxed_type(ptr.elem, ns, &TypeConversionContext::WithinReference)?;
                 ptr.elem = innerty.ty;
@@ -470,7 +480,7 @@
                 // be a plain value. We should detect and abort.
                 let mut outer = elem.map(|elem| match mutability {
                     Some(_) => Type::Path(parse_quote! {
-                        ::std::pin::Pin < & #mutability #elem >
+                        ::core::pin::Pin < & #mutability #elem >
                     }),
                     None => Type::Reference(parse_quote! {
                         & #elem
@@ -484,7 +494,7 @@
                 Ok(outer)
             }
             PointerTreatment::RValueReference => {
-                crate::known_types::ensure_pointee_is_valid(&ptr)?;
+                Self::ensure_pointee_is_valid(&ptr)?;
                 let innerty =
                     self.convert_boxed_type(ptr.elem, ns, &TypeConversionContext::WithinReference)?;
                 ptr.elem = innerty.ty;
@@ -498,15 +508,26 @@
         }
     }
 
+    fn ensure_pointee_is_valid(ptr: &TypePtr) -> Result<(), ConvertErrorFromCpp> {
+        match *ptr.elem {
+            Type::Path(..) => Ok(()),
+            Type::Array(..) => Err(ConvertErrorFromCpp::InvalidArrayPointee),
+            Type::Ptr(..) => Err(ConvertErrorFromCpp::InvalidPointerPointee),
+            _ => Err(ConvertErrorFromCpp::InvalidPointee(
+                ptr.elem.to_token_stream().to_string(),
+            )),
+        }
+    }
+
     fn get_templated_typename(
         &mut self,
         rs_definition: &Type,
-    ) -> Result<(QualifiedName, Option<UnanalyzedApi>), ConvertError> {
+    ) -> Result<(QualifiedName, Option<UnanalyzedApi>), ConvertErrorFromCpp> {
         let count = self.concrete_templates.len();
         // We just use this as a hash key, essentially.
         // TODO: Once we've completed the TypeConverter refactoring (see #220),
         // pass in an actual original_name_map here.
-        let cpp_definition = type_to_cpp(rs_definition, &HashMap::new())?;
+        let cpp_definition = self.original_name_map.type_to_cpp(rs_definition)?;
         let e = self.concrete_templates.get(&cpp_definition);
         match e {
             Some(tn) => Ok((tn.clone(), None)),
@@ -530,12 +551,12 @@
                     .find(|s| s == &synthetic_ident)
                 {
                     None => synthetic_ident,
-                    Some(_) => format!("AutocxxConcrete{}", count),
+                    Some(_) => format!("AutocxxConcrete{count}"),
                 };
                 let api = UnanalyzedApi::ConcreteType {
-                    name: ApiName::new_in_root_namespace(make_ident(&synthetic_ident)),
+                    name: ApiName::new_in_root_namespace(make_ident(synthetic_ident)),
                     cpp_definition: cpp_definition.clone(),
-                    rs_definition: Some(Box::new(rs_definition.clone())),
+                    rs_definition: Some(Box::new(rs_definition.clone().into())),
                 };
                 self.concrete_templates
                     .insert(cpp_definition, api.name().clone());
@@ -550,21 +571,25 @@
         desc: &QualifiedName,
         generic_behavior: CxxGenericType,
         forward_declarations_ok: bool,
-    ) -> Result<TypeKind, ConvertError> {
+    ) -> Result<TypeKind, ConvertErrorFromCpp> {
         for inner in path_args {
             match inner {
                 GenericArgument::Type(Type::Path(typ)) => {
                     let inner_qn = QualifiedName::from_type_path(typ);
                     if !forward_declarations_ok && self.forward_declarations.contains(&inner_qn) {
-                        return Err(ConvertError::TypeContainingForwardDeclaration(inner_qn));
+                        return Err(ConvertErrorFromCpp::TypeContainingForwardDeclaration(
+                            inner_qn,
+                        ));
                     }
                     match generic_behavior {
                         CxxGenericType::Rust => {
                             if !inner_qn.get_namespace().is_empty() {
-                                return Err(ConvertError::RustTypeWithAPath(inner_qn));
+                                return Err(ConvertErrorFromCpp::RustTypeWithAPath(inner_qn));
                             }
                             if !self.config.is_rust_type(&inner_qn.get_final_ident()) {
-                                return Err(ConvertError::BoxContainingNonRustType(inner_qn));
+                                return Err(ConvertErrorFromCpp::BoxContainingNonRustType(
+                                    inner_qn,
+                                ));
                             }
                             if self
                                 .config
@@ -577,12 +602,12 @@
                         }
                         CxxGenericType::CppPtr => {
                             if !known_types().permissible_within_unique_ptr(&inner_qn) {
-                                return Err(ConvertError::InvalidTypeForCppPtr(inner_qn));
+                                return Err(ConvertErrorFromCpp::InvalidTypeForCppPtr(inner_qn));
                             }
                         }
                         CxxGenericType::CppVector => {
                             if !known_types().permissible_within_vector(&inner_qn) {
-                                return Err(ConvertError::InvalidTypeForCppVector(inner_qn));
+                                return Err(ConvertErrorFromCpp::InvalidTypeForCppVector(inner_qn));
                             }
                             if matches!(
                                 typ.path.segments.last().map(|ps| &ps.arguments),
@@ -591,14 +616,14 @@
                                         | PathArguments::AngleBracketed(_)
                                 )
                             ) {
-                                return Err(ConvertError::GenericsWithinVector);
+                                return Err(ConvertErrorFromCpp::GenericsWithinVector);
                             }
                         }
                         _ => {}
                     }
                 }
                 _ => {
-                    return Err(ConvertError::TemplatedTypeContainingNonPathArg(
+                    return Err(ConvertErrorFromCpp::TemplatedTypeContainingNonPathArg(
                         desc.clone(),
                     ))
                 }
diff --git a/engine/src/conversion/api.rs b/engine/src/conversion/api.rs
index c5a1b60..d5da41c 100644
--- a/engine/src/conversion/api.rs
+++ b/engine/src/conversion/api.rs
@@ -9,17 +9,20 @@
 use indexmap::set::IndexSet as HashSet;
 use std::fmt::Display;
 
-use crate::types::{make_ident, Namespace, QualifiedName};
-use autocxx_parser::{ExternCppType, RustFun, RustPath};
-use itertools::Itertools;
-use quote::ToTokens;
 use syn::{
     parse::Parse,
     punctuated::Punctuated,
     token::{Comma, Unsafe},
+};
+
+use crate::minisyn::{
     Attribute, FnArg, Ident, ItemConst, ItemEnum, ItemStruct, ItemType, ItemUse, LitBool, LitInt,
     Pat, ReturnType, Type, Visibility,
 };
+use crate::types::{make_ident, Namespace, QualifiedName};
+use autocxx_parser::{ExternCppType, RustFun, RustPath};
+use itertools::Itertools;
+use quote::ToTokens;
 
 use super::{
     analysis::{
@@ -30,10 +33,10 @@
         PointerTreatment,
     },
     convert_error::{ConvertErrorWithContext, ErrorContext},
-    ConvertError,
+    ConvertErrorFromCpp,
 };
 
-#[derive(Copy, Clone, Eq, PartialEq)]
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub(crate) enum TypeKind {
     Pod,    // trivial. Can be moved and copied in Rust.
     NonPod, // has destructor or non-trivial move constructors. Can only hold by UniquePtr
@@ -53,6 +56,7 @@
 }
 
 /// Details about a C++ struct.
+#[derive(Debug)]
 pub(crate) struct StructDetails {
     pub(crate) item: ItemStruct,
     pub(crate) layout: Option<Layout>,
@@ -60,7 +64,7 @@
 }
 
 /// Layout of a type, equivalent to the same type in ir/layout.rs in bindgen
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct Layout {
     /// The size (in bytes) of this layout.
     pub(crate) size: usize,
@@ -85,14 +89,14 @@
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) enum Virtualness {
     None,
     Virtual,
     PureVirtual,
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 pub(crate) enum CastMutability {
     ConstToConst,
     MutToConst,
@@ -101,7 +105,7 @@
 
 /// Indicates that this function (which is synthetic) should
 /// be a trait implementation rather than a method or free function.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) enum TraitSynthesis {
     Cast {
         to_type: QualifiedName,
@@ -113,7 +117,7 @@
 
 /// Details of a subclass constructor.
 /// TODO: zap this; replace with an extra API.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct SubclassConstructorDetails {
     pub(crate) subclass: SubclassName,
     pub(crate) is_trivial: bool,
@@ -124,7 +128,7 @@
 
 /// Contributions to traits representing C++ superclasses that
 /// we may implement as Rust subclasses.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct SuperclassMethod {
     pub(crate) name: Ident,
     pub(crate) receiver: QualifiedName,
@@ -139,7 +143,7 @@
 /// Information about references (as opposed to pointers) to be found
 /// within the function signature. This is derived from bindgen annotations
 /// which is why it's not within `FuncToConvert::inputs`
-#[derive(Default, Clone)]
+#[derive(Default, Clone, Debug)]
 pub(crate) struct References {
     pub(crate) rvalue_ref_params: HashSet<Ident>,
     pub(crate) ref_params: HashSet<Ident>,
@@ -175,7 +179,7 @@
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct TraitImplSignature {
     pub(crate) ty: Type,
     pub(crate) trait_signature: Type,
@@ -239,13 +243,21 @@
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) enum Provenance {
     Bindgen,
     SynthesizedOther,
     SynthesizedSubclassConstructor(Box<SubclassConstructorDetails>),
 }
 
+/// Whether a function has =delete or =default
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum DeletedOrDefaulted {
+    Neither,
+    Deleted,
+    Defaulted,
+}
+
 /// A C++ function for which we need to generate bindings, but haven't
 /// yet analyzed in depth. This is little more than a `ForeignItemFn`
 /// broken down into its constituent parts, plus some metadata from the
@@ -256,7 +268,7 @@
 /// during normal bindgen parsing. If that happens, they'll create one
 /// of these structures, and typically fill in some of the
 /// `synthesized_*` members which are not filled in from bindgen.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct FuncToConvert {
     pub(crate) provenance: Provenance,
     pub(crate) ident: Ident,
@@ -283,18 +295,20 @@
     /// If Some, this function didn't really exist in the original
     /// C++ and instead we're synthesizing it.
     pub(crate) synthetic_cpp: Option<(CppFunctionBody, CppFunctionKind)>,
-    pub(crate) is_deleted: bool,
+    /// =delete
+    pub(crate) is_deleted: DeletedOrDefaulted,
 }
 
 /// Layers of analysis which may be applied to decorate each API.
 /// See description of the purpose of this trait within `Api`.
-pub(crate) trait AnalysisPhase {
-    type TypedefAnalysis;
-    type StructAnalysis;
-    type FunAnalysis;
+pub(crate) trait AnalysisPhase: std::fmt::Debug {
+    type TypedefAnalysis: std::fmt::Debug;
+    type StructAnalysis: std::fmt::Debug;
+    type FunAnalysis: std::fmt::Debug;
 }
 
 /// No analysis has been applied to this API.
+#[derive(std::fmt::Debug)]
 pub(crate) struct NullPhase;
 
 impl AnalysisPhase for NullPhase {
@@ -303,7 +317,7 @@
     type FunAnalysis = ();
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) enum TypedefKind {
     Use(ItemUse, Box<Type>),
     Type(ItemType),
@@ -365,7 +379,7 @@
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.name)?;
         if let Some(cpp_name) = &self.cpp_name {
-            write!(f, " (cpp={})", cpp_name)?;
+            write!(f, " (cpp={cpp_name})")?;
         }
         Ok(())
     }
@@ -418,7 +432,7 @@
     }
     // TODO this and the following should probably include both class name and method name
     pub(crate) fn get_super_fn_name(superclass_namespace: &Namespace, id: &str) -> QualifiedName {
-        let id = make_ident(format!("{}_super", id));
+        let id = make_ident(format!("{id}_super"));
         QualifiedName::new(superclass_namespace, id)
     }
     pub(crate) fn get_methods_trait_name(superclass_name: &QualifiedName) -> QualifiedName {
@@ -434,7 +448,7 @@
     }
 }
 
-#[derive(strum_macros::Display)]
+#[derive(std::fmt::Debug)]
 /// Different types of API we might encounter.
 ///
 /// This type is parameterized over an `ApiAnalysis`. This is any additional
@@ -445,11 +459,9 @@
 /// because sometimes we pass on the `bindgen` output directly in the
 /// Rust codegen output.
 ///
-/// This derives from [strum_macros::Display] because we want to be
-/// able to debug-print the enum discriminant without worrying about
-/// the fact that their payloads may not be `Debug` or `Display`.
-/// (Specifically, allowing `syn` Types to be `Debug` requires
-/// enabling syn's `extra-traits` feature which increases compile time.)
+/// Any `syn` types represented in this `Api` type, or any of the types from
+/// which it is composed, should be wrapped in `crate::minisyn` equivalents
+/// to avoid excessively verbose `Debug` logging.
 pub(crate) enum Api<T: AnalysisPhase> {
     /// A forward declaration, which we mustn't store in a UniquePtr.
     ForwardDeclaration {
@@ -522,7 +534,7 @@
     /// dependent items.
     IgnoredItem {
         name: ApiName,
-        err: ConvertError,
+        err: ConvertErrorFromCpp,
         ctx: Option<ErrorContext>,
     },
     /// A Rust type which is not a C++ type.
@@ -531,7 +543,7 @@
     RustFn {
         name: ApiName,
         details: RustFun,
-        receiver: Option<QualifiedName>,
+        deps: Vec<QualifiedName>,
     },
     /// Some function for the extern "Rust" block.
     RustSubclassFn {
@@ -559,6 +571,7 @@
     },
 }
 
+#[derive(Debug)]
 pub(crate) struct RustSubclassFnDetails {
     pub(crate) params: Punctuated<FnArg, Comma>,
     pub(crate) ret: ReturnType,
@@ -646,12 +659,6 @@
     }
 }
 
-impl<T: AnalysisPhase> std::fmt::Debug for Api<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?} (kind={})", self.name_info(), self)
-    }
-}
-
 pub(crate) type UnanalyzedApi = Api<NullPhase>;
 
 impl<T: AnalysisPhase> Api<T> {
diff --git a/engine/src/conversion/apivec.rs b/engine/src/conversion/apivec.rs
index 1e440cc..24e70ed 100644
--- a/engine/src/conversion/apivec.rs
+++ b/engine/src/conversion/apivec.rs
@@ -15,7 +15,7 @@
 use indexmap::set::IndexSet as HashSet;
 
 use crate::{
-    conversion::{api::ApiName, convert_error::ErrorContext, ConvertError},
+    conversion::{api::ApiName, convert_error::ErrorContext, ConvertErrorFromCpp},
     types::QualifiedName,
 };
 
@@ -64,7 +64,7 @@
                 self.retain(|api| api.name() != name);
                 self.push(Api::IgnoredItem {
                     name: ApiName::new_from_qualified_name(name.clone()),
-                    err: ConvertError::DuplicateItemsFoundInParsing,
+                    err: ConvertErrorFromCpp::DuplicateItemsFoundInParsing,
                     ctx: Some(ErrorContext::new_for_item(name.get_final_ident())),
                 })
             }
diff --git a/engine/src/conversion/codegen_cpp/function_wrapper_cpp.rs b/engine/src/conversion/codegen_cpp/function_wrapper_cpp.rs
index 5367626..661a5b3 100644
--- a/engine/src/conversion/codegen_cpp/function_wrapper_cpp.rs
+++ b/engine/src/conversion/codegen_cpp/function_wrapper_cpp.rs
@@ -11,16 +11,16 @@
 use crate::conversion::{
     analysis::fun::function_wrapper::{CppConversionType, TypeConversionPolicy},
     api::Pointerness,
-    ConvertError,
+    ConvertErrorFromCpp,
 };
 
-use super::type_to_cpp::{type_to_cpp, CppNameMap};
+use super::type_to_cpp::CppNameMap;
 
 impl TypeConversionPolicy {
     pub(super) fn unconverted_type(
         &self,
         cpp_name_map: &CppNameMap,
-    ) -> Result<String, ConvertError> {
+    ) -> Result<String, ConvertErrorFromCpp> {
         match self.cpp_conversion {
             CppConversionType::FromUniquePtrToValue => self.unique_ptr_wrapped_type(cpp_name_map),
             CppConversionType::FromPtrToValue => {
@@ -30,7 +30,10 @@
         }
     }
 
-    pub(super) fn converted_type(&self, cpp_name_map: &CppNameMap) -> Result<String, ConvertError> {
+    pub(super) fn converted_type(
+        &self,
+        cpp_name_map: &CppNameMap,
+    ) -> Result<String, ConvertErrorFromCpp> {
         match self.cpp_conversion {
             CppConversionType::FromValueToUniquePtr => self.unique_ptr_wrapped_type(cpp_name_map),
             CppConversionType::FromReferenceToPointer => {
@@ -46,15 +49,18 @@
                 Ok(format!(
                     "{}{}*",
                     const_string,
-                    type_to_cpp(ty, cpp_name_map)?
+                    cpp_name_map.type_to_cpp(ty)?
                 ))
             }
             _ => self.unwrapped_type_as_string(cpp_name_map),
         }
     }
 
-    fn unwrapped_type_as_string(&self, cpp_name_map: &CppNameMap) -> Result<String, ConvertError> {
-        type_to_cpp(self.cxxbridge_type(), cpp_name_map)
+    fn unwrapped_type_as_string(
+        &self,
+        cpp_name_map: &CppNameMap,
+    ) -> Result<String, ConvertErrorFromCpp> {
+        cpp_name_map.type_to_cpp(self.cxxbridge_type())
     }
 
     pub(crate) fn is_a_pointer(&self) -> Pointerness {
@@ -71,7 +77,7 @@
     fn unique_ptr_wrapped_type(
         &self,
         original_name_map: &CppNameMap,
-    ) -> Result<String, ConvertError> {
+    ) -> Result<String, ConvertErrorFromCpp> {
         Ok(format!(
             "std::unique_ptr<{}>",
             self.unwrapped_type_as_string(original_name_map)?
@@ -83,17 +89,17 @@
         var_name: &str,
         cpp_name_map: &CppNameMap,
         is_return: bool,
-    ) -> Result<Option<String>, ConvertError> {
+    ) -> Result<Option<String>, ConvertErrorFromCpp> {
         // If is_return we want to avoid unnecessary std::moves because they
         // make RVO less effective
         Ok(match self.cpp_conversion {
             CppConversionType::None | CppConversionType::FromReturnValueToPlacementPtr => {
                 Some(var_name.to_string())
             }
-            CppConversionType::FromPointerToReference { .. } => Some(format!("(*{})", var_name)),
-            CppConversionType::Move => Some(format!("std::move({})", var_name)),
+            CppConversionType::FromPointerToReference { .. } => Some(format!("(*{var_name})")),
+            CppConversionType::Move => Some(format!("std::move({var_name})")),
             CppConversionType::FromUniquePtrToValue | CppConversionType::FromPtrToMove => {
-                Some(format!("std::move(*{})", var_name))
+                Some(format!("std::move(*{var_name})"))
             }
             CppConversionType::FromValueToUniquePtr => Some(format!(
                 "std::make_unique<{}>({})",
@@ -101,15 +107,15 @@
                 var_name
             )),
             CppConversionType::FromPtrToValue => {
-                let dereference = format!("*{}", var_name);
+                let dereference = format!("*{var_name}");
                 Some(if is_return {
                     dereference
                 } else {
-                    format!("std::move({})", dereference)
+                    format!("std::move({dereference})")
                 })
             }
             CppConversionType::IgnoredPlacementPtrParameter => None,
-            CppConversionType::FromReferenceToPointer { .. } => Some(format!("&{}", var_name)),
+            CppConversionType::FromReferenceToPointer { .. } => Some(format!("&{var_name}")),
         })
     }
 }
diff --git a/engine/src/conversion/codegen_cpp/mod.rs b/engine/src/conversion/codegen_cpp/mod.rs
index 0e6dcce..bb341a8 100644
--- a/engine/src/conversion/codegen_cpp/mod.rs
+++ b/engine/src/conversion/codegen_cpp/mod.rs
@@ -20,11 +20,7 @@
 use indexmap::set::IndexSet as HashSet;
 use itertools::Itertools;
 use std::borrow::Cow;
-use type_to_cpp::{original_name_map_from_apis, type_to_cpp, CppNameMap};
-
-use self::type_to_cpp::{
-    final_ident_using_original_name_map, namespaced_name_using_original_name_map,
-};
+use type_to_cpp::CppNameMap;
 
 use super::{
     analysis::{
@@ -36,7 +32,7 @@
     },
     api::{Api, Provenance, SubclassName, TypeKind},
     apivec::ApiVec,
-    ConvertError,
+    ConvertErrorFromCpp,
 };
 
 #[derive(Ord, PartialOrd, Eq, PartialEq, Clone, Hash)]
@@ -55,17 +51,17 @@
     ) -> String {
         let blank = "".to_string();
         match self {
-            Self::System(name) => format!("#include <{}>", name),
+            Self::System(name) => format!("#include <{name}>"),
             Self::CxxH => {
                 let prefix = cpp_codegen_options.path_to_cxx_h.as_ref().unwrap_or(&blank);
-                format!("#include \"{}cxx.h\"", prefix)
+                format!("#include \"{prefix}cxx.h\"")
             }
             Self::CxxgenH => {
                 let prefix = cpp_codegen_options
                     .path_to_cxxgen_h
                     .as_ref()
                     .unwrap_or(&blank);
-                format!("#include \"{}{}\"", prefix, cxxgen_header_name)
+                format!("#include \"{prefix}{cxxgen_header_name}\"")
             }
             Header::NewDeletePrelude => new_and_delete_prelude::NEW_AND_DELETE_PRELUDE.to_string(),
         }
@@ -120,11 +116,11 @@
         config: &'a IncludeCppConfig,
         cpp_codegen_options: &CppCodegenOptions,
         cxxgen_header_name: &str,
-    ) -> Result<Option<CppFilePair>, ConvertError> {
+    ) -> Result<Option<CppFilePair>, ConvertErrorFromCpp> {
         let mut gen = CppCodeGenerator {
             additional_functions: Vec::new(),
             inclusions,
-            original_name_map: original_name_map_from_apis(apis),
+            original_name_map: CppNameMap::new_from_apis(apis),
             config,
             cpp_codegen_options,
             cxxgen_header_name,
@@ -139,7 +135,7 @@
     fn add_needs<'b>(
         &mut self,
         apis: impl Iterator<Item = &'a Api<FnPhase>>,
-    ) -> Result<(), ConvertError> {
+    ) -> Result<(), ConvertErrorFromCpp> {
         let mut constructors_by_subclass: HashMap<SubclassName, Vec<&CppFunction>> = HashMap::new();
         let mut methods_by_subclass: HashMap<SubclassName, Vec<SubclassFunction>> = HashMap::new();
         let mut deferred_apis = Vec::new();
@@ -172,7 +168,7 @@
                 } => {
                     let effective_cpp_definition = match rs_definition {
                         Some(rs_definition) => {
-                            Cow::Owned(type_to_cpp(rs_definition, &self.original_name_map)?)
+                            Cow::Owned(self.original_name_map.type_to_cpp(rs_definition)?)
                         }
                         None => Cow::Borrowed(cpp_definition),
                     };
@@ -248,10 +244,8 @@
                 .any(|x| x.definition.is_some())
             {
                 let definitions = self.concat_additional_items(|x| x.definition.as_ref());
-                let definitions = format!(
-                    "#include \"{}\"\n{}\n{}",
-                    header_name, cpp_headers, definitions
-                );
+                let definitions =
+                    format!("#include \"{header_name}\"\n{cpp_headers}\n{definitions}");
                 log::info!("Additional C++ defs:\n{}", definitions);
                 Some(definitions.into_bytes())
             } else {
@@ -302,7 +296,7 @@
         // can result in destructors for nested types being called multiple times
         // if we represent them as trivial types. So generate an extra
         // assertion to make sure.
-        let declaration = Some(format!("static_assert(::rust::IsRelocatable<{}>::value, \"type {} should be trivially move constructible and trivially destructible to be used with generate_pod! in autocxx\");", name, name));
+        let declaration = Some(format!("static_assert(::rust::IsRelocatable<{name}>::value, \"type {name} should be trivially move constructible and trivially destructible to be used with generate_pod! in autocxx\");"));
         self.additional_functions.push(ExtraCpp {
             declaration,
             headers: vec![Header::CxxH],
@@ -312,7 +306,7 @@
 
     fn generate_string_constructor(&mut self) {
         let makestring_name = self.config.get_makestring_name();
-        let declaration = Some(format!("inline std::unique_ptr<std::string> {}(::rust::Str str) {{ return std::make_unique<std::string>(std::string(str)); }}", makestring_name));
+        let declaration = Some(format!("inline std::unique_ptr<std::string> {makestring_name}(::rust::Str str) {{ return std::make_unique<std::string>(std::string(str)); }}"));
         self.additional_functions.push(ExtraCpp {
             declaration,
             headers: vec![
@@ -324,7 +318,7 @@
         })
     }
 
-    fn generate_cpp_function(&mut self, details: &CppFunction) -> Result<(), ConvertError> {
+    fn generate_cpp_function(&mut self, details: &CppFunction) -> Result<(), ConvertErrorFromCpp> {
         self.additional_functions
             .push(self.generate_cpp_function_inner(
                 details,
@@ -343,7 +337,7 @@
         conversion_direction: ConversionDirection,
         requires_rust_declarations: bool,
         force_name: Option<&str>,
-    ) -> Result<ExtraCpp, ConvertError> {
+    ) -> Result<ExtraCpp, ConvertErrorFromCpp> {
         // Even if the original function call is in a namespace,
         // we generate this wrapper in the global namespace.
         // We could easily do this the other way round, and when
@@ -373,7 +367,7 @@
                 // may be able to remove this.
                 "autocxx_gen_this".to_string()
             } else {
-                format!("arg{}", counter)
+                format!("arg{counter}")
             }
         };
         // If this returns a non-POD value, we may instead wish to emplace
@@ -425,16 +419,13 @@
             CppFunctionKind::ConstMethod => " const",
             _ => "",
         };
-        let declaration = format!("{} {}({}){}", ret_type, name, args, constness);
+        let declaration = format!("{ret_type} {name}({args}){constness}");
         let qualification = if let Some(qualification) = &details.qualification {
             format!("{}::", qualification.to_cpp_name())
         } else {
             "".to_string()
         };
-        let qualified_declaration = format!(
-            "{} {}{}({}){}",
-            ret_type, qualification, name, args, constness
-        );
+        let qualified_declaration = format!("{ret_type} {qualification}{name}({args}){constness}");
         // Whether there's a placement param in which to put the return value
         let placement_param = details
             .argument_conversion
@@ -491,13 +482,38 @@
                 )
             }
             CppFunctionBody::Destructor(ns, id) => {
-                let ty_id = QualifiedName::new(ns, id.clone());
-                let ty_id = final_ident_using_original_name_map(&ty_id, &self.original_name_map);
-                (format!("{}->~{}()", arg_list, ty_id), "".to_string(), false)
+                let full_name = QualifiedName::new(ns, id.clone());
+                let ty_id = self.original_name_map.get_final_item(&full_name);
+                let is_a_nested_struct = self.original_name_map.get(&full_name).is_some();
+                // This is all super duper fiddly.
+                // All we want to do is call a destructor. Constraints:
+                // * an unnamed struct, e.g. typedef struct { .. } A, does not
+                //   have any way of fully qualifying its destructor name.
+                //   We have to use a 'using' statement.
+                // * we don't get enough information from bindgen to distinguish
+                //   typedef struct { .. } A  // unnamed struct
+                //   from
+                //   struct A { .. }          // named struct
+                // * we can only do 'using A::B::C' if 'B' is a namespace,
+                //   as opposed to a type with an inner type.
+                // * we can always do 'using C = A::B::C' but then SOME C++
+                //   compilers complain that it's unused, iff it's a named struct.
+                let destructor_call = format!("{arg_list}->{ty_id}::~{ty_id}()");
+                let destructor_call = if ns.is_empty() {
+                    destructor_call
+                } else {
+                    let path = self.original_name_map.map(&full_name);
+                    if is_a_nested_struct {
+                        format!("{{ using {ty_id} = {path}; {destructor_call}; {ty_id}* pointless; (void)pointless; }}")
+                    } else {
+                        format!("{{ using {path}; {destructor_call}; }}")
+                    }
+                };
+                (destructor_call, "".to_string(), false)
             }
             CppFunctionBody::FunctionCall(ns, id) => match receiver {
                 Some(receiver) => (
-                    format!("{}.{}({})", receiver, id, arg_list),
+                    format!("{receiver}.{id}({arg_list})"),
                     "".to_string(),
                     false,
                 ),
@@ -508,7 +524,7 @@
                         .chain(std::iter::once(id.to_string()))
                         .join("::");
                     (
-                        format!("{}({})", underlying_function_call, arg_list),
+                        format!("{underlying_function_call}({arg_list})"),
                         "".to_string(),
                         false,
                     )
@@ -521,7 +537,7 @@
                     .chain([ty_id.to_string(), fn_id.to_string()].iter().cloned())
                     .join("::");
                 (
-                    format!("{}({})", underlying_function_call, arg_list),
+                    format!("{underlying_function_call}({arg_list})"),
                     "".to_string(),
                     false,
                 )
@@ -530,7 +546,7 @@
             CppFunctionBody::AllocUninitialized(ty) => {
                 let namespaced_ty = self.namespaced_name(ty);
                 (
-                    format!("new_appropriately<{}>();", namespaced_ty,),
+                    format!("new_appropriately<{namespaced_ty}>();",),
                     "".to_string(),
                     true,
                 )
@@ -559,39 +575,35 @@
 
             underlying_function_call = match placement_param {
                 Some(placement_param) => {
-                    let tyname = type_to_cpp(ret.cxxbridge_type(), &self.original_name_map)?;
-                    format!("new({}) {}({})", placement_param, tyname, call_itself)
+                    let tyname = self.original_name_map.type_to_cpp(ret.cxxbridge_type())?;
+                    format!("new({placement_param}) {tyname}({call_itself})")
                 }
-                None => format!("return {}", call_itself),
+                None => format!("return {call_itself}"),
             };
         };
         if !underlying_function_call.is_empty() {
-            underlying_function_call = format!("{};", underlying_function_call);
+            underlying_function_call = format!("{underlying_function_call};");
         }
         let field_assignments =
             if let CppFunctionBody::ConstructSuperclass(superclass_name) = &details.payload {
                 let superclass_assignments = if field_assignments.is_empty() {
                     "".to_string()
                 } else {
-                    format!("{}({}), ", superclass_name, field_assignments)
+                    format!("{superclass_name}({field_assignments}), ")
                 };
-                format!(": {}obs(std::move(arg0))", superclass_assignments)
+                format!(": {superclass_assignments}obs(std::move(arg0))")
             } else {
                 "".into()
             };
-        let definition_after_sig =
-            format!("{} {{ {} }}", field_assignments, underlying_function_call,);
+        let definition_after_sig = format!("{field_assignments} {{ {underlying_function_call} }}",);
         let (declaration, definition) = if requires_rust_declarations {
             (
-                Some(format!("{};", declaration)),
-                Some(format!(
-                    "{} {}",
-                    qualified_declaration, definition_after_sig
-                )),
+                Some(format!("{declaration};")),
+                Some(format!("{qualified_declaration} {definition_after_sig}")),
             )
         } else {
             (
-                Some(format!("inline {} {}", declaration, definition_after_sig)),
+                Some(format!("inline {declaration} {definition_after_sig}")),
                 None,
             )
         };
@@ -609,7 +621,7 @@
     }
 
     fn namespaced_name(&self, name: &QualifiedName) -> String {
-        namespaced_name_using_original_name_map(name, &self.original_name_map)
+        self.original_name_map.map(name)
     }
 
     fn generate_ctype_typedef(&mut self, tn: &QualifiedName) {
@@ -620,7 +632,7 @@
     fn generate_typedef(&mut self, tn: &QualifiedName, definition: &str) {
         let our_name = tn.get_final_item();
         self.additional_functions.push(ExtraCpp {
-            type_definition: Some(format!("typedef {} {};", definition, our_name)),
+            type_definition: Some(format!("typedef {definition} {our_name};")),
             ..Default::default()
         })
     }
@@ -631,10 +643,10 @@
         subclass: &SubclassName,
         constructors: Vec<&CppFunction>,
         methods: Vec<SubclassFunction>,
-    ) -> Result<(), ConvertError> {
+    ) -> Result<(), ConvertErrorFromCpp> {
         let holder = subclass.holder();
         self.additional_functions.push(ExtraCpp {
-            type_definition: Some(format!("struct {};", holder)),
+            type_definition: Some(format!("struct {holder};")),
             ..Default::default()
         });
         let mut method_decls = Vec::new();
@@ -677,12 +689,10 @@
         // In future, for each superclass..
         let super_name = superclass.get_final_item();
         method_decls.push(format!(
-            "const {}& As_{}() const {{ return *this; }}",
-            super_name, super_name,
+            "const {super_name}& As_{super_name}() const {{ return *this; }}",
         ));
         method_decls.push(format!(
-            "{}& As_{}_mut() {{ return *this; }}",
-            super_name, super_name
+            "{super_name}& As_{super_name}_mut() {{ return *this; }}"
         ));
         self.additional_functions.push(ExtraCpp {
             declaration: Some(format!(
diff --git a/engine/src/conversion/codegen_cpp/type_to_cpp.rs b/engine/src/conversion/codegen_cpp/type_to_cpp.rs
index 7febb7a..b2da44b 100644
--- a/engine/src/conversion/codegen_cpp/type_to_cpp.rs
+++ b/engine/src/conversion/codegen_cpp/type_to_cpp.rs
@@ -7,7 +7,7 @@
 // except according to those terms.
 
 use crate::{
-    conversion::{apivec::ApiVec, AnalysisPhase, ConvertError},
+    conversion::{apivec::ApiVec, AnalysisPhase, ConvertErrorFromCpp},
     types::QualifiedName,
 };
 use indexmap::map::IndexMap as HashMap;
@@ -19,116 +19,129 @@
 /// Map from QualifiedName to original C++ name. Original C++ name does not
 /// include the namespace; this can be assumed to be the same as the namespace
 /// in the QualifiedName.
-pub(crate) type CppNameMap = HashMap<QualifiedName, String>;
+/// The "original C++ name" is mostly relevant in the case of nested types,
+/// where the typename might be A::B within a namespace C::D.
+pub(crate) struct CppNameMap(HashMap<QualifiedName, String>);
 
-pub(crate) fn original_name_map_from_apis<T: AnalysisPhase>(apis: &ApiVec<T>) -> CppNameMap {
-    apis.iter()
-        .filter_map(|api| {
-            api.cpp_name()
-                .as_ref()
-                .map(|cpp_name| (api.name().clone(), cpp_name.clone()))
-        })
-        .collect()
-}
-
-pub(crate) fn namespaced_name_using_original_name_map(
-    qual_name: &QualifiedName,
-    original_name_map: &CppNameMap,
-) -> String {
-    if let Some(cpp_name) = original_name_map.get(qual_name) {
-        qual_name
-            .get_namespace()
-            .iter()
-            .chain(once(cpp_name))
-            .join("::")
-    } else {
-        qual_name.to_cpp_name()
-    }
-}
-
-pub(crate) fn final_ident_using_original_name_map(
-    qual_name: &QualifiedName,
-    original_name_map: &CppNameMap,
-) -> String {
-    match original_name_map.get(qual_name) {
-        Some(original_name) => {
-            // If we have an original name, this may be a nested struct
-            // (e.g. A::B). The final ident here is just 'B' so...
-            original_name
-                .rsplit_once("::")
-                .map_or(original_name.clone(), |(_, original_name)| {
-                    original_name.to_string()
+impl CppNameMap {
+    /// Look through the APIs we've found to assemble the original name
+    /// map.
+    pub(crate) fn new_from_apis<T: AnalysisPhase>(apis: &ApiVec<T>) -> Self {
+        Self(
+            apis.iter()
+                .filter_map(|api| {
+                    api.cpp_name()
+                        .as_ref()
+                        .map(|cpp_name| (api.name().clone(), cpp_name.clone()))
                 })
-        }
-        None => qual_name.get_final_cpp_item(),
+                .collect(),
+        )
     }
-}
 
-pub(crate) fn type_to_cpp(ty: &Type, cpp_name_map: &CppNameMap) -> Result<String, ConvertError> {
-    match ty {
-        Type::Path(typ) => {
-            // If this is a std::unique_ptr we do need to pass
-            // its argument through.
-            let qual_name = QualifiedName::from_type_path(typ);
-            let root = namespaced_name_using_original_name_map(&qual_name, cpp_name_map);
-            if root == "Pin" {
-                // Strip all Pins from type names when describing them in C++.
-                let inner_type = &typ.path.segments.last().unwrap().arguments;
-                if let syn::PathArguments::AngleBracketed(ab) = inner_type {
-                    let inner_type = ab.args.iter().next().unwrap();
-                    if let syn::GenericArgument::Type(gat) = inner_type {
-                        return type_to_cpp(gat, cpp_name_map);
-                    }
-                }
-                panic!("Pin<...> didn't contain the inner types we expected");
-            }
-            let suffix = match &typ.path.segments.last().unwrap().arguments {
-                syn::PathArguments::AngleBracketed(ab) => {
-                    let results: Result<Vec<_>, _> = ab
-                        .args
-                        .iter()
-                        .map(|x| match x {
-                            syn::GenericArgument::Type(gat) => type_to_cpp(gat, cpp_name_map),
-                            _ => Ok("".to_string()),
-                        })
-                        .collect();
-                    Some(results?.join(", "))
-                }
-                syn::PathArguments::None | syn::PathArguments::Parenthesized(_) => None,
-            };
-            match suffix {
-                None => Ok(root),
-                Some(suffix) => Ok(format!("{}<{}>", root, suffix)),
-            }
+    /// Imagine a nested struct in namespace::outer::inner
+    /// This function converts from the bindgen name, namespace::outer_inner,
+    /// to namespace::outer::inner.
+    pub(crate) fn map(&self, qual_name: &QualifiedName) -> String {
+        if let Some(cpp_name) = self.0.get(qual_name) {
+            qual_name
+                .get_namespace()
+                .iter()
+                .chain(once(cpp_name))
+                .join("::")
+        } else {
+            qual_name.to_cpp_name()
         }
-        Type::Reference(typr) => match &*typr.elem {
-            Type::Path(typ) if typ.path.is_ident("str") => Ok("rust::Str".into()),
-            _ => Ok(format!(
-                "{}{}&",
-                get_mut_string(&typr.mutability),
-                type_to_cpp(typr.elem.as_ref(), cpp_name_map)?
+    }
+
+    /// Get a stringified version of the last ident in the name.
+    /// e.g. for namespace::outer_inner this will return inner.
+    /// This is useful for doing things such as calling constructors
+    /// such as inner() or destructors such as ~inner()
+    pub(crate) fn get_final_item<'b>(&'b self, qual_name: &'b QualifiedName) -> &'b str {
+        match self.get(qual_name) {
+            Some(n) => match n.rsplit_once("::") {
+                Some((_, suffix)) => suffix,
+                None => qual_name.get_final_item(),
+            },
+            None => qual_name.get_final_item(),
+        }
+    }
+
+    /// Convert a type to its C++ spelling.
+    pub(crate) fn type_to_cpp(&self, ty: &Type) -> Result<String, ConvertErrorFromCpp> {
+        match ty {
+            Type::Path(typ) => {
+                // If this is a std::unique_ptr we do need to pass
+                // its argument through.
+                let qual_name = QualifiedName::from_type_path(typ);
+                let root = self.map(&qual_name);
+                if root == "Pin" {
+                    // Strip all Pins from type names when describing them in C++.
+                    let inner_type = &typ.path.segments.last().unwrap().arguments;
+                    if let syn::PathArguments::AngleBracketed(ab) = inner_type {
+                        let inner_type = ab.args.iter().next().unwrap();
+                        if let syn::GenericArgument::Type(gat) = inner_type {
+                            return self.type_to_cpp(gat);
+                        }
+                    }
+                    panic!("Pin<...> didn't contain the inner types we expected");
+                }
+                let suffix = match &typ.path.segments.last().unwrap().arguments {
+                    syn::PathArguments::AngleBracketed(ab) => {
+                        let results: Result<Vec<_>, _> = ab
+                            .args
+                            .iter()
+                            .map(|x| match x {
+                                syn::GenericArgument::Type(gat) => self.type_to_cpp(gat),
+                                _ => Ok("".to_string()),
+                            })
+                            .collect();
+                        Some(results?.join(", "))
+                    }
+                    syn::PathArguments::None | syn::PathArguments::Parenthesized(_) => None,
+                };
+                match suffix {
+                    None => Ok(root),
+                    Some(suffix) => Ok(format!("{root}<{suffix}>")),
+                }
+            }
+            Type::Reference(typr) => match &*typr.elem {
+                Type::Path(typ) if typ.path.is_ident("str") => Ok("rust::Str".into()),
+                _ => Ok(format!(
+                    "{}{}&",
+                    get_mut_string(&typr.mutability),
+                    self.type_to_cpp(typr.elem.as_ref())?
+                )),
+            },
+            Type::Ptr(typp) => Ok(format!(
+                "{}{}*",
+                get_mut_string(&typp.mutability),
+                self.type_to_cpp(typp.elem.as_ref())?
             )),
-        },
-        Type::Ptr(typp) => Ok(format!(
-            "{}{}*",
-            get_mut_string(&typp.mutability),
-            type_to_cpp(typp.elem.as_ref(), cpp_name_map)?
-        )),
-        Type::Array(_)
-        | Type::BareFn(_)
-        | Type::Group(_)
-        | Type::ImplTrait(_)
-        | Type::Infer(_)
-        | Type::Macro(_)
-        | Type::Never(_)
-        | Type::Paren(_)
-        | Type::Slice(_)
-        | Type::TraitObject(_)
-        | Type::Tuple(_)
-        | Type::Verbatim(_) => Err(ConvertError::UnsupportedType(
-            ty.to_token_stream().to_string(),
-        )),
-        _ => Err(ConvertError::UnknownType(ty.to_token_stream().to_string())),
+            Type::Array(_)
+            | Type::BareFn(_)
+            | Type::Group(_)
+            | Type::ImplTrait(_)
+            | Type::Infer(_)
+            | Type::Macro(_)
+            | Type::Never(_)
+            | Type::Paren(_)
+            | Type::Slice(_)
+            | Type::TraitObject(_)
+            | Type::Tuple(_)
+            | Type::Verbatim(_) => Err(ConvertErrorFromCpp::UnsupportedType(
+                ty.to_token_stream().to_string(),
+            )),
+            _ => Err(ConvertErrorFromCpp::UnknownType(
+                ty.to_token_stream().to_string(),
+            )),
+        }
+    }
+
+    /// Check an individual item in the name map. Returns a thing if
+    /// it's an inner type, otherwise returns none.
+    pub(crate) fn get(&self, name: &QualifiedName) -> Option<&String> {
+        self.0.get(name)
     }
 }
 
diff --git a/engine/src/conversion/codegen_rs/fun_codegen.rs b/engine/src/conversion/codegen_rs/fun_codegen.rs
index db222a6..1b68e8c 100644
--- a/engine/src/conversion/codegen_rs/fun_codegen.rs
+++ b/engine/src/conversion/codegen_rs/fun_codegen.rs
@@ -34,6 +34,7 @@
         },
         api::{Pointerness, UnsafetyNeeded},
     },
+    minisyn::minisynize_vec,
     types::{Namespace, QualifiedName},
 };
 use crate::{
@@ -104,7 +105,7 @@
     let params = analysis.params;
     let vis = analysis.vis;
     let kind = analysis.kind;
-    let doc_attrs = fun.doc_attrs;
+    let doc_attrs = minisynize_vec(fun.doc_attrs);
 
     let mut cpp_name_attr = Vec::new();
     let mut impl_entry = None;
@@ -132,7 +133,6 @@
         params,
         Cow::Borrowed(&ret_type),
         non_pod_types,
-        true,
     );
 
     if analysis.rust_wrapper_needed {
@@ -170,10 +170,10 @@
         FnKind::Method { .. } | FnKind::TraitMethod { .. } => None,
         FnKind::Function => match analysis.rust_rename_strategy {
             _ if analysis.rust_wrapper_needed => {
-                Some(Use::SpecificNameFromBindgen(make_ident(rust_name)))
+                Some(Use::SpecificNameFromBindgen(make_ident(rust_name).into()))
             }
             RustRenameStrategy::RenameInOutputMod(ref alias) => {
-                Some(Use::UsedFromCxxBridgeWithAlias(alias.clone()))
+                Some(Use::UsedFromCxxBridgeWithAlias(alias.clone().into()))
             }
             _ => Some(Use::UsedFromCxxBridge),
         },
@@ -259,14 +259,14 @@
         let mut ptr_arg_name = None;
         let mut ret_type: Cow<'a, _> = ret_type
             .map(Cow::Owned)
-            .unwrap_or(Cow::Borrowed(self.ret_type));
+            .unwrap_or_else(|| Cow::Borrowed(self.ret_type));
         let mut any_conversion_requires_unsafe = false;
         let mut variable_counter = 0usize;
         for pd in self.param_details {
-            let wrapper_arg_name = if pd.self_type.is_some() && !avoid_self {
+            let wrapper_arg_name: syn::Pat = if pd.self_type.is_some() && !avoid_self {
                 parse_quote!(self)
             } else {
-                pd.name.clone()
+                pd.name.clone().into()
             };
             let rust_for_param = pd
                 .conversion
@@ -308,7 +308,6 @@
             wrapper_params,
             ret_type,
             self.non_pod_types,
-            false,
         );
 
         let cxxbridge_name = self.cxxbridge_name;
@@ -322,6 +321,17 @@
             || self.always_unsafe_due_to_trait_definition;
         let (call_body, ret_type) = match self.ret_conversion {
             Some(ret_conversion) if ret_conversion.rust_work_needed() => {
+                // There's a potential lurking bug below. If the return type conversion requires
+                // unsafe, then we'll end up doing something like
+                //   unsafe { do_return_conversion( unsafe { call_body() })}
+                // and the generated code will get warnings about nested unsafe blocks.
+                // That's because we convert the call body to tokens in the following
+                // line without considering the fact it's embedded in another expression.
+                // At the moment this is OK because no return type conversions require
+                // unsafe, but if this happens in future, we should do:
+                //   let temp_ret_val = unsafe { call_body() };
+                //   do_return_conversion(temp_ret_val)
+                // by returning a vector of MaybeUnsafes within call_body.
                 let expr = maybe_unsafes_to_tokens(vec![call_body], context_is_unsafe);
                 let conv =
                     ret_conversion.rust_conversion(parse_quote! { #expr }, &mut variable_counter);
@@ -391,33 +401,26 @@
             .map(|pd| pd.conversion.is_a_pointer())
             .unwrap_or(Pointerness::Not);
         let ty = impl_block_type_name.get_final_ident();
-        let ty = if self.reference_wrappers {
-            match receiver_pointerness {
-                Pointerness::MutPtr => ImplBlockKey {
-                    ty: parse_quote! {
-                        CppMutRef< 'a, #ty>
-                    },
-                    lifetime: Some(parse_quote! { 'a }),
+        let ty = match receiver_pointerness {
+            Pointerness::MutPtr if self.reference_wrappers => ImplBlockKey {
+                ty: parse_quote! {
+                    #ty
                 },
-                Pointerness::ConstPtr => ImplBlockKey {
-                    ty: parse_quote! {
-                        CppRef< 'a, #ty>
-                    },
-                    lifetime: Some(parse_quote! { 'a }),
+                lifetime: Some(parse_quote! { 'a }),
+            },
+            Pointerness::ConstPtr if self.reference_wrappers => ImplBlockKey {
+                ty: parse_quote! {
+                    #ty
                 },
-                Pointerness::Not => ImplBlockKey {
-                    ty: parse_quote! { # ty },
-                    lifetime: None,
-                },
-            }
-        } else {
-            ImplBlockKey {
+                lifetime: Some(parse_quote! { 'a }),
+            },
+            _ => ImplBlockKey {
                 ty: parse_quote! { # ty },
                 lifetime: None,
-            }
+            },
         };
         Box::new(ImplBlockDetails {
-            item: ImplItem::Method(parse_quote! {
+            item: ImplItem::Fn(parse_quote! {
                 #(#doc_attrs)*
                 pub #unsafety fn #rust_name #lifetime_tokens ( #wrapper_params ) #ret_type {
                     #call_body
@@ -453,7 +456,7 @@
         let ret_type: ReturnType = parse_quote! { -> impl autocxx::moveit::new::New<Output=Self> };
         let (lifetime_tokens, wrapper_params, ret_type, call_body) =
             self.common_parts(true, &None, Some(ret_type));
-        let rust_name = make_ident(&self.rust_name);
+        let rust_name = make_ident(self.rust_name);
         let doc_attrs = self.doc_attrs;
         let unsafety = self.unsafety.wrapper_token();
         let ty = impl_block_type_name.get_final_ident();
@@ -465,7 +468,7 @@
                 }
         };
         Box::new(ImplBlockDetails {
-            item: ImplItem::Method(parse_quote! { #stuff }),
+            item: ImplItem::Fn(parse_quote! { #stuff }),
             ty: ImplBlockKey { ty, lifetime: None },
         })
     }
diff --git a/engine/src/conversion/codegen_rs/function_wrapper_rs.rs b/engine/src/conversion/codegen_rs/function_wrapper_rs.rs
index 708d41c..4afe3c7 100644
--- a/engine/src/conversion/codegen_rs/function_wrapper_rs.rs
+++ b/engine/src/conversion/codegen_rs/function_wrapper_rs.rs
@@ -63,11 +63,11 @@
             }
             RustConversionType::FromPinMaybeUninitToPtr => {
                 let ty = match self.cxxbridge_type() {
-                    Type::Ptr(TypePtr { elem, .. }) => &*elem,
+                    Type::Ptr(TypePtr { elem, .. }) => elem,
                     _ => panic!("Not a ptr"),
                 };
                 let ty = parse_quote! {
-                    ::std::pin::Pin<&mut ::std::mem::MaybeUninit< #ty >>
+                    ::core::pin::Pin<&mut ::core::mem::MaybeUninit< #ty >>
                 };
                 RustParamConversion::Param {
                     ty,
@@ -80,17 +80,17 @@
             }
             RustConversionType::FromPinMoveRefToPtr => {
                 let ty = match self.cxxbridge_type() {
-                    Type::Ptr(TypePtr { elem, .. }) => &*elem,
+                    Type::Ptr(TypePtr { elem, .. }) => elem,
                     _ => panic!("Not a ptr"),
                 };
                 let ty = parse_quote! {
-                    ::std::pin::Pin<autocxx::moveit::MoveRef< '_, #ty >>
+                    ::core::pin::Pin<autocxx::moveit::MoveRef< '_, #ty >>
                 };
                 RustParamConversion::Param {
                     ty,
                     local_variables: Vec::new(),
                     conversion: quote! {
-                        { let r: &mut _ = ::std::pin::Pin::into_inner_unchecked(#var.as_mut());
+                        { let r: &mut _ = ::core::pin::Pin::into_inner_unchecked(#var.as_mut());
                             r
                         }
                     },
@@ -99,7 +99,7 @@
             }
             RustConversionType::FromTypeToPtr => {
                 let ty = match self.cxxbridge_type() {
-                    Type::Ptr(TypePtr { elem, .. }) => &*elem,
+                    Type::Ptr(TypePtr { elem, .. }) => elem,
                     _ => panic!("Not a ptr"),
                 };
                 let ty = parse_quote! { &mut #ty };
@@ -124,7 +124,7 @@
                 let param_trait = make_ident(param_trait);
                 let var_counter = *counter;
                 *counter += 1;
-                let space_var_name = format!("space{}", var_counter);
+                let space_var_name = format!("space{var_counter}");
                 let space_var_name = make_ident(space_var_name);
                 let ty = self.cxxbridge_type();
                 let ty = parse_quote! { impl autocxx::#param_trait<#ty> };
@@ -138,10 +138,10 @@
                         ),
                         MaybeUnsafeStmt::binary(
                             quote! { let mut #space_var_name =
-                                unsafe { ::std::pin::Pin::new_unchecked(&mut #space_var_name) };
+                                unsafe { ::core::pin::Pin::new_unchecked(&mut #space_var_name) };
                             },
                             quote! { let mut #space_var_name =
-                                ::std::pin::Pin::new_unchecked(&mut #space_var_name);
+                                ::core::pin::Pin::new_unchecked(&mut #space_var_name);
                             },
                         ),
                         MaybeUnsafeStmt::needs_unsafe(
@@ -172,16 +172,16 @@
                     _ => panic!("Not a pointer"),
                 };
                 let (ty, wrapper_name) = if is_mut {
-                    (parse_quote! { CppMutRef<'a, #ty> }, "CppMutRef")
+                    (parse_quote! { autocxx::CppMutRef<'a, #ty> }, "CppMutRef")
                 } else {
-                    (parse_quote! { CppRef<'a, #ty> }, "CppRef")
+                    (parse_quote! { autocxx::CppRef<'a, #ty> }, "CppRef")
                 };
                 let wrapper_name = make_ident(wrapper_name);
                 RustParamConversion::Param {
                     ty,
                     local_variables: Vec::new(),
                     conversion: quote! {
-                        #wrapper_name (#var, std::marker::PhantomData)
+                        autocxx::#wrapper_name::from_ptr (#var)
                     },
                     conversion_requires_unsafe: false,
                 }
@@ -194,15 +194,21 @@
                     _ => panic!("Not a pointer"),
                 };
                 let ty = if is_mut {
-                    parse_quote! { &mut CppMutRef<'a, #ty> }
+                    parse_quote! { &mut autocxx::CppMutRef<'a, #ty> }
                 } else {
-                    parse_quote! { &CppRef<'a, #ty> }
+                    parse_quote! { &autocxx::CppRef<'a, #ty> }
                 };
                 RustParamConversion::Param {
                     ty,
                     local_variables: Vec::new(),
-                    conversion: quote! {
-                        #var .0
+                    conversion: if is_mut {
+                        quote! {
+                            #var .as_mut_ptr()
+                        }
+                    } else {
+                        quote! {
+                            #var .as_ptr()
+                        }
                     },
                     conversion_requires_unsafe: false,
                 }
diff --git a/engine/src/conversion/codegen_rs/lifetime.rs b/engine/src/conversion/codegen_rs/lifetime.rs
index ea2c782..5560158 100644
--- a/engine/src/conversion/codegen_rs/lifetime.rs
+++ b/engine/src/conversion/codegen_rs/lifetime.rs
@@ -36,7 +36,6 @@
     mut params: Punctuated<FnArg, Comma>,
     ret_type: Cow<'r, ReturnType>,
     non_pod_types: &HashSet<QualifiedName>,
-    assert_all_parameters_are_references: bool,
 ) -> (
     Option<TokenStream>,
     Punctuated<FnArg, Comma>,
@@ -92,25 +91,16 @@
     match new_return_type {
         None => (None, params, ret_type),
         Some(new_return_type) => {
-            for mut param in params.iter_mut() {
-                match &mut param {
-                    FnArg::Typed(PatType { ty, .. }) => match ty.as_mut() {
-                        Type::Path(TypePath {
-                            path: Path { segments, .. },
-                            ..
-                        }) => add_lifetime_to_pinned_reference(segments).unwrap_or_else(|e| {
-                            if assert_all_parameters_are_references {
-                                panic!("Expected a pinned reference: {:?}", e)
-                            }
-                        }),
-                        Type::Reference(tyr) => add_lifetime_to_reference(tyr),
-                        Type::ImplTrait(tyit) => add_lifetime_to_impl_trait(tyit),
-                        _ if assert_all_parameters_are_references => {
-                            panic!("Expected Pin<&mut T> or &T")
-                        }
-                        _ => {}
-                    },
-                    _ if assert_all_parameters_are_references => panic!("Unexpected fnarg"),
+            for FnArg::Typed(PatType { ty, .. }) | FnArg::Receiver(syn::Receiver { ty, .. }) in
+                params.iter_mut()
+            {
+                match ty.as_mut() {
+                    Type::Path(TypePath {
+                        path: Path { segments, .. },
+                        ..
+                    }) => add_lifetime_to_pinned_reference(segments).unwrap_or(()),
+                    Type::Reference(tyr) => add_lifetime_to_reference(tyr),
+                    Type::ImplTrait(tyit) => add_lifetime_to_impl_trait(tyit),
                     _ => {}
                 }
             }
@@ -168,16 +158,19 @@
 }
 
 fn add_lifetime_to_pinned_reference(
-    segments: &mut Punctuated<PathSegment, syn::token::Colon2>,
+    segments: &mut Punctuated<PathSegment, syn::token::PathSep>,
 ) -> Result<(), AddLifetimeError> {
-    static EXPECTED_SEGMENTS: &[(&str, bool)] = &[
-        ("std", false),
-        ("pin", false),
-        ("Pin", true), // true = act on the arguments of this segment
+    static EXPECTED_SEGMENTS: &[(&[&str], bool)] = &[
+        (&["std", "core"], false),
+        (&["pin"], false),
+        (&["Pin"], true), // true = act on the arguments of this segment
     ];
 
     for (seg, (expected_name, act)) in segments.iter_mut().zip(EXPECTED_SEGMENTS.iter()) {
-        if seg.ident != expected_name {
+        if !expected_name
+            .iter()
+            .any(|expected_name| seg.ident == expected_name)
+        {
             return Err(AddLifetimeError::WasNotPin);
         }
         if *act {
diff --git a/engine/src/conversion/codegen_rs/mod.rs b/engine/src/conversion/codegen_rs/mod.rs
index 5dd4cbb..abab612 100644
--- a/engine/src/conversion/codegen_rs/mod.rs
+++ b/engine/src/conversion/codegen_rs/mod.rs
@@ -28,13 +28,11 @@
 };
 
 use crate::{
-    conversion::{
-        codegen_rs::{
-            non_pod_struct::{make_non_pod, new_non_pod_struct},
-            unqualify::{unqualify_params, unqualify_ret_type},
-        },
-        doc_attr::get_doc_attrs,
+    conversion::codegen_rs::{
+        non_pod_struct::{make_non_pod, new_non_pod_struct},
+        unqualify::{unqualify_params, unqualify_ret_type},
     },
+    minisyn::minisynize_punctuated,
     types::{make_ident, Namespace, QualifiedName},
 };
 use impl_item_creator::create_impl_items;
@@ -51,15 +49,14 @@
     },
     api::{AnalysisPhase, Api, SubclassName, TypeKind, TypedefKind},
     convert_error::ErrorContextType,
+    doc_attr::get_doc_attrs,
 };
 use super::{
     api::{Layout, Provenance, RustSubclassFnDetails, SuperclassMethod, TraitImplSignature},
     apivec::ApiVec,
-    codegen_cpp::type_to_cpp::{
-        namespaced_name_using_original_name_map, original_name_map_from_apis, CppNameMap,
-    },
+    codegen_cpp::type_to_cpp::CppNameMap,
 };
-use super::{convert_error::ErrorContext, ConvertError};
+use super::{convert_error::ErrorContext, ConvertErrorFromCpp};
 use quote::quote;
 
 #[derive(Clone, Hash, PartialEq, Eq)]
@@ -137,91 +134,6 @@
     .to_vec()
 }
 
-fn get_cppref_items() -> Vec<Item> {
-    [
-        Item::Struct(parse_quote! {
-            #[repr(transparent)]
-            pub struct CppRef<'a, T>(pub *const T, pub ::std::marker::PhantomData<&'a T>);
-        }),
-        Item::Impl(parse_quote! {
-            impl<'a, T> autocxx::CppRef<'a, T> for CppRef<'a, T> {
-                fn as_ptr(&self) -> *const T {
-                    self.0
-                }
-            }
-        }),
-        Item::Struct(parse_quote! {
-            #[repr(transparent)]
-            pub struct CppMutRef<'a, T>(pub *mut T, pub ::std::marker::PhantomData<&'a T>);
-        }),
-        Item::Impl(parse_quote! {
-            impl<'a, T> autocxx::CppRef<'a, T> for CppMutRef<'a, T> {
-                fn as_ptr(&self) -> *const T {
-                    self.0
-                }
-            }
-        }),
-        Item::Impl(parse_quote! {
-            impl<'a, T> autocxx::CppMutRef<'a, T> for CppMutRef<'a, T> {
-                fn as_mut_ptr(&self) -> *mut T {
-                    self.0
-                }
-            }
-        }),
-        Item::Impl(parse_quote! {
-            impl<'a, T: ::cxx::private::UniquePtrTarget> CppMutRef<'a, T> {
-                /// Create a const C++ reference from this mutable C++ reference.
-                pub fn as_cpp_ref(&self) -> CppRef<'a, T> {
-                    use autocxx::CppRef;
-                    CppRef(self.as_ptr(), ::std::marker::PhantomData)
-                }
-            }
-        }),
-        Item::Struct(parse_quote! {
-            /// "Pins" a `UniquePtr` to an object, so that C++-compatible references can be created.
-            /// See [`::autocxx::CppPin`]
-            #[repr(transparent)]
-            pub struct CppUniquePtrPin<T: ::cxx::private::UniquePtrTarget>(::cxx::UniquePtr<T>);
-        }),
-        Item::Impl(parse_quote! {
-            impl<'a, T: 'a + ::cxx::private::UniquePtrTarget> autocxx::CppPin<'a, T> for CppUniquePtrPin<T>
-            {
-                type CppRef = CppRef<'a, T>;
-                type CppMutRef = CppMutRef<'a, T>;
-                fn as_ptr(&self) -> *const T {
-                    // TODO add as_ptr to cxx to avoid the ephemeral reference
-                    self.0.as_ref().unwrap() as *const T
-                }
-                fn as_mut_ptr(&mut self) -> *mut T {
-                    unsafe { ::std::pin::Pin::into_inner_unchecked(self.0.as_mut().unwrap()) as *mut T  }
-                }
-                fn as_cpp_ref(&self) -> Self::CppRef {
-                    CppRef(self.as_ptr(), ::std::marker::PhantomData)
-                }
-                fn as_cpp_mut_ref(&mut self) -> Self::CppMutRef {
-                    CppMutRef(self.as_mut_ptr(), ::std::marker::PhantomData)
-                }
-            }
-        }),
-        Item::Impl(parse_quote! {
-            impl<T: ::cxx::private::UniquePtrTarget> CppUniquePtrPin<T> {
-                pub fn new(item: ::cxx::UniquePtr<T>) -> Self {
-                    Self(item)
-                }
-            }
-        }),
-        Item::Fn(parse_quote! {
-            /// Pin this item so that we can create C++ references to it.
-            /// This makes it impossible to hold Rust references because Rust
-            /// references are fundamentally incompatible with C++ references.
-            pub fn cpp_pin_uniqueptr<T: ::cxx::private::UniquePtrTarget> (item: ::cxx::UniquePtr<T>) -> CppUniquePtrPin<T> {
-                CppUniquePtrPin::new(item)
-            }
-        })
-    ]
-    .to_vec()
-}
-
 /// Type which handles generation of Rust code.
 /// In practice, much of the "generation" involves connecting together
 /// existing lumps of code within the Api structures.
@@ -248,7 +160,7 @@
             unsafe_policy,
             include_list,
             bindgen_mod,
-            original_name_map: original_name_map_from_apis(&all_apis),
+            original_name_map: CppNameMap::new_from_apis(&all_apis),
             config,
             header_name,
         };
@@ -314,9 +226,6 @@
         let mut extern_rust_mod_items = extern_rust_mod_items.into_iter().flatten().collect();
         // And a list of global items to include at the top level.
         let mut all_items: Vec<Item> = all_items.into_iter().flatten().collect();
-        if self.config.unsafe_policy.requires_cpprefs() {
-            all_items.append(&mut get_cppref_items())
-        }
         // And finally any C++ we need to generate. And by "we" I mean autocxx not cxx.
         let has_additional_cpp_needs = additional_cpp_needs.into_iter().any(std::convert::identity);
         extern_c_mod_items.extend(self.build_include_foreign_items(has_additional_cpp_needs));
@@ -430,7 +339,7 @@
                     Use::UsedFromCxxBridge => Self::generate_cxx_use_stmt(name, None),
                     Use::UsedFromBindgen => Self::generate_bindgen_use_stmt(name),
                     Use::SpecificNameFromBindgen(id) => {
-                        let name = QualifiedName::new(name.get_namespace(), id.clone());
+                        let name = QualifiedName::new(name.get_namespace(), id.clone().into());
                         Self::generate_bindgen_use_stmt(&name)
                     }
                     Use::Custom(item) => *item.clone(),
@@ -459,9 +368,6 @@
         if !self.config.exclude_utilities() {
             imports_from_super.push("ToCppString");
         }
-        if self.config.unsafe_policy.requires_cpprefs() {
-            imports_from_super.extend(["CppRef", "CppMutRef"]);
-        }
         let imports_from_super = imports_from_super.into_iter().map(make_ident);
         let super_duper = std::iter::repeat(make_ident("super")); // I'll get my coat
         let supers = super_duper.clone().take(ns.depth() + 2);
@@ -576,9 +482,9 @@
                         fn #make_string_name(str_: &str) -> UniquePtr<CxxString>;
                     ))],
                     global_items: get_string_items(),
-                    materializations: vec![Use::UsedFromCxxBridgeWithAlias(make_ident(
-                        "make_string",
-                    ))],
+                    materializations: vec![Use::UsedFromCxxBridgeWithAlias(
+                        make_ident("make_string").into(),
+                    )],
                     ..Default::default()
                 }
             }
@@ -591,14 +497,14 @@
                 self.config,
             ),
             Api::Const { const_item, .. } => RsCodegenResult {
-                bindgen_mod_items: vec![Item::Const(const_item)],
+                bindgen_mod_items: vec![Item::Const(const_item.into())],
                 materializations: vec![Use::UsedFromBindgen],
                 ..Default::default()
             },
             Api::Typedef { analysis, .. } => RsCodegenResult {
                 bindgen_mod_items: vec![match analysis.kind {
-                    TypedefKind::Type(type_item) => Item::Type(type_item),
-                    TypedefKind::Use(use_item, _) => Item::Use(use_item),
+                    TypedefKind::Type(type_item) => Item::Type(type_item.into()),
+                    TypedefKind::Use(use_item, _) => Item::Use(use_item.into()),
                 }],
                 materializations: vec![Use::UsedFromBindgen],
                 ..Default::default()
@@ -624,7 +530,7 @@
                     kind,
                     constructors.move_constructor,
                     constructors.destructor,
-                    || Some((Item::Struct(details.item), doc_attrs)),
+                    || Some((Item::Struct(details.item.into()), doc_attrs)),
                     associated_methods,
                     layout,
                     is_generic,
@@ -638,15 +544,13 @@
                     TypeKind::Pod,
                     true,
                     true,
-                    || Some((Item::Enum(item), doc_attrs)),
+                    || Some((Item::Enum(item.into()), doc_attrs)),
                     associated_methods,
                     None,
                     false,
                 )
             }
-            Api::ForwardDeclaration { .. }
-            | Api::ConcreteType { .. }
-            | Api::OpaqueTypedef { .. } => self.generate_type(
+            Api::ConcreteType { .. } => self.generate_type(
                 &name,
                 id,
                 TypeKind::Abstract,
@@ -657,56 +561,68 @@
                 None,
                 false,
             ),
+            Api::ForwardDeclaration { .. } | Api::OpaqueTypedef { .. } => self.generate_type(
+                &name,
+                id,
+                TypeKind::Abstract,
+                false, // these types can't be kept in a Vector
+                false, // these types can't be put in a smart pointer
+                || None,
+                associated_methods,
+                None,
+                false,
+            ),
             Api::CType { .. } => RsCodegenResult {
                 extern_c_mod_items: vec![ForeignItem::Verbatim(quote! {
                     type #id = autocxx::#id;
                 })],
                 ..Default::default()
             },
-            Api::RustType { path, .. } => RsCodegenResult {
-                global_items: vec![parse_quote! {
-                    use super::#path;
-                }],
-                extern_rust_mod_items: vec![parse_quote! {
-                    type #id;
-                }],
-                ..Default::default()
-            },
+            Api::RustType { path, .. } => {
+                let id = path.get_final_ident();
+                RsCodegenResult {
+                    global_items: vec![parse_quote! {
+                        use super::#path;
+                    }],
+                    extern_rust_mod_items: vec![parse_quote! {
+                        type #id;
+                    }],
+                    bindgen_mod_items: vec![parse_quote! {
+                        #[allow(unused_imports)]
+                        use super::super::#id;
+                    }],
+                    ..Default::default()
+                }
+            }
             Api::RustFn {
                 details:
                     RustFun {
                         path,
-                        sig,
-                        receiver: None,
+                        mut sig,
+                        has_receiver,
                         ..
                     },
                 ..
-            } => RsCodegenResult {
-                global_items: vec![parse_quote! {
-                    use super::#path;
-                }],
-                extern_rust_mod_items: vec![parse_quote! {
-                    #sig;
-                }],
-                ..Default::default()
-            },
-            Api::RustFn {
-                details:
-                    RustFun {
-                        sig,
-                        receiver: Some(_),
-                        ..
+            } => {
+                sig.inputs = unqualify_params(sig.inputs);
+                sig.output = unqualify_ret_type(sig.output);
+                RsCodegenResult {
+                    global_items: if !has_receiver {
+                        vec![parse_quote! {
+                            use super::#path;
+                        }]
+                    } else {
+                        Vec::new()
                     },
-                ..
-            } => RsCodegenResult {
-                extern_rust_mod_items: vec![parse_quote! {
-                    #sig;
-                }],
-                ..Default::default()
-            },
+                    extern_rust_mod_items: vec![parse_quote! {
+                        #sig;
+                    }],
+                    ..Default::default()
+                }
+            }
             Api::RustSubclassFn {
                 details, subclass, ..
-            } => Self::generate_subclass_fn(id, *details, subclass),
+            } => Self::generate_subclass_fn(id.into(), *details, subclass),
             Api::Subclass {
                 name, superclass, ..
             } => {
@@ -812,7 +728,7 @@
             bindgen_mod_items.push(parse_quote! {
                 impl autocxx::subclass::CppPeerConstructor<#cpp_id> for super::super::super::#id {
                     fn make_peer(&mut self, peer_holder: autocxx::subclass::CppSubclassRustPeerHolder<Self>) -> cxx::UniquePtr<#cpp_path> {
-                        use autocxx::moveit::EmplaceUnpinned;
+                        use autocxx::moveit::Emplace;
                         cxx::UniquePtr::emplace(#cpp_id :: new(peer_holder))
                     }
                 }
@@ -820,15 +736,15 @@
         };
 
         // Once for each superclass, in future...
-        let as_id = make_ident(format!("As_{}", super_name));
+        let as_id = make_ident(format!("As_{super_name}"));
         extern_c_mod_items.push(parse_quote! {
             fn #as_id(self: &#cpp_id) -> &#super_cxxxbridge_id;
         });
-        let as_mut_id = make_ident(format!("As_{}_mut", super_name));
+        let as_mut_id = make_ident(format!("As_{super_name}_mut"));
         extern_c_mod_items.push(parse_quote! {
             fn #as_mut_id(self: Pin<&mut #cpp_id>) -> Pin<&mut #super_cxxxbridge_id>;
         });
-        let as_unique_ptr_id = make_ident(format!("{}_As_{}_UniquePtr", cpp_id, super_name));
+        let as_unique_ptr_id = make_ident(format!("{cpp_id}_As_{super_name}_UniquePtr"));
         extern_c_mod_items.push(parse_quote! {
             fn #as_unique_ptr_id(u: UniquePtr<#cpp_id>) -> UniquePtr<#super_cxxxbridge_id>;
         });
@@ -843,13 +759,13 @@
         // TODO it would be nice to impl AsMut here but pin prevents us
         bindgen_mod_items.push(parse_quote! {
             impl super::super::super::#id {
-                pub fn pin_mut(&mut self) -> ::std::pin::Pin<&mut cxxbridge::#super_cxxxbridge_id> {
+                pub fn pin_mut(&mut self) -> ::core::pin::Pin<&mut cxxbridge::#super_cxxxbridge_id> {
                     use autocxx::subclass::CppSubclass;
                     self.peer_mut().#as_mut_id()
                 }
             }
         });
-        let rs_as_unique_ptr_id = make_ident(format!("as_{}_unique_ptr", super_name));
+        let rs_as_unique_ptr_id = make_ident(format!("as_{super_name}_unique_ptr"));
         bindgen_mod_items.push(parse_quote! {
             impl super::super::super::#id {
                 pub fn #rs_as_unique_ptr_id(u: cxx::UniquePtr<#cpp_id>) -> cxx::UniquePtr<cxxbridge::#super_cxxxbridge_id> {
@@ -896,8 +812,8 @@
         let ret = details.ret;
         let unsafe_token = details.requires_unsafe.wrapper_token();
         let global_def = quote! { #unsafe_token fn #api_name(#params) #ret };
-        let params = unqualify_params(params);
-        let ret = unqualify_ret_type(ret);
+        let params = unqualify_params(minisynize_punctuated(params));
+        let ret = unqualify_ret_type(ret.into());
         let method_name = details.method_name;
         let cxxbridge_decl: ForeignItemFn =
             parse_quote! { #unsafe_token fn #api_name(#params) #ret; };
@@ -930,7 +846,7 @@
                         .as_ref()
                         .#borrow()
                         .expect(#reentrancy_panic_msg);
-                    let r = ::std::ops::#deref_ty::#deref_call(& #mut_token b);
+                    let r = ::core::ops::#deref_ty::#deref_call(& #mut_token b);
                     #methods_trait :: #method_name
                         (r,
                         #args)
@@ -955,7 +871,7 @@
     fn generate_type<F>(
         &self,
         name: &QualifiedName,
-        id: Ident,
+        id: crate::minisyn::Ident,
         type_kind: TypeKind,
         movable: bool,
         destroyable: bool,
@@ -1004,7 +920,7 @@
                         make_non_pod(s, layout);
                     } else {
                         // enum
-                        item = Item::Struct(new_non_pod_struct(id.clone()));
+                        item = Item::Struct(new_non_pod_struct(id.clone().into()));
                     }
                 }
                 bindgen_mod_items.push(item);
@@ -1042,6 +958,7 @@
                         extern_c_mod_items: vec![
                             self.generate_cxxbridge_type(name, false, doc_attrs)
                         ],
+                        bridge_items: create_impl_items(&id, movable, destroyable, self.config),
                         bindgen_mod_items,
                         materializations,
                         ..Default::default()
@@ -1065,8 +982,9 @@
                     let super_id =
                         SubclassName::get_super_fn_name(&Namespace::new(), &id.to_string())
                             .get_final_ident();
+                    let params = minisynize_punctuated(method.params.clone());
                     let param_names: Punctuated<Expr, Comma> =
-                        Self::args_from_sig(&method.params).collect();
+                        Self::args_from_sig(&params).collect();
                     let mut params = method.params.clone();
                     *(params.iter_mut().next().unwrap()) = match method.receiver_mutability {
                         ReceiverMutability::Const => parse_quote!(&self),
@@ -1110,7 +1028,7 @@
                         #(#mains)*
                     }
                 });
-                materializations.push(Use::SpecificNameFromBindgen(supers_name));
+                materializations.push(Use::SpecificNameFromBindgen(supers_name.into()));
             } else {
                 bindgen_mod_items.push(parse_quote! {
                     #[allow(non_snake_case)]
@@ -1119,7 +1037,7 @@
                     }
                 });
             }
-            materializations.push(Use::SpecificNameFromBindgen(methods_name));
+            materializations.push(Use::SpecificNameFromBindgen(methods_name.into()));
         }
     }
 
@@ -1132,13 +1050,16 @@
         let id = name.type_path_from_root();
         let super_duper = std::iter::repeat(make_ident("super"));
         let supers = super_duper.take(ns_depth + 2);
+        let name_final = name.get_final_ident();
         let use_statement = parse_quote! {
             pub use #(#supers)::* :: #id;
         };
         RsCodegenResult {
             bindgen_mod_items: vec![use_statement],
             extern_c_mod_items: vec![self.generate_cxxbridge_type(name, true, Vec::new())],
-            materializations: vec![Use::Custom(Box::new(parse_quote! { pub use #rust_path; }))],
+            materializations: vec![Use::Custom(Box::new(
+                parse_quote! { pub use #rust_path as #name_final; },
+            ))],
             ..Default::default()
         }
     }
@@ -1146,8 +1067,8 @@
     /// Generates something in the output mod that will carry a docstring
     /// explaining why a given type or function couldn't have bindings
     /// generated.
-    fn generate_error_entry(err: ConvertError, ctx: ErrorContext) -> RsCodegenResult {
-        let err = format!("autocxx bindings couldn't be generated: {}", err);
+    fn generate_error_entry(err: ConvertErrorFromCpp, ctx: ErrorContext) -> RsCodegenResult {
+        let err = format!("autocxx bindings couldn't be generated: {err}");
         let (impl_entry, bindgen_mod_item, materialization) = match ctx.into_type() {
             ErrorContextType::Item(id) => (
                 // Populate within bindgen mod because impl blocks may attach.
@@ -1156,7 +1077,7 @@
                     #[doc = #err]
                     pub struct #id;
                 }),
-                Some(Use::SpecificNameFromBindgen(id)),
+                Some(Use::SpecificNameFromBindgen(id.into())),
             ),
             ErrorContextType::SanitizedItem(id) => (
                 // Guaranteed to be no impl blocks - populate directly in output mod.
@@ -1214,7 +1135,7 @@
     }
 
     fn generate_extern_type_impl(&self, type_kind: TypeKind, tyname: &QualifiedName) -> Vec<Item> {
-        let tynamestring = namespaced_name_using_original_name_map(tyname, &self.original_name_map);
+        let tynamestring = self.original_name_map.map(tyname);
         let fulltypath = tyname.get_bindgen_path_idents();
         let kind_item = match type_kind {
             TypeKind::Pod => "Trivial",
@@ -1288,7 +1209,7 @@
         ForeignItem::Verbatim(for_extern_c_ts)
     }
 
-    fn find_output_mod_root(ns: &Namespace) -> impl Iterator<Item = Ident> {
+    fn find_output_mod_root(ns: &Namespace) -> impl Iterator<Item = crate::minisyn::Ident> {
         std::iter::repeat(make_ident("super")).take(ns.depth())
     }
 }
diff --git a/engine/src/conversion/codegen_rs/non_pod_struct.rs b/engine/src/conversion/codegen_rs/non_pod_struct.rs
index e4bec2f..d9a75c8 100644
--- a/engine/src/conversion/codegen_rs/non_pod_struct.rs
+++ b/engine/src/conversion/codegen_rs/non_pod_struct.rs
@@ -55,7 +55,7 @@
     let doc_attr = s
         .attrs
         .iter()
-        .filter(|a| a.path.get_ident().iter().any(|p| *p == "doc"))
+        .filter(|a| a.path().get_ident().iter().any(|p| *p == "doc"))
         .cloned();
     let repr_attr = if let Some(layout) = &layout {
         let align = make_lit_int(layout.align);
@@ -85,9 +85,9 @@
         .filter_map(|(counter, gp)| match gp {
             GenericParam::Type(gpt) => {
                 let id = &gpt.ident;
-                let field_name = make_ident(&format!("_phantom_{}", counter));
+                let field_name = make_ident(format!("_phantom_{counter}"));
                 let toks = quote! {
-                    #field_name: ::std::marker::PhantomData<::std::cell::UnsafeCell< #id >>
+                    #field_name: ::core::marker::PhantomData<::core::cell::UnsafeCell< #id >>
                 };
                 Some(Field::parse_named.parse2(toks).unwrap())
             }
diff --git a/engine/src/conversion/conversion_tests.rs b/engine/src/conversion/conversion_tests.rs
index b0474d6..e74888e 100644
--- a/engine/src/conversion/conversion_tests.rs
+++ b/engine/src/conversion/conversion_tests.rs
@@ -11,7 +11,7 @@
 use syn::parse_quote;
 use syn::ItemMod;
 
-use crate::CppCodegenOptions;
+use crate::CodegenOptions;
 
 use super::BridgeConverter;
 
@@ -33,7 +33,8 @@
         input,
         UnsafePolicy::AllFunctionsSafe,
         inclusions,
-        &CppCodegenOptions::default(),
+        &CodegenOptions::default(),
+        "",
     )
     .unwrap();
 }
diff --git a/engine/src/conversion/convert_error.rs b/engine/src/conversion/convert_error.rs
index ba8344d..855b235 100644
--- a/engine/src/conversion/convert_error.rs
+++ b/engine/src/conversion/convert_error.rs
@@ -8,19 +8,35 @@
 
 use indexmap::set::IndexSet as HashSet;
 
+use crate::minisyn::Ident;
 use itertools::Itertools;
-use syn::Ident;
+use miette::{Diagnostic, SourceSpan};
+use proc_macro2::Span;
 use thiserror::Error;
 
 use crate::{
-    known_types,
-    types::{make_ident, Namespace, QualifiedName},
+    known_types, proc_macro_span_to_miette_span,
+    types::{make_ident, InvalidIdentError, Namespace, QualifiedName},
 };
 
-#[derive(Debug, Clone, Error)]
+/// Errors which can occur during conversion
+#[derive(Debug, Clone, Error, Diagnostic)]
 pub enum ConvertError {
     #[error("The initial run of 'bindgen' did not generate any content. This might be because none of the requested items for generation could be converted.")]
     NoContent,
+    #[error(transparent)]
+    Cpp(ConvertErrorFromCpp),
+    #[error(transparent)]
+    #[diagnostic(transparent)]
+    Rust(LocatedConvertErrorFromRust),
+}
+
+/// Errors that can occur during conversion which are detected from some C++
+/// source code. Currently, we do not gain span information from bindgen
+/// so these errors are presented without useful source code snippets.
+/// We hope to change this in future.
+#[derive(Debug, Clone, Error)]
+pub enum ConvertErrorFromCpp {
     #[error("An item was requested using 'generate_pod' which was not safe to hold by value in Rust. {0}")]
     UnsafePodType(String),
     #[error("Bindgen generated some unexpected code in a foreign mod section. You may have specified something in a 'generate' directive which is not currently compatible with autocxx.")]
@@ -39,8 +55,14 @@
     ConflictingTemplatedArgsWithTypedef(QualifiedName),
     #[error("Function {0} has a parameter or return type which is either on the blocklist or a forward declaration")]
     UnacceptableParam(String),
-    #[error("Function {0} has a return reference parameter, but 0 or >1 input reference parameters, so the lifetime of the output reference cannot be deduced.")]
-    NotOneInputReference(String),
+    #[error("Function {0} has a reference return value, but no reference parameters, so the lifetime of the output reference cannot be deduced.")]
+    NoInputReference(String),
+    #[error("Function {0} has a reference return value, but >1 input reference parameters, so the lifetime of the output reference cannot be deduced.")]
+    MultipleInputReferences(String),
+    #[error("Function {0} has a mutable reference return value, but no mutable reference parameters, so the lifetime of the output reference cannot be deduced.")]
+    NoMutableInputReference(String),
+    #[error("Function {0} has a mutable reference return value, but >1 input mutable reference parameters, so the lifetime of the output reference cannot be deduced.")]
+    MultipleMutableInputReferences(String),
     #[error("Encountered type not yet supported by autocxx: {0}")]
     UnsupportedType(String),
     #[error("Encountered type not yet known by autocxx: {0}")]
@@ -53,8 +75,12 @@
     UnexpectedUseStatement(Option<String>),
     #[error("Type {} was parameterized over something complex which we don't yet support", .0.to_cpp_name())]
     TemplatedTypeContainingNonPathArg(QualifiedName),
-    #[error("Pointer pointed to something unsupported")]
-    InvalidPointee,
+    #[error("Pointer pointed to an array, which is not yet supported")]
+    InvalidArrayPointee,
+    #[error("Pointer pointed to another pointer, which is not yet supported")]
+    InvalidPointerPointee,
+    #[error("Pointer pointed to something unsupported (autocxx only supports pointers to named types): {0}")]
+    InvalidPointee(String),
     #[error("The 'generate' or 'generate_pod' directive for '{0}' did not result in any code being generated. Perhaps this was mis-spelled or you didn't qualify the name with any namespaces? Otherwise please report a bug.")]
     DidNotGenerateAnything(String),
     #[error("Found an attempt at using a forward declaration ({}) inside a templated cxx type such as UniquePtr or CxxVector. If the forward declaration is a typedef, perhaps autocxx wasn't sure whether or not it involved a forward declaration. If you're sure it didn't, then you may be able to solve this by using instantiable!.", .0.to_cpp_name())]
@@ -63,14 +89,12 @@
     Blocked(QualifiedName),
     #[error("This function or method uses a type where one of the template parameters was incomprehensible to bindgen/autocxx - probably because it uses template specialization.")]
     UnusedTemplateParam,
-    #[error("Names containing __ are reserved by C++ so not acceptable to cxx")]
-    TooManyUnderscores,
     #[error("This item relies on a type not known to autocxx ({})", .0.to_cpp_name())]
     UnknownDependentType(QualifiedName),
     #[error("This item depends on some other type(s) which autocxx could not generate, some of them are: {}", .0.iter().join(", "))]
     IgnoredDependent(HashSet<QualifiedName>),
-    #[error("The item name '{0}' is a reserved word in Rust.")]
-    ReservedName(String),
+    #[error(transparent)]
+    InvalidIdent(InvalidIdentError),
     #[error("This item name is used in multiple namespaces. At present, autocxx and cxx allow only one type of a given name. This limitation will be fixed in future. (Items found with this name: {})", .0.iter().join(", "))]
     DuplicateCxxBridgeName(Vec<String>),
     #[error("This is a method on a type which can't be used as the receiver in Rust (i.e. self/this). This is probably because some type involves template specialization.")]
@@ -123,29 +147,71 @@
     MethodInAnonymousNamespace,
     #[error("We're unable to make a concrete version of this template, because we found an error handling the template.")]
     ConcreteVersionOfIgnoredTemplate,
-    #[error("bindgen decided to call this type _bindgen_ty_N because it couldn't deduce the correct name for it. That means we can't generate C++ bindings to it.")]
-    BindgenTy,
     #[error("This is a typedef to a type in an anonymous namespace, not currently supported.")]
     TypedefToTypeInAnonymousNamespace,
     #[error("This type refers to a generic type parameter of an outer type, which is not yet supported.")]
     ReferringToGenericTypeParam,
     #[error("This forward declaration was nested within another struct/class. autocxx is unable to represent inner types if they are forward declarations.")]
     ForwardDeclaredNestedType,
+    #[error("Problem handling function argument {arg}: {err}")]
+    Argument {
+        arg: String,
+        #[source]
+        err: Box<ConvertErrorFromCpp>,
+    },
+}
+
+/// Error types derived from Rust code. This is separate from [`ConvertError`] because these
+/// may have spans attached for better diagnostics.
+#[derive(Debug, Clone, Error)]
+pub enum ConvertErrorFromRust {
+    #[error("extern_rust_function only supports limited parameter and return types. This is not such a supported type")]
+    UnsupportedTypeForExternFun,
+    #[error("extern_rust_function requires a fully qualified receiver, that is: fn a(self: &SomeType) as opposed to fn a(&self)")]
+    ExternRustFunRequiresFullyQualifiedReceiver,
+    #[error("extern_rust_function cannot support &mut T references; instead use Pin<&mut T> (see cxx documentation for more details")]
+    PinnedReferencesRequiredForExternFun,
+    #[error("extern_rust_function cannot currently support qualified type paths (that is, foo::bar::Baz). All type paths must be within the current module, imported using 'use'. This restriction may be lifted in future.")]
+    NamespacesNotSupportedForExternFun,
+    #[error("extern_rust_function signatures must never reference Self: instead, spell out the type explicitly.")]
+    ExplicitSelf,
+}
+
+/// A [`ConvertErrorFromRust`] which also implements [`miette::Diagnostic`] so can be pretty-printed
+/// to show the affected span of code.
+#[derive(Error, Debug, Diagnostic, Clone)]
+#[error("{err}")]
+pub struct LocatedConvertErrorFromRust {
+    err: ConvertErrorFromRust,
+    #[source_code]
+    file: String,
+    #[label("error here")]
+    span: SourceSpan,
+}
+
+impl LocatedConvertErrorFromRust {
+    pub(crate) fn new(err: ConvertErrorFromRust, span: &Span, file: &str) -> Self {
+        Self {
+            err,
+            span: proc_macro_span_to_miette_span(span),
+            file: file.to_string(),
+        }
+    }
 }
 
 /// Ensures that error contexts are always created using the constructors in this
 /// mod, therefore undergoing identifier sanitation.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 struct PhantomSanitized;
 
 /// The context of an error, e.g. whether it applies to a function or a method.
 /// This is used to generate suitable rustdoc in the output codegen so that
 /// the errors can be revealed in rust-analyzer-based IDEs, etc.
-#[derive(Clone)]
-pub(crate) struct ErrorContext(ErrorContextType, PhantomSanitized);
+#[derive(Clone, Debug)]
+pub(crate) struct ErrorContext(Box<ErrorContextType>, PhantomSanitized);
 
 /// All idents in this structure are guaranteed to be something we can safely codegen for.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) enum ErrorContextType {
     Item(Ident),
     SanitizedItem(Ident),
@@ -155,8 +221,11 @@
 impl ErrorContext {
     pub(crate) fn new_for_item(id: Ident) -> Self {
         match Self::sanitize_error_ident(&id) {
-            None => Self(ErrorContextType::Item(id), PhantomSanitized),
-            Some(sanitized) => Self(ErrorContextType::SanitizedItem(sanitized), PhantomSanitized),
+            None => Self(Box::new(ErrorContextType::Item(id)), PhantomSanitized),
+            Some(sanitized) => Self(
+                Box::new(ErrorContextType::SanitizedItem(sanitized)),
+                PhantomSanitized,
+            ),
         }
     }
 
@@ -166,14 +235,16 @@
         // an impl block.
         match Self::sanitize_error_ident(&self_ty) {
             None => Self(
-                ErrorContextType::Method {
+                Box::new(ErrorContextType::Method {
                     self_ty,
                     method: Self::sanitize_error_ident(&method).unwrap_or(method),
-                },
+                }),
                 PhantomSanitized,
             ),
             Some(_) => Self(
-                ErrorContextType::SanitizedItem(make_ident(format!("{}_{}", self_ty, method))),
+                Box::new(ErrorContextType::SanitizedItem(make_ident(format!(
+                    "{self_ty}_{method}"
+                )))),
                 PhantomSanitized,
             ),
         }
@@ -195,21 +266,24 @@
     }
 
     pub(crate) fn into_type(self) -> ErrorContextType {
-        self.0
+        *self.0
     }
 }
 
 impl std::fmt::Display for ErrorContext {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match &self.0 {
-            ErrorContextType::Item(id) | ErrorContextType::SanitizedItem(id) => write!(f, "{}", id),
-            ErrorContextType::Method { self_ty, method } => write!(f, "{}::{}", self_ty, method),
+        match &*self.0 {
+            ErrorContextType::Item(id) | ErrorContextType::SanitizedItem(id) => write!(f, "{id}"),
+            ErrorContextType::Method { self_ty, method } => write!(f, "{self_ty}::{method}"),
         }
     }
 }
 
 #[derive(Clone)]
-pub(crate) struct ConvertErrorWithContext(pub(crate) ConvertError, pub(crate) Option<ErrorContext>);
+pub(crate) struct ConvertErrorWithContext(
+    pub(crate) ConvertErrorFromCpp,
+    pub(crate) Option<ErrorContext>,
+);
 
 impl std::fmt::Debug for ConvertErrorWithContext {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
diff --git a/engine/src/conversion/doc_attr.rs b/engine/src/conversion/doc_attr.rs
index 8fe9d0b..7a44f9b 100644
--- a/engine/src/conversion/doc_attr.rs
+++ b/engine/src/conversion/doc_attr.rs
@@ -12,7 +12,7 @@
 pub(super) fn get_doc_attrs(attrs: &[Attribute]) -> Vec<Attribute> {
     attrs
         .iter()
-        .filter(|a| a.path.get_ident().iter().any(|p| *p == "doc"))
+        .filter(|a| a.path().get_ident().iter().any(|p| *p == "doc"))
         .cloned()
         .collect()
 }
diff --git a/engine/src/conversion/error_reporter.rs b/engine/src/conversion/error_reporter.rs
index 7942a32..adea153 100644
--- a/engine/src/conversion/error_reporter.rs
+++ b/engine/src/conversion/error_reporter.rs
@@ -6,13 +6,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use syn::ItemEnum;
+use crate::minisyn::ItemEnum;
 
 use super::{
     api::{AnalysisPhase, Api, ApiName, FuncToConvert, StructDetails, TypedefKind},
     apivec::ApiVec,
     convert_error::{ConvertErrorWithContext, ErrorContext},
-    ConvertError,
+    ConvertErrorFromCpp,
 };
 use crate::{
     conversion::convert_error::ErrorContextType,
@@ -33,7 +33,7 @@
     match fun() {
         Ok(result) => Some(result),
         Err(ConvertErrorWithContext(err, None)) => {
-            eprintln!("Ignored item: {}", err);
+            eprintln!("Ignored item: {err}");
             None
         }
         Err(ConvertErrorWithContext(err, Some(ctx))) => {
@@ -127,11 +127,11 @@
             Api::RustFn {
                 name,
                 details,
-                receiver,
+                deps,
             } => Ok(Box::new(std::iter::once(Api::RustFn {
                 name,
                 details,
-                receiver,
+                deps,
             }))),
             Api::RustSubclassFn {
                 name,
@@ -210,7 +210,7 @@
     out_apis: &mut ApiVec<B>,
     mut fun: F,
 ) where
-    F: FnMut(Api<A>) -> Result<Box<dyn Iterator<Item = Api<B>>>, ConvertError>,
+    F: FnMut(Api<A>) -> Result<Box<dyn Iterator<Item = Api<B>>>, ConvertErrorFromCpp>,
     A: AnalysisPhase,
     B: AnalysisPhase,
 {
diff --git a/engine/src/conversion/mod.rs b/engine/src/conversion/mod.rs
index aa639a2..61d7d6d 100644
--- a/engine/src/conversion/mod.rs
+++ b/engine/src/conversion/mod.rs
@@ -17,18 +17,18 @@
 mod doc_attr;
 mod error_reporter;
 mod parse;
+mod type_helpers;
 mod utilities;
 
 use analysis::fun::FnAnalyzer;
 use autocxx_parser::IncludeCppConfig;
 pub(crate) use codegen_cpp::CppCodeGenerator;
 pub(crate) use convert_error::ConvertError;
+use convert_error::ConvertErrorFromCpp;
 use itertools::Itertools;
 use syn::{Item, ItemMod};
 
-use crate::{
-    conversion::analysis::deps::HasDependencies, CppCodegenOptions, CppFilePair, UnsafePolicy,
-};
+use crate::{CodegenOptions, CppFilePair, UnsafePolicy};
 
 use self::{
     analysis::{
@@ -37,7 +37,6 @@
         casts::add_casts,
         check_names,
         constructor_deps::decorate_types_with_constructor_deps,
-        fun::FnPhase,
         gc::filter_apis_by_following_edges_from_allowlist,
         pod::analyze_pod_apis,
         remove_ignored::filter_apis_by_ignored_dependents,
@@ -87,23 +86,10 @@
     fn dump_apis<T: AnalysisPhase>(label: &str, apis: &ApiVec<T>) {
         if LOG_APIS {
             log::info!(
-                "APIs after {}:\n{}",
+                "##### APIs after {}:\n{}",
                 label,
                 apis.iter()
-                    .map(|api| { format!("  {:?}", api) })
-                    .sorted()
-                    .join("\n")
-            )
-        }
-    }
-
-    fn dump_apis_with_deps(label: &str, apis: &ApiVec<FnPhase>) {
-        if LOG_APIS {
-            log::info!(
-                "APIs after {}:\n{}",
-                label,
-                apis.iter()
-                    .map(|api| { format!("  {:?}, deps={}", api, api.format_deps()) })
+                    .map(|api| { format!("  {api:?}") })
                     .sorted()
                     .join("\n")
             )
@@ -121,7 +107,8 @@
         mut bindgen_mod: ItemMod,
         unsafe_policy: UnsafePolicy,
         inclusions: String,
-        cpp_codegen_options: &CppCodegenOptions,
+        codegen_options: &CodegenOptions,
+        source_file_contents: &str,
     ) -> Result<CodegenResults, ConvertError> {
         match &mut bindgen_mod.content {
             None => Err(ConvertError::NoContent),
@@ -129,7 +116,7 @@
                 // Parse the bindgen mod.
                 let items_to_process = items.drain(..).collect();
                 let parser = ParseBindgen::new(self.config);
-                let apis = parser.parse_items(items_to_process)?;
+                let apis = parser.parse_items(items_to_process, source_file_contents)?;
                 Self::dump_apis("parsing", &apis);
                 // Inside parse_results, we now have a list of APIs.
                 // We now enter various analysis phases.
@@ -143,9 +130,9 @@
                 // Specifically, let's confirm that the items requested by the user to be
                 // POD really are POD, and duly mark any dependent types.
                 // This returns a new list of `Api`s, which will be parameterized with
-                // the analysis results. It also returns an object which can be used
-                // by subsequent phases to work out which objects are POD.
-                let analyzed_apis = analyze_pod_apis(apis, self.config)?;
+                // the analysis results.
+                let analyzed_apis =
+                    analyze_pod_apis(apis, self.config).map_err(ConvertError::Cpp)?;
                 Self::dump_apis("pod analysis", &analyzed_apis);
                 let analyzed_apis = replace_hopeless_typedef_targets(self.config, analyzed_apis);
                 let analyzed_apis = add_casts(analyzed_apis);
@@ -156,8 +143,12 @@
                 // part of `autocxx`. Again, this returns a new set of `Api`s, but
                 // parameterized by a richer set of metadata.
                 Self::dump_apis("adding casts", &analyzed_apis);
-                let analyzed_apis =
-                    FnAnalyzer::analyze_functions(analyzed_apis, &unsafe_policy, self.config);
+                let analyzed_apis = FnAnalyzer::analyze_functions(
+                    analyzed_apis,
+                    &unsafe_policy,
+                    self.config,
+                    codegen_options.force_wrapper_gen,
+                );
                 // If any of those functions turned out to be pure virtual, don't attempt
                 // to generate UniquePtr implementations for the type, since it can't
                 // be instantiated.
@@ -167,9 +158,9 @@
                 // Annotate structs with a note of any copy/move constructors which
                 // we may want to retain to avoid garbage collecting them later.
                 let analyzed_apis = decorate_types_with_constructor_deps(analyzed_apis);
-                Self::dump_apis_with_deps("adding constructor deps", &analyzed_apis);
+                Self::dump_apis("adding constructor deps", &analyzed_apis);
                 let analyzed_apis = discard_ignored_functions(analyzed_apis);
-                Self::dump_apis_with_deps("ignoring ignorable fns", &analyzed_apis);
+                Self::dump_apis("ignoring ignorable fns", &analyzed_apis);
                 // Remove any APIs whose names are not compatible with cxx.
                 let analyzed_apis = check_names(analyzed_apis);
                 // During parsing or subsequent processing we might have encountered
@@ -177,24 +168,28 @@
                 // There might be other items depending on such things. Let's remove them
                 // too.
                 let analyzed_apis = filter_apis_by_ignored_dependents(analyzed_apis);
-                Self::dump_apis_with_deps("removing ignored dependents", &analyzed_apis);
+                Self::dump_apis("removing ignored dependents", &analyzed_apis);
 
                 // We now garbage collect the ones we don't need...
                 let mut analyzed_apis =
                     filter_apis_by_following_edges_from_allowlist(analyzed_apis, self.config);
                 // Determine what variably-sized C types (e.g. int) we need to include
                 analysis::ctypes::append_ctype_information(&mut analyzed_apis);
-                Self::dump_apis_with_deps("GC", &analyzed_apis);
+                Self::dump_apis("GC", &analyzed_apis);
                 // And finally pass them to the code gen phases, which outputs
                 // code suitable for cxx to consume.
-                let cxxgen_header_name = cpp_codegen_options.cxxgen_header_namer.name_header();
+                let cxxgen_header_name = codegen_options
+                    .cpp_codegen_options
+                    .cxxgen_header_namer
+                    .name_header();
                 let cpp = CppCodeGenerator::generate_cpp_code(
                     inclusions,
                     &analyzed_apis,
                     self.config,
-                    cpp_codegen_options,
+                    &codegen_options.cpp_codegen_options,
                     &cxxgen_header_name,
-                )?;
+                )
+                .map_err(ConvertError::Cpp)?;
                 let rs = RsCodeGenerator::generate_rs_code(
                     analyzed_apis,
                     &unsafe_policy,
diff --git a/engine/src/conversion/parse/bindgen_semantic_attributes.rs b/engine/src/conversion/parse/bindgen_semantic_attributes.rs
index a8de9ce..f2dd7d7 100644
--- a/engine/src/conversion/parse/bindgen_semantic_attributes.rs
+++ b/engine/src/conversion/parse/bindgen_semantic_attributes.rs
@@ -14,9 +14,9 @@
 };
 
 use crate::conversion::{
-    api::{CppVisibility, Layout, References, SpecialMemberKind, Virtualness},
+    api::{CppVisibility, DeletedOrDefaulted, Layout, References, SpecialMemberKind, Virtualness},
     convert_error::{ConvertErrorWithContext, ErrorContext},
-    ConvertError,
+    ConvertErrorFromCpp,
 };
 
 /// The set of all annotations that autocxx_bindgen has added
@@ -31,7 +31,7 @@
     // item can't be processed.
     pub(crate) fn new_retaining_others(attrs: &mut Vec<Attribute>) -> Self {
         let metadata = Self::new(attrs);
-        attrs.retain(|a| a.path.segments.last().unwrap().ident != "cpp_semantics");
+        attrs.retain(|a| a.path().segments.last().unwrap().ident != "cpp_semantics");
         metadata
     }
 
@@ -40,7 +40,7 @@
             attrs
                 .iter()
                 .filter_map(|attr| {
-                    if attr.path.segments.last().unwrap().ident == "cpp_semantics" {
+                    if attr.path().segments.last().unwrap().ident == "cpp_semantics" {
                         let r: Result<BindgenSemanticAttribute, syn::Error> = attr.parse_args();
                         r.ok()
                     } else {
@@ -58,13 +58,13 @@
     ) -> Result<(), ConvertErrorWithContext> {
         if self.has_attr("unused_template_param") {
             Err(ConvertErrorWithContext(
-                ConvertError::UnusedTemplateParam,
-                Some(ErrorContext::new_for_item(id_for_context.clone())),
+                ConvertErrorFromCpp::UnusedTemplateParam,
+                Some(ErrorContext::new_for_item(id_for_context.clone().into())),
             ))
         } else if self.get_cpp_visibility() != CppVisibility::Public {
             Err(ConvertErrorWithContext(
-                ConvertError::NonPublicNestedType,
-                Some(ErrorContext::new_for_item(id_for_context.clone())),
+                ConvertErrorFromCpp::NonPublicNestedType,
+                Some(ErrorContext::new_for_item(id_for_context.clone().into())),
             ))
         } else {
             Ok(())
@@ -98,6 +98,16 @@
         }
     }
 
+    pub(super) fn get_deleted_or_defaulted(&self) -> DeletedOrDefaulted {
+        if self.has_attr("deleted") {
+            DeletedOrDefaulted::Deleted
+        } else if self.has_attr("defaulted") {
+            DeletedOrDefaulted::Defaulted
+        } else {
+            DeletedOrDefaulted::Neither
+        }
+    }
+
     fn parse_if_present<T: Parse>(&self, annotation: &str) -> Option<T> {
         self.0
             .iter()
@@ -144,12 +154,12 @@
             } else if a.is_ident("arg_type_reference") {
                 let r: Result<Ident, syn::Error> = a.parse_args();
                 if let Ok(ls) = r {
-                    results.ref_params.insert(ls);
+                    results.ref_params.insert(ls.into());
                 }
             } else if a.is_ident("arg_type_rvalue_reference") {
                 let r: Result<Ident, syn::Error> = a.parse_args();
                 if let Ok(ls) = r {
-                    results.rvalue_ref_params.insert(ls);
+                    results.rvalue_ref_params.insert(ls.into());
                 }
             }
         }
diff --git a/engine/src/conversion/parse/extern_fun_signatures.rs b/engine/src/conversion/parse/extern_fun_signatures.rs
new file mode 100644
index 0000000..cb002b5
--- /dev/null
+++ b/engine/src/conversion/parse/extern_fun_signatures.rs
@@ -0,0 +1,253 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use indexmap::IndexSet as HashSet;
+
+use syn::{
+    spanned::Spanned, AngleBracketedGenericArguments, GenericArgument, PatType, PathArguments,
+    PathSegment, ReturnType, Signature, Type, TypePath, TypeReference,
+};
+
+use crate::{
+    conversion::convert_error::{ConvertErrorFromRust, LocatedConvertErrorFromRust},
+    types::QualifiedName,
+};
+
+pub(super) fn assemble_extern_fun_deps(
+    sig: &Signature,
+    file: &str,
+) -> Result<Vec<QualifiedName>, LocatedConvertErrorFromRust> {
+    let mut deps = HashSet::new();
+    // It's possible that this will need to be implemented using TypeConverter
+    // and the encountered_types field on its annotated results.
+    // But the design of that code is intended to convert from C++ types
+    // (via bindgen) to cxx types, and instead here we're starting with pure
+    // Rust types as written by a Rustacean human. It may therefore not
+    // be quite right to go via TypeConverter.
+    // Also, by doing it ourselves here, we're in a better place to emit
+    // meaningful errors about types which can't be supported within
+    // extern_rust_fun.
+    if let ReturnType::Type(_, ty) = &sig.output {
+        add_type_to_deps(ty, &mut deps, file)?;
+    }
+    for input in &sig.inputs {
+        match input {
+            syn::FnArg::Receiver(_) => {
+                return Err(LocatedConvertErrorFromRust::new(
+                    ConvertErrorFromRust::ExternRustFunRequiresFullyQualifiedReceiver,
+                    &input.span(),
+                    file,
+                ))
+            }
+            syn::FnArg::Typed(PatType { ty, .. }) => add_type_to_deps(ty, &mut deps, file)?,
+        }
+    }
+    Ok(deps.into_iter().collect())
+}
+
+/// For all types within an extern_rust_function signature, add them to the deps
+/// hash, or raise an appropriate error.
+fn add_type_to_deps(
+    ty: &Type,
+    deps: &mut HashSet<QualifiedName>,
+    file: &str,
+) -> Result<(), LocatedConvertErrorFromRust> {
+    match ty {
+        Type::Reference(TypeReference {
+            mutability: Some(_),
+            ..
+        }) => {
+            return Err(LocatedConvertErrorFromRust::new(
+                ConvertErrorFromRust::PinnedReferencesRequiredForExternFun,
+                &ty.span(),
+                file,
+            ))
+        }
+        Type::Reference(TypeReference { elem, .. }) => match &**elem {
+            Type::Path(tp) => add_path_to_deps(tp, deps, file)?,
+            _ => {
+                return Err(LocatedConvertErrorFromRust::new(
+                    ConvertErrorFromRust::UnsupportedTypeForExternFun,
+                    &ty.span(),
+                    file,
+                ))
+            }
+        },
+        Type::Path(tp) => {
+            if tp.path.segments.len() != 1 {
+                return Err(LocatedConvertErrorFromRust::new(
+                    ConvertErrorFromRust::NamespacesNotSupportedForExternFun,
+                    &tp.span(),
+                    file,
+                ));
+            }
+            if let Some(PathSegment {
+                ident,
+                arguments:
+                    PathArguments::AngleBracketed(AngleBracketedGenericArguments { args, .. }),
+            }) = tp.path.segments.last()
+            {
+                if ident == "Pin" {
+                    if args.len() != 1 {
+                        return Err(LocatedConvertErrorFromRust::new(
+                            ConvertErrorFromRust::UnsupportedTypeForExternFun,
+                            &tp.span(),
+                            file,
+                        ));
+                    }
+
+                    if let Some(GenericArgument::Type(Type::Reference(TypeReference {
+                        mutability: Some(_),
+                        elem,
+                        ..
+                    }))) = args.first()
+                    {
+                        if let Type::Path(tp) = &**elem {
+                            add_path_to_deps(tp, deps, file)?
+                        } else {
+                            return Err(LocatedConvertErrorFromRust::new(
+                                ConvertErrorFromRust::UnsupportedTypeForExternFun,
+                                &elem.span(),
+                                file,
+                            ));
+                        }
+                    } else {
+                        return Err(LocatedConvertErrorFromRust::new(
+                            ConvertErrorFromRust::UnsupportedTypeForExternFun,
+                            &ty.span(),
+                            file,
+                        ));
+                    }
+                } else if ident == "Box" || ident == "Vec" {
+                    if args.len() != 1 {
+                        return Err(LocatedConvertErrorFromRust::new(
+                            ConvertErrorFromRust::UnsupportedTypeForExternFun,
+                            &tp.span(),
+                            file,
+                        ));
+                    }
+                    if let Some(GenericArgument::Type(Type::Path(tp))) = args.first() {
+                        add_path_to_deps(tp, deps, file)?
+                    } else {
+                        return Err(LocatedConvertErrorFromRust::new(
+                            ConvertErrorFromRust::UnsupportedTypeForExternFun,
+                            &ty.span(),
+                            file,
+                        ));
+                    }
+                } else {
+                    return Err(LocatedConvertErrorFromRust::new(
+                        ConvertErrorFromRust::UnsupportedTypeForExternFun,
+                        &ident.span(),
+                        file,
+                    ));
+                }
+            } else {
+                add_path_to_deps(tp, deps, file)?
+            }
+        }
+        _ => {
+            return Err(LocatedConvertErrorFromRust::new(
+                ConvertErrorFromRust::UnsupportedTypeForExternFun,
+                &ty.span(),
+                file,
+            ))
+        }
+    };
+    Ok(())
+}
+
+fn add_path_to_deps(
+    type_path: &TypePath,
+    deps: &mut HashSet<QualifiedName>,
+    file: &str,
+) -> Result<(), LocatedConvertErrorFromRust> {
+    if let Some(PathSegment {
+        arguments: PathArguments::AngleBracketed(..) | PathArguments::Parenthesized(..),
+        ..
+    }) = type_path.path.segments.last()
+    {
+        return Err(LocatedConvertErrorFromRust::new(
+            ConvertErrorFromRust::UnsupportedTypeForExternFun,
+            &type_path.span(),
+            file,
+        ));
+    }
+    let qn = QualifiedName::from_type_path(type_path);
+    if !qn.get_namespace().is_empty() {
+        return Err(LocatedConvertErrorFromRust::new(
+            ConvertErrorFromRust::NamespacesNotSupportedForExternFun,
+            &type_path.span(),
+            file,
+        ));
+    }
+    if qn.get_final_item() == "Self" {
+        return Err(LocatedConvertErrorFromRust::new(
+            ConvertErrorFromRust::ExplicitSelf,
+            &type_path.span(),
+            file,
+        ));
+    }
+    deps.insert(qn);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use syn::parse_quote;
+
+    use super::*;
+
+    fn run_test_expect_ok(sig: Signature, expected_deps: &[&str]) {
+        let expected_as_set: HashSet<QualifiedName> = expected_deps
+            .iter()
+            .cloned()
+            .map(QualifiedName::new_from_cpp_name)
+            .collect();
+        let result = assemble_extern_fun_deps(&sig, "").unwrap();
+        let actual_as_set: HashSet<QualifiedName> = result.into_iter().collect();
+        assert_eq!(expected_as_set, actual_as_set);
+    }
+
+    fn run_test_expect_fail(sig: Signature) {
+        assert!(assemble_extern_fun_deps(&sig, "").is_err())
+    }
+
+    #[test]
+    fn test_assemble_extern_fun_deps() {
+        run_test_expect_fail(parse_quote! { fn function(self: A::B)});
+        run_test_expect_fail(parse_quote! { fn function(self: Self)});
+        run_test_expect_fail(parse_quote! { fn function(self: Self)});
+        run_test_expect_fail(parse_quote! { fn function(self)});
+        run_test_expect_fail(parse_quote! { fn function(&self)});
+        run_test_expect_fail(parse_quote! { fn function(&mut self)});
+        run_test_expect_fail(parse_quote! { fn function(self: Pin<&mut Self>)});
+        run_test_expect_fail(parse_quote! { fn function(self: Pin<&mut A::B>)});
+        run_test_expect_fail(parse_quote! { fn function(a: Pin<A>)});
+        run_test_expect_fail(parse_quote! { fn function(a: Pin<A::B>)});
+        run_test_expect_fail(parse_quote! { fn function(a: A::B)});
+        run_test_expect_fail(parse_quote! { fn function(a: &mut A)});
+        run_test_expect_fail(parse_quote! { fn function() -> A::B});
+        run_test_expect_fail(parse_quote! { fn function() -> &A::B});
+        run_test_expect_fail(parse_quote! { fn function(a: ())});
+        run_test_expect_fail(parse_quote! { fn function(a: &[A])});
+        run_test_expect_fail(parse_quote! { fn function(a: Bob<A>)});
+        run_test_expect_fail(parse_quote! { fn function(a: Box<A, B>)});
+        run_test_expect_fail(parse_quote! { fn function(a: a::Pin<&mut A>)});
+        run_test_expect_fail(parse_quote! { fn function(a: Pin<&A>)});
+        run_test_expect_ok(parse_quote! { fn function(a: A, b: B)}, &["A", "B"]);
+        run_test_expect_ok(parse_quote! { fn function(a: Box<A>)}, &["A"]);
+        run_test_expect_ok(parse_quote! { fn function(a: Vec<A>)}, &["A"]);
+        run_test_expect_ok(parse_quote! { fn function(a: &A)}, &["A"]);
+        run_test_expect_ok(parse_quote! { fn function(a: Pin<&mut A>)}, &["A"]);
+        run_test_expect_ok(
+            parse_quote! { fn function(a: A, b: B) -> Box<C>},
+            &["A", "B", "C"],
+        );
+    }
+}
diff --git a/engine/src/conversion/parse/mod.rs b/engine/src/conversion/parse/mod.rs
index 3f42ce4..b4f2e07 100644
--- a/engine/src/conversion/parse/mod.rs
+++ b/engine/src/conversion/parse/mod.rs
@@ -7,6 +7,7 @@
 // except according to those terms.
 
 mod bindgen_semantic_attributes;
+mod extern_fun_signatures;
 mod parse_bindgen;
 mod parse_foreign_mod;
 
diff --git a/engine/src/conversion/parse/parse_bindgen.rs b/engine/src/conversion/parse/parse_bindgen.rs
index 2d4e3de..f499145 100644
--- a/engine/src/conversion/parse/parse_bindgen.rs
+++ b/engine/src/conversion/parse/parse_bindgen.rs
@@ -13,7 +13,8 @@
     conversion::{
         api::{Api, ApiName, NullPhase, StructDetails, SubclassName, TypedefKind, UnanalyzedApi},
         apivec::ApiVec,
-        ConvertError,
+        convert_error::LocatedConvertErrorFromRust,
+        ConvertError, ConvertErrorFromCpp,
     },
     types::Namespace,
     types::QualifiedName,
@@ -41,7 +42,7 @@
 }
 
 fn api_name(ns: &Namespace, id: Ident, attrs: &BindgenSemanticAttributes) -> ApiName {
-    ApiName::new_with_cpp_name(ns, id, attrs.get_original_name())
+    ApiName::new_with_cpp_name(ns, id.into(), attrs.get_original_name())
 }
 
 pub(crate) fn api_name_qualified(
@@ -51,8 +52,11 @@
 ) -> Result<ApiName, ConvertErrorWithContext> {
     match validate_ident_ok_for_cxx(&id.to_string()) {
         Err(e) => {
-            let ctx = ErrorContext::new_for_item(id);
-            Err(ConvertErrorWithContext(e, Some(ctx)))
+            let ctx = ErrorContext::new_for_item(id.into());
+            Err(ConvertErrorWithContext(
+                ConvertErrorFromCpp::InvalidIdent(e),
+                Some(ctx),
+            ))
         }
         Ok(..) => Ok(api_name(ns, id, attrs)),
     }
@@ -71,43 +75,49 @@
     pub(crate) fn parse_items(
         mut self,
         items: Vec<Item>,
+        source_file_contents: &str,
     ) -> Result<ApiVec<NullPhase>, ConvertError> {
-        let items = Self::find_items_in_root(items)?;
+        let items = Self::find_items_in_root(items).map_err(ConvertError::Cpp)?;
         if !self.config.exclude_utilities() {
             generate_utilities(&mut self.apis, self.config);
         }
-        self.add_apis_from_config();
+        self.add_apis_from_config(source_file_contents)
+            .map_err(ConvertError::Rust)?;
         let root_ns = Namespace::new();
         self.parse_mod_items(items, root_ns);
-        self.confirm_all_generate_directives_obeyed()?;
+        self.confirm_all_generate_directives_obeyed()
+            .map_err(ConvertError::Cpp)?;
         self.replace_extern_cpp_types();
         Ok(self.apis)
     }
 
     /// Some API items are not populated from bindgen output, but instead
     /// directly from items in the config.
-    fn add_apis_from_config(&mut self) {
+    fn add_apis_from_config(
+        &mut self,
+        source_file_contents: &str,
+    ) -> Result<(), LocatedConvertErrorFromRust> {
         self.apis
             .extend(self.config.subclasses.iter().map(|sc| Api::Subclass {
-                name: SubclassName::new(sc.subclass.clone()),
+                name: SubclassName::new(sc.subclass.clone().into()),
                 superclass: QualifiedName::new_from_cpp_name(&sc.superclass),
             }));
-        self.apis
-            .extend(self.config.extern_rust_funs.iter().map(|fun| {
-                let id = fun.sig.ident.clone();
-                Api::RustFn {
-                    name: ApiName::new_in_root_namespace(id),
-                    details: fun.clone(),
-                    receiver: fun.receiver.as_ref().map(|receiver_id| {
-                        QualifiedName::new(&Namespace::new(), receiver_id.clone())
-                    }),
-                }
-            }));
+        for fun in &self.config.extern_rust_funs {
+            let id = fun.sig.ident.clone();
+            self.apis.push(Api::RustFn {
+                name: ApiName::new_in_root_namespace(id.into()),
+                details: fun.clone(),
+                deps: super::extern_fun_signatures::assemble_extern_fun_deps(
+                    &fun.sig,
+                    source_file_contents,
+                )?,
+            })
+        }
         let unique_rust_types: HashSet<&RustPath> = self.config.rust_types.iter().collect();
         self.apis.extend(unique_rust_types.into_iter().map(|path| {
             let id = path.get_final_ident();
             Api::RustType {
-                name: ApiName::new_in_root_namespace(id.clone()),
+                name: ApiName::new_in_root_namespace(id.clone().into()),
                 path: path.clone(),
             }
         }));
@@ -117,7 +127,7 @@
                 .0
                 .iter()
                 .map(|(cpp_definition, rust_id)| {
-                    let name = ApiName::new_in_root_namespace(rust_id.clone());
+                    let name = ApiName::new_in_root_namespace(rust_id.clone().into());
                     Api::ConcreteType {
                         name,
                         cpp_definition: cpp_definition.clone(),
@@ -125,6 +135,7 @@
                     }
                 }),
         );
+        Ok(())
     }
 
     /// We do this last, _after_ we've parsed all the APIs, because we might want to actually
@@ -154,7 +165,7 @@
         self.apis.extend(replacements.into_iter().map(|(_, v)| v));
     }
 
-    fn find_items_in_root(items: Vec<Item>) -> Result<Vec<Item>, ConvertError> {
+    fn find_items_in_root(items: Vec<Item>) -> Result<Vec<Item>, ConvertErrorFromCpp> {
         for item in items {
             match item {
                 Item::Mod(root_mod) => {
@@ -166,7 +177,7 @@
                         return Ok(items);
                     }
                 }
-                _ => return Err(ConvertError::UnexpectedOuterItem),
+                _ => return Err(ConvertErrorFromCpp::UnexpectedOuterItem),
             }
         }
         Ok(Vec::new())
@@ -224,8 +235,8 @@
                     // forward declarations.
                     if err.is_none() && name.cpp_name().contains("::") {
                         err = Some(ConvertErrorWithContext(
-                            ConvertError::ForwardDeclaredNestedType,
-                            Some(ErrorContext::new_for_item(s.ident)),
+                            ConvertErrorFromCpp::ForwardDeclaredNestedType,
+                            Some(ErrorContext::new_for_item(s.ident.into())),
                         ));
                     }
                     Some(UnanalyzedApi::ForwardDeclaration { name, err })
@@ -237,7 +248,7 @@
                         name,
                         details: Box::new(StructDetails {
                             layout: annotations.get_layout(),
-                            item: s,
+                            item: s.into(),
                             has_rvalue_reference_fields,
                         }),
                         analysis: (),
@@ -254,7 +265,7 @@
                 let annotations = BindgenSemanticAttributes::new(&e.attrs);
                 let api = UnanalyzedApi::Enum {
                     name: api_name_qualified(ns, e.ident.clone(), &annotations)?,
-                    item: e,
+                    item: e.into(),
                 };
                 if !self.config.is_on_blocklist(&api.name().to_cpp_name()) {
                     self.apis.push(api);
@@ -293,7 +304,7 @@
                         UseTree::Rename(urn) => {
                             let old_id = &urn.ident;
                             let new_id = &urn.rename;
-                            let new_tyname = QualifiedName::new(ns, new_id.clone());
+                            let new_tyname = QualifiedName::new(ns, new_id.clone().into());
                             assert!(segs.remove(0) == "self", "Path didn't start with self");
                             assert!(
                                 segs.remove(0) == "super",
@@ -309,8 +320,8 @@
                             let old_tyname = QualifiedName::from_type_path(&old_path);
                             if new_tyname == old_tyname {
                                 return Err(ConvertErrorWithContext(
-                                    ConvertError::InfinitelyRecursiveTypedef(new_tyname),
-                                    Some(ErrorContext::new_for_item(new_id.clone())),
+                                    ConvertErrorFromCpp::InfinitelyRecursiveTypedef(new_tyname),
+                                    Some(ErrorContext::new_for_item(new_id.clone().into())),
                                 ));
                             }
                             let annotations = BindgenSemanticAttributes::new(&use_item.attrs);
@@ -320,7 +331,7 @@
                                     parse_quote! {
                                         pub use #old_path as #new_id;
                                     },
-                                    Box::new(Type::Path(old_path)),
+                                    Box::new(Type::Path(old_path).into()),
                                 ),
                                 old_tyname: Some(old_tyname),
                                 analysis: (),
@@ -329,7 +340,7 @@
                         }
                         _ => {
                             return Err(ConvertErrorWithContext(
-                                ConvertError::UnexpectedUseStatement(
+                                ConvertErrorFromCpp::UnexpectedUseStatement(
                                     segs.into_iter().last().map(|i| i.to_string()),
                                 ),
                                 None,
@@ -341,10 +352,23 @@
             }
             Item::Const(const_item) => {
                 let annotations = BindgenSemanticAttributes::new(&const_item.attrs);
-                self.apis.push(UnanalyzedApi::Const {
-                    name: api_name(ns, const_item.ident.clone(), &annotations),
-                    const_item,
-                });
+                // Bindgen generates const expressions for nested unnamed enums,
+                // but autcxx will refuse to expand those enums, making these consts
+                // invalid.
+                let mut enum_type_name_valid = true;
+                if let Type::Path(p) = &*const_item.ty {
+                    if let Some(p) = &p.path.segments.last() {
+                        if validate_ident_ok_for_cxx(&p.ident.to_string()).is_err() {
+                            enum_type_name_valid = false;
+                        }
+                    }
+                }
+                if enum_type_name_valid {
+                    self.apis.push(UnanalyzedApi::Const {
+                        name: api_name(ns, const_item.ident.clone(), &annotations),
+                        const_item: const_item.into(),
+                    });
+                }
                 Ok(())
             }
             Item::Type(ity) => {
@@ -353,14 +377,14 @@
                 // same name - see test_issue_264.
                 self.apis.push(UnanalyzedApi::Typedef {
                     name: api_name(ns, ity.ident.clone(), &annotations),
-                    item: TypedefKind::Type(ity),
+                    item: TypedefKind::Type(ity.into()),
                     old_tyname: None,
                     analysis: (),
                 });
                 Ok(())
             }
             _ => Err(ConvertErrorWithContext(
-                ConvertError::UnexpectedItemInMod,
+                ConvertErrorFromCpp::UnexpectedItemInMod,
                 None,
             )),
         }
@@ -380,7 +404,7 @@
             .any(|id| id == desired_id)
     }
 
-    fn confirm_all_generate_directives_obeyed(&self) -> Result<(), ConvertError> {
+    fn confirm_all_generate_directives_obeyed(&self) -> Result<(), ConvertErrorFromCpp> {
         let api_names: HashSet<_> = self
             .apis
             .iter()
@@ -388,7 +412,9 @@
             .collect();
         for generate_directive in self.config.must_generate_list() {
             if !api_names.contains(&generate_directive) {
-                return Err(ConvertError::DidNotGenerateAnything(generate_directive));
+                return Err(ConvertErrorFromCpp::DidNotGenerateAnything(
+                    generate_directive,
+                ));
             }
         }
         Ok(())
diff --git a/engine/src/conversion/parse/parse_foreign_mod.rs b/engine/src/conversion/parse/parse_foreign_mod.rs
index 08c1fd8..ea82ff8 100644
--- a/engine/src/conversion/parse/parse_foreign_mod.rs
+++ b/engine/src/conversion/parse/parse_foreign_mod.rs
@@ -15,8 +15,9 @@
     convert_error::ConvertErrorWithContext,
     convert_error::ErrorContext,
 };
+use crate::minisyn::{minisynize_punctuated, minisynize_vec};
 use crate::{
-    conversion::ConvertError,
+    conversion::ConvertErrorFromCpp,
     types::{Namespace, QualifiedName},
 };
 use std::collections::HashMap;
@@ -72,11 +73,11 @@
                 self.funcs_to_convert.push(FuncToConvert {
                     provenance: Provenance::Bindgen,
                     self_ty: None,
-                    ident: item.sig.ident,
-                    doc_attrs,
-                    inputs: item.sig.inputs,
-                    output: item.sig.output,
-                    vis: item.vis,
+                    ident: item.sig.ident.into(),
+                    doc_attrs: minisynize_vec(doc_attrs),
+                    inputs: minisynize_punctuated(item.sig.inputs),
+                    output: item.sig.output.into(),
+                    vis: item.vis.into(),
                     virtualness: annotations.get_virtualness(),
                     cpp_vis: annotations.get_cpp_visibility(),
                     special_member: annotations.special_member_kind(),
@@ -86,18 +87,18 @@
                     original_name: annotations.get_original_name(),
                     synthesized_this_type: None,
                     add_to_trait: None,
-                    is_deleted: annotations.has_attr("deleted"),
+                    is_deleted: annotations.get_deleted_or_defaulted(),
                     synthetic_cpp: None,
                     variadic: item.sig.variadic.is_some(),
                 });
                 Ok(())
             }
             ForeignItem::Static(item) => Err(ConvertErrorWithContext(
-                ConvertError::StaticData(item.ident.to_string()),
-                Some(ErrorContext::new_for_item(item.ident)),
+                ConvertErrorFromCpp::StaticData(item.ident.to_string()),
+                Some(ErrorContext::new_for_item(item.ident.into())),
             )),
             _ => Err(ConvertErrorWithContext(
-                ConvertError::UnexpectedForeignItem,
+                ConvertErrorFromCpp::UnexpectedForeignItem,
                 None,
             )),
         }
@@ -111,14 +112,14 @@
             _ => return,
         };
         for i in imp.items {
-            if let ImplItem::Method(itm) = i {
+            if let ImplItem::Fn(itm) = i {
                 let effective_fun_name = match get_called_function(&itm.block) {
                     Some(id) => id.clone(),
                     None => itm.sig.ident,
                 };
                 self.method_receivers.insert(
                     effective_fun_name,
-                    QualifiedName::new(&self.ns, ty_id.clone()),
+                    QualifiedName::new(&self.ns, ty_id.clone().into()),
                 );
             }
         }
@@ -151,7 +152,7 @@
 /// name of the actual function call inside the block's body.
 fn get_called_function(block: &Block) -> Option<&Ident> {
     match block.stmts.first() {
-        Some(Stmt::Expr(Expr::Call(ExprCall { func, .. }))) => match **func {
+        Some(Stmt::Expr(Expr::Call(ExprCall { func, .. }), _)) => match **func {
             Expr::Path(ref exp) => exp.path.segments.first().map(|ps| &ps.ident),
             _ => None,
         },
diff --git a/engine/src/conversion/type_helpers.rs b/engine/src/conversion/type_helpers.rs
new file mode 100644
index 0000000..8eb3a3a
--- /dev/null
+++ b/engine/src/conversion/type_helpers.rs
@@ -0,0 +1,58 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use syn::{
+    AngleBracketedGenericArguments, GenericArgument, PathArguments, PathSegment, Type, TypePath,
+    TypeReference,
+};
+
+/// Looks in a `core::pin::Pin<&mut Something>` and returns the `Something`
+/// if it's found.
+/// This code could _almost_ be used from various other places around autocxx
+/// but they each have slightly different requirements. Over time we should
+/// try to migrate other instances to use this, though.
+pub(crate) fn extract_pinned_mutable_reference_type(tp: &TypePath) -> Option<&Type> {
+    if !is_pin(tp) {
+        return None;
+    }
+    if let Some(PathSegment {
+        arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments { args, .. }),
+        ..
+    }) = tp.path.segments.last()
+    {
+        if args.len() == 1 {
+            if let Some(GenericArgument::Type(Type::Reference(TypeReference {
+                mutability: Some(_),
+                elem,
+                ..
+            }))) = args.first()
+            {
+                return Some(elem);
+            }
+        }
+    }
+    None
+}
+
+/// Whether this type path is a `Pin`
+fn is_pin(tp: &TypePath) -> bool {
+    if tp.path.segments.len() != 3 {
+        return false;
+    }
+    static EXPECTED_SEGMENTS: &[&[&str]] = &[&["std", "core"], &["pin"], &["Pin"]];
+
+    for (seg, expected_name) in tp.path.segments.iter().zip(EXPECTED_SEGMENTS.iter()) {
+        if !expected_name
+            .iter()
+            .any(|expected_name| seg.ident == expected_name)
+        {
+            return false;
+        }
+    }
+    true
+}
diff --git a/engine/src/known_types.rs b/engine/src/known_types.rs
index 377101a..10199fb 100644
--- a/engine/src/known_types.rs
+++ b/engine/src/known_types.rs
@@ -6,14 +6,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use crate::{
-    conversion::ConvertError,
-    types::{make_ident, QualifiedName},
-};
+use crate::types::{make_ident, QualifiedName};
 use indexmap::map::IndexMap as HashMap;
 use indoc::indoc;
 use once_cell::sync::OnceCell;
-use syn::{parse_quote, Type, TypePath, TypePtr};
+use syn::{parse_quote, TypePath};
 
 //// The behavior of the type.
 #[derive(Debug)]
@@ -103,12 +100,12 @@
         let mut segs = self.rs_name.split("::").peekable();
         if segs.peek().map(|seg| seg.is_empty()).unwrap_or_default() {
             segs.next();
-            let segs = segs.into_iter().map(make_ident);
+            let segs = segs.map(make_ident);
             parse_quote! {
                 ::#(#segs)::*
             }
         } else {
-            let segs = segs.into_iter().map(make_ident);
+            let segs = segs.map(make_ident);
             parse_quote! {
                 #(#segs)::*
             }
@@ -143,7 +140,7 @@
 }
 
 /// The type of payload that a cxx generic can contain.
-#[derive(PartialEq, Clone, Copy)]
+#[derive(PartialEq, Eq, Clone, Copy)]
 pub enum CxxGenericType {
     /// Not a generic at all
     Not,
@@ -247,7 +244,9 @@
             .map(|td| {
                 matches!(
                     td.behavior,
-                    Behavior::CxxContainerPtr | Behavior::CxxContainerVector
+                    Behavior::CxxContainerPtr
+                        | Behavior::CxxContainerVector
+                        | Behavior::RustContainerByValueSafe
                 )
             })
             .unwrap_or(false)
@@ -447,8 +446,8 @@
     ));
     for (cpp_type, rust_type) in (4..7).map(|x| 2i32.pow(x)).flat_map(|x| {
         vec![
-            (format!("uint{}_t", x), format!("u{}", x)),
-            (format!("int{}_t", x), format!("i{}", x)),
+            (format!("uint{x}_t"), format!("u{x}")),
+            (format!("int{x}_t"), format!("i{x}")),
         ]
     }) {
         db.insert(TypeDetails::new(
@@ -470,10 +469,10 @@
     ));
 
     db.insert(TypeDetails::new(
-        "std::pin::Pin",
+        "core::pin::Pin",
         "Pin",
         Behavior::RustByValue, // because this is actually Pin<&something>
-        None,
+        Some("std::pin::Pin".to_string()),
         true,
         false,
     ));
@@ -481,18 +480,18 @@
     let mut insert_ctype = |cname: &str| {
         let concatenated_name = cname.replace(' ', "");
         db.insert(TypeDetails::new(
-            format!("autocxx::c_{}", concatenated_name),
+            format!("autocxx::c_{concatenated_name}"),
             cname,
             Behavior::CVariableLengthByValue,
-            Some(format!("std::os::raw::c_{}", concatenated_name)),
+            Some(format!("std::os::raw::c_{concatenated_name}")),
             true,
             true,
         ));
         db.insert(TypeDetails::new(
-            format!("autocxx::c_u{}", concatenated_name),
-            format!("unsigned {}", cname),
+            format!("autocxx::c_u{concatenated_name}"),
+            format!("unsigned {cname}"),
             Behavior::CVariableLengthByValue,
-            Some(format!("std::os::raw::c_u{}", concatenated_name)),
+            Some(format!("std::os::raw::c_u{concatenated_name}")),
             true,
             true,
         ));
@@ -553,10 +552,3 @@
     ));
     db
 }
-
-pub(crate) fn ensure_pointee_is_valid(ptr: &TypePtr) -> Result<(), ConvertError> {
-    match *ptr.elem {
-        Type::Path(..) => Ok(()),
-        _ => Err(ConvertError::InvalidPointee),
-    }
-}
diff --git a/engine/src/lib.rs b/engine/src/lib.rs
index 86a31ea..3988ab2 100644
--- a/engine/src/lib.rs
+++ b/engine/src/lib.rs
@@ -10,15 +10,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// This feature=nightly could be set by build.rs, but since we only care
-// about it for docs, we ask docs.rs to set it in the Cargo.toml.
-#![cfg_attr(feature = "nightly", feature(doc_cfg))]
 #![forbid(unsafe_code)]
+#![cfg_attr(feature = "nightly", feature(doc_cfg))]
 
 mod ast_discoverer;
 mod conversion;
 mod cxxbridge;
 mod known_types;
+mod minisyn;
 mod output_generators;
 mod parse_callbacks;
 mod parse_file;
@@ -28,6 +27,7 @@
 #[cfg(any(test, feature = "build"))]
 mod builder;
 
+use autocxx_bindgen::BindgenError;
 use autocxx_parser::{IncludeCppConfig, UnsafePolicy};
 use conversion::BridgeConverter;
 use miette::{SourceOffset, SourceSpan};
@@ -35,7 +35,9 @@
 use parse_file::CppBuildable;
 use proc_macro2::TokenStream as TokenStream2;
 use regex::Regex;
+use std::cell::RefCell;
 use std::path::PathBuf;
+use std::rc::Rc;
 use std::{
     fs::File,
     io::prelude::*,
@@ -113,7 +115,7 @@
 #[derive(Debug, Error, Diagnostic)]
 pub enum Error {
     #[error("Bindgen was unable to generate the initial .rs bindings for this file. This may indicate a parsing problem with the C++ headers.")]
-    Bindgen(()),
+    Bindgen(BindgenError),
     #[error(transparent)]
     #[diagnostic(transparent)]
     MacroParsing(LocatedSynError),
@@ -123,7 +125,10 @@
     #[error("no C++ include directory was provided.")]
     NoAutoCxxInc,
     #[error(transparent)]
+    #[diagnostic(transparent)]
     Conversion(conversion::ConvertError),
+    #[error("Using `unsafe_references_wrapped` requires the Rust nightly `arbitrary_self_types` feature")]
+    WrappedReferencesButNoArbitrarySelfTypes,
 }
 
 /// Result type.
@@ -142,6 +147,16 @@
     Generated(Box<GenerationResults>),
 }
 
+/// Code generation options.
+#[derive(Default)]
+pub struct CodegenOptions<'a> {
+    // An option used by the test suite to force a more convoluted
+    // route through our code, to uncover bugs.
+    pub force_wrapper_gen: bool,
+    /// Options about the C++ code generation.
+    pub cpp_codegen_options: CppCodegenOptions<'a>,
+}
+
 const AUTOCXX_CLANG_ARGS: &[&str; 4] = &["-x", "c++", "-std=c++14", "-DBINDGEN"];
 
 /// Implement to learn of header files which get included
@@ -254,6 +269,7 @@
 pub struct IncludeCppEngine {
     config: IncludeCppConfig,
     state: State,
+    source_code: Option<Rc<String>>, // so we can create diagnostics
 }
 
 impl Parse for IncludeCppEngine {
@@ -264,14 +280,31 @@
         } else {
             State::NotGenerated
         };
-        Ok(Self { config, state })
+        Ok(Self {
+            config,
+            state,
+            source_code: None,
+        })
     }
 }
 
 impl IncludeCppEngine {
-    pub fn new_from_syn(mac: Macro, file_contents: &str) -> Result<Self> {
-        mac.parse_body::<IncludeCppEngine>()
-            .map_err(|e| Error::MacroParsing(LocatedSynError::new(e, file_contents)))
+    pub fn new_from_syn(mac: Macro, file_contents: Rc<String>) -> Result<Self> {
+        let mut this = mac
+            .parse_body::<IncludeCppEngine>()
+            .map_err(|e| Error::MacroParsing(LocatedSynError::new(e, &file_contents)))?;
+        this.source_code = Some(file_contents);
+        Ok(this)
+    }
+
+    /// Used if we find that we're asked to auto-discover extern_rust_type and similar
+    /// but didn't have any include_cpp macro at all.
+    pub fn new_for_autodiscover() -> Self {
+        Self {
+            config: IncludeCppConfig::default(),
+            state: State::NotGenerated,
+            source_code: None,
+        }
     }
 
     pub fn config_mut(&mut self) -> &mut IncludeCppConfig {
@@ -287,7 +320,7 @@
             self.config
                 .inclusions
                 .iter()
-                .map(|path| format!("#include \"{}\"\n", path)),
+                .map(|path| format!("#include \"{path}\"\n")),
             "",
         )
     }
@@ -304,7 +337,11 @@
             .default_enum_style(bindgen::EnumVariation::Rust {
                 non_exhaustive: false,
             })
-            .rustfmt_bindings(log::log_enabled!(log::Level::Info))
+            .formatter(if log::log_enabled!(log::Level::Info) {
+                bindgen::Formatter::Rustfmt
+            } else {
+                bindgen::Formatter::None
+            })
             .size_t_is_usize(true)
             .enable_cxx_namespaces()
             .generate_inline_functions(true)
@@ -335,7 +372,7 @@
             builder
                 .command_line_flags()
                 .into_iter()
-                .map(|f| format!("\"{}\"", f))
+                .map(|f| format!("\"{f}\""))
                 .join(" ")
         );
         builder
@@ -370,7 +407,7 @@
         let bindings = bindings.to_string();
         // Manually add the mod ffi {} so that we can ask syn to parse
         // into a single construct.
-        let bindings = format!("mod bindgen {{ {} }}", bindings);
+        let bindings = format!("mod bindgen {{ {bindings} }}");
         info!("Bindings: {}", bindings);
         syn::parse_str::<ItemMod>(&bindings)
             .map_err(|e| Error::BindingsParsing(LocatedSynError::new(e, &bindings)))
@@ -386,7 +423,7 @@
         inc_dirs: Vec<PathBuf>,
         extra_clang_args: &[&str],
         dep_recorder: Option<Box<dyn RebuildDependencyRecorder>>,
-        cpp_codegen_options: &CppCodegenOptions,
+        codegen_options: &CodegenOptions,
     ) -> Result<()> {
         // If we are in parse only mode, do nothing. This is used for
         // doc tests to ensure the parsing is valid, but we can't expect
@@ -397,6 +434,14 @@
             State::Generated(_) => panic!("Only call generate once"),
         }
 
+        if matches!(
+            self.config.unsafe_policy,
+            UnsafePolicy::ReferencesWrappedAllFunctionsSafe
+        ) && !rustversion::cfg!(nightly)
+        {
+            return Err(Error::WrappedReferencesButNoArbitrarySelfTypes);
+        }
+
         let mod_name = self.config.get_mod_name();
         let mut builder = self.make_bindgen_builder(&inc_dirs, extra_clang_args);
         if let Some(dep_recorder) = dep_recorder {
@@ -411,6 +456,14 @@
         let bindings = builder.generate().map_err(Error::Bindgen)?;
         let bindings = self.parse_bindings(bindings)?;
 
+        // Source code contents just used for diagnostics - if we don't have it,
+        // use a blank string and miette will not attempt to annotate it nicely.
+        let source_file_contents = self
+            .source_code
+            .as_ref()
+            .cloned()
+            .unwrap_or_else(|| Rc::new("".to_string()));
+
         let converter = BridgeConverter::new(&self.config.inclusions, &self.config);
 
         let conversion = converter
@@ -418,7 +471,8 @@
                 bindings,
                 self.config.unsafe_policy.clone(),
                 header_contents,
-                cpp_codegen_options,
+                codegen_options,
+                &source_file_contents,
             )
             .map_err(Error::Conversion)?;
         let mut items = conversion.rs;
@@ -433,7 +487,7 @@
         new_bindings.content.as_mut().unwrap().1.append(&mut items);
         info!(
             "New bindings:\n{}",
-            rust_pretty_printer::pretty_print(&new_bindings.to_token_stream())
+            rust_pretty_printer::pretty_print(&new_bindings)
         );
         self.state = State::Generated(Box::new(GenerationResults {
             item_mod: new_bindings,
@@ -484,7 +538,7 @@
                 "header": header,
                 "config": config
             });
-            let f = File::create(&output_path).unwrap();
+            let f = File::create(output_path).unwrap();
             serde_json::to_writer(f, &json).unwrap();
         }
     }
@@ -505,12 +559,12 @@
         // to refer to local headers on the reduction machine too.
         let suffix = ALL_KNOWN_SYSTEM_HEADERS
             .iter()
-            .map(|hdr| format!("#include <{}>\n", hdr))
+            .map(|hdr| format!("#include <{hdr}>\n"))
             .join("\n");
         let input = format!("/*\nautocxx config:\n\n{:?}\n\nend autocxx config.\nautocxx preprocessed input:\n*/\n\n{}\n\n/* autocxx: extra headers added below for completeness. */\n\n{}\n{}\n",
             self.config, header, suffix, cxx_gen::HEADER);
         let mut tf = NamedTempFile::new().unwrap();
-        write!(tf, "{}", input).unwrap();
+        write!(tf, "{input}").unwrap();
         let tp = tf.into_temp_path();
         preprocess(&tp, &PathBuf::from(output_path), inc_dirs, extra_clang_args).unwrap();
     }
@@ -565,7 +619,11 @@
     })
 }
 
-pub(crate) fn strip_system_headers(input: Vec<u8>, suppress_system_headers: bool) -> Vec<u8> {
+pub fn get_cxx_header_bytes(suppress_system_headers: bool) -> Vec<u8> {
+    strip_system_headers(cxx_gen::HEADER.as_bytes().to_vec(), suppress_system_headers)
+}
+
+fn strip_system_headers(input: Vec<u8>, suppress_system_headers: bool) -> Vec<u8> {
     if suppress_system_headers {
         std::str::from_utf8(&input)
             .unwrap()
@@ -660,7 +718,7 @@
 
 impl Default for AutocxxgenHeaderNamer<'static> {
     fn default() -> Self {
-        Self(Box::new(|mod_name| format!("autocxxgen_{}.h", mod_name)))
+        Self(Box::new(|mod_name| format!("autocxxgen_{mod_name}.h")))
     }
 }
 
@@ -677,7 +735,27 @@
 
 impl Default for CxxgenHeaderNamer<'static> {
     fn default() -> Self {
-        Self(Box::new(|| "cxxgen.h".into()))
+        // The default implementation here is to name these headers
+        // cxxgen.h, cxxgen1.h, cxxgen2.h etc.
+        // These names are not especially predictable by callers and this
+        // behavior is not tested anywhere - so this is considered semi-
+        // supported, at best. This only comes into play in the rare case
+        // that you're generating bindings to multiple include_cpp!
+        // or a mix of include_cpp! and #[cxx::bridge] bindings.
+        let header_counter = Rc::new(RefCell::new(0));
+        Self(Box::new(move || {
+            let header_counter = header_counter.clone();
+            let header_counter_cell = header_counter.as_ref();
+            let mut header_counter = header_counter_cell.borrow_mut();
+            if *header_counter == 0 {
+                *header_counter += 1;
+                "cxxgen.h".into()
+            } else {
+                let count = *header_counter;
+                *header_counter += 1;
+                format!("cxxgen{count}.h")
+            }
+        }))
     }
 }
 
@@ -694,10 +772,10 @@
     /// You may wish to do this to make a hermetic test case with no
     /// external dependencies.
     pub suppress_system_headers: bool,
-    /// Optionally, a prefix to go at `#include "<here>cxx.h". This is a header file from the `cxx`
+    /// Optionally, a prefix to go at `#include "*here*cxx.h". This is a header file from the `cxx`
     /// crate.
     pub path_to_cxx_h: Option<String>,
-    /// Optionally, a prefix to go at `#include "<here>cxxgen.h". This is a header file which we
+    /// Optionally, a prefix to go at `#include "*here*cxxgen.h". This is a header file which we
     /// generate.
     pub path_to_cxxgen_h: Option<String>,
     /// Optionally, a function called to determine the name that will be used
@@ -720,7 +798,7 @@
     // miette.
     struct Err;
     let r: Result<(usize, usize), Err> = (|| {
-        let span_desc = format!("{:?}", span);
+        let span_desc = format!("{span:?}");
         let re = Regex::new(r"(\d+)..(\d+)").unwrap();
         let captures = re.captures(&span_desc).ok_or(Err)?;
         let start = captures.get(1).ok_or(Err)?;
diff --git a/engine/src/minisyn.rs b/engine/src/minisyn.rs
new file mode 100644
index 0000000..e675baa
--- /dev/null
+++ b/engine/src/minisyn.rs
@@ -0,0 +1,187 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Newtype wrappers for `syn` types implementing a different
+//! `Debug` implementation that results in more concise output.
+
+use std::fmt::Display;
+
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn::punctuated::{Pair, Punctuated};
+
+macro_rules! minisyn_no_parse {
+    ($syntype:ident) => {
+        /// Equivalent to the identically-named `syn` type except
+        /// that its `Debug` implementation is more concise.
+        #[derive(Clone, Hash, Eq, PartialEq)]
+        pub struct $syntype(pub ::syn::$syntype);
+        impl std::fmt::Debug for $syntype {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+                write!(f, "{}", self.0.to_token_stream().to_string())
+            }
+        }
+        impl ToTokens for $syntype
+        where
+            ::syn::$syntype: ToTokens,
+        {
+            fn to_tokens(&self, tokens: &mut TokenStream) {
+                self.0.to_tokens(tokens)
+            }
+
+            fn to_token_stream(&self) -> TokenStream {
+                self.0.to_token_stream()
+            }
+            fn into_token_stream(self) -> TokenStream
+            where
+                Self: Sized,
+            {
+                self.0.into_token_stream()
+            }
+        }
+        impl std::ops::Deref for $syntype {
+            type Target = ::syn::$syntype;
+            fn deref(&self) -> &Self::Target {
+                &self.0
+            }
+        }
+        impl std::ops::DerefMut for $syntype {
+            fn deref_mut(&mut self) -> &mut Self::Target {
+                &mut self.0
+            }
+        }
+        impl std::convert::From<::syn::$syntype> for $syntype {
+            fn from(inner: ::syn::$syntype) -> Self {
+                Self(inner)
+            }
+        }
+        impl std::convert::From<$syntype> for syn::$syntype {
+            fn from(inner: $syntype) -> Self {
+                inner.0
+            }
+        }
+    };
+}
+
+macro_rules! minisyn {
+    ($syntype:ident) => {
+        minisyn_no_parse!($syntype);
+
+        impl syn::parse::Parse for $syntype {
+            fn parse(input: syn::parse::ParseStream<'_>) -> syn::parse::Result<Self> {
+                syn::parse::Parse::parse(input).map(Self)
+            }
+        }
+    };
+}
+
+minisyn!(ItemMod);
+minisyn_no_parse!(Attribute);
+minisyn_no_parse!(AssocConst);
+minisyn_no_parse!(AssocType);
+minisyn!(Expr);
+minisyn!(ExprAssign);
+minisyn!(ExprAwait);
+minisyn!(ExprBinary);
+minisyn!(ExprBlock);
+minisyn!(ExprBreak);
+minisyn!(ExprConst);
+minisyn!(ExprCast);
+minisyn!(ExprField);
+minisyn_no_parse!(ExprGroup);
+minisyn!(ExprLet);
+minisyn!(ExprParen);
+minisyn!(ExprReference);
+minisyn!(ExprTry);
+minisyn!(ExprUnary);
+minisyn_no_parse!(Field);
+minisyn_no_parse!(Fields);
+minisyn!(ForeignItem);
+minisyn!(FnArg);
+minisyn!(GenericArgument);
+minisyn!(GenericParam);
+minisyn!(Ident);
+minisyn!(ImplItem);
+minisyn!(Item);
+minisyn!(ItemConst);
+minisyn!(ItemEnum);
+minisyn!(ItemForeignMod);
+minisyn!(ItemStruct);
+minisyn!(ItemType);
+minisyn!(ItemUse);
+minisyn!(LitBool);
+minisyn!(LitInt);
+minisyn!(Macro);
+minisyn_no_parse!(Pat);
+minisyn_no_parse!(PatType);
+minisyn_no_parse!(PatReference);
+minisyn_no_parse!(PatSlice);
+minisyn_no_parse!(PatTuple);
+minisyn!(Path);
+minisyn_no_parse!(PathArguments);
+minisyn!(PathSegment);
+minisyn!(Receiver);
+minisyn!(ReturnType);
+minisyn!(Signature);
+minisyn!(Stmt);
+minisyn!(TraitItem);
+minisyn!(Type);
+minisyn!(TypeArray);
+minisyn!(TypeGroup);
+minisyn!(TypeParamBound);
+minisyn!(TypeParen);
+minisyn!(TypePath);
+minisyn!(TypePtr);
+minisyn!(TypeReference);
+minisyn!(TypeSlice);
+minisyn!(Visibility);
+
+/// Converts a `syn::Punctuated` from being full of `syn` types to being
+/// full of `minisyn` types or vice-versa.
+pub(crate) fn minisynize_punctuated<T1, T2, S>(input: Punctuated<T1, S>) -> Punctuated<T2, S>
+where
+    T1: Into<T2>,
+{
+    input
+        .into_pairs()
+        .map(|p| match p {
+            Pair::Punctuated(t, p) => Pair::Punctuated(t.into(), p),
+            Pair::End(t) => Pair::End(t.into()),
+        })
+        .collect()
+}
+
+/// Converts a `Vec` from being full of `syn` types to being
+/// full of `minisyn` types or vice-versa.
+pub(crate) fn minisynize_vec<T1, T2>(input: Vec<T1>) -> Vec<T2>
+where
+    T1: Into<T2>,
+{
+    input.into_iter().map(Into::into).collect()
+}
+
+impl Ident {
+    pub(crate) fn new(string: &str, span: proc_macro2::Span) -> Self {
+        Self(syn::Ident::new(string, span))
+    }
+}
+
+impl Display for Ident {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.0.to_string())
+    }
+}
+
+impl<T> PartialEq<T> for Ident
+where
+    T: AsRef<str> + ?Sized,
+{
+    fn eq(&self, rhs: &T) -> bool {
+        self.0.eq(rhs)
+    }
+}
diff --git a/engine/src/output_generators.rs b/engine/src/output_generators.rs
index a862558..09c143a 100644
--- a/engine/src/output_generators.rs
+++ b/engine/src/output_generators.rs
@@ -19,7 +19,7 @@
 
 /// Creates an on-disk archive (actually a JSON file) of the Rust side of the bindings
 /// for multiple `include_cpp` macros. If you use this, you will want to tell
-/// `autocxx_macro` how to find this file using the `AUTOCXX_RS_ARCHIVE`
+/// `autocxx_macro` how to find this file using the `AUTOCXX_RS_JSON_ARCHIVE`
 /// environment variable.
 pub fn generate_rs_archive<'a>(rs_outputs: impl Iterator<Item = RsOutput<'a>>) -> String {
     let mut multi_bindings = MultiBindings::default();
diff --git a/engine/src/parse_file.rs b/engine/src/parse_file.rs
index 3571d19..16ea625 100644
--- a/engine/src/parse_file.rs
+++ b/engine/src/parse_file.rs
@@ -12,14 +12,15 @@
     cxxbridge::CxxBridge, Error as EngineError, GeneratedCpp, IncludeCppEngine,
     RebuildDependencyRecorder,
 };
-use crate::{CppCodegenOptions, LocatedSynError};
+use crate::{proc_macro_span_to_miette_span, CodegenOptions, CppCodegenOptions, LocatedSynError};
 use autocxx_parser::directive_names::SUBCLASS;
 use autocxx_parser::{AllowlistEntry, RustPath, Subclass, SubclassAttrs};
 use indexmap::set::IndexSet as HashSet;
-use miette::Diagnostic;
+use miette::{Diagnostic, SourceSpan};
 use quote::ToTokens;
 use std::{io::Read, path::PathBuf};
 use std::{panic::UnwindSafe, path::Path, rc::Rc};
+use syn::spanned::Spanned;
 use syn::{token::Brace, Item, ItemMod};
 use thiserror::Error;
 
@@ -27,7 +28,7 @@
 /// and interpret include_cxx macros.
 #[derive(Error, Diagnostic, Debug)]
 pub enum ParseError {
-    #[error("unable to open the source file: {0}")]
+    #[error("unable to open the source file containing your autocxx bindings. (This filename is usually specified within your build.rs file.): {0}")]
     FileOpen(std::io::Error),
     #[error("the .rs file couldn't be read: {0}")]
     FileRead(std::io::Error),
@@ -39,6 +40,8 @@
     #[error("the subclass attribute couldn't be parsed: {0}")]
     #[diagnostic(transparent)]
     SubclassSyntax(LocatedSynError),
+    #[error("the subclass attribute macro with a superclass attribute requires the Builder::auto_allowlist option to be specified (probably in your build script). This is not recommended - instead you can specify subclass! within your include_cpp!.")]
+    SubclassSuperclassWithoutAutoAllowlist(#[source_code] String, #[label("here")] SourceSpan),
     /// The include CPP macro could not be expanded into
     /// Rust bindings to C++, because of some problem during the conversion
     /// process. This could be anything from a C++ parsing error to some
@@ -52,8 +55,6 @@
     /// mod name.
     #[error("there are two or more include_cpp! mods with the same mod name")]
     ConflictingModNames,
-    #[error("dynamic discovery was enabled but no mod was found")]
-    ZeroModsForDynamicDiscovery,
     #[error("dynamic discovery was enabled but multiple mods were found")]
     MultipleModsForDynamicDiscovery,
     #[error("a problem occurred while discovering C++ APIs used within the Rust: {0}")]
@@ -87,12 +88,13 @@
         extra_superclasses: Vec<Subclass>,
         discoveries: Discoveries,
     }
+    let file_contents = Rc::new(file_contents.to_string());
     impl State {
         fn parse_item(
             &mut self,
             item: Item,
             mod_path: Option<RustPath>,
-            file_contents: &str,
+            file_contents: Rc<String>,
         ) -> Result<(), ParseError> {
             let result = match item {
                 Item::Macro(mac)
@@ -110,10 +112,9 @@
                     )
                 }
                 Item::Mod(itm)
-                    if itm
-                        .attrs
-                        .iter()
-                        .any(|attr| attr.path.to_token_stream().to_string() == "cxx :: bridge") =>
+                    if itm.attrs.iter().any(|attr| {
+                        attr.path().to_token_stream().to_string() == "cxx :: bridge"
+                    }) =>
                 {
                     Segment::Cxx(CxxBridge::from(itm))
                 }
@@ -128,7 +129,11 @@
                             Some(mod_path) => mod_path.append(itm.ident.clone()),
                         };
                         for item in items {
-                            mod_state.parse_item(item, Some(mod_path.clone()), file_contents)?
+                            mod_state.parse_item(
+                                item,
+                                Some(mod_path.clone()),
+                                file_contents.clone(),
+                            )?
                         }
                         self.extra_superclasses.extend(mod_state.extra_superclasses);
                         self.discoveries.extend(mod_state.discoveries);
@@ -146,26 +151,34 @@
                         Segment::Other(Item::Mod(itm))
                     }
                 }
-                Item::Struct(ref its) if self.auto_allowlist => {
+                Item::Struct(ref its) => {
                     let attrs = &its.attrs;
                     let is_superclass_attr = attrs.iter().find(|attr| {
-                        attr.path
+                        attr.path()
                             .segments
                             .last()
                             .map(|seg| seg.ident == "is_subclass" || seg.ident == SUBCLASS)
                             .unwrap_or(false)
                     });
                     if let Some(is_superclass_attr) = is_superclass_attr {
-                        if !is_superclass_attr.tokens.is_empty() {
+                        if is_superclass_attr.meta.require_path_only().is_err() {
                             let subclass = its.ident.clone();
                             let args: SubclassAttrs =
                                 is_superclass_attr.parse_args().map_err(|e| {
                                     ParseError::SubclassSyntax(LocatedSynError::new(
                                         e,
-                                        file_contents,
+                                        &file_contents,
                                     ))
                                 })?;
                             if let Some(superclass) = args.superclass {
+                                if !self.auto_allowlist {
+                                    return Err(
+                                        ParseError::SubclassSuperclassWithoutAutoAllowlist(
+                                            file_contents.to_string(),
+                                            proc_macro_span_to_miette_span(&its.span()),
+                                        ),
+                                    );
+                                }
                                 self.extra_superclasses.push(Subclass {
                                     superclass,
                                     subclass,
@@ -194,7 +207,7 @@
         ..Default::default()
     };
     for item in source.items {
-        state.parse_item(item, None, file_contents)?
+        state.parse_item(item, None, file_contents.clone())?
     }
     let State {
         auto_allowlist,
@@ -210,13 +223,18 @@
     // We do not want to enter this 'if' block unless the above conditions are true,
     // since we may emit errors.
     if must_handle_discovered_things {
+        // If we have to handle discovered things but there was no include_cpp! macro,
+        // fake one.
+        if !results.iter().any(|seg| matches!(seg, Segment::Autocxx(_))) {
+            results.push(Segment::Autocxx(IncludeCppEngine::new_for_autodiscover()));
+        }
         let mut autocxx_seg_iterator = results.iter_mut().filter_map(|seg| match seg {
             Segment::Autocxx(engine) => Some(engine),
             _ => None,
         });
         let our_seg = autocxx_seg_iterator.next();
         match our_seg {
-            None => return Err(ParseError::ZeroModsForDynamicDiscovery),
+            None => panic!("We should have just added a fake mod but apparently didn't"),
             Some(engine) => {
                 engine
                     .config_mut()
@@ -364,7 +382,7 @@
         autocxx_inc: Vec<PathBuf>,
         extra_clang_args: &[&str],
         dep_recorder: Option<Box<dyn RebuildDependencyRecorder>>,
-        cpp_codegen_options: &CppCodegenOptions,
+        codegen_options: &CodegenOptions,
     ) -> Result<(), ParseError> {
         let mut mods_found = HashSet::new();
         let inner_dep_recorder: Option<Rc<dyn RebuildDependencyRecorder>> =
@@ -386,7 +404,7 @@
                     autocxx_inc.clone(),
                     extra_clang_args,
                     dep_recorder,
-                    cpp_codegen_options,
+                    codegen_options,
                 )
                 .map_err(ParseError::AutocxxCodegenError)?
         }
diff --git a/engine/src/rust_pretty_printer.rs b/engine/src/rust_pretty_printer.rs
index 9c23cbc..7c9d36c 100644
--- a/engine/src/rust_pretty_printer.rs
+++ b/engine/src/rust_pretty_printer.rs
@@ -6,35 +6,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use proc_macro2::TokenStream;
-use std::io::Write;
-use std::process::{Command, Stdio};
+use syn::{Item, ItemMod};
 
-enum Error {
-    Run(std::io::Error),
-    Write(std::io::Error),
-    Utf8(std::string::FromUtf8Error),
-    Wait(std::io::Error),
-}
-
-pub(crate) fn pretty_print(ts: &TokenStream) -> String {
-    reformat_or_else(ts.to_string())
-}
-
-fn reformat_or_else(text: impl std::fmt::Display) -> String {
-    match reformat(&text) {
-        Ok(s) => s,
-        Err(_) => text.to_string(),
-    }
-}
-
-fn reformat(text: impl std::fmt::Display) -> Result<String, Error> {
-    let mut rustfmt = Command::new("rustfmt")
-        .stdin(Stdio::piped())
-        .stdout(Stdio::piped())
-        .spawn()
-        .map_err(Error::Run)?;
-    write!(rustfmt.stdin.take().unwrap(), "{}", text).map_err(Error::Write)?;
-    let output = rustfmt.wait_with_output().map_err(Error::Wait)?;
-    String::from_utf8(output.stdout).map_err(Error::Utf8)
+pub(crate) fn pretty_print(itm: &ItemMod) -> String {
+    prettyplease::unparse(&syn::File {
+        shebang: None,
+        attrs: Vec::new(),
+        items: vec![Item::Mod(itm.clone())],
+    })
 }
diff --git a/engine/src/types.rs b/engine/src/types.rs
index 337da14..f7eaae0 100644
--- a/engine/src/types.rs
+++ b/engine/src/types.rs
@@ -6,14 +6,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use crate::minisyn::Ident;
 use itertools::Itertools;
 use proc_macro2::Span;
 use quote::ToTokens;
 use std::iter::Peekable;
 use std::{fmt::Display, sync::Arc};
-use syn::{parse_quote, Ident, PathSegment, TypePath};
+use syn::{parse_quote, PathSegment, TypePath};
+use thiserror::Error;
 
-use crate::{conversion::ConvertError, known_types::known_types};
+use crate::known_types::known_types;
 
 pub(crate) fn make_ident<S: AsRef<str>>(id: S) -> Ident {
     Ident::new(id.as_ref(), Span::call_site())
@@ -52,11 +54,15 @@
     pub(crate) fn depth(&self) -> usize {
         self.0.len()
     }
+
+    pub(crate) fn to_cpp_path(&self) -> String {
+        self.0.join("::")
+    }
 }
 
 impl Display for Namespace {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&self.0.join("::"))
+        f.write_str(&self.to_cpp_path())
     }
 }
 
@@ -80,7 +86,7 @@
 /// either. It doesn't directly have functionality to convert
 /// from one to the other; `replace_type_path_without_arguments`
 /// does that.
-#[derive(Debug, PartialEq, PartialOrd, Eq, Hash, Clone)]
+#[derive(PartialEq, PartialOrd, Eq, Hash, Clone)]
 pub struct QualifiedName(Namespace, String);
 
 impl QualifiedName {
@@ -140,7 +146,7 @@
 
     /// cxx doesn't accept names containing double underscores,
     /// but these are OK elsewhere in our output mod.
-    pub(crate) fn validate_ok_for_cxx(&self) -> Result<(), ConvertError> {
+    pub(crate) fn validate_ok_for_cxx(&self) -> Result<(), InvalidIdentError> {
         validate_ident_ok_for_cxx(self.get_final_item())
     }
 
@@ -172,14 +178,6 @@
         }
     }
 
-    pub(crate) fn get_final_cpp_item(&self) -> String {
-        let special_cpp_name = known_types().special_cpp_name(self);
-        match special_cpp_name {
-            Some(name) => name,
-            None => self.1.to_string(),
-        }
-    }
-
     pub(crate) fn to_type_path(&self) -> TypePath {
         if let Some(known_type_path) = known_types().known_type_type_path(self) {
             known_type_path
@@ -228,26 +226,44 @@
     }
 }
 
+impl std::fmt::Debug for QualifiedName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(self, f)
+    }
+}
+
+/// Problems representing C++ identifiers in a way which is compatible with
+/// cxx.
+#[derive(Error, Clone, Debug)]
+pub enum InvalidIdentError {
+    #[error("Names containing __ are reserved by C++ so not acceptable to cxx")]
+    TooManyUnderscores,
+    #[error("bindgen decided to call this type _bindgen_ty_N because it couldn't deduce the correct name for it. That means we can't generate C++ bindings to it.")]
+    BindgenTy,
+    #[error("The item name '{0}' is a reserved word in Rust.")]
+    ReservedName(String),
+}
+
 /// cxx doesn't allow identifiers containing __. These are OK elsewhere
 /// in our output mod. It would be nice in future to think of a way we
 /// can enforce this using the Rust type system, e.g. a newtype
 /// wrapper for a CxxCompatibleIdent which is used in any context
 /// where code will be output as part of the `#[cxx::bridge]` mod.
-pub fn validate_ident_ok_for_cxx(id: &str) -> Result<(), ConvertError> {
+pub fn validate_ident_ok_for_cxx(id: &str) -> Result<(), InvalidIdentError> {
     validate_ident_ok_for_rust(id)?;
     if id.contains("__") {
-        Err(ConvertError::TooManyUnderscores)
+        Err(InvalidIdentError::TooManyUnderscores)
     } else if id.starts_with("_bindgen_ty_") {
-        Err(ConvertError::BindgenTy)
+        Err(InvalidIdentError::BindgenTy)
     } else {
         Ok(())
     }
 }
 
-pub fn validate_ident_ok_for_rust(label: &str) -> Result<(), ConvertError> {
+pub fn validate_ident_ok_for_rust(label: &str) -> Result<(), InvalidIdentError> {
     let id = make_ident(label);
     syn::parse2::<syn::Ident>(id.into_token_stream())
-        .map_err(|_| ConvertError::ReservedName(label.to_string()))
+        .map_err(|_| InvalidIdentError::ReservedName(label.to_string()))
         .map(|_| ())
 }