diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0b82cd9..3fafd9b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -54,7 +54,6 @@
   buck:
     name: Buck
     runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request'
     steps:
       - uses: actions/checkout@v2
       - uses: dtolnay/rust-toolchain@stable
@@ -81,7 +80,6 @@
   bazel:
     name: Bazel
     runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request'
     steps:
       - uses: actions/checkout@v2
       - name: Install Bazel
diff --git a/Android.bp b/Android.bp
index 05ef387..014c937 100644
--- a/Android.bp
+++ b/Android.bp
@@ -51,13 +51,6 @@
     ],
     shared_libs: ["libc++"],
     host_supported: true,
-    apex_available: [
-        "//apex_available:platform",
-        "com.android.bluetooth",
-        "com.android.compos",
-        "com.android.virt",
-    ],
-    min_sdk_version: "29",
 }
 
 cc_library_static {
@@ -67,11 +60,8 @@
     srcs: ["src/cxx.cc"],
     apex_available: [
         "//apex_available:platform",
-        "com.android.bluetooth",
-        "com.android.compos",
-        "com.android.virt",
+        "com.android.bluetooth.updatable",
     ],
-    min_sdk_version: "29",
 }
 
 cc_library_static {
diff --git a/BUCK b/BUCK
index 86174e9..da6fcb2 100644
--- a/BUCK
+++ b/BUCK
@@ -25,19 +25,19 @@
 cxx_library(
     name = "core",
     srcs = ["src/cxx.cc"],
+    visibility = ["PUBLIC"],
+    header_namespace = "rust",
     exported_headers = {
         "cxx.h": "include/cxx.h",
     },
     exported_linker_flags = ["-lstdc++"],
-    header_namespace = "rust",
-    visibility = ["PUBLIC"],
 )
 
 rust_library(
     name = "macro",
     srcs = glob(["macro/src/**"]),
-    crate = "cxxbridge_macro",
     proc_macro = True,
+    crate = "cxxbridge_macro",
     deps = [
         "//third-party:proc-macro2",
         "//third-party:quote",
diff --git a/BUILD b/BUILD
index c2c2edf..24a1c8b 100644
--- a/BUILD
+++ b/BUILD
@@ -1,5 +1,5 @@
 load("@rules_cc//cc:defs.bzl", "cc_library")
-load("@rules_rust//rust:rust.bzl", "rust_binary", "rust_library")
+load("//tools/bazel:rust.bzl", "rust_binary", "rust_library")
 
 rust_library(
     name = "cxx",
diff --git a/Cargo.toml b/Cargo.toml
index 0414c72..e2b189e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cxx"
-version = "1.0.54" # remember to update html_root_url
+version = "1.0.42" # remember to update html_root_url
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 edition = "2018"
 links = "cxxbridge1"
@@ -21,15 +21,15 @@
 "c++20" = ["cxxbridge-flags/c++20"]
 
 [dependencies]
-cxxbridge-macro = { version = "=1.0.54", path = "macro" }
+cxxbridge-macro = { version = "=1.0.42", path = "macro" }
 link-cplusplus = "1.0"
 
 [build-dependencies]
 cc = "1.0.49"
-cxxbridge-flags = { version = "=1.0.54", path = "flags", default-features = false }
+cxxbridge-flags = { version = "=1.0.42", path = "flags", default-features = false }
 
 [dev-dependencies]
-cxx-build = { version = "=1.0.54", path = "gen/build" }
+cxx-build = { version = "=1.0.42", path = "gen/build" }
 cxx-gen = { version = "0.7", path = "gen/lib" }
 cxx-test-suite = { version = "0", path = "tests/ffi" }
 rustversion = "1.0"
diff --git a/METADATA b/METADATA
index 85611d6..2b3490c 100644
--- a/METADATA
+++ b/METADATA
@@ -1,5 +1,7 @@
 name: "cxx"
-description: "Safe interop between Rust and C++"
+description:
+    "Safe interop between Rust and C++"
+
 third_party {
   url {
     type: HOMEPAGE
@@ -9,11 +11,7 @@
     type: GIT
     value: "https://github.com/dtolnay/cxx.git"
   }
-  version: "36d9ac1fab726e14305ce1919ebf8a3d64949d30"
+  version: "4ab117115718908768df8366ac130bbbb3478331"
+  last_upgrade_date { year: 2021 month: 2 day: 17 }
   license_type: NOTICE
-  last_upgrade_date {
-    year: 2021
-    month: 9
-    day: 23
-  }
 }
diff --git a/WORKSPACE b/WORKSPACE
index 08aacf2..17a0af5 100644
--- a/WORKSPACE
+++ b/WORKSPACE
@@ -1,30 +1,26 @@
 workspace(name = "cxx.rs")
 
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("//tools/bazel:vendor.bzl", "vendor")
 
 http_archive(
     name = "rules_rust",
-    sha256 = "697a6f4f2adbd1b00f792346d6eca4cd45f691be63069c7d7ebf4fcf82a377a8",
-    strip_prefix = "rules_rust-8bad4c5e4e53d9f6f8d4d5228e26a44d92f37ab2",
+    sha256 = "e6d835ee673f388aa5b62dc23d82db8fc76497e93fa47d8a4afe97abaf09b10d",
+    strip_prefix = "rules_rust-f37b9d6a552e9412285e627f30cb124e709f4f7a",
     urls = [
-        # Master branch as of 2021-04-11
-        "https://github.com/bazelbuild/rules_rust/archive/8bad4c5e4e53d9f6f8d4d5228e26a44d92f37ab2.tar.gz",
+        # Master branch as of 2021-01-27
+        "https://github.com/bazelbuild/rules_rust/archive/f37b9d6a552e9412285e627f30cb124e709f4f7a.tar.gz",
     ],
 )
 
 load("@rules_rust//rust:repositories.bzl", "rust_repositories")
 
-RUST_VERSION = "1.54.0"
-
 rust_repositories(
     edition = "2018",
-    version = RUST_VERSION,
+    version = "1.50.0",
 )
 
-load("//tools/bazel:vendor.bzl", "vendor")
-
 vendor(
     name = "third-party",
     lockfile = "//third-party:Cargo.lock",
-    cargo_version = RUST_VERSION,
 )
diff --git a/book/src/binding/str.md b/book/src/binding/str.md
index 9c1e0a7..a4820aa 100644
--- a/book/src/binding/str.md
+++ b/book/src/binding/str.md
@@ -30,7 +30,6 @@
   const char *data() const noexcept;
   size_t size() const noexcept;
   size_t length() const noexcept;
-  bool empty() const noexcept;
 
   using iterator = const char *;
   using const_iterator = const char *;
diff --git a/book/src/binding/string.md b/book/src/binding/string.md
index d564e00..a7d0790 100644
--- a/book/src/binding/string.md
+++ b/book/src/binding/string.md
@@ -23,10 +23,6 @@
   String(const char *);
   String(const char *, size_t);
 
-  // Throws std::invalid_argument if not utf-16.
-  String(const char16_t *);
-  String(const char16_t *, size_t);
-
   String &operator=(const String &) noexcept;
   String &operator=(String &&) noexcept;
 
@@ -36,13 +32,9 @@
   const char *data() const noexcept;
   size_t size() const noexcept;
   size_t length() const noexcept;
-  bool empty() const noexcept;
 
   const char *c_str() noexcept;
 
-  size_t capacity() const noexcept;
-  void reserve(size_t new_cap) noexcept;
-
   using iterator = char *;
   iterator begin() noexcept;
   iterator end() noexcept;
diff --git a/book/src/build/bazel.md b/book/src/build/bazel.md
index 8f91055..08edb19 100644
--- a/book/src/build/bazel.md
+++ b/book/src/build/bazel.md
@@ -70,7 +70,7 @@
 # demo/BUILD
 
 load("@rules_cc//cc:defs.bzl", "cc_library")
-load("@rules_rust//rust:rust.bzl", "rust_binary")
+load("//tools/bazel:rust.bzl", "rust_binary")
 load("//tools/bazel:rust_cxx_bridge.bzl", "rust_cxx_bridge")
 
 rust_binary(
diff --git a/book/src/build/cmake.md b/book/src/build/cmake.md
index 4b50746..ed3cb61 100644
--- a/book/src/build/cmake.md
+++ b/book/src/build/cmake.md
@@ -22,10 +22,3 @@
   - Tested on Windows 10 with MSVC, and on Linux
 
 ---
-
-- **<https://github.com/trondhe/rusty_cmake>**
-
-  - Alias target that can be linked into a C++ project
-  - Tested on Windows 10 with GNU target, and on Linux
-
----
diff --git a/build.rs b/build.rs
index a953639..f799441 100644
--- a/build.rs
+++ b/build.rs
@@ -28,12 +28,6 @@
                 rustc.version,
             );
         }
-
-        if rustc.minor < 52 {
-            // #![deny(unsafe_op_in_unsafe_fn)].
-            // https://github.com/rust-lang/rust/issues/71668
-            println!("cargo:rustc-cfg=no_unsafe_op_in_unsafe_fn_lint");
-        }
     }
 }
 
diff --git a/demo/BUILD b/demo/BUILD
index 4ab5ecb..cce8119 100644
--- a/demo/BUILD
+++ b/demo/BUILD
@@ -1,5 +1,5 @@
 load("@rules_cc//cc:defs.bzl", "cc_library")
-load("@rules_rust//rust:rust.bzl", "rust_binary")
+load("//tools/bazel:rust.bzl", "rust_binary")
 load("//tools/bazel:rust_cxx_bridge.bzl", "rust_cxx_bridge")
 
 rust_binary(
diff --git a/flags/Cargo.toml b/flags/Cargo.toml
index baf1157..87c796c 100644
--- a/flags/Cargo.toml
+++ b/flags/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cxxbridge-flags"
-version = "1.0.54"
+version = "1.0.42"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
diff --git a/gen/build/Cargo.toml b/gen/build/Cargo.toml
index 393fc1c..33f17df 100644
--- a/gen/build/Cargo.toml
+++ b/gen/build/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cxx-build"
-version = "1.0.54"
+version = "1.0.42"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
@@ -21,7 +21,7 @@
 proc-macro2 = { version = "1.0.26", default-features = false, features = ["span-locations"] }
 quote = { version = "1.0", default-features = false }
 scratch = "1.0"
-syn = { version = "1.0.70", default-features = false, features = ["parsing", "printing", "clone-impls", "full"] }
+syn = { version = "1.0.68", default-features = false, features = ["parsing", "printing", "clone-impls", "full"] }
 
 [dev-dependencies]
 cxx-gen = { version = "0.7", path = "../lib" }
diff --git a/gen/build/src/lib.rs b/gen/build/src/lib.rs
index b8a463c..63b2cf6 100644
--- a/gen/build/src/lib.rs
+++ b/gen/build/src/lib.rs
@@ -51,7 +51,6 @@
     clippy::doc_markdown,
     clippy::drop_copy,
     clippy::enum_glob_use,
-    clippy::if_same_then_else,
     clippy::inherent_to_string,
     clippy::items_after_statements,
     clippy::let_underscore_drop,
diff --git a/gen/cmd/Cargo.toml b/gen/cmd/Cargo.toml
index 4b3a299..7db0206 100644
--- a/gen/cmd/Cargo.toml
+++ b/gen/cmd/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cxxbridge-cmd"
-version = "1.0.54"
+version = "1.0.42"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
@@ -20,7 +20,7 @@
 codespan-reporting = "0.11"
 proc-macro2 = { version = "1.0.26", default-features = false, features = ["span-locations"] }
 quote = { version = "1.0", default-features = false }
-syn = { version = "1.0.70", default-features = false, features = ["parsing", "printing", "clone-impls", "full"] }
+syn = { version = "1.0.68", default-features = false, features = ["parsing", "printing", "clone-impls", "full"] }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
diff --git a/gen/cmd/src/main.rs b/gen/cmd/src/main.rs
index 1c15db6..f419dad 100644
--- a/gen/cmd/src/main.rs
+++ b/gen/cmd/src/main.rs
@@ -3,7 +3,6 @@
     clippy::cognitive_complexity,
     clippy::default_trait_access,
     clippy::enum_glob_use,
-    clippy::if_same_then_else,
     clippy::inherent_to_string,
     clippy::items_after_statements,
     clippy::large_enum_variant,
diff --git a/gen/lib/Cargo.toml b/gen/lib/Cargo.toml
index 37d8168..ff33d97 100644
--- a/gen/lib/Cargo.toml
+++ b/gen/lib/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cxx-gen"
-version = "0.7.54"
+version = "0.7.42"
 authors = ["Adrian Taylor <adetaylor@chromium.org>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
@@ -15,7 +15,7 @@
 codespan-reporting = "0.11"
 proc-macro2 = { version = "1.0.26", default-features = false, features = ["span-locations"] }
 quote = { version = "1.0", default-features = false }
-syn = { version = "1.0.70", default-features = false, features = ["parsing", "printing", "clone-impls", "full"] }
+syn = { version = "1.0.68", default-features = false, features = ["parsing", "printing", "clone-impls", "full"] }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
diff --git a/gen/lib/src/lib.rs b/gen/lib/src/lib.rs
index 411953b..e3eca5e 100644
--- a/gen/lib/src/lib.rs
+++ b/gen/lib/src/lib.rs
@@ -12,7 +12,6 @@
     clippy::cast_sign_loss,
     clippy::default_trait_access,
     clippy::enum_glob_use,
-    clippy::if_same_then_else,
     clippy::inherent_to_string,
     clippy::items_after_statements,
     clippy::match_bool,
diff --git a/gen/src/builtin.rs b/gen/src/builtin.rs
index 7ac9209..eaaa08d 100644
--- a/gen/src/builtin.rs
+++ b/gen/src/builtin.rs
@@ -30,7 +30,6 @@
     pub relocatable: bool,
     pub friend_impl: bool,
     pub is_complete: bool,
-    pub destroy: bool,
     pub deleter_if: bool,
     pub content: Content<'a>,
 }
@@ -335,14 +334,6 @@
         writeln!(out, "}};");
     }
 
-    if builtin.destroy {
-        out.next_section();
-        writeln!(out, "template <typename T>");
-        writeln!(out, "void destroy(T *ptr) {{");
-        writeln!(out, "  ptr->~T();");
-        writeln!(out, "}}");
-    }
-
     if builtin.deleter_if {
         out.next_section();
         writeln!(out, "template <bool> struct deleter_if {{");
diff --git a/gen/src/check.rs b/gen/src/check.rs
index 15add20..35929ad 100644
--- a/gen/src/check.rs
+++ b/gen/src/check.rs
@@ -4,7 +4,7 @@
 use quote::{quote, quote_spanned};
 use std::path::{Component, Path};
 
-pub(super) use crate::syntax::check::{typecheck, Generator};
+pub(super) use crate::syntax::check::typecheck;
 
 pub(super) fn precheck(cx: &mut Errors, apis: &[Api], opt: &Opt) {
     if !opt.allow_dot_includes {
diff --git a/gen/src/error.rs b/gen/src/error.rs
index 3672e26..2c8287f 100644
--- a/gen/src/error.rs
+++ b/gen/src/error.rs
@@ -87,11 +87,12 @@
 
     impl<E: StdError> Display for Report<E> {
         fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            write!(formatter, "{}", self.0)?;
+            Display::fmt(&self.0, formatter)?;
             let mut error: &dyn StdError = &self.0;
 
             while let Some(cause) = error.source() {
-                write!(formatter, "\n\nCaused by:\n    {}", cause)?;
+                formatter.write_str("\n\nCaused by:\n    ")?;
+                Display::fmt(cause, formatter)?;
                 error = cause;
             }
 
diff --git a/gen/src/mod.rs b/gen/src/mod.rs
index d8b90d0..3d12c71 100644
--- a/gen/src/mod.rs
+++ b/gen/src/mod.rs
@@ -130,8 +130,7 @@
     let ref types = Types::collect(errors, apis);
     check::precheck(errors, apis, opt);
     errors.propagate()?;
-    let generator = check::Generator::Build;
-    check::typecheck(errors, apis, types, generator);
+    check::typecheck(errors, apis, types);
     errors.propagate()?;
 
     // Some callers may wish to generate both header and implementation from the
diff --git a/gen/src/write.rs b/gen/src/write.rs
index a3b9c9f..9f9c039 100644
--- a/gen/src/write.rs
+++ b/gen/src/write.rs
@@ -9,8 +9,8 @@
 use crate::syntax::symbol::Symbol;
 use crate::syntax::trivial::{self, TrivialReason};
 use crate::syntax::{
-    derive, mangle, Api, Doc, Enum, EnumRepr, ExternFn, ExternType, Pair, Signature, Struct, Trait,
-    Type, TypeAlias, Types, Var,
+    derive, mangle, Api, Enum, ExternFn, ExternType, Pair, Signature, Struct, Trait, Type,
+    TypeAlias, Types, Var,
 };
 use proc_macro2::Ident;
 
@@ -101,10 +101,10 @@
             }
             Api::Enum(enm) => {
                 out.next_section();
-                if !out.types.cxx.contains(&enm.name.rust) {
-                    write_enum(out, enm);
-                } else if !enm.variants_from_header {
+                if out.types.cxx.contains(&enm.name.rust) {
                     check_enum(out, enm);
+                } else {
+                    write_enum(out, enm);
                 }
             }
             Api::RustType(ety) => {
@@ -249,24 +249,14 @@
         writeln!(out, "{};", field.name.cxx);
     }
 
-    out.next_section();
+    writeln!(out);
 
     for method in methods {
-        if !method.doc.is_empty() {
-            out.next_section();
-        }
-        for line in method.doc.to_string().lines() {
-            writeln!(out, "  //{}", line);
-        }
         write!(out, "  ");
         let sig = &method.sig;
         let local_name = method.name.cxx.to_string();
-        let indirect_call = false;
-        write_rust_function_shim_decl(out, &local_name, sig, indirect_call);
+        write_rust_function_shim_decl(out, &local_name, sig, false);
         writeln!(out, ";");
-        if !method.doc.is_empty() {
-            out.next_section();
-        }
     }
 
     if operator_eq {
@@ -317,12 +307,8 @@
 }
 
 fn write_enum_decl(out: &mut OutFile, enm: &Enum) {
-    let repr = match &enm.repr {
-        EnumRepr::Foreign { .. } => return,
-        EnumRepr::Native { atom, .. } => *atom,
-    };
     write!(out, "enum class {} : ", enm.name.cxx);
-    write_atom(out, repr);
+    write_atom(out, enm.repr);
     writeln!(out, ";");
 }
 
@@ -346,22 +332,12 @@
         ety.name.cxx,
     );
 
-    for (i, method) in methods.iter().enumerate() {
-        if i > 0 && !method.doc.is_empty() {
-            out.next_section();
-        }
-        for line in method.doc.to_string().lines() {
-            writeln!(out, "  //{}", line);
-        }
+    for method in methods {
         write!(out, "  ");
         let sig = &method.sig;
         let local_name = method.name.cxx.to_string();
-        let indirect_call = false;
-        write_rust_function_shim_decl(out, &local_name, sig, indirect_call);
+        write_rust_function_shim_decl(out, &local_name, sig, false);
         writeln!(out, ";");
-        if !method.doc.is_empty() {
-            out.next_section();
-        }
     }
 
     writeln!(out, "  ~{}() = delete;", ety.name.cxx);
@@ -380,10 +356,6 @@
 }
 
 fn write_enum<'a>(out: &mut OutFile<'a>, enm: &'a Enum) {
-    let repr = match &enm.repr {
-        EnumRepr::Foreign { .. } => return,
-        EnumRepr::Native { atom, .. } => *atom,
-    };
     out.set_namespace(&enm.name.namespace);
     let guard = format!("CXXBRIDGE1_ENUM_{}", enm.name.to_symbol());
     writeln!(out, "#ifndef {}", guard);
@@ -392,7 +364,7 @@
         writeln!(out, "//{}", line);
     }
     write!(out, "enum class {} : ", enm.name.cxx);
-    write_atom(out, repr);
+    write_atom(out, enm.repr);
     writeln!(out, " {{");
     for variant in &enm.variants {
         for line in variant.doc.to_string().lines() {
@@ -405,10 +377,6 @@
 }
 
 fn check_enum<'a>(out: &mut OutFile<'a>, enm: &'a Enum) {
-    let repr = match &enm.repr {
-        EnumRepr::Foreign { .. } => return,
-        EnumRepr::Native { atom, .. } => *atom,
-    };
     out.set_namespace(&enm.name.namespace);
     out.include.type_traits = true;
     writeln!(
@@ -417,11 +385,11 @@
         enm.name.cxx,
     );
     write!(out, "static_assert(sizeof({}) == sizeof(", enm.name.cxx);
-    write_atom(out, repr);
+    write_atom(out, enm.repr);
     writeln!(out, "), \"incorrect size\");");
     for variant in &enm.variants {
         write!(out, "static_assert(static_cast<");
-        write_atom(out, repr);
+        write_atom(out, enm.repr);
         writeln!(
             out,
             ">({}::{}) == {}, \"disagrees with the value in #[cxx::bridge]\");",
@@ -856,8 +824,7 @@
 
     out.next_section();
     let c_trampoline = mangle::c_trampoline(efn, var, out.types).to_string();
-    let doc = Doc::new();
-    write_rust_function_shim_impl(out, &c_trampoline, f, &doc, &r_trampoline, indirect_call);
+    write_rust_function_shim_impl(out, &c_trampoline, f, &r_trampoline, indirect_call);
 }
 
 fn write_rust_function_decl<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) {
@@ -927,6 +894,9 @@
 
 fn write_rust_function_shim<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) {
     out.set_namespace(&efn.name.namespace);
+    for line in efn.doc.to_string().lines() {
+        writeln!(out, "//{}", line);
+    }
     let local_name = match &efn.sig.receiver {
         None => efn.name.cxx.to_string(),
         Some(receiver) => format!(
@@ -935,10 +905,9 @@
             efn.name.cxx,
         ),
     };
-    let doc = &efn.doc;
     let invoke = mangle::extern_fn(efn, out.types);
     let indirect_call = false;
-    write_rust_function_shim_impl(out, &local_name, efn, doc, &invoke, indirect_call);
+    write_rust_function_shim_impl(out, &local_name, efn, &invoke, indirect_call);
 }
 
 fn write_rust_function_shim_decl(
@@ -978,7 +947,6 @@
     out: &mut OutFile,
     local_name: &str,
     sig: &Signature,
-    doc: &Doc,
     invoke: &Symbol,
     indirect_call: bool,
 ) {
@@ -986,12 +954,6 @@
         // We've already defined this inside the struct.
         return;
     }
-    if sig.receiver.is_none() {
-        // Member functions already documented at their declaration.
-        for line in doc.to_string().lines() {
-            writeln!(out, "//{}", line);
-        }
-    }
     write_rust_function_shim_decl(out, local_name, sig, indirect_call);
     if out.header {
         writeln!(out, ";");
@@ -1467,7 +1429,7 @@
     );
     writeln!(
         out,
-        "void cxxbridge1$rust_vec${}$reserve_total(::rust::Vec<{}> *ptr, ::std::size_t new_cap) noexcept;",
+        "void cxxbridge1$rust_vec${}$reserve_total(::rust::Vec<{}> *ptr, ::std::size_t cap) noexcept;",
         instance, inner,
     );
     writeln!(
@@ -1562,12 +1524,12 @@
     begin_function_definition(out);
     writeln!(
         out,
-        "void Vec<{}>::reserve_total(::std::size_t new_cap) noexcept {{",
+        "void Vec<{}>::reserve_total(::std::size_t cap) noexcept {{",
         inner,
     );
     writeln!(
         out,
-        "  return cxxbridge1$rust_vec${}$reserve_total(this, new_cap);",
+        "  return cxxbridge1$rust_vec${}$reserve_total(this, cap);",
         instance,
     );
     writeln!(out, "}}");
@@ -1604,7 +1566,11 @@
         // know at code generation time, so we generate both C++ and Rust side
         // bindings for a "new" method anyway. But the Rust code can't be called
         // for Opaque types because the 'new' method is not implemented.
-        UniquePtr::Ident(ident) => out.types.is_maybe_trivial(ident),
+        UniquePtr::Ident(ident) => {
+            out.types.structs.contains_key(ident)
+                || out.types.enums.contains_key(ident)
+                || out.types.aliases.contains_key(ident)
+        }
         UniquePtr::CxxVector(_) => false,
     };
 
@@ -1712,7 +1678,9 @@
     // know at code generation time, so we generate both C++ and Rust side
     // bindings for a "new" method anyway. But the Rust code can't be called for
     // Opaque types because the 'new' method is not implemented.
-    let can_construct_from_value = out.types.is_maybe_trivial(ident);
+    let can_construct_from_value = out.types.structs.contains_key(ident)
+        || out.types.enums.contains_key(ident)
+        || out.types.aliases.contains_key(ident);
 
     writeln!(
         out,
@@ -1835,8 +1803,6 @@
     let instance = element.to_mangled(out.types);
 
     out.include.cstddef = true;
-    out.include.utility = true;
-    out.builtin.destroy = true;
 
     writeln!(
         out,
@@ -1845,7 +1811,6 @@
     );
     writeln!(out, "  return s.size();");
     writeln!(out, "}}");
-
     writeln!(
         out,
         "{} *cxxbridge1$std$vector${}$get_unchecked(::std::vector<{}> *s, ::std::size_t pos) noexcept {{",
@@ -1854,26 +1819,6 @@
     writeln!(out, "  return &(*s)[pos];");
     writeln!(out, "}}");
 
-    if out.types.is_maybe_trivial(element) {
-        writeln!(
-            out,
-            "void cxxbridge1$std$vector${}$push_back(::std::vector<{}> *v, {} *value) noexcept {{",
-            instance, inner, inner,
-        );
-        writeln!(out, "  v->push_back(::std::move(*value));");
-        writeln!(out, "  ::rust::destroy(value);");
-        writeln!(out, "}}");
-
-        writeln!(
-            out,
-            "void cxxbridge1$std$vector${}$pop_back(::std::vector<{}> *v, {} *out) noexcept {{",
-            instance, inner, inner,
-        );
-        writeln!(out, "  ::new (out) {}(::std::move(v->back()));", inner);
-        writeln!(out, "  v->pop_back();");
-        writeln!(out, "}}");
-    }
-
     out.include.memory = true;
     write_unique_ptr_common(out, UniquePtr::CxxVector(element));
 }
diff --git a/include/cxx.h b/include/cxx.h
index dffcb01..cdc63fb 100644
--- a/include/cxx.h
+++ b/include/cxx.h
@@ -43,8 +43,6 @@
   String(const std::string &);
   String(const char *);
   String(const char *, std::size_t);
-  String(const char16_t *);
-  String(const char16_t *, std::size_t);
 
   String &operator=(const String &) &noexcept;
   String &operator=(String &&) &noexcept;
@@ -55,13 +53,9 @@
   const char *data() const noexcept;
   std::size_t size() const noexcept;
   std::size_t length() const noexcept;
-  bool empty() const noexcept;
 
   const char *c_str() noexcept;
 
-  std::size_t capacity() const noexcept;
-  void reserve(size_t new_cap) noexcept;
-
   using iterator = char *;
   iterator begin() noexcept;
   iterator end() noexcept;
@@ -111,7 +105,6 @@
   const char *data() const noexcept;
   std::size_t size() const noexcept;
   std::size_t length() const noexcept;
-  bool empty() const noexcept;
 
   // Important in order for System V ABI to pass in registers.
   Str(const Str &) noexcept = default;
@@ -341,7 +334,7 @@
   Vec(unsafe_bitcopy_t, const Vec &) noexcept;
 
 private:
-  void reserve_total(std::size_t new_cap) noexcept;
+  void reserve_total(std::size_t cap) noexcept;
   void set_len(std::size_t len) noexcept;
   void drop() noexcept;
 
@@ -482,7 +475,7 @@
 #define CXXBRIDGE1_RUST_FN
 template <typename Ret, typename... Args>
 Ret Fn<Ret(Args...)>::operator()(Args... args) const noexcept {
-  return (*this->trampoline)(std::forward<Args>(args)..., this->fn);
+  return (*this->trampoline)(std::move(args)..., this->fn);
 }
 
 template <typename Ret, typename... Args>
@@ -543,8 +536,8 @@
 template <typename T>
 T &Slice<T>::operator[](std::size_t n) const noexcept {
   assert(n < this->size());
-  auto ptr = static_cast<char *>(slicePtr(this)) + size_of<T>() * n;
-  return *reinterpret_cast<T *>(ptr);
+  auto pos = static_cast<char *>(slicePtr(this)) + size_of<T>() * n;
+  return *reinterpret_cast<T *>(pos);
 }
 
 template <typename T>
@@ -582,8 +575,8 @@
 template <typename T>
 typename Slice<T>::iterator::reference Slice<T>::iterator::operator[](
     typename Slice<T>::iterator::difference_type n) const noexcept {
-  auto ptr = static_cast<char *>(this->pos) + this->stride * n;
-  return *reinterpret_cast<T *>(ptr);
+  auto pos = static_cast<char *>(this->pos) + this->stride * n;
+  return *reinterpret_cast<T *>(pos);
 }
 
 template <typename T>
diff --git a/macro/Cargo.toml b/macro/Cargo.toml
index 65f15c3..a3df101 100644
--- a/macro/Cargo.toml
+++ b/macro/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cxxbridge-macro"
-version = "1.0.54"
+version = "1.0.42"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
@@ -14,20 +14,10 @@
 [lib]
 proc-macro = true
 
-[features]
-experimental = ["clang-ast", "flate2", "memmap", "serde", "serde_json"]
-
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0.4"
-syn = { version = "1.0.70", features = ["full"] }
-
-# optional dependencies
-clang-ast = { version = "0.1", optional = true }
-flate2 = { version = "1.0", optional = true }
-memmap = { version = "0.7", optional = true }
-serde = { version = "1.0", optional = true, features = ["derive"] }
-serde_json = { version = "1.0", optional = true }
+syn = { version = "1.0.68", features = ["full"] }
 
 [dev-dependencies]
 cxx = { version = "1.0", path = ".." }
diff --git a/macro/src/clang.rs b/macro/src/clang.rs
deleted file mode 100644
index 099d5a6..0000000
--- a/macro/src/clang.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-pub type Node = clang_ast::Node<Clang>;
-
-#[derive(Deserialize, Serialize)]
-pub enum Clang {
-    NamespaceDecl(NamespaceDecl),
-    EnumDecl(EnumDecl),
-    EnumConstantDecl(EnumConstantDecl),
-    ImplicitCastExpr,
-    ConstantExpr(ConstantExpr),
-    Unknown,
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct NamespaceDecl {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub name: Option<Box<str>>,
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct EnumDecl {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub name: Option<Box<str>>,
-    #[serde(
-        rename = "fixedUnderlyingType",
-        skip_serializing_if = "Option::is_none"
-    )]
-    pub fixed_underlying_type: Option<Type>,
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct EnumConstantDecl {
-    pub name: Box<str>,
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct ConstantExpr {
-    pub value: Box<str>,
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct Type {
-    #[serde(rename = "qualType")]
-    pub qual_type: Box<str>,
-    #[serde(rename = "desugaredQualType", skip_serializing_if = "Option::is_none")]
-    pub desugared_qual_type: Option<Box<str>>,
-}
-
-#[cfg(all(test, target_pointer_width = "64"))]
-const _: [(); std::mem::size_of::<Node>()] = [(); 88];
diff --git a/macro/src/derive.rs b/macro/src/derive.rs
index ea36e3e..2f77095 100644
--- a/macro/src/derive.rs
+++ b/macro/src/derive.rs
@@ -151,7 +151,6 @@
     let fields = strct.fields.iter().map(|field| &field.name.rust);
 
     quote_spanned! {span=>
-        #[allow(clippy::derivable_impls)] // different spans than the derived impl
         impl #generics ::std::default::Default for #ident #generics {
             fn default() -> Self {
                 #ident {
diff --git a/macro/src/expand.rs b/macro/src/expand.rs
index 5a879cb..7c194ad 100644
--- a/macro/src/expand.rs
+++ b/macro/src/expand.rs
@@ -14,7 +14,7 @@
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{format_ident, quote, quote_spanned, ToTokens};
 use std::mem;
-use syn::{parse_quote, punctuated, Generics, Lifetime, Result, Token};
+use syn::{parse_quote, punctuated, Lifetime, Result, Token};
 
 pub fn bridge(mut ffi: Module) -> Result<TokenStream> {
     let ref mut errors = Errors::new();
@@ -32,14 +32,10 @@
     let content = mem::take(&mut ffi.content);
     let trusted = ffi.unsafety.is_some();
     let namespace = &ffi.namespace;
-    let ref mut apis = syntax::parse_items(errors, content, trusted, namespace);
-    #[cfg(feature = "experimental")]
-    crate::load::load(errors, apis);
+    let ref apis = syntax::parse_items(errors, content, trusted, namespace);
     let ref types = Types::collect(errors, apis);
     errors.propagate()?;
-
-    let generator = check::Generator::Macro;
-    check::typecheck(errors, apis, types, generator);
+    check::typecheck(errors, apis, types);
     errors.propagate()?;
 
     Ok(expand(ffi, doc, attrs, apis, types))
@@ -134,9 +130,8 @@
     quote! {
         #doc
         #attrs
-        #[deny(improper_ctypes, improper_ctypes_definitions)]
-        #[allow(clippy::unknown_clippy_lints)]
-        #[allow(non_camel_case_types, non_snake_case, clippy::upper_case_acronyms)]
+        #[deny(improper_ctypes)]
+        #[allow(non_camel_case_types, non_snake_case, clippy::upper_case_acronyms, clippy::unknown_clippy_lints)]
         #vis #mod_token #ident #expanded
     }
 }
@@ -293,7 +288,7 @@
     let ident = &enm.name.rust;
     let doc = &enm.doc;
     let attrs = &enm.attrs;
-    let repr = &enm.repr;
+    let repr = enm.repr;
     let type_id = type_id(&enm.name);
     let variants = enm.variants.iter().map(|variant| {
         let doc = &variant.doc;
@@ -424,19 +419,18 @@
         quote!(_: #receiver_type)
     });
     let args = efn.args.iter().map(|arg| {
-        let var = &arg.name.rust;
-        let colon = arg.colon_token;
+        let ident = &arg.name.rust;
         let ty = expand_extern_type(&arg.ty, types, true);
         if arg.ty == RustString {
-            quote!(#var #colon *const #ty)
+            quote!(#ident: *const #ty)
         } else if let Type::RustVec(_) = arg.ty {
-            quote!(#var #colon *const #ty)
+            quote!(#ident: *const #ty)
         } else if let Type::Fn(_) = arg.ty {
-            quote!(#var #colon ::cxx::private::FatFunction)
+            quote!(#ident: ::cxx::private::FatFunction)
         } else if types.needs_indirect_abi(&arg.ty) {
-            quote!(#var #colon *mut #ty)
+            quote!(#ident: *mut #ty)
         } else {
-            quote!(#var #colon #ty)
+            quote!(#ident: #ty)
         }
     });
     let all_args = receiver.chain(args);
@@ -465,9 +459,8 @@
     let receiver = efn.receiver.iter().map(|receiver| {
         let var = receiver.var;
         if receiver.pinned {
-            let colon = receiver.colon_token;
             let ty = receiver.ty_self();
-            quote!(#var #colon #ty)
+            quote!(#var: #ty)
         } else {
             let ampersand = receiver.ampersand;
             let lifetime = &receiver.lifetime;
@@ -493,66 +486,53 @@
         .map(|receiver| receiver.var.to_token_stream());
     let arg_vars = efn.args.iter().map(|arg| {
         let var = &arg.name.rust;
-        let span = var.span();
         match &arg.ty {
             Type::Ident(ident) if ident.rust == RustString => {
-                quote_spanned!(span=> #var.as_mut_ptr() as *const ::cxx::private::RustString)
+                quote!(#var.as_mut_ptr() as *const ::cxx::private::RustString)
             }
-            Type::RustBox(ty) => {
-                if types.is_considered_improper_ctype(&ty.inner) {
-                    quote_spanned!(span=> ::std::boxed::Box::into_raw(#var).cast())
-                } else {
-                    quote_spanned!(span=> ::std::boxed::Box::into_raw(#var))
-                }
-            }
-            Type::UniquePtr(ty) => {
-                if types.is_considered_improper_ctype(&ty.inner) {
-                    quote_spanned!(span=> ::cxx::UniquePtr::into_raw(#var).cast())
-                } else {
-                    quote_spanned!(span=> ::cxx::UniquePtr::into_raw(#var))
-                }
-            }
-            Type::RustVec(_) => quote_spanned!(span=> #var.as_mut_ptr() as *const ::cxx::private::RustVec<_>),
+            Type::RustBox(_) => quote!(::std::boxed::Box::into_raw(#var)),
+            Type::UniquePtr(_) => quote!(::cxx::UniquePtr::into_raw(#var)),
+            Type::RustVec(_) => quote!(#var.as_mut_ptr() as *const ::cxx::private::RustVec<_>),
             Type::Ref(ty) => match &ty.inner {
                 Type::Ident(ident) if ident.rust == RustString => match ty.mutable {
-                    false => quote_spanned!(span=> ::cxx::private::RustString::from_ref(#var)),
-                    true => quote_spanned!(span=> ::cxx::private::RustString::from_mut(#var)),
+                    false => quote!(::cxx::private::RustString::from_ref(#var)),
+                    true => quote!(::cxx::private::RustString::from_mut(#var)),
                 },
                 Type::RustVec(vec) if vec.inner == RustString => match ty.mutable {
-                    false => quote_spanned!(span=> ::cxx::private::RustVec::from_ref_vec_string(#var)),
-                    true => quote_spanned!(span=> ::cxx::private::RustVec::from_mut_vec_string(#var)),
+                    false => quote!(::cxx::private::RustVec::from_ref_vec_string(#var)),
+                    true => quote!(::cxx::private::RustVec::from_mut_vec_string(#var)),
                 },
                 Type::RustVec(_) => match ty.mutable {
-                    false => quote_spanned!(span=> ::cxx::private::RustVec::from_ref(#var)),
-                    true => quote_spanned!(span=> ::cxx::private::RustVec::from_mut(#var)),
+                    false => quote!(::cxx::private::RustVec::from_ref(#var)),
+                    true => quote!(::cxx::private::RustVec::from_mut(#var)),
                 },
                 inner if types.is_considered_improper_ctype(inner) => {
                     let var = match ty.pinned {
                         false => quote!(#var),
-                        true => quote_spanned!(span=> ::std::pin::Pin::into_inner_unchecked(#var)),
+                        true => quote!(::std::pin::Pin::into_inner_unchecked(#var)),
                     };
                     match ty.mutable {
                         false => {
-                            quote_spanned!(span=> #var as *const #inner as *const ::std::ffi::c_void)
+                            quote!(#var as *const #inner as *const ::std::ffi::c_void)
                         }
-                        true => quote_spanned!(span=> #var as *mut #inner as *mut ::std::ffi::c_void),
+                        true => quote!(#var as *mut #inner as *mut ::std::ffi::c_void),
                     }
                 }
                 _ => quote!(#var),
             },
             Type::Ptr(ty) => {
                 if types.is_considered_improper_ctype(&ty.inner) {
-                    quote_spanned!(span=> #var.cast())
+                    quote!(#var.cast())
                 } else {
                     quote!(#var)
                 }
             }
-            Type::Str(_) => quote_spanned!(span=> ::cxx::private::RustStr::from(#var)),
+            Type::Str(_) => quote!(::cxx::private::RustStr::from(#var)),
             Type::SliceRef(ty) => match ty.mutable {
-                false => quote_spanned!(span=> ::cxx::private::RustSlice::from_ref(#var)),
-                true => quote_spanned!(span=> ::cxx::private::RustSlice::from_mut(#var)),
+                false => quote!(::cxx::private::RustSlice::from_ref(#var)),
+                true => quote!(::cxx::private::RustSlice::from_mut(#var)),
             },
-            ty if types.needs_indirect_abi(ty) => quote_spanned!(span=> #var.as_mut_ptr()),
+            ty if types.needs_indirect_abi(ty) => quote!(#var.as_mut_ptr()),
             _ => quote!(#var),
         }
     });
@@ -575,37 +555,35 @@
         .filter(|arg| types.needs_indirect_abi(&arg.ty))
         .map(|arg| {
             let var = &arg.name.rust;
-            let span = var.span();
             // These are arguments for which C++ has taken ownership of the data
             // behind the mut reference it received.
-            quote_spanned! {span=>
+            quote! {
                 let mut #var = ::std::mem::MaybeUninit::new(#var);
             }
         })
         .collect::<TokenStream>();
     let local_name = format_ident!("__{}", efn.name.rust);
-    let span = efn.semi_token.span;
     let call = if indirect_return {
         let ret = expand_extern_type(efn.ret.as_ref().unwrap(), types, true);
-        setup.extend(quote_spanned! {span=>
+        setup.extend(quote! {
             let mut __return = ::std::mem::MaybeUninit::<#ret>::uninit();
         });
         setup.extend(if efn.throws {
-            quote_spanned! {span=>
+            quote! {
                 #local_name(#(#vars,)* __return.as_mut_ptr()).exception()?;
             }
         } else {
-            quote_spanned! {span=>
+            quote! {
                 #local_name(#(#vars,)* __return.as_mut_ptr());
             }
         });
-        quote_spanned!(span=> __return.assume_init())
+        quote!(__return.assume_init())
     } else if efn.throws {
-        quote_spanned! {span=>
+        quote! {
             #local_name(#(#vars),*).exception()
         }
     } else {
-        quote_spanned! {span=>
+        quote! {
             #local_name(#(#vars),*)
         }
     };
@@ -616,88 +594,72 @@
         expr = match &efn.ret {
             None => call,
             Some(ret) => match ret {
-                Type::Ident(ident) if ident.rust == RustString => {
-                    quote_spanned!(span=> #call.into_string())
-                }
-                Type::RustBox(ty) => {
-                    if types.is_considered_improper_ctype(&ty.inner) {
-                        quote_spanned!(span=> ::std::boxed::Box::from_raw(#call.cast()))
-                    } else {
-                        quote_spanned!(span=> ::std::boxed::Box::from_raw(#call))
-                    }
-                }
+                Type::Ident(ident) if ident.rust == RustString => quote!(#call.into_string()),
+                Type::RustBox(_) => quote!(::std::boxed::Box::from_raw(#call)),
                 Type::RustVec(vec) => {
                     if vec.inner == RustString {
-                        quote_spanned!(span=> #call.into_vec_string())
+                        quote!(#call.into_vec_string())
                     } else {
-                        quote_spanned!(span=> #call.into_vec())
+                        quote!(#call.into_vec())
                     }
                 }
-                Type::UniquePtr(ty) => {
-                    if types.is_considered_improper_ctype(&ty.inner) {
-                        quote_spanned!(span=> ::cxx::UniquePtr::from_raw(#call.cast()))
-                    } else {
-                        quote_spanned!(span=> ::cxx::UniquePtr::from_raw(#call))
-                    }
-                }
+                Type::UniquePtr(_) => quote!(::cxx::UniquePtr::from_raw(#call)),
                 Type::Ref(ty) => match &ty.inner {
                     Type::Ident(ident) if ident.rust == RustString => match ty.mutable {
-                        false => quote_spanned!(span=> #call.as_string()),
-                        true => quote_spanned!(span=> #call.as_mut_string()),
+                        false => quote!(#call.as_string()),
+                        true => quote!(#call.as_mut_string()),
                     },
                     Type::RustVec(vec) if vec.inner == RustString => match ty.mutable {
-                        false => quote_spanned!(span=> #call.as_vec_string()),
-                        true => quote_spanned!(span=> #call.as_mut_vec_string()),
+                        false => quote!(#call.as_vec_string()),
+                        true => quote!(#call.as_mut_vec_string()),
                     },
                     Type::RustVec(_) => match ty.mutable {
-                        false => quote_spanned!(span=> #call.as_vec()),
-                        true => quote_spanned!(span=> #call.as_mut_vec()),
+                        false => quote!(#call.as_vec()),
+                        true => quote!(#call.as_mut_vec()),
                     },
                     inner if types.is_considered_improper_ctype(inner) => {
                         let mutability = ty.mutability;
-                        let deref_mut = quote_spanned!(span=> &#mutability *#call.cast());
+                        let deref_mut = quote!(&#mutability *#call.cast());
                         match ty.pinned {
                             false => deref_mut,
-                            true => {
-                                quote_spanned!(span=> ::std::pin::Pin::new_unchecked(#deref_mut))
-                            }
+                            true => quote!(::std::pin::Pin::new_unchecked(#deref_mut)),
                         }
                     }
                     _ => call,
                 },
                 Type::Ptr(ty) => {
                     if types.is_considered_improper_ctype(&ty.inner) {
-                        quote_spanned!(span=> #call.cast())
+                        quote!(#call.cast())
                     } else {
                         call
                     }
                 }
-                Type::Str(_) => quote_spanned!(span=> #call.as_str()),
+                Type::Str(_) => quote!(#call.as_str()),
                 Type::SliceRef(slice) => {
                     let inner = &slice.inner;
                     match slice.mutable {
-                        false => quote_spanned!(span=> #call.as_slice::<#inner>()),
-                        true => quote_spanned!(span=> #call.as_mut_slice::<#inner>()),
+                        false => quote!(#call.as_slice::<#inner>()),
+                        true => quote!(#call.as_mut_slice::<#inner>()),
                     }
                 }
                 _ => call,
             },
         };
         if efn.throws {
-            expr = quote_spanned!(span=> ::std::result::Result::Ok(#expr));
+            expr = quote!(::std::result::Result::Ok(#expr));
         }
     };
     let mut dispatch = quote!(#setup #expr);
     let visibility = efn.visibility;
     let unsafety = &efn.sig.unsafety;
     if unsafety.is_none() {
-        dispatch = quote_spanned!(span=> unsafe { #dispatch });
+        dispatch = quote!(unsafe { #dispatch });
     }
     let fn_token = efn.sig.fn_token;
     let ident = &efn.name.rust;
     let generics = &efn.generics;
     let arg_list = quote_spanned!(efn.sig.paren_token.span=> (#(#all_args,)*));
-    let fn_body = quote_spanned!(span=> {
+    let fn_body = quote_spanned!(efn.semi_token.span=> {
         extern "C" {
             #decl
         }
@@ -735,7 +697,7 @@
                 };
                 &elided_generics
             };
-            quote_spanned! {ident.span()=>
+            quote! {
                 impl #generics #receiver_ident #receiver_generics {
                     #doc
                     #attrs
@@ -756,7 +718,6 @@
     let r_trampoline = mangle::r_trampoline(efn, var, types);
     let local_name = parse_quote!(__);
     let catch_unwind_label = format!("::{}::{}", efn.name.rust, var.rust);
-    let body_span = efn.semi_token.span;
     let shim = expand_rust_function_shim_impl(
         sig,
         types,
@@ -764,8 +725,6 @@
         local_name,
         catch_unwind_label,
         None,
-        Some(&efn.generics),
-        body_span,
     );
     let var = &var.rust;
 
@@ -777,9 +736,9 @@
                     fn trampoline();
                 }
                 #shim
-                trampoline as usize as *const ::std::ffi::c_void
+                trampoline as usize as *const ()
             },
-            ptr: #var as usize as *const ::std::ffi::c_void,
+            ptr: #var as usize as *const (),
         };
     }
 }
@@ -898,7 +857,6 @@
         Some(receiver) => format!("::{}::{}", receiver.ty.rust, efn.name.rust),
     };
     let invoke = Some(&efn.name.rust);
-    let body_span = efn.semi_token.span;
     expand_rust_function_shim_impl(
         efn,
         types,
@@ -906,8 +864,6 @@
         local_name,
         catch_unwind_label,
         invoke,
-        None,
-        body_span,
     )
 }
 
@@ -918,166 +874,138 @@
     local_name: Ident,
     catch_unwind_label: String,
     invoke: Option<&Ident>,
-    outer_generics: Option<&Generics>,
-    body_span: Span,
 ) -> TokenStream {
-    let generics = outer_generics.unwrap_or(&sig.generics);
+    let generics = &sig.generics;
     let receiver_var = sig
         .receiver
         .as_ref()
         .map(|receiver| quote_spanned!(receiver.var.span=> __self));
     let receiver = sig.receiver.as_ref().map(|receiver| {
-        let colon = receiver.colon_token;
         let receiver_type = receiver.ty();
-        quote!(#receiver_var #colon #receiver_type)
+        quote!(#receiver_var: #receiver_type)
     });
     let args = sig.args.iter().map(|arg| {
-        let var = &arg.name.rust;
-        let colon = arg.colon_token;
+        let ident = &arg.name.rust;
         let ty = expand_extern_type(&arg.ty, types, false);
         if types.needs_indirect_abi(&arg.ty) {
-            quote!(#var #colon *mut #ty)
+            quote!(#ident: *mut #ty)
         } else {
-            quote!(#var #colon #ty)
+            quote!(#ident: #ty)
         }
     });
     let all_args = receiver.into_iter().chain(args);
 
     let arg_vars = sig.args.iter().map(|arg| {
-        let var = &arg.name.rust;
-        let span = var.span();
+        let ident = &arg.name.rust;
         match &arg.ty {
             Type::Ident(i) if i.rust == RustString => {
-                quote_spanned!(span=> ::std::mem::take((*#var).as_mut_string()))
+                quote!(::std::mem::take((*#ident).as_mut_string()))
             }
-            Type::RustBox(_) => quote_spanned!(span=> ::std::boxed::Box::from_raw(#var)),
+            Type::RustBox(_) => quote!(::std::boxed::Box::from_raw(#ident)),
             Type::RustVec(vec) => {
                 if vec.inner == RustString {
-                    quote_spanned!(span=> ::std::mem::take((*#var).as_mut_vec_string()))
+                    quote!(::std::mem::take((*#ident).as_mut_vec_string()))
                 } else {
-                    quote_spanned!(span=> ::std::mem::take((*#var).as_mut_vec()))
+                    quote!(::std::mem::take((*#ident).as_mut_vec()))
                 }
             }
-            Type::UniquePtr(_) => quote_spanned!(span=> ::cxx::UniquePtr::from_raw(#var)),
+            Type::UniquePtr(_) => quote!(::cxx::UniquePtr::from_raw(#ident)),
             Type::Ref(ty) => match &ty.inner {
                 Type::Ident(i) if i.rust == RustString => match ty.mutable {
-                    false => quote_spanned!(span=> #var.as_string()),
-                    true => quote_spanned!(span=> #var.as_mut_string()),
+                    false => quote!(#ident.as_string()),
+                    true => quote!(#ident.as_mut_string()),
                 },
                 Type::RustVec(vec) if vec.inner == RustString => match ty.mutable {
-                    false => quote_spanned!(span=> #var.as_vec_string()),
-                    true => quote_spanned!(span=> #var.as_mut_vec_string()),
+                    false => quote!(#ident.as_vec_string()),
+                    true => quote!(#ident.as_mut_vec_string()),
                 },
                 Type::RustVec(_) => match ty.mutable {
-                    false => quote_spanned!(span=> #var.as_vec()),
-                    true => quote_spanned!(span=> #var.as_mut_vec()),
+                    false => quote!(#ident.as_vec()),
+                    true => quote!(#ident.as_mut_vec()),
                 },
-                _ => quote!(#var),
+                _ => quote!(#ident),
             },
-            Type::Str(_) => quote_spanned!(span=> #var.as_str()),
+            Type::Str(_) => quote!(#ident.as_str()),
             Type::SliceRef(slice) => {
                 let inner = &slice.inner;
                 match slice.mutable {
-                    false => quote_spanned!(span=> #var.as_slice::<#inner>()),
-                    true => quote_spanned!(span=> #var.as_mut_slice::<#inner>()),
+                    false => quote!(#ident.as_slice::<#inner>()),
+                    true => quote!(#ident.as_mut_slice::<#inner>()),
                 }
             }
-            ty if types.needs_indirect_abi(ty) => quote_spanned!(span=> ::std::ptr::read(#var)),
-            _ => quote!(#var),
+            ty if types.needs_indirect_abi(ty) => quote!(::std::ptr::read(#ident)),
+            _ => quote!(#ident),
         }
     });
-    let vars: Vec<_> = receiver_var.into_iter().chain(arg_vars).collect();
+    let vars = receiver_var.into_iter().chain(arg_vars);
 
     let wrap_super = invoke.map(|invoke| expand_rust_function_shim_super(sig, &local_name, invoke));
 
-    let mut requires_closure;
     let mut call = match invoke {
-        Some(_) => {
-            requires_closure = false;
-            quote!(#local_name)
-        }
-        None => {
-            requires_closure = true;
-            quote!(::std::mem::transmute::<*const (), #sig>(__extern))
-        }
+        Some(_) => quote!(#local_name),
+        None => quote!(::std::mem::transmute::<*const (), #sig>(__extern)),
     };
-    requires_closure |= !vars.is_empty();
     call.extend(quote! { (#(#vars),*) });
 
-    let span = body_span;
     let conversion = sig.ret.as_ref().and_then(|ret| match ret {
         Type::Ident(ident) if ident.rust == RustString => {
-            Some(quote_spanned!(span=> ::cxx::private::RustString::from))
+            Some(quote!(::cxx::private::RustString::from))
         }
-        Type::RustBox(_) => Some(quote_spanned!(span=> ::std::boxed::Box::into_raw)),
+        Type::RustBox(_) => Some(quote!(::std::boxed::Box::into_raw)),
         Type::RustVec(vec) => {
             if vec.inner == RustString {
-                Some(quote_spanned!(span=> ::cxx::private::RustVec::from_vec_string))
+                Some(quote!(::cxx::private::RustVec::from_vec_string))
             } else {
-                Some(quote_spanned!(span=> ::cxx::private::RustVec::from))
+                Some(quote!(::cxx::private::RustVec::from))
             }
         }
-        Type::UniquePtr(_) => Some(quote_spanned!(span=> ::cxx::UniquePtr::into_raw)),
+        Type::UniquePtr(_) => Some(quote!(::cxx::UniquePtr::into_raw)),
         Type::Ref(ty) => match &ty.inner {
             Type::Ident(ident) if ident.rust == RustString => match ty.mutable {
-                false => Some(quote_spanned!(span=> ::cxx::private::RustString::from_ref)),
-                true => Some(quote_spanned!(span=> ::cxx::private::RustString::from_mut)),
+                false => Some(quote!(::cxx::private::RustString::from_ref)),
+                true => Some(quote!(::cxx::private::RustString::from_mut)),
             },
             Type::RustVec(vec) if vec.inner == RustString => match ty.mutable {
-                false => Some(quote_spanned!(span=> ::cxx::private::RustVec::from_ref_vec_string)),
-                true => Some(quote_spanned!(span=> ::cxx::private::RustVec::from_mut_vec_string)),
+                false => Some(quote!(::cxx::private::RustVec::from_ref_vec_string)),
+                true => Some(quote!(::cxx::private::RustVec::from_mut_vec_string)),
             },
             Type::RustVec(_) => match ty.mutable {
-                false => Some(quote_spanned!(span=> ::cxx::private::RustVec::from_ref)),
-                true => Some(quote_spanned!(span=> ::cxx::private::RustVec::from_mut)),
+                false => Some(quote!(::cxx::private::RustVec::from_ref)),
+                true => Some(quote!(::cxx::private::RustVec::from_mut)),
             },
             _ => None,
         },
-        Type::Str(_) => Some(quote_spanned!(span=> ::cxx::private::RustStr::from)),
+        Type::Str(_) => Some(quote!(::cxx::private::RustStr::from)),
         Type::SliceRef(ty) => match ty.mutable {
-            false => Some(quote_spanned!(span=> ::cxx::private::RustSlice::from_ref)),
-            true => Some(quote_spanned!(span=> ::cxx::private::RustSlice::from_mut)),
+            false => Some(quote!(::cxx::private::RustSlice::from_ref)),
+            true => Some(quote!(::cxx::private::RustSlice::from_mut)),
         },
         _ => None,
     });
 
     let mut expr = match conversion {
         None => call,
-        Some(conversion) if !sig.throws => {
-            requires_closure = true;
-            quote_spanned!(span=> #conversion(#call))
-        }
-        Some(conversion) => {
-            requires_closure = true;
-            quote_spanned!(span=> ::std::result::Result::map(#call, #conversion))
-        }
+        Some(conversion) if !sig.throws => quote!(#conversion(#call)),
+        Some(conversion) => quote!(::std::result::Result::map(#call, #conversion)),
     };
 
     let mut outparam = None;
     let indirect_return = indirect_return(sig, types);
     if indirect_return {
         let ret = expand_extern_type(sig.ret.as_ref().unwrap(), types, false);
-        outparam = Some(quote_spanned!(span=> __return: *mut #ret,));
+        outparam = Some(quote!(__return: *mut #ret,));
     }
     if sig.throws {
         let out = match sig.ret {
-            Some(_) => quote_spanned!(span=> __return),
-            None => quote_spanned!(span=> &mut ()),
+            Some(_) => quote!(__return),
+            None => quote!(&mut ()),
         };
-        requires_closure = true;
-        expr = quote_spanned!(span=> ::cxx::private::r#try(#out, #expr));
+        expr = quote!(::cxx::private::r#try(#out, #expr));
     } else if indirect_return {
-        requires_closure = true;
-        expr = quote_spanned!(span=> ::std::ptr::write(__return, #expr));
+        expr = quote!(::std::ptr::write(__return, #expr));
     }
 
-    let closure = if requires_closure {
-        quote_spanned!(span=> move || #expr)
-    } else {
-        quote!(#local_name)
-    };
-
-    expr = quote_spanned!(span=> ::cxx::private::catch_unwind(__fn, #closure));
+    expr = quote!(::cxx::private::catch_unwind(__fn, move || #expr));
 
     let ret = if sig.throws {
         quote!(-> ::cxx::private::Result)
@@ -1086,11 +1014,11 @@
     };
 
     let pointer = match invoke {
-        None => Some(quote_spanned!(span=> __extern: *const ())),
+        None => Some(quote!(__extern: *const ())),
         Some(_) => None,
     };
 
-    quote_spanned! {span=>
+    quote! {
         #[doc(hidden)]
         #[export_name = #link_name]
         unsafe extern "C" fn #local_name #generics(#(#all_args,)* #outparam #pointer) #ret {
@@ -1127,11 +1055,9 @@
             Some(ret) => quote!(#ret),
             None => quote!(()),
         };
-        // Set spans that result in the `Result<...>` written by the user being
-        // highlighted as the cause if their error type has no Display impl.
-        let result_begin = quote_spanned!(result.span=> ::std::result::Result<#ok, impl);
-        let result_end = quote_spanned!(rangle.span=> ::std::fmt::Display>);
-        quote!(-> #result_begin #result_end)
+        let impl_trait = quote_spanned!(result.span=> impl);
+        let display = quote_spanned!(rangle.span=> ::std::fmt::Display);
+        quote!(-> ::std::result::Result<#ok, #impl_trait #display>)
     } else {
         expand_return_type(&sig.ret)
     };
@@ -1301,8 +1227,8 @@
         }
         #[doc(hidden)]
         #[export_name = #link_reserve_total]
-        unsafe extern "C" fn #local_reserve_total #impl_generics(this: *mut ::cxx::private::RustVec<#elem #ty_generics>, new_cap: usize) {
-            (*this).reserve_total(new_cap);
+        unsafe extern "C" fn #local_reserve_total #impl_generics(this: *mut ::cxx::private::RustVec<#elem #ty_generics>, cap: usize) {
+            (*this).reserve_total(cap);
         }
         #[doc(hidden)]
         #[export_name = #link_set_len]
@@ -1330,16 +1256,18 @@
 
     let (impl_generics, ty_generics) = generics::split_for_impl(key, explicit_impl, resolve);
 
-    let can_construct_from_value = types.is_maybe_trivial(ident);
+    let can_construct_from_value = types.structs.contains_key(ident)
+        || types.enums.contains_key(ident)
+        || types.aliases.contains_key(ident);
     let new_method = if can_construct_from_value {
         Some(quote! {
             #[doc(hidden)]
-            fn __new(value: Self) -> ::std::mem::MaybeUninit<*mut ::std::ffi::c_void> {
+            fn __new(value: Self) -> *mut ::std::ffi::c_void {
                 extern "C" {
                     #[link_name = #link_uninit]
-                    fn __uninit(this: *mut ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>) -> *mut ::std::ffi::c_void;
+                    fn __uninit(this: *mut *mut ::std::ffi::c_void) -> *mut ::std::ffi::c_void;
                 }
-                let mut repr = ::std::mem::MaybeUninit::uninit();
+                let mut repr = ::std::ptr::null_mut::<::std::ffi::c_void>();
                 unsafe { __uninit(&mut repr).cast::<#ident #ty_generics>().write(value) }
                 repr
             }
@@ -1359,47 +1287,47 @@
                 f.write_str(#name)
             }
             #[doc(hidden)]
-            fn __null() -> ::std::mem::MaybeUninit<*mut ::std::ffi::c_void> {
+            fn __null() -> *mut ::std::ffi::c_void {
                 extern "C" {
                     #[link_name = #link_null]
-                    fn __null(this: *mut ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>);
+                    fn __null(this: *mut *mut ::std::ffi::c_void);
                 }
-                let mut repr = ::std::mem::MaybeUninit::uninit();
+                let mut repr = ::std::ptr::null_mut::<::std::ffi::c_void>();
                 unsafe { __null(&mut repr) }
                 repr
             }
             #new_method
             #[doc(hidden)]
-            unsafe fn __raw(raw: *mut Self) -> ::std::mem::MaybeUninit<*mut ::std::ffi::c_void> {
+            unsafe fn __raw(raw: *mut Self) -> *mut ::std::ffi::c_void {
                 extern "C" {
                     #[link_name = #link_raw]
-                    fn __raw(this: *mut ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>, raw: *mut ::std::ffi::c_void);
+                    fn __raw(this: *mut *mut ::std::ffi::c_void, raw: *mut ::std::ffi::c_void);
                 }
-                let mut repr = ::std::mem::MaybeUninit::uninit();
+                let mut repr = ::std::ptr::null_mut::<::std::ffi::c_void>();
                 __raw(&mut repr, raw.cast());
                 repr
             }
             #[doc(hidden)]
-            unsafe fn __get(repr: ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>) -> *const Self {
+            unsafe fn __get(repr: *mut ::std::ffi::c_void) -> *const Self {
                 extern "C" {
                     #[link_name = #link_get]
-                    fn __get(this: *const ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>) -> *const ::std::ffi::c_void;
+                    fn __get(this: *const *mut ::std::ffi::c_void) -> *const ::std::ffi::c_void;
                 }
                 __get(&repr).cast()
             }
             #[doc(hidden)]
-            unsafe fn __release(mut repr: ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>) -> *mut Self {
+            unsafe fn __release(mut repr: *mut ::std::ffi::c_void) -> *mut Self {
                 extern "C" {
                     #[link_name = #link_release]
-                    fn __release(this: *mut ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>) -> *mut ::std::ffi::c_void;
+                    fn __release(this: *mut *mut ::std::ffi::c_void) -> *mut ::std::ffi::c_void;
                 }
                 __release(&mut repr).cast()
             }
             #[doc(hidden)]
-            unsafe fn __drop(mut repr: ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>) {
+            unsafe fn __drop(mut repr: *mut ::std::ffi::c_void) {
                 extern "C" {
                     #[link_name = #link_drop]
-                    fn __drop(this: *mut ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>);
+                    fn __drop(this: *mut *mut ::std::ffi::c_void);
                 }
                 __drop(&mut repr);
             }
@@ -1424,7 +1352,9 @@
 
     let (impl_generics, ty_generics) = generics::split_for_impl(key, explicit_impl, resolve);
 
-    let can_construct_from_value = types.is_maybe_trivial(ident);
+    let can_construct_from_value = types.structs.contains_key(ident)
+        || types.enums.contains_key(ident)
+        || types.aliases.contains_key(ident);
     let new_method = if can_construct_from_value {
         Some(quote! {
             #[doc(hidden)]
@@ -1565,8 +1495,6 @@
     let prefix = format!("cxxbridge1$std$vector${}$", resolve.name.to_symbol());
     let link_size = format!("{}size", prefix);
     let link_get_unchecked = format!("{}get_unchecked", prefix);
-    let link_push_back = format!("{}push_back", prefix);
-    let link_pop_back = format!("{}pop_back", prefix);
     let unique_ptr_prefix = format!(
         "cxxbridge1$unique_ptr$std$vector${}$",
         resolve.name.to_symbol(),
@@ -1583,42 +1511,6 @@
     let end_span = explicit_impl.map_or(key.end_span, |explicit| explicit.brace_token.span);
     let unsafe_token = format_ident!("unsafe", span = begin_span);
 
-    let can_pass_element_by_value = types.is_maybe_trivial(elem);
-    let by_value_methods = if can_pass_element_by_value {
-        Some(quote_spanned! {end_span=>
-            #[doc(hidden)]
-            unsafe fn __push_back(
-                this: ::std::pin::Pin<&mut ::cxx::CxxVector<Self>>,
-                value: &mut ::std::mem::ManuallyDrop<Self>,
-            ) {
-                extern "C" {
-                    #[link_name = #link_push_back]
-                    fn __push_back #impl_generics(
-                        this: ::std::pin::Pin<&mut ::cxx::CxxVector<#elem #ty_generics>>,
-                        value: *mut ::std::ffi::c_void,
-                    );
-                }
-                __push_back(this, value as *mut ::std::mem::ManuallyDrop<Self> as *mut ::std::ffi::c_void);
-            }
-            #[doc(hidden)]
-            unsafe fn __pop_back(
-                this: ::std::pin::Pin<&mut ::cxx::CxxVector<Self>>,
-                out: &mut ::std::mem::MaybeUninit<Self>,
-            ) {
-                extern "C" {
-                    #[link_name = #link_pop_back]
-                    fn __pop_back #impl_generics(
-                        this: ::std::pin::Pin<&mut ::cxx::CxxVector<#elem #ty_generics>>,
-                        out: *mut ::std::ffi::c_void,
-                    );
-                }
-                __pop_back(this, out as *mut ::std::mem::MaybeUninit<Self> as *mut ::std::ffi::c_void);
-            }
-        })
-    } else {
-        None
-    };
-
     quote_spanned! {end_span=>
         #unsafe_token impl #impl_generics ::cxx::private::VectorElement for #elem #ty_generics {
             #[doc(hidden)]
@@ -1637,55 +1529,51 @@
             unsafe fn __get_unchecked(v: *mut ::cxx::CxxVector<Self>, pos: usize) -> *mut Self {
                 extern "C" {
                     #[link_name = #link_get_unchecked]
-                    fn __get_unchecked #impl_generics(
-                        v: *mut ::cxx::CxxVector<#elem #ty_generics>,
-                        pos: usize,
-                    ) -> *mut ::std::ffi::c_void;
+                    fn __get_unchecked #impl_generics(_: *mut ::cxx::CxxVector<#elem #ty_generics>, _: usize) -> *mut #elem #ty_generics;
                 }
-                __get_unchecked(v, pos) as *mut Self
+                __get_unchecked(v, pos)
             }
-            #by_value_methods
             #[doc(hidden)]
-            fn __unique_ptr_null() -> ::std::mem::MaybeUninit<*mut ::std::ffi::c_void> {
+            fn __unique_ptr_null() -> *mut ::std::ffi::c_void {
                 extern "C" {
                     #[link_name = #link_unique_ptr_null]
-                    fn __unique_ptr_null(this: *mut ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>);
+                    fn __unique_ptr_null(this: *mut *mut ::std::ffi::c_void);
                 }
-                let mut repr = ::std::mem::MaybeUninit::uninit();
+                let mut repr = ::std::ptr::null_mut::<::std::ffi::c_void>();
                 unsafe { __unique_ptr_null(&mut repr) }
                 repr
             }
             #[doc(hidden)]
-            unsafe fn __unique_ptr_raw(raw: *mut ::cxx::CxxVector<Self>) -> ::std::mem::MaybeUninit<*mut ::std::ffi::c_void> {
+            unsafe fn __unique_ptr_raw(raw: *mut ::cxx::CxxVector<Self>) -> *mut ::std::ffi::c_void {
                 extern "C" {
                     #[link_name = #link_unique_ptr_raw]
-                    fn __unique_ptr_raw #impl_generics(this: *mut ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>, raw: *mut ::cxx::CxxVector<#elem #ty_generics>);
+                    fn __unique_ptr_raw #impl_generics(this: *mut *mut ::std::ffi::c_void, raw: *mut ::cxx::CxxVector<#elem #ty_generics>);
                 }
-                let mut repr = ::std::mem::MaybeUninit::uninit();
+                let mut repr = ::std::ptr::null_mut::<::std::ffi::c_void>();
                 __unique_ptr_raw(&mut repr, raw);
                 repr
             }
             #[doc(hidden)]
-            unsafe fn __unique_ptr_get(repr: ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>) -> *const ::cxx::CxxVector<Self> {
+            unsafe fn __unique_ptr_get(repr: *mut ::std::ffi::c_void) -> *const ::cxx::CxxVector<Self> {
                 extern "C" {
                     #[link_name = #link_unique_ptr_get]
-                    fn __unique_ptr_get #impl_generics(this: *const ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>) -> *const ::cxx::CxxVector<#elem #ty_generics>;
+                    fn __unique_ptr_get #impl_generics(this: *const *mut ::std::ffi::c_void) -> *const ::cxx::CxxVector<#elem #ty_generics>;
                 }
                 __unique_ptr_get(&repr)
             }
             #[doc(hidden)]
-            unsafe fn __unique_ptr_release(mut repr: ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>) -> *mut ::cxx::CxxVector<Self> {
+            unsafe fn __unique_ptr_release(mut repr: *mut ::std::ffi::c_void) -> *mut ::cxx::CxxVector<Self> {
                 extern "C" {
                     #[link_name = #link_unique_ptr_release]
-                    fn __unique_ptr_release #impl_generics(this: *mut ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>) -> *mut ::cxx::CxxVector<#elem #ty_generics>;
+                    fn __unique_ptr_release #impl_generics(this: *mut *mut ::std::ffi::c_void) -> *mut ::cxx::CxxVector<#elem #ty_generics>;
                 }
                 __unique_ptr_release(&mut repr)
             }
             #[doc(hidden)]
-            unsafe fn __unique_ptr_drop(mut repr: ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>) {
+            unsafe fn __unique_ptr_drop(mut repr: *mut ::std::ffi::c_void) {
                 extern "C" {
                     #[link_name = #link_unique_ptr_drop]
-                    fn __unique_ptr_drop(this: *mut ::std::mem::MaybeUninit<*mut ::std::ffi::c_void>);
+                    fn __unique_ptr_drop(this: *mut *mut ::std::ffi::c_void);
                 }
                 __unique_ptr_drop(&mut repr);
             }
@@ -1708,72 +1596,43 @@
 
 fn expand_extern_type(ty: &Type, types: &Types, proper: bool) -> TokenStream {
     match ty {
-        Type::Ident(ident) if ident.rust == RustString => {
-            let span = ident.rust.span();
-            quote_spanned!(span=> ::cxx::private::RustString)
-        }
+        Type::Ident(ident) if ident.rust == RustString => quote!(::cxx::private::RustString),
         Type::RustBox(ty) | Type::UniquePtr(ty) => {
-            let span = ty.name.span();
-            if proper && types.is_considered_improper_ctype(&ty.inner) {
-                quote_spanned!(span=> *mut ::std::ffi::c_void)
-            } else {
-                let inner = expand_extern_type(&ty.inner, types, proper);
-                quote_spanned!(span=> *mut #inner)
-            }
+            let inner = expand_extern_type(&ty.inner, types, proper);
+            quote!(*mut #inner)
         }
         Type::RustVec(ty) => {
-            let span = ty.name.span();
-            let langle = ty.langle;
             let elem = expand_extern_type(&ty.inner, types, proper);
-            let rangle = ty.rangle;
-            quote_spanned!(span=> ::cxx::private::RustVec #langle #elem #rangle)
+            quote!(::cxx::private::RustVec<#elem>)
         }
         Type::Ref(ty) => {
-            let ampersand = ty.ampersand;
-            let lifetime = &ty.lifetime;
             let mutability = ty.mutability;
             match &ty.inner {
                 Type::Ident(ident) if ident.rust == RustString => {
-                    let span = ident.rust.span();
-                    quote_spanned!(span=> #ampersand #lifetime #mutability ::cxx::private::RustString)
+                    quote!(&#mutability ::cxx::private::RustString)
                 }
                 Type::RustVec(ty) => {
-                    let span = ty.name.span();
-                    let langle = ty.langle;
                     let inner = expand_extern_type(&ty.inner, types, proper);
-                    let rangle = ty.rangle;
-                    quote_spanned!(span=> #ampersand #lifetime #mutability ::cxx::private::RustVec #langle #inner #rangle)
+                    quote!(&#mutability ::cxx::private::RustVec<#inner>)
                 }
-                inner if proper && types.is_considered_improper_ctype(inner) => {
-                    let star = Token![*](ampersand.span);
-                    match ty.mutable {
-                        false => quote!(#star const ::std::ffi::c_void),
-                        true => quote!(#star #mutability ::std::ffi::c_void),
-                    }
-                }
+                inner if proper && types.is_considered_improper_ctype(inner) => match ty.mutable {
+                    false => quote!(*const ::std::ffi::c_void),
+                    true => quote!(*#mutability ::std::ffi::c_void),
+                },
                 _ => quote!(#ty),
             }
         }
         Type::Ptr(ty) => {
             if proper && types.is_considered_improper_ctype(&ty.inner) {
-                let star = ty.star;
                 let mutability = ty.mutability;
                 let constness = ty.constness;
-                quote!(#star #mutability #constness ::std::ffi::c_void)
+                quote!(*#mutability #constness ::std::ffi::c_void)
             } else {
                 quote!(#ty)
             }
         }
-        Type::Str(ty) => {
-            let span = ty.ampersand.span;
-            let rust_str = Ident::new("RustStr", syn::spanned::Spanned::span(&ty.inner));
-            quote_spanned!(span=> ::cxx::private::#rust_str)
-        }
-        Type::SliceRef(ty) => {
-            let span = ty.ampersand.span;
-            let rust_slice = Ident::new("RustSlice", ty.bracket.span);
-            quote_spanned!(span=> ::cxx::private::#rust_slice)
-        }
+        Type::Str(_) => quote!(::cxx::private::RustStr),
+        Type::SliceRef(_) => quote!(::cxx::private::RustSlice),
         _ => quote!(#ty),
     }
 }
diff --git a/macro/src/lib.rs b/macro/src/lib.rs
index 324881d..f8e7903 100644
--- a/macro/src/lib.rs
+++ b/macro/src/lib.rs
@@ -3,7 +3,7 @@
     clippy::default_trait_access,
     clippy::doc_markdown,
     clippy::enum_glob_use,
-    clippy::if_same_then_else,
+    clippy::filter_map,
     clippy::inherent_to_string,
     clippy::items_after_statements,
     clippy::large_enum_variant,
@@ -36,11 +36,6 @@
 mod syntax;
 mod type_id;
 
-#[cfg(feature = "experimental")]
-mod clang;
-#[cfg(feature = "experimental")]
-mod load;
-
 use crate::syntax::file::Module;
 use crate::syntax::namespace::Namespace;
 use crate::syntax::qualified::QualifiedName;
diff --git a/macro/src/load.rs b/macro/src/load.rs
deleted file mode 100644
index d769ebf..0000000
--- a/macro/src/load.rs
+++ /dev/null
@@ -1,315 +0,0 @@
-use crate::clang::{Clang, Node};
-use crate::syntax::attrs::OtherAttrs;
-use crate::syntax::namespace::Namespace;
-use crate::syntax::report::Errors;
-use crate::syntax::{Api, Discriminant, Doc, Enum, EnumRepr, ForeignName, Pair, Variant};
-use flate2::write::GzDecoder;
-use memmap::Mmap;
-use proc_macro2::{Delimiter, Group, Ident, TokenStream};
-use quote::{format_ident, quote, quote_spanned};
-use std::env;
-use std::fmt::{self, Display};
-use std::fs::File;
-use std::io::Write;
-use std::path::PathBuf;
-use std::str::FromStr;
-use syn::{parse_quote, Path};
-
-const CXX_CLANG_AST: &str = "CXX_CLANG_AST";
-
-pub fn load(cx: &mut Errors, apis: &mut [Api]) {
-    let ref mut variants_from_header = Vec::new();
-    for api in apis {
-        if let Api::Enum(enm) = api {
-            if enm.variants_from_header {
-                if enm.variants.is_empty() {
-                    variants_from_header.push(enm);
-                } else {
-                    let span = span_for_enum_error(enm);
-                    cx.error(
-                        span,
-                        "enum with #![variants_from_header] must be written with no explicit variants",
-                    );
-                }
-            }
-        }
-    }
-
-    let span = match variants_from_header.get(0) {
-        None => return,
-        Some(enm) => enm.variants_from_header_attr.clone().unwrap(),
-    };
-
-    let ast_dump_path = match env::var_os(CXX_CLANG_AST) {
-        Some(ast_dump_path) => PathBuf::from(ast_dump_path),
-        None => {
-            let msg = format!(
-                "environment variable ${} has not been provided",
-                CXX_CLANG_AST,
-            );
-            return cx.error(span, msg);
-        }
-    };
-
-    let memmap = File::open(&ast_dump_path).and_then(|file| unsafe { Mmap::map(&file) });
-    let mut gunzipped;
-    let ast_dump_bytes = match match memmap {
-        Ok(ref memmap) => {
-            let is_gzipped = memmap.get(..2) == Some(b"\x1f\x8b");
-            if is_gzipped {
-                gunzipped = Vec::new();
-                let decode_result = GzDecoder::new(&mut gunzipped).write_all(&memmap);
-                decode_result.map(|_| gunzipped.as_slice())
-            } else {
-                Ok(&memmap as &[u8])
-            }
-        }
-        Err(error) => Err(error),
-    } {
-        Ok(bytes) => bytes,
-        Err(error) => {
-            let msg = format!("failed to read {}: {}", ast_dump_path.display(), error);
-            return cx.error(span, msg);
-        }
-    };
-
-    let ref root: Node = match serde_json::from_slice(ast_dump_bytes) {
-        Ok(root) => root,
-        Err(error) => {
-            let msg = format!("failed to read {}: {}", ast_dump_path.display(), error);
-            return cx.error(span, msg);
-        }
-    };
-
-    let ref mut namespace = Vec::new();
-    traverse(cx, root, namespace, variants_from_header, None);
-
-    for enm in variants_from_header {
-        if enm.variants.is_empty() {
-            let span = &enm.variants_from_header_attr;
-            let name = CxxName(&enm.name);
-            let msg = format!("failed to find any C++ definition of enum {}", name);
-            cx.error(span, msg);
-        }
-    }
-}
-
-fn traverse<'a>(
-    cx: &mut Errors,
-    node: &'a Node,
-    namespace: &mut Vec<&'a str>,
-    variants_from_header: &mut [&mut Enum],
-    mut idx: Option<usize>,
-) {
-    match &node.kind {
-        Clang::NamespaceDecl(decl) => {
-            let name = match &decl.name {
-                Some(name) => name,
-                // Can ignore enums inside an anonymous namespace.
-                None => return,
-            };
-            namespace.push(name);
-            idx = None;
-        }
-        Clang::EnumDecl(decl) => {
-            let name = match &decl.name {
-                Some(name) => name,
-                None => return,
-            };
-            idx = None;
-            for (i, enm) in variants_from_header.iter_mut().enumerate() {
-                if enm.name.cxx == **name && enm.name.namespace.iter().eq(&*namespace) {
-                    if !enm.variants.is_empty() {
-                        let span = &enm.variants_from_header_attr;
-                        let qual_name = CxxName(&enm.name);
-                        let msg = format!("found multiple C++ definitions of enum {}", qual_name);
-                        cx.error(span, msg);
-                        return;
-                    }
-                    let fixed_underlying_type = match &decl.fixed_underlying_type {
-                        Some(fixed_underlying_type) => fixed_underlying_type,
-                        None => {
-                            let span = &enm.variants_from_header_attr;
-                            let name = &enm.name.cxx;
-                            let qual_name = CxxName(&enm.name);
-                            let msg = format!(
-                                "implicit implementation-defined repr for enum {} is not supported yet; consider changing its C++ definition to `enum {}: int {{...}}",
-                                qual_name, name,
-                            );
-                            cx.error(span, msg);
-                            return;
-                        }
-                    };
-                    let repr = translate_qual_type(
-                        cx,
-                        &enm,
-                        fixed_underlying_type
-                            .desugared_qual_type
-                            .as_ref()
-                            .unwrap_or(&fixed_underlying_type.qual_type),
-                    );
-                    enm.repr = EnumRepr::Foreign { rust_type: repr };
-                    idx = Some(i);
-                    break;
-                }
-            }
-            if idx.is_none() {
-                return;
-            }
-        }
-        Clang::EnumConstantDecl(decl) => {
-            if let Some(idx) = idx {
-                let enm = &mut *variants_from_header[idx];
-                let span = enm
-                    .variants_from_header_attr
-                    .as_ref()
-                    .unwrap()
-                    .path
-                    .get_ident()
-                    .unwrap()
-                    .span();
-                let cxx_name = match ForeignName::parse(&decl.name, span) {
-                    Ok(foreign_name) => foreign_name,
-                    Err(_) => {
-                        let span = &enm.variants_from_header_attr;
-                        let msg = format!("unsupported C++ variant name: {}", decl.name);
-                        return cx.error(span, msg);
-                    }
-                };
-                let rust_name: Ident = match syn::parse_str(&decl.name) {
-                    Ok(ident) => ident,
-                    Err(_) => format_ident!("__Variant{}", enm.variants.len()),
-                };
-                let discriminant = match discriminant_value(&node.inner) {
-                    ParsedDiscriminant::Constant(discriminant) => discriminant,
-                    ParsedDiscriminant::Successor => match enm.variants.last() {
-                        None => Discriminant::zero(),
-                        Some(last) => match last.discriminant.checked_succ() {
-                            Some(discriminant) => discriminant,
-                            None => {
-                                let span = &enm.variants_from_header_attr;
-                                let msg = format!(
-                                    "overflow processing discriminant value for variant: {}",
-                                    decl.name,
-                                );
-                                return cx.error(span, msg);
-                            }
-                        },
-                    },
-                    ParsedDiscriminant::Fail => {
-                        let span = &enm.variants_from_header_attr;
-                        let msg = format!(
-                            "failed to obtain discriminant value for variant: {}",
-                            decl.name,
-                        );
-                        cx.error(span, msg);
-                        Discriminant::zero()
-                    }
-                };
-                enm.variants.push(Variant {
-                    doc: Doc::new(),
-                    attrs: OtherAttrs::none(),
-                    name: Pair {
-                        namespace: Namespace::ROOT,
-                        cxx: cxx_name,
-                        rust: rust_name,
-                    },
-                    discriminant,
-                    expr: None,
-                });
-            }
-        }
-        _ => {}
-    }
-    for inner in &node.inner {
-        traverse(cx, inner, namespace, variants_from_header, idx);
-    }
-    if let Clang::NamespaceDecl(_) = &node.kind {
-        let _ = namespace.pop().unwrap();
-    }
-}
-
-fn translate_qual_type(cx: &mut Errors, enm: &Enum, qual_type: &str) -> Path {
-    let rust_std_name = match qual_type {
-        "char" => "c_char",
-        "int" => "c_int",
-        "long" => "c_long",
-        "long long" => "c_longlong",
-        "signed char" => "c_schar",
-        "short" => "c_short",
-        "unsigned char" => "c_uchar",
-        "unsigned int" => "c_uint",
-        "unsigned long" => "c_ulong",
-        "unsigned long long" => "c_ulonglong",
-        "unsigned short" => "c_ushort",
-        unsupported => {
-            let span = &enm.variants_from_header_attr;
-            let qual_name = CxxName(&enm.name);
-            let msg = format!(
-                "unsupported underlying type for {}: {}",
-                qual_name, unsupported,
-            );
-            cx.error(span, msg);
-            "c_int"
-        }
-    };
-    let span = enm
-        .variants_from_header_attr
-        .as_ref()
-        .unwrap()
-        .path
-        .get_ident()
-        .unwrap()
-        .span();
-    let ident = Ident::new(rust_std_name, span);
-    let path = quote_spanned!(span=> ::std::os::raw::#ident);
-    parse_quote!(#path)
-}
-
-enum ParsedDiscriminant {
-    Constant(Discriminant),
-    Successor,
-    Fail,
-}
-
-fn discriminant_value(mut clang: &[Node]) -> ParsedDiscriminant {
-    if clang.is_empty() {
-        // No discriminant expression provided; use successor of previous
-        // descriminant.
-        return ParsedDiscriminant::Successor;
-    }
-
-    loop {
-        if clang.len() != 1 {
-            return ParsedDiscriminant::Fail;
-        }
-
-        let node = &clang[0];
-        match &node.kind {
-            Clang::ImplicitCastExpr => clang = &node.inner,
-            Clang::ConstantExpr(expr) => match Discriminant::from_str(&expr.value) {
-                Ok(discriminant) => return ParsedDiscriminant::Constant(discriminant),
-                Err(_) => return ParsedDiscriminant::Fail,
-            },
-            _ => return ParsedDiscriminant::Fail,
-        }
-    }
-}
-
-fn span_for_enum_error(enm: &Enum) -> TokenStream {
-    let enum_token = enm.enum_token;
-    let mut brace_token = Group::new(Delimiter::Brace, TokenStream::new());
-    brace_token.set_span(enm.brace_token.span);
-    quote!(#enum_token #brace_token)
-}
-
-struct CxxName<'a>(&'a Pair);
-
-impl<'a> Display for CxxName<'a> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        for namespace in &self.0.namespace {
-            write!(formatter, "{}::", namespace)?;
-        }
-        write!(formatter, "{}", self.0.cxx)
-    }
-}
diff --git a/src/cxx.cc b/src/cxx.cc
index 5dca531..c0ef738 100644
--- a/src/cxx.cc
+++ b/src/cxx.cc
@@ -22,13 +22,6 @@
   return s.length();
 }
 
-void cxxbridge1$cxx_string$clear(std::string &s) noexcept { s.clear(); }
-
-void cxxbridge1$cxx_string$reserve_total(std::string &s,
-                                         size_t new_cap) noexcept {
-  s.reserve(new_cap);
-}
-
 void cxxbridge1$cxx_string$push(std::string &s, const std::uint8_t *ptr,
                                 std::size_t len) noexcept {
   s.append(reinterpret_cast<const char *>(ptr), len);
@@ -38,18 +31,12 @@
 void cxxbridge1$string$new(rust::String *self) noexcept;
 void cxxbridge1$string$clone(rust::String *self,
                              const rust::String &other) noexcept;
-bool cxxbridge1$string$from_utf8(rust::String *self, const char *ptr,
-                                 std::size_t len) noexcept;
-bool cxxbridge1$string$from_utf16(rust::String *self, const char16_t *ptr,
-                                  std::size_t len) noexcept;
+bool cxxbridge1$string$from(rust::String *self, const char *ptr,
+                            std::size_t len) noexcept;
 void cxxbridge1$string$drop(rust::String *self) noexcept;
 const char *cxxbridge1$string$ptr(const rust::String *self) noexcept;
 std::size_t cxxbridge1$string$len(const rust::String *self) noexcept;
-std::size_t cxxbridge1$string$capacity(const rust::String *self) noexcept;
-void cxxbridge1$string$reserve_additional(rust::String *self,
-                                          size_t additional) noexcept;
-void cxxbridge1$string$reserve_total(rust::String *self,
-                                     size_t new_cap) noexcept;
+void cxxbridge1$string$reserve_total(rust::String *self, size_t cap) noexcept;
 
 // rust::Str
 void cxxbridge1$str$new(rust::Str *self) noexcept;
@@ -94,17 +81,11 @@
 String::~String() noexcept { cxxbridge1$string$drop(this); }
 
 static void initString(String *self, const char *s, std::size_t len) {
-  if (!cxxbridge1$string$from_utf8(self, s, len)) {
+  if (!cxxbridge1$string$from(self, s, len)) {
     panic<std::invalid_argument>("data for rust::String is not utf-8");
   }
 }
 
-static void initString(String *self, const char16_t *s, std::size_t len) {
-  if (!cxxbridge1$string$from_utf16(self, s, len)) {
-    panic<std::invalid_argument>("data for rust::String is not utf-16");
-  }
-}
-
 String::String(const std::string &s) { initString(this, s.data(), s.length()); }
 
 String::String(const char *s) {
@@ -119,19 +100,6 @@
              len);
 }
 
-String::String(const char16_t *s) {
-  assert(s != nullptr);
-  initString(this, s, std::char_traits<char16_t>::length(s));
-}
-
-String::String(const char16_t *s, std::size_t len) {
-  assert(s != nullptr || len == 0);
-  initString(this,
-             s == nullptr && len == 0 ? reinterpret_cast<const char16_t *>(2)
-                                      : s,
-             len);
-}
-
 String &String::operator=(const String &other) &noexcept {
   if (this != &other) {
     cxxbridge1$string$drop(this);
@@ -163,24 +131,14 @@
   return cxxbridge1$string$len(this);
 }
 
-bool String::empty() const noexcept { return this->size() == 0; }
-
 const char *String::c_str() noexcept {
   auto len = this->length();
-  cxxbridge1$string$reserve_additional(this, 1);
+  cxxbridge1$string$reserve_total(this, len + 1);
   auto ptr = this->data();
   const_cast<char *>(ptr)[len] = '\0';
   return ptr;
 }
 
-std::size_t String::capacity() const noexcept {
-  return cxxbridge1$string$capacity(this);
-}
-
-void String::reserve(std::size_t new_cap) noexcept {
-  cxxbridge1$string$reserve_total(this, new_cap);
-}
-
 String::iterator String::begin() noexcept {
   return const_cast<char *>(this->data());
 }
@@ -270,8 +228,6 @@
 
 std::size_t Str::length() const noexcept { return this->size(); }
 
-bool Str::empty() const noexcept { return this->size() == 0; }
-
 Str::const_iterator Str::begin() const noexcept { return this->cbegin(); }
 
 Str::const_iterator Str::end() const noexcept { return this->cend(); }
@@ -471,13 +427,6 @@
 } // namespace cxxbridge1
 } // namespace rust
 
-namespace {
-template <typename T>
-void destroy(T *ptr) {
-  ptr->~T();
-}
-} // namespace
-
 extern "C" {
 void cxxbridge1$unique_ptr$std$string$null(
     std::unique_ptr<std::string> *ptr) noexcept {
@@ -542,18 +491,6 @@
     ptr->~unique_ptr();                                                        \
   }
 
-#define STD_VECTOR_TRIVIAL_OPS(RUST_TYPE, CXX_TYPE)                            \
-  void cxxbridge1$std$vector$##RUST_TYPE##$push_back(                          \
-      std::vector<CXX_TYPE> *v, CXX_TYPE *value) noexcept {                    \
-    v->push_back(std::move(*value));                                           \
-    destroy(value);                                                            \
-  }                                                                            \
-  void cxxbridge1$std$vector$##RUST_TYPE##$pop_back(std::vector<CXX_TYPE> *v,  \
-                                                    CXX_TYPE *out) noexcept {  \
-    new (out) CXX_TYPE(std::move(v->back()));                                  \
-    v->pop_back();                                                             \
-  }
-
 #define RUST_VEC_EXTERNS(RUST_TYPE, CXX_TYPE)                                  \
   void cxxbridge1$rust_vec$##RUST_TYPE##$new(                                  \
       rust::Vec<CXX_TYPE> *ptr) noexcept;                                      \
@@ -566,7 +503,7 @@
   const CXX_TYPE *cxxbridge1$rust_vec$##RUST_TYPE##$data(                      \
       const rust::Vec<CXX_TYPE> *ptr) noexcept;                                \
   void cxxbridge1$rust_vec$##RUST_TYPE##$reserve_total(                        \
-      rust::Vec<CXX_TYPE> *ptr, std::size_t new_cap) noexcept;                 \
+      rust::Vec<CXX_TYPE> *ptr, std::size_t cap) noexcept;                     \
   void cxxbridge1$rust_vec$##RUST_TYPE##$set_len(rust::Vec<CXX_TYPE> *ptr,     \
                                                  std::size_t len) noexcept;
 
@@ -592,8 +529,8 @@
     return cxxbridge1$rust_vec$##RUST_TYPE##$data(this);                       \
   }                                                                            \
   template <>                                                                  \
-  void Vec<CXX_TYPE>::reserve_total(std::size_t new_cap) noexcept {            \
-    cxxbridge1$rust_vec$##RUST_TYPE##$reserve_total(this, new_cap);            \
+  void Vec<CXX_TYPE>::reserve_total(std::size_t cap) noexcept {                \
+    cxxbridge1$rust_vec$##RUST_TYPE##$reserve_total(this, cap);                \
   }                                                                            \
   template <>                                                                  \
   void Vec<CXX_TYPE>::set_len(std::size_t len) noexcept {                      \
@@ -666,13 +603,10 @@
   MACRO(f32, float)                                                            \
   MACRO(f64, double)
 
-#define FOR_EACH_TRIVIAL_STD_VECTOR(MACRO)                                     \
+#define FOR_EACH_STD_VECTOR(MACRO)                                             \
   FOR_EACH_NUMERIC(MACRO)                                                      \
   MACRO(usize, std::size_t)                                                    \
-  MACRO(isize, rust::isize)
-
-#define FOR_EACH_STD_VECTOR(MACRO)                                             \
-  FOR_EACH_TRIVIAL_STD_VECTOR(MACRO)                                           \
+  MACRO(isize, rust::isize)                                                    \
   MACRO(string, std::string)
 
 #define FOR_EACH_RUST_VEC(MACRO)                                               \
@@ -693,7 +627,6 @@
 
 extern "C" {
 FOR_EACH_STD_VECTOR(STD_VECTOR_OPS)
-FOR_EACH_TRIVIAL_STD_VECTOR(STD_VECTOR_TRIVIAL_OPS)
 FOR_EACH_RUST_VEC(RUST_VEC_EXTERNS)
 FOR_EACH_SHARED_PTR(SHARED_PTR_OPS)
 } // extern "C"
diff --git a/src/cxx_string.rs b/src/cxx_string.rs
index 626c2c8..dce7053 100644
--- a/src/cxx_string.rs
+++ b/src/cxx_string.rs
@@ -19,10 +19,6 @@
     fn string_data(this: &CxxString) -> *const u8;
     #[link_name = "cxxbridge1$cxx_string$length"]
     fn string_length(this: &CxxString) -> usize;
-    #[link_name = "cxxbridge1$cxx_string$clear"]
-    fn string_clear(this: Pin<&mut CxxString>);
-    #[link_name = "cxxbridge1$cxx_string$reserve_total"]
-    fn string_reserve_total(this: Pin<&mut CxxString>, new_cap: usize);
     #[link_name = "cxxbridge1$cxx_string$push"]
     fn string_push(this: Pin<&mut CxxString>, ptr: *const u8, len: usize);
 }
@@ -148,49 +144,6 @@
         String::from_utf8_lossy(self.as_bytes())
     }
 
-    /// Removes all characters from the string.
-    ///
-    /// Matches the behavior of C++ [std::string::clear][clear].
-    ///
-    /// Note: **unlike** the guarantee of Rust's `std::string::String::clear`,
-    /// the C++ standard does not require that capacity is unchanged by this
-    /// operation. In practice existing implementations do not change the
-    /// capacity but all pointers, references, and iterators into the string
-    /// contents are nevertheless invalidated.
-    ///
-    /// [clear]: https://en.cppreference.com/w/cpp/string/basic_string/clear
-    pub fn clear(self: Pin<&mut Self>) {
-        unsafe { string_clear(self) }
-    }
-
-    /// Ensures that this string's capacity is at least `additional` bytes
-    /// larger than its length.
-    ///
-    /// The capacity may be increased by more than `additional` bytes if it
-    /// chooses, to amortize the cost of frequent reallocations.
-    ///
-    /// **The meaning of the argument is not the same as
-    /// [std::string::reserve][reserve] in C++.** The C++ standard library and
-    /// Rust standard library both have a `reserve` method on strings, but in
-    /// C++ code the argument always refers to total capacity, whereas in Rust
-    /// code it always refers to additional capacity. This API on `CxxString`
-    /// follows the Rust convention, the same way that for the length accessor
-    /// we use the Rust conventional `len()` naming and not C++ `size()` or
-    /// `length()`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows usize.
-    ///
-    /// [reserve]: https://en.cppreference.com/w/cpp/string/basic_string/reserve
-    pub fn reserve(self: Pin<&mut Self>, additional: usize) {
-        let new_cap = self
-            .len()
-            .checked_add(additional)
-            .expect("CxxString capacity overflow");
-        unsafe { string_reserve_total(self, new_cap) }
-    }
-
     /// Appends a given string slice onto the end of this C++ string.
     pub fn push_str(self: Pin<&mut Self>, s: &str) {
         self.push_bytes(s.as_bytes());
@@ -260,7 +213,6 @@
     space: MaybeUninit<[usize; 8]>,
 }
 
-#[allow(missing_docs)]
 impl StackString {
     pub fn new() -> Self {
         StackString {
@@ -270,11 +222,9 @@
 
     pub unsafe fn init(&mut self, value: impl AsRef<[u8]>) -> Pin<&mut CxxString> {
         let value = value.as_ref();
-        unsafe {
-            let this = &mut *self.space.as_mut_ptr().cast::<MaybeUninit<CxxString>>();
-            string_init(this, value.as_ptr(), value.len());
-            Pin::new_unchecked(&mut *this.as_mut_ptr())
-        }
+        let this = &mut *self.space.as_mut_ptr().cast::<MaybeUninit<CxxString>>();
+        string_init(this, value.as_ptr(), value.len());
+        Pin::new_unchecked(&mut *this.as_mut_ptr())
     }
 }
 
diff --git a/src/cxx_vector.rs b/src/cxx_vector.rs
index d1fa23a..1643341 100644
--- a/src/cxx_vector.rs
+++ b/src/cxx_vector.rs
@@ -8,8 +8,9 @@
 use core::fmt::{self, Debug};
 use core::iter::FusedIterator;
 use core::marker::{PhantomData, PhantomPinned};
-use core::mem::{self, ManuallyDrop, MaybeUninit};
+use core::mem;
 use core::pin::Pin;
+use core::ptr;
 use core::slice;
 
 /// Binding to C++ `std::vector<T, std::allocator<T>>`.
@@ -22,13 +23,7 @@
 /// pointer, as in `&CxxVector<T>` or `UniquePtr<CxxVector<T>>`.
 #[repr(C, packed)]
 pub struct CxxVector<T> {
-    // A thing, because repr(C) structs are not allowed to consist exclusively
-    // of PhantomData fields.
-    _void: [c_void; 0],
-    // The conceptual vector elements to ensure that autotraits are propagated
-    // correctly, e.g. CxxVector is UnwindSafe iff T is.
-    _elements: PhantomData<[T]>,
-    // Prevent unpin operation from Pin<&mut CxxVector<T>> to &mut CxxVector<T>.
+    _private: [T; 0],
     _pinned: PhantomData<PhantomPinned>,
 }
 
@@ -86,10 +81,8 @@
     /// [operator_at]: https://en.cppreference.com/w/cpp/container/vector/operator_at
     pub unsafe fn get_unchecked(&self, pos: usize) -> &T {
         let this = self as *const CxxVector<T> as *mut CxxVector<T>;
-        unsafe {
-            let ptr = T::__get_unchecked(this, pos) as *const T;
-            &*ptr
-        }
+        let ptr = T::__get_unchecked(this, pos) as *const T;
+        &*ptr
     }
 
     /// Returns a pinned mutable reference to an element without doing bounds
@@ -104,10 +97,8 @@
     ///
     /// [operator_at]: https://en.cppreference.com/w/cpp/container/vector/operator_at
     pub unsafe fn index_unchecked_mut(self: Pin<&mut Self>, pos: usize) -> Pin<&mut T> {
-        unsafe {
-            let ptr = T::__get_unchecked(self.get_unchecked_mut(), pos);
-            Pin::new_unchecked(&mut *ptr)
-        }
+        let ptr = T::__get_unchecked(self.get_unchecked_mut(), pos);
+        Pin::new_unchecked(&mut *ptr)
     }
 
     /// Returns a slice to the underlying contiguous array of elements.
@@ -155,39 +146,6 @@
     pub fn iter_mut(self: Pin<&mut Self>) -> IterMut<T> {
         IterMut { v: self, index: 0 }
     }
-
-    /// Appends an element to the back of the vector.
-    ///
-    /// Matches the behavior of C++ [std::vector\<T\>::push_back][push_back].
-    ///
-    /// [push_back]: https://en.cppreference.com/w/cpp/container/vector/push_back
-    pub fn push(self: Pin<&mut Self>, value: T)
-    where
-        T: ExternType<Kind = Trivial>,
-    {
-        let mut value = ManuallyDrop::new(value);
-        unsafe {
-            // C++ calls move constructor followed by destructor on `value`.
-            T::__push_back(self, &mut value);
-        }
-    }
-
-    /// Removes the last element from a vector and returns it, or `None` if the
-    /// vector is empty.
-    pub fn pop(self: Pin<&mut Self>) -> Option<T>
-    where
-        T: ExternType<Kind = Trivial>,
-    {
-        if self.is_empty() {
-            None
-        } else {
-            let mut value = MaybeUninit::uninit();
-            Some(unsafe {
-                T::__pop_back(self, &mut value);
-                value.assume_init()
-            })
-        }
-    }
 }
 
 /// Iterator over elements of a `CxxVector` by shared reference.
@@ -338,62 +296,19 @@
     #[doc(hidden)]
     unsafe fn __get_unchecked(v: *mut CxxVector<Self>, pos: usize) -> *mut Self;
     #[doc(hidden)]
-    unsafe fn __push_back(v: Pin<&mut CxxVector<Self>>, value: &mut ManuallyDrop<Self>) {
-        // Opaque C type vector elements do not get this method because they can
-        // never exist by value on the Rust side of the bridge.
-        let _ = v;
-        let _ = value;
-        unreachable!()
-    }
+    fn __unique_ptr_null() -> *mut c_void;
     #[doc(hidden)]
-    unsafe fn __pop_back(v: Pin<&mut CxxVector<Self>>, out: &mut MaybeUninit<Self>) {
-        // Opaque C type vector elements do not get this method because they can
-        // never exist by value on the Rust side of the bridge.
-        let _ = v;
-        let _ = out;
-        unreachable!()
-    }
+    unsafe fn __unique_ptr_raw(raw: *mut CxxVector<Self>) -> *mut c_void;
     #[doc(hidden)]
-    fn __unique_ptr_null() -> MaybeUninit<*mut c_void>;
+    unsafe fn __unique_ptr_get(repr: *mut c_void) -> *const CxxVector<Self>;
     #[doc(hidden)]
-    unsafe fn __unique_ptr_raw(raw: *mut CxxVector<Self>) -> MaybeUninit<*mut c_void>;
+    unsafe fn __unique_ptr_release(repr: *mut c_void) -> *mut CxxVector<Self>;
     #[doc(hidden)]
-    unsafe fn __unique_ptr_get(repr: MaybeUninit<*mut c_void>) -> *const CxxVector<Self>;
-    #[doc(hidden)]
-    unsafe fn __unique_ptr_release(repr: MaybeUninit<*mut c_void>) -> *mut CxxVector<Self>;
-    #[doc(hidden)]
-    unsafe fn __unique_ptr_drop(repr: MaybeUninit<*mut c_void>);
-}
-
-macro_rules! vector_element_by_value_methods {
-    (opaque, $segment:expr, $ty:ty) => {};
-    (trivial, $segment:expr, $ty:ty) => {
-        #[doc(hidden)]
-        unsafe fn __push_back(v: Pin<&mut CxxVector<$ty>>, value: &mut ManuallyDrop<$ty>) {
-            extern "C" {
-                attr! {
-                    #[link_name = concat!("cxxbridge1$std$vector$", $segment, "$push_back")]
-                    fn __push_back(_: Pin<&mut CxxVector<$ty>>, _: &mut ManuallyDrop<$ty>);
-                }
-            }
-            unsafe { __push_back(v, value) }
-        }
-        #[doc(hidden)]
-        unsafe fn __pop_back(v: Pin<&mut CxxVector<$ty>>, out: &mut MaybeUninit<$ty>) {
-            extern "C" {
-                attr! {
-                    #[link_name = concat!("cxxbridge1$std$vector$", $segment, "$pop_back")]
-                    fn __pop_back(_: Pin<&mut CxxVector<$ty>>, _: &mut MaybeUninit<$ty>);
-                }
-            }
-            unsafe { __pop_back(v, out) }
-        }
-    };
+    unsafe fn __unique_ptr_drop(repr: *mut c_void);
 }
 
 macro_rules! impl_vector_element {
-    ($kind:ident, $segment:expr, $name:expr, $ty:ty) => {
-        const_assert_eq!(0, mem::size_of::<CxxVector<$ty>>());
+    ($segment:expr, $name:expr, $ty:ty) => {
         const_assert_eq!(1, mem::align_of::<CxxVector<$ty>>());
 
         unsafe impl VectorElement for $ty {
@@ -419,62 +334,61 @@
                         fn __get_unchecked(_: *mut CxxVector<$ty>, _: usize) -> *mut $ty;
                     }
                 }
-                unsafe { __get_unchecked(v, pos) }
+                __get_unchecked(v, pos)
             }
-            vector_element_by_value_methods!($kind, $segment, $ty);
             #[doc(hidden)]
-            fn __unique_ptr_null() -> MaybeUninit<*mut c_void> {
+            fn __unique_ptr_null() -> *mut c_void {
                 extern "C" {
                     attr! {
                         #[link_name = concat!("cxxbridge1$unique_ptr$std$vector$", $segment, "$null")]
-                        fn __unique_ptr_null(this: *mut MaybeUninit<*mut c_void>);
+                        fn __unique_ptr_null(this: *mut *mut c_void);
                     }
                 }
-                let mut repr = MaybeUninit::uninit();
+                let mut repr = ptr::null_mut::<c_void>();
                 unsafe { __unique_ptr_null(&mut repr) }
                 repr
             }
             #[doc(hidden)]
-            unsafe fn __unique_ptr_raw(raw: *mut CxxVector<Self>) -> MaybeUninit<*mut c_void> {
+            unsafe fn __unique_ptr_raw(raw: *mut CxxVector<Self>) -> *mut c_void {
                 extern "C" {
                     attr! {
                         #[link_name = concat!("cxxbridge1$unique_ptr$std$vector$", $segment, "$raw")]
-                        fn __unique_ptr_raw(this: *mut MaybeUninit<*mut c_void>, raw: *mut CxxVector<$ty>);
+                        fn __unique_ptr_raw(this: *mut *mut c_void, raw: *mut CxxVector<$ty>);
                     }
                 }
-                let mut repr = MaybeUninit::uninit();
-                unsafe { __unique_ptr_raw(&mut repr, raw) }
+                let mut repr = ptr::null_mut::<c_void>();
+                __unique_ptr_raw(&mut repr, raw);
                 repr
             }
             #[doc(hidden)]
-            unsafe fn __unique_ptr_get(repr: MaybeUninit<*mut c_void>) -> *const CxxVector<Self> {
+            unsafe fn __unique_ptr_get(repr: *mut c_void) -> *const CxxVector<Self> {
                 extern "C" {
                     attr! {
                         #[link_name = concat!("cxxbridge1$unique_ptr$std$vector$", $segment, "$get")]
-                        fn __unique_ptr_get(this: *const MaybeUninit<*mut c_void>) -> *const CxxVector<$ty>;
+                        fn __unique_ptr_get(this: *const *mut c_void) -> *const CxxVector<$ty>;
                     }
                 }
-                unsafe { __unique_ptr_get(&repr) }
+                __unique_ptr_get(&repr)
             }
             #[doc(hidden)]
-            unsafe fn __unique_ptr_release(mut repr: MaybeUninit<*mut c_void>) -> *mut CxxVector<Self> {
+            unsafe fn __unique_ptr_release(mut repr: *mut c_void) -> *mut CxxVector<Self> {
                 extern "C" {
                     attr! {
                         #[link_name = concat!("cxxbridge1$unique_ptr$std$vector$", $segment, "$release")]
-                        fn __unique_ptr_release(this: *mut MaybeUninit<*mut c_void>) -> *mut CxxVector<$ty>;
+                        fn __unique_ptr_release(this: *mut *mut c_void) -> *mut CxxVector<$ty>;
                     }
                 }
-                unsafe { __unique_ptr_release(&mut repr) }
+                __unique_ptr_release(&mut repr)
             }
             #[doc(hidden)]
-            unsafe fn __unique_ptr_drop(mut repr: MaybeUninit<*mut c_void>) {
+            unsafe fn __unique_ptr_drop(mut repr: *mut c_void) {
                 extern "C" {
                     attr! {
                         #[link_name = concat!("cxxbridge1$unique_ptr$std$vector$", $segment, "$drop")]
-                        fn __unique_ptr_drop(this: *mut MaybeUninit<*mut c_void>);
+                        fn __unique_ptr_drop(this: *mut *mut c_void);
                     }
                 }
-                unsafe { __unique_ptr_drop(&mut repr) }
+                __unique_ptr_drop(&mut repr);
             }
         }
     };
@@ -482,7 +396,7 @@
 
 macro_rules! impl_vector_element_for_primitive {
     ($ty:ident) => {
-        impl_vector_element!(trivial, stringify!($ty), stringify!($ty), $ty);
+        impl_vector_element!(stringify!($ty), stringify!($ty), $ty);
     };
 }
 
@@ -499,4 +413,4 @@
 impl_vector_element_for_primitive!(f32);
 impl_vector_element_for_primitive!(f64);
 
-impl_vector_element!(opaque, "string", "CxxString", CxxString);
+impl_vector_element!("string", "CxxString", CxxString);
diff --git a/src/exception.rs b/src/exception.rs
index 2ae470e..f61e8fa 100644
--- a/src/exception.rs
+++ b/src/exception.rs
@@ -1,5 +1,5 @@
 use alloc::boxed::Box;
-use core::fmt::{self, Display};
+use core::fmt::{self, Debug, Display};
 
 /// Exception thrown from an `extern "C++"` function.
 #[derive(Debug)]
@@ -16,7 +16,6 @@
 impl std::error::Error for Exception {}
 
 impl Exception {
-    #[allow(missing_docs)]
     pub fn what(&self) -> &str {
         &self.what
     }
diff --git a/src/extern_type.rs b/src/extern_type.rs
index 8c9c286..35057ac 100644
--- a/src/extern_type.rs
+++ b/src/extern_type.rs
@@ -167,7 +167,6 @@
     /// indirection.
     pub enum Trivial {}
 
-    #[allow(missing_docs)]
     pub trait Kind: private::Sealed {}
     impl Kind for Opaque {}
     impl Kind for Trivial {}
diff --git a/src/function.rs b/src/function.rs
index f0a2010..1166b3d 100644
--- a/src/function.rs
+++ b/src/function.rs
@@ -1,9 +1,5 @@
-#![allow(missing_docs)]
-
-use core::ffi::c_void;
-
 #[repr(C)]
 pub struct FatFunction {
-    pub trampoline: *const c_void,
-    pub ptr: *const c_void,
+    pub trampoline: *const (),
+    pub ptr: *const (),
 }
diff --git a/src/lib.rs b/src/lib.rs
index 9880e71..19a708c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -364,10 +364,8 @@
 //! </table>
 
 #![no_std]
-#![doc(html_root_url = "https://docs.rs/cxx/1.0.54")]
-#![deny(improper_ctypes, improper_ctypes_definitions, missing_docs)]
-#![cfg_attr(not(no_unsafe_op_in_unsafe_fn_lint), deny(unsafe_op_in_unsafe_fn))]
-#![cfg_attr(no_unsafe_op_in_unsafe_fn_lint, allow(unused_unsafe))]
+#![doc(html_root_url = "https://docs.rs/cxx/1.0.42")]
+#![deny(improper_ctypes)]
 #![allow(non_camel_case_types)]
 #![allow(
     clippy::cognitive_complexity,
@@ -488,6 +486,3 @@
     a b c d e f g h i j k l m n o p q r s t u v w x y z
     __ // underscore
 }
-
-#[repr(transparent)]
-struct void(core::ffi::c_void);
diff --git a/src/memory.rs b/src/memory.rs
index fd8df12..441d3d8 100644
--- a/src/memory.rs
+++ b/src/memory.rs
@@ -4,6 +4,5 @@
 
 pub use crate::shared_ptr::SharedPtrTarget;
 pub use crate::unique_ptr::UniquePtrTarget;
-pub use crate::weak_ptr::WeakPtrTarget;
 #[doc(no_inline)]
 pub use cxx::{SharedPtr, UniquePtr};
diff --git a/src/opaque.rs b/src/opaque.rs
index e0f8ce2..3c8f536 100644
--- a/src/opaque.rs
+++ b/src/opaque.rs
@@ -1,6 +1,3 @@
-#![allow(missing_docs)]
-
-use crate::void;
 use core::marker::{PhantomData, PhantomPinned};
 use core::mem;
 
@@ -12,7 +9,7 @@
 // . !Unpin
 #[repr(C, packed)]
 pub struct Opaque {
-    _private: [*const void; 0],
+    _private: [*const u8; 0],
     _pinned: PhantomData<PhantomPinned>,
 }
 
diff --git a/src/result.rs b/src/result.rs
index d7a31f0..f41639a 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -1,5 +1,3 @@
-#![allow(missing_docs)]
-
 use crate::exception::Exception;
 use alloc::boxed::Box;
 use alloc::string::{String, ToString};
@@ -28,16 +26,16 @@
 {
     match result {
         Ok(ok) => {
-            unsafe { ptr::write(ret, ok) }
+            ptr::write(ret, ok);
             Result { ok: ptr::null() }
         }
-        Err(err) => unsafe { to_c_error(err.to_string()) },
+        Err(err) => to_c_error(err.to_string()),
     }
 }
 
 unsafe fn to_c_error(msg: String) -> Result {
     let mut msg = msg;
-    unsafe { msg.as_mut_vec() }.push(b'\0');
+    msg.as_mut_vec().push(b'\0');
     let ptr = msg.as_ptr();
     let len = msg.len();
 
@@ -46,24 +44,22 @@
         fn error(ptr: *const u8, len: usize) -> NonNull<u8>;
     }
 
-    let copy = unsafe { error(ptr, len) };
+    let copy = error(ptr, len);
     let err = PtrLen { ptr: copy, len };
     Result { err }
 }
 
 impl Result {
     pub unsafe fn exception(self) -> StdResult<(), Exception> {
-        unsafe {
-            if self.ok.is_null() {
-                Ok(())
-            } else {
-                let err = self.err;
-                let slice = slice::from_raw_parts_mut(err.ptr.as_ptr(), err.len);
-                let s = str::from_utf8_unchecked_mut(slice);
-                Err(Exception {
-                    what: Box::from_raw(s),
-                })
-            }
+        if self.ok.is_null() {
+            Ok(())
+        } else {
+            let err = self.err;
+            let slice = slice::from_raw_parts_mut(err.ptr.as_ptr(), err.len);
+            let s = str::from_utf8_unchecked_mut(slice);
+            Err(Exception {
+                what: Box::from_raw(s),
+            })
         }
     }
 }
diff --git a/src/rust_slice.rs b/src/rust_slice.rs
index 0696311..b4b5f2c 100644
--- a/src/rust_slice.rs
+++ b/src/rust_slice.rs
@@ -1,66 +1,41 @@
-#![allow(missing_docs)]
-
-use core::mem::{self, MaybeUninit};
+use core::mem;
 use core::ptr::{self, NonNull};
 use core::slice;
 
-// ABI compatible with C++ rust::Slice<T> (not necessarily &[T]).
 #[repr(C)]
 pub struct RustSlice {
-    repr: [MaybeUninit<usize>; mem::size_of::<NonNull<[()]>>() / mem::size_of::<usize>()],
+    pub(crate) repr: NonNull<[()]>,
 }
 
 impl RustSlice {
     pub fn from_ref<T>(slice: &[T]) -> Self {
-        let ptr = NonNull::from(slice).cast::<T>();
-        let len = slice.len();
-        Self::from_raw_parts(ptr, len)
+        let ptr = ptr::slice_from_raw_parts::<()>(slice.as_ptr().cast(), slice.len());
+        RustSlice {
+            repr: unsafe { NonNull::new_unchecked(ptr as *mut _) },
+        }
     }
 
     pub fn from_mut<T>(slice: &mut [T]) -> Self {
-        let ptr = NonNull::from(&mut *slice).cast::<T>();
-        let len = slice.len();
-        Self::from_raw_parts(ptr, len)
+        let ptr = ptr::slice_from_raw_parts_mut(slice.as_mut_ptr().cast(), slice.len());
+        RustSlice {
+            repr: unsafe { NonNull::new_unchecked(ptr) },
+        }
     }
 
     pub unsafe fn as_slice<'a, T>(self) -> &'a [T] {
-        let ptr = self.as_non_null_ptr().as_ptr();
-        let len = self.len();
-        unsafe { slice::from_raw_parts(ptr, len) }
+        let ptr = self.repr.as_ptr();
+        let len = self.repr.as_ref().len();
+        slice::from_raw_parts(ptr.cast(), len)
     }
 
     pub unsafe fn as_mut_slice<'a, T>(self) -> &'a mut [T] {
-        let ptr = self.as_non_null_ptr().as_ptr();
-        let len = self.len();
-        unsafe { slice::from_raw_parts_mut(ptr, len) }
-    }
-
-    pub(crate) fn from_raw_parts<T>(ptr: NonNull<T>, len: usize) -> Self {
-        // TODO: use NonNull::from_raw_parts(ptr.cast(), len) when stable.
-        // https://doc.rust-lang.org/nightly/std/ptr/struct.NonNull.html#method.from_raw_parts
-        // https://github.com/rust-lang/rust/issues/81513
-        let ptr = ptr::slice_from_raw_parts_mut(ptr.as_ptr().cast(), len);
-        unsafe { mem::transmute::<NonNull<[()]>, RustSlice>(NonNull::new_unchecked(ptr)) }
-    }
-
-    pub(crate) fn as_non_null_ptr<T>(&self) -> NonNull<T> {
-        let rust_slice = RustSlice { repr: self.repr };
-        let repr = unsafe { mem::transmute::<RustSlice, NonNull<[()]>>(rust_slice) };
-        repr.cast()
-    }
-
-    pub(crate) fn len(&self) -> usize {
-        let rust_slice = RustSlice { repr: self.repr };
-        let repr = unsafe { mem::transmute::<RustSlice, NonNull<[()]>>(rust_slice) };
-        // TODO: use repr.len() when stable.
-        // https://doc.rust-lang.org/nightly/std/ptr/struct.NonNull.html#method.len
-        // https://github.com/rust-lang/rust/issues/71146
-        unsafe { repr.as_ref() }.len()
+        let ptr = self.repr.as_ptr();
+        let len = self.repr.as_ref().len();
+        slice::from_raw_parts_mut(ptr.cast(), len)
     }
 }
 
-const_assert_eq!(mem::size_of::<NonNull<[()]>>(), mem::size_of::<RustSlice>());
 const_assert_eq!(
-    mem::align_of::<NonNull<[()]>>(),
-    mem::align_of::<RustSlice>(),
+    mem::size_of::<Option<RustSlice>>(),
+    mem::size_of::<RustSlice>(),
 );
diff --git a/src/rust_str.rs b/src/rust_str.rs
index b1b46e3..9bc2614 100644
--- a/src/rust_str.rs
+++ b/src/rust_str.rs
@@ -1,28 +1,21 @@
-#![allow(missing_docs)]
-
-use core::mem::{self, MaybeUninit};
+use core::mem;
 use core::ptr::NonNull;
 use core::str;
 
-// ABI compatible with C++ rust::Str (not necessarily &str).
 #[repr(C)]
 pub struct RustStr {
-    repr: [MaybeUninit<usize>; mem::size_of::<NonNull<str>>() / mem::size_of::<usize>()],
+    repr: NonNull<str>,
 }
 
 impl RustStr {
     pub fn from(repr: &str) -> Self {
         let repr = NonNull::from(repr);
-        unsafe { mem::transmute::<NonNull<str>, RustStr>(repr) }
+        RustStr { repr }
     }
 
     pub unsafe fn as_str<'a>(self) -> &'a str {
-        unsafe {
-            let repr = mem::transmute::<RustStr, NonNull<str>>(self);
-            &*repr.as_ptr()
-        }
+        &*self.repr.as_ptr()
     }
 }
 
-const_assert_eq!(mem::size_of::<NonNull<str>>(), mem::size_of::<RustStr>());
-const_assert_eq!(mem::align_of::<NonNull<str>>(), mem::align_of::<RustStr>());
+const_assert_eq!(mem::size_of::<Option<RustStr>>(), mem::size_of::<RustStr>());
diff --git a/src/rust_string.rs b/src/rust_string.rs
index 051e35c..a5fa3f4 100644
--- a/src/rust_string.rs
+++ b/src/rust_string.rs
@@ -1,18 +1,14 @@
-#![allow(missing_docs)]
-
 use alloc::string::String;
-use core::mem::{self, MaybeUninit};
-use core::ptr;
+use core::mem;
 
-// ABI compatible with C++ rust::String (not necessarily alloc::string::String).
 #[repr(C)]
 pub struct RustString {
-    repr: [MaybeUninit<usize>; mem::size_of::<String>() / mem::size_of::<usize>()],
+    repr: String,
 }
 
 impl RustString {
     pub fn from(s: String) -> Self {
-        unsafe { mem::transmute::<String, RustString>(s) }
+        RustString { repr: s }
     }
 
     pub fn from_ref(s: &String) -> &Self {
@@ -24,24 +20,17 @@
     }
 
     pub fn into_string(self) -> String {
-        unsafe { mem::transmute::<RustString, String>(self) }
+        self.repr
     }
 
     pub fn as_string(&self) -> &String {
-        unsafe { &*(self as *const RustString as *const String) }
+        &self.repr
     }
 
     pub fn as_mut_string(&mut self) -> &mut String {
-        unsafe { &mut *(self as *mut RustString as *mut String) }
+        &mut self.repr
     }
 }
 
-impl Drop for RustString {
-    fn drop(&mut self) {
-        unsafe { ptr::drop_in_place(self.as_mut_string()) }
-    }
-}
-
-const_assert_eq!(mem::size_of::<[usize; 3]>(), mem::size_of::<RustString>());
-const_assert_eq!(mem::size_of::<String>(), mem::size_of::<RustString>());
-const_assert_eq!(mem::align_of::<String>(), mem::align_of::<RustString>());
+const_assert_eq!(mem::size_of::<[usize; 3]>(), mem::size_of::<String>());
+const_assert_eq!(mem::align_of::<usize>(), mem::align_of::<String>());
diff --git a/src/rust_type.rs b/src/rust_type.rs
index eacb530..7bcf440 100644
--- a/src/rust_type.rs
+++ b/src/rust_type.rs
@@ -1,5 +1,3 @@
-#![allow(missing_docs)]
-
 pub unsafe trait RustType {}
 pub unsafe trait ImplBox {}
 pub unsafe trait ImplVec {}
diff --git a/src/rust_vec.rs b/src/rust_vec.rs
index 9f4484d..126fdbf 100644
--- a/src/rust_vec.rs
+++ b/src/rust_vec.rs
@@ -1,27 +1,20 @@
-#![allow(missing_docs)]
-
 use crate::rust_string::RustString;
 use alloc::string::String;
 use alloc::vec::Vec;
-use core::ffi::c_void;
-use core::marker::PhantomData;
-use core::mem::{self, ManuallyDrop, MaybeUninit};
-use core::ptr;
+use core::mem::ManuallyDrop;
 
-// ABI compatible with C++ rust::Vec<T> (not necessarily alloc::vec::Vec<T>).
 #[repr(C)]
 pub struct RustVec<T> {
-    repr: [MaybeUninit<usize>; mem::size_of::<Vec<c_void>>() / mem::size_of::<usize>()],
-    marker: PhantomData<Vec<T>>,
+    pub(crate) repr: Vec<T>,
 }
 
 impl<T> RustVec<T> {
     pub fn new() -> Self {
-        Self::from(Vec::new())
+        RustVec { repr: Vec::new() }
     }
 
     pub fn from(v: Vec<T>) -> Self {
-        unsafe { mem::transmute::<Vec<T>, RustVec<T>>(v) }
+        RustVec { repr: v }
     }
 
     pub fn from_ref(v: &Vec<T>) -> &Self {
@@ -33,39 +26,38 @@
     }
 
     pub fn into_vec(self) -> Vec<T> {
-        unsafe { mem::transmute::<RustVec<T>, Vec<T>>(self) }
+        self.repr
     }
 
     pub fn as_vec(&self) -> &Vec<T> {
-        unsafe { &*(self as *const RustVec<T> as *const Vec<T>) }
+        &self.repr
     }
 
     pub fn as_mut_vec(&mut self) -> &mut Vec<T> {
-        unsafe { &mut *(self as *mut RustVec<T> as *mut Vec<T>) }
+        &mut self.repr
     }
 
     pub fn len(&self) -> usize {
-        self.as_vec().len()
+        self.repr.len()
     }
 
     pub fn capacity(&self) -> usize {
-        self.as_vec().capacity()
+        self.repr.capacity()
     }
 
     pub fn as_ptr(&self) -> *const T {
-        self.as_vec().as_ptr()
+        self.repr.as_ptr()
     }
 
-    pub fn reserve_total(&mut self, new_cap: usize) {
-        let vec = self.as_mut_vec();
-        if new_cap > vec.capacity() {
-            let additional = new_cap - vec.len();
-            vec.reserve(additional);
+    pub fn reserve_total(&mut self, cap: usize) {
+        let len = self.repr.len();
+        if cap > len {
+            self.repr.reserve(cap - len);
         }
     }
 
     pub unsafe fn set_len(&mut self, len: usize) {
-        unsafe { self.as_mut_vec().set_len(len) }
+        self.repr.set_len(len);
     }
 }
 
@@ -87,7 +79,7 @@
     }
 
     pub fn into_vec_string(self) -> Vec<String> {
-        let mut v = ManuallyDrop::new(self.into_vec());
+        let mut v = ManuallyDrop::new(self.repr);
         let ptr = v.as_mut_ptr().cast::<String>();
         let len = v.len();
         let cap = v.capacity();
@@ -95,16 +87,10 @@
     }
 
     pub fn as_vec_string(&self) -> &Vec<String> {
-        unsafe { &*(self as *const RustVec<RustString> as *const Vec<String>) }
+        unsafe { &*(&self.repr as *const Vec<RustString> as *const Vec<String>) }
     }
 
     pub fn as_mut_vec_string(&mut self) -> &mut Vec<String> {
-        unsafe { &mut *(self as *mut RustVec<RustString> as *mut Vec<String>) }
-    }
-}
-
-impl<T> Drop for RustVec<T> {
-    fn drop(&mut self) {
-        unsafe { ptr::drop_in_place(self.as_mut_vec()) }
+        unsafe { &mut *(&mut self.repr as *mut Vec<RustString> as *mut Vec<String>) }
     }
 }
diff --git a/src/shared_ptr.rs b/src/shared_ptr.rs
index 317773d..66b988b 100644
--- a/src/shared_ptr.rs
+++ b/src/shared_ptr.rs
@@ -15,7 +15,7 @@
 where
     T: SharedPtrTarget,
 {
-    repr: [MaybeUninit<*mut c_void>; 2],
+    repr: [*mut c_void; 2],
     ty: PhantomData<T>,
 }
 
@@ -216,7 +216,7 @@
                         fn __null(new: *mut c_void);
                     }
                 }
-                unsafe { __null(new) }
+                __null(new);
             }
             #[doc(hidden)]
             unsafe fn __new(value: Self, new: *mut c_void) {
@@ -226,7 +226,7 @@
                         fn __uninit(new: *mut c_void) -> *mut c_void;
                     }
                 }
-                unsafe { __uninit(new).cast::<$ty>().write(value) }
+                __uninit(new).cast::<$ty>().write(value);
             }
             #[doc(hidden)]
             unsafe fn __clone(this: *const c_void, new: *mut c_void) {
@@ -236,7 +236,7 @@
                         fn __clone(this: *const c_void, new: *mut c_void);
                     }
                 }
-                unsafe { __clone(this, new) }
+                __clone(this, new);
             }
             #[doc(hidden)]
             unsafe fn __get(this: *const c_void) -> *const Self {
@@ -246,7 +246,7 @@
                         fn __get(this: *const c_void) -> *const c_void;
                     }
                 }
-                unsafe { __get(this) }.cast()
+                __get(this).cast()
             }
             #[doc(hidden)]
             unsafe fn __drop(this: *mut c_void) {
@@ -256,7 +256,7 @@
                         fn __drop(this: *mut c_void);
                     }
                 }
-                unsafe { __drop(this) }
+                __drop(this);
             }
         }
     };
diff --git a/src/symbols/exception.rs b/src/symbols/exception.rs
index cf0701b..0c1bb87 100644
--- a/src/symbols/exception.rs
+++ b/src/symbols/exception.rs
@@ -4,7 +4,7 @@
 
 #[export_name = "cxxbridge1$exception"]
 unsafe extern "C" fn exception(ptr: *const u8, len: usize) -> *const u8 {
-    let slice = unsafe { slice::from_raw_parts(ptr, len) };
+    let slice = slice::from_raw_parts(ptr, len);
     let boxed = String::from_utf8_lossy(slice).into_owned().into_boxed_str();
     Box::leak(boxed).as_ptr()
 }
diff --git a/src/symbols/rust_slice.rs b/src/symbols/rust_slice.rs
index df215ac..055b4de 100644
--- a/src/symbols/rust_slice.rs
+++ b/src/symbols/rust_slice.rs
@@ -3,18 +3,20 @@
 use core::ptr::{self, NonNull};
 
 #[export_name = "cxxbridge1$slice$new"]
-unsafe extern "C" fn slice_new(this: &mut MaybeUninit<RustSlice>, ptr: NonNull<()>, len: usize) {
-    let this = this.as_mut_ptr();
-    let rust_slice = RustSlice::from_raw_parts(ptr, len);
-    unsafe { ptr::write(this, rust_slice) }
+unsafe extern "C" fn slice_new(this: &mut MaybeUninit<RustSlice>, ptr: *const (), len: usize) {
+    let ptr = ptr::slice_from_raw_parts(ptr, len);
+    let rust_slice = RustSlice {
+        repr: NonNull::new_unchecked(ptr as *mut _),
+    };
+    ptr::write(this.as_mut_ptr(), rust_slice);
 }
 
 #[export_name = "cxxbridge1$slice$ptr"]
-unsafe extern "C" fn slice_ptr(this: &RustSlice) -> NonNull<()> {
-    this.as_non_null_ptr()
+unsafe extern "C" fn slice_ptr(this: &RustSlice) -> *const () {
+    this.repr.as_ptr().cast()
 }
 
 #[export_name = "cxxbridge1$slice$len"]
 unsafe extern "C" fn slice_len(this: &RustSlice) -> usize {
-    this.len()
+    this.repr.as_ref().len()
 }
diff --git a/src/symbols/rust_str.rs b/src/symbols/rust_str.rs
index 3d5ec34..a9e84ef 100644
--- a/src/symbols/rust_str.rs
+++ b/src/symbols/rust_str.rs
@@ -6,24 +6,20 @@
 
 #[export_name = "cxxbridge1$str$new"]
 unsafe extern "C" fn str_new(this: &mut MaybeUninit<&str>) {
-    let this = this.as_mut_ptr();
-    unsafe { ptr::write(this, "") }
+    ptr::write(this.as_mut_ptr(), "");
 }
 
 #[export_name = "cxxbridge1$str$ref"]
 unsafe extern "C" fn str_ref<'a>(this: &mut MaybeUninit<&'a str>, string: &'a String) {
-    let this = this.as_mut_ptr();
-    let s = string.as_str();
-    unsafe { ptr::write(this, s) }
+    ptr::write(this.as_mut_ptr(), string.as_str());
 }
 
 #[export_name = "cxxbridge1$str$from"]
 unsafe extern "C" fn str_from(this: &mut MaybeUninit<&str>, ptr: *const u8, len: usize) -> bool {
-    let slice = unsafe { slice::from_raw_parts(ptr, len) };
+    let slice = slice::from_raw_parts(ptr, len);
     match str::from_utf8(slice) {
         Ok(s) => {
-            let this = this.as_mut_ptr();
-            unsafe { ptr::write(this, s) }
+            ptr::write(this.as_mut_ptr(), s);
             true
         }
         Err(_) => false,
diff --git a/src/symbols/rust_string.rs b/src/symbols/rust_string.rs
index 49d4069..91fd78a 100644
--- a/src/symbols/rust_string.rs
+++ b/src/symbols/rust_string.rs
@@ -7,47 +7,24 @@
 
 #[export_name = "cxxbridge1$string$new"]
 unsafe extern "C" fn string_new(this: &mut MaybeUninit<String>) {
-    let this = this.as_mut_ptr();
-    let new = String::new();
-    unsafe { ptr::write(this, new) }
+    ptr::write(this.as_mut_ptr(), String::new());
 }
 
 #[export_name = "cxxbridge1$string$clone"]
 unsafe extern "C" fn string_clone(this: &mut MaybeUninit<String>, other: &String) {
-    let this = this.as_mut_ptr();
-    let clone = other.clone();
-    unsafe { ptr::write(this, clone) }
+    ptr::write(this.as_mut_ptr(), other.clone());
 }
 
-#[export_name = "cxxbridge1$string$from_utf8"]
-unsafe extern "C" fn string_from_utf8(
+#[export_name = "cxxbridge1$string$from"]
+unsafe extern "C" fn string_from(
     this: &mut MaybeUninit<String>,
     ptr: *const u8,
     len: usize,
 ) -> bool {
-    let slice = unsafe { slice::from_raw_parts(ptr, len) };
+    let slice = slice::from_raw_parts(ptr, len);
     match str::from_utf8(slice) {
         Ok(s) => {
-            let this = this.as_mut_ptr();
-            let owned = s.to_owned();
-            unsafe { ptr::write(this, owned) }
-            true
-        }
-        Err(_) => false,
-    }
-}
-
-#[export_name = "cxxbridge1$string$from_utf16"]
-unsafe extern "C" fn string_from_utf16(
-    this: &mut MaybeUninit<String>,
-    ptr: *const u16,
-    len: usize,
-) -> bool {
-    let slice = unsafe { slice::from_raw_parts(ptr, len) };
-    match String::from_utf16(slice) {
-        Ok(s) => {
-            let this = this.as_mut_ptr();
-            unsafe { ptr::write(this, s) }
+            ptr::write(this.as_mut_ptr(), s.to_owned());
             true
         }
         Err(_) => false,
@@ -56,7 +33,7 @@
 
 #[export_name = "cxxbridge1$string$drop"]
 unsafe extern "C" fn string_drop(this: &mut ManuallyDrop<String>) {
-    unsafe { ManuallyDrop::drop(this) }
+    ManuallyDrop::drop(this);
 }
 
 #[export_name = "cxxbridge1$string$ptr"]
@@ -69,20 +46,7 @@
     this.len()
 }
 
-#[export_name = "cxxbridge1$string$capacity"]
-unsafe extern "C" fn string_capacity(this: &String) -> usize {
-    this.capacity()
-}
-
-#[export_name = "cxxbridge1$string$reserve_additional"]
-unsafe extern "C" fn string_reserve_additional(this: &mut String, additional: usize) {
-    this.reserve(additional);
-}
-
 #[export_name = "cxxbridge1$string$reserve_total"]
-unsafe extern "C" fn string_reserve_total(this: &mut String, new_cap: usize) {
-    if new_cap > this.capacity() {
-        let additional = new_cap - this.len();
-        this.reserve(additional);
-    }
+unsafe extern "C" fn string_reserve_total(this: &mut String, cap: usize) {
+    this.reserve(cap);
 }
diff --git a/src/symbols/rust_vec.rs b/src/symbols/rust_vec.rs
index 6f2dab9..a26a156 100644
--- a/src/symbols/rust_vec.rs
+++ b/src/symbols/rust_vec.rs
@@ -7,51 +7,50 @@
 
 macro_rules! rust_vec_shims {
     ($segment:expr, $ty:ty) => {
-        const_assert_eq!(mem::size_of::<[usize; 3]>(), mem::size_of::<RustVec<$ty>>());
-        const_assert_eq!(mem::size_of::<Vec<$ty>>(), mem::size_of::<RustVec<$ty>>());
-        const_assert_eq!(mem::align_of::<Vec<$ty>>(), mem::align_of::<RustVec<$ty>>());
+        const_assert_eq!(mem::size_of::<[usize; 3]>(), mem::size_of::<Vec<$ty>>());
+        const_assert_eq!(mem::align_of::<usize>(), mem::align_of::<Vec<$ty>>());
 
         const _: () = {
             attr! {
                 #[export_name = concat!("cxxbridge1$rust_vec$", $segment, "$new")]
                 unsafe extern "C" fn __new(this: *mut RustVec<$ty>) {
-                    unsafe { ptr::write(this, RustVec::new()) }
+                    ptr::write(this, RustVec { repr: Vec::new() });
                 }
             }
             attr! {
                 #[export_name = concat!("cxxbridge1$rust_vec$", $segment, "$drop")]
                 unsafe extern "C" fn __drop(this: *mut RustVec<$ty>) {
-                    unsafe { ptr::drop_in_place(this) }
+                    ptr::drop_in_place(this);
                 }
             }
             attr! {
                 #[export_name = concat!("cxxbridge1$rust_vec$", $segment, "$len")]
                 unsafe extern "C" fn __len(this: *const RustVec<$ty>) -> usize {
-                    unsafe { &*this }.len()
+                    (*this).repr.len()
                 }
             }
             attr! {
                 #[export_name = concat!("cxxbridge1$rust_vec$", $segment, "$capacity")]
                 unsafe extern "C" fn __capacity(this: *const RustVec<$ty>) -> usize {
-                    unsafe { &*this }.capacity()
+                    (*this).repr.capacity()
                 }
             }
             attr! {
                 #[export_name = concat!("cxxbridge1$rust_vec$", $segment, "$data")]
                 unsafe extern "C" fn __data(this: *const RustVec<$ty>) -> *const $ty {
-                    unsafe { &*this }.as_ptr()
+                    (*this).repr.as_ptr()
                 }
             }
             attr! {
                 #[export_name = concat!("cxxbridge1$rust_vec$", $segment, "$reserve_total")]
-                unsafe extern "C" fn __reserve_total(this: *mut RustVec<$ty>, new_cap: usize) {
-                    unsafe { &mut *this }.reserve_total(new_cap);
+                unsafe extern "C" fn __reserve_total(this: *mut RustVec<$ty>, cap: usize) {
+                    (*this).reserve_total(cap);
                 }
             }
             attr! {
                 #[export_name = concat!("cxxbridge1$rust_vec$", $segment, "$set_len")]
                 unsafe extern "C" fn __set_len(this: *mut RustVec<$ty>, len: usize) {
-                    unsafe { (*this).set_len(len) }
+                    (*this).repr.set_len(len);
                 }
             }
         };
diff --git a/src/unique_ptr.rs b/src/unique_ptr.rs
index 63a1ca7..836f467 100644
--- a/src/unique_ptr.rs
+++ b/src/unique_ptr.rs
@@ -6,9 +6,10 @@
 use core::ffi::c_void;
 use core::fmt::{self, Debug, Display};
 use core::marker::PhantomData;
-use core::mem::{self, MaybeUninit};
+use core::mem;
 use core::ops::{Deref, DerefMut};
 use core::pin::Pin;
+use core::ptr;
 
 /// Binding to C++ `std::unique_ptr<T, std::default_delete<T>>`.
 #[repr(C)]
@@ -16,7 +17,7 @@
 where
     T: UniquePtrTarget,
 {
-    repr: MaybeUninit<*mut c_void>,
+    repr: *mut c_void,
     ty: PhantomData<T>,
 }
 
@@ -103,7 +104,7 @@
     /// twice on the same raw pointer.
     pub unsafe fn from_raw(raw: *mut T) -> Self {
         UniquePtr {
-            repr: unsafe { T::__raw(raw) },
+            repr: T::__raw(raw),
             ty: PhantomData,
         }
     }
@@ -206,9 +207,9 @@
     #[doc(hidden)]
     fn __typename(f: &mut fmt::Formatter) -> fmt::Result;
     #[doc(hidden)]
-    fn __null() -> MaybeUninit<*mut c_void>;
+    fn __null() -> *mut c_void;
     #[doc(hidden)]
-    fn __new(value: Self) -> MaybeUninit<*mut c_void>
+    fn __new(value: Self) -> *mut c_void
     where
         Self: Sized,
     {
@@ -218,26 +219,26 @@
         unreachable!()
     }
     #[doc(hidden)]
-    unsafe fn __raw(raw: *mut Self) -> MaybeUninit<*mut c_void>;
+    unsafe fn __raw(raw: *mut Self) -> *mut c_void;
     #[doc(hidden)]
-    unsafe fn __get(repr: MaybeUninit<*mut c_void>) -> *const Self;
+    unsafe fn __get(repr: *mut c_void) -> *const Self;
     #[doc(hidden)]
-    unsafe fn __release(repr: MaybeUninit<*mut c_void>) -> *mut Self;
+    unsafe fn __release(repr: *mut c_void) -> *mut Self;
     #[doc(hidden)]
-    unsafe fn __drop(repr: MaybeUninit<*mut c_void>);
+    unsafe fn __drop(repr: *mut c_void);
 }
 
 extern "C" {
     #[link_name = "cxxbridge1$unique_ptr$std$string$null"]
-    fn unique_ptr_std_string_null(this: *mut MaybeUninit<*mut c_void>);
+    fn unique_ptr_std_string_null(this: *mut *mut c_void);
     #[link_name = "cxxbridge1$unique_ptr$std$string$raw"]
-    fn unique_ptr_std_string_raw(this: *mut MaybeUninit<*mut c_void>, raw: *mut CxxString);
+    fn unique_ptr_std_string_raw(this: *mut *mut c_void, raw: *mut CxxString);
     #[link_name = "cxxbridge1$unique_ptr$std$string$get"]
-    fn unique_ptr_std_string_get(this: *const MaybeUninit<*mut c_void>) -> *const CxxString;
+    fn unique_ptr_std_string_get(this: *const *mut c_void) -> *const CxxString;
     #[link_name = "cxxbridge1$unique_ptr$std$string$release"]
-    fn unique_ptr_std_string_release(this: *mut MaybeUninit<*mut c_void>) -> *mut CxxString;
+    fn unique_ptr_std_string_release(this: *mut *mut c_void) -> *mut CxxString;
     #[link_name = "cxxbridge1$unique_ptr$std$string$drop"]
-    fn unique_ptr_std_string_drop(this: *mut MaybeUninit<*mut c_void>);
+    fn unique_ptr_std_string_drop(this: *mut *mut c_void);
 }
 
 unsafe impl UniquePtrTarget for CxxString {
@@ -246,30 +247,30 @@
         f.write_str("CxxString")
     }
     #[doc(hidden)]
-    fn __null() -> MaybeUninit<*mut c_void> {
-        let mut repr = MaybeUninit::uninit();
+    fn __null() -> *mut c_void {
+        let mut repr = ptr::null_mut::<c_void>();
         unsafe {
             unique_ptr_std_string_null(&mut repr);
         }
         repr
     }
     #[doc(hidden)]
-    unsafe fn __raw(raw: *mut Self) -> MaybeUninit<*mut c_void> {
-        let mut repr = MaybeUninit::uninit();
-        unsafe { unique_ptr_std_string_raw(&mut repr, raw) }
+    unsafe fn __raw(raw: *mut Self) -> *mut c_void {
+        let mut repr = ptr::null_mut::<c_void>();
+        unique_ptr_std_string_raw(&mut repr, raw);
         repr
     }
     #[doc(hidden)]
-    unsafe fn __get(repr: MaybeUninit<*mut c_void>) -> *const Self {
-        unsafe { unique_ptr_std_string_get(&repr) }
+    unsafe fn __get(repr: *mut c_void) -> *const Self {
+        unique_ptr_std_string_get(&repr)
     }
     #[doc(hidden)]
-    unsafe fn __release(mut repr: MaybeUninit<*mut c_void>) -> *mut Self {
-        unsafe { unique_ptr_std_string_release(&mut repr) }
+    unsafe fn __release(mut repr: *mut c_void) -> *mut Self {
+        unique_ptr_std_string_release(&mut repr)
     }
     #[doc(hidden)]
-    unsafe fn __drop(mut repr: MaybeUninit<*mut c_void>) {
-        unsafe { unique_ptr_std_string_drop(&mut repr) }
+    unsafe fn __drop(mut repr: *mut c_void) {
+        unique_ptr_std_string_drop(&mut repr);
     }
 }
 
@@ -282,23 +283,23 @@
         write!(f, "CxxVector<{}>", display(T::__typename))
     }
     #[doc(hidden)]
-    fn __null() -> MaybeUninit<*mut c_void> {
+    fn __null() -> *mut c_void {
         T::__unique_ptr_null()
     }
     #[doc(hidden)]
-    unsafe fn __raw(raw: *mut Self) -> MaybeUninit<*mut c_void> {
-        unsafe { T::__unique_ptr_raw(raw) }
+    unsafe fn __raw(raw: *mut Self) -> *mut c_void {
+        T::__unique_ptr_raw(raw)
     }
     #[doc(hidden)]
-    unsafe fn __get(repr: MaybeUninit<*mut c_void>) -> *const Self {
-        unsafe { T::__unique_ptr_get(repr) }
+    unsafe fn __get(repr: *mut c_void) -> *const Self {
+        T::__unique_ptr_get(repr)
     }
     #[doc(hidden)]
-    unsafe fn __release(repr: MaybeUninit<*mut c_void>) -> *mut Self {
-        unsafe { T::__unique_ptr_release(repr) }
+    unsafe fn __release(repr: *mut c_void) -> *mut Self {
+        T::__unique_ptr_release(repr)
     }
     #[doc(hidden)]
-    unsafe fn __drop(repr: MaybeUninit<*mut c_void>) {
-        unsafe { T::__unique_ptr_drop(repr) }
+    unsafe fn __drop(repr: *mut c_void) {
+        T::__unique_ptr_drop(repr);
     }
 }
diff --git a/src/unwind.rs b/src/unwind.rs
index 4967a21..36f6ae3 100644
--- a/src/unwind.rs
+++ b/src/unwind.rs
@@ -1,5 +1,3 @@
-#![allow(missing_docs)]
-
 use std::io::{self, Write};
 use std::panic::{self, AssertUnwindSafe};
 use std::process;
diff --git a/src/weak_ptr.rs b/src/weak_ptr.rs
index 8a9f1a6..8291d59 100644
--- a/src/weak_ptr.rs
+++ b/src/weak_ptr.rs
@@ -16,7 +16,7 @@
 where
     T: WeakPtrTarget,
 {
-    repr: [MaybeUninit<*mut c_void>; 2],
+    repr: [*mut c_void; 2],
     ty: PhantomData<T>,
 }
 
@@ -91,11 +91,8 @@
     }
 }
 
-/// Trait bound for types which may be used as the `T` inside of a `WeakPtr<T>`
-/// in generic code.
-///
-/// This trait has no publicly callable or implementable methods. Implementing
-/// it outside of the CXX codebase is not supported.
+// Methods are private; not intended to be implemented outside of cxxbridge
+// codebase.
 pub unsafe trait WeakPtrTarget {
     #[doc(hidden)]
     fn __typename(f: &mut fmt::Formatter) -> fmt::Result;
@@ -126,7 +123,7 @@
                         fn __null(new: *mut c_void);
                     }
                 }
-                unsafe { __null(new) }
+                __null(new);
             }
             #[doc(hidden)]
             unsafe fn __clone(this: *const c_void, new: *mut c_void) {
@@ -136,7 +133,7 @@
                         fn __clone(this: *const c_void, new: *mut c_void);
                     }
                 }
-                unsafe { __clone(this, new) }
+                __clone(this, new);
             }
             #[doc(hidden)]
             unsafe fn __downgrade(shared: *const c_void, weak: *mut c_void) {
@@ -146,7 +143,7 @@
                         fn __downgrade(shared: *const c_void, weak: *mut c_void);
                     }
                 }
-                unsafe { __downgrade(shared, weak) }
+                __downgrade(shared, weak);
             }
             #[doc(hidden)]
             unsafe fn __upgrade(weak: *const c_void, shared: *mut c_void) {
@@ -156,7 +153,7 @@
                         fn __upgrade(weak: *const c_void, shared: *mut c_void);
                     }
                 }
-                unsafe { __upgrade(weak, shared) }
+                __upgrade(weak, shared);
             }
             #[doc(hidden)]
             unsafe fn __drop(this: *mut c_void) {
@@ -166,7 +163,7 @@
                         fn __drop(this: *mut c_void);
                     }
                 }
-                unsafe { __drop(this) }
+                __drop(this);
             }
         }
     };
diff --git a/syntax/attrs.rs b/syntax/attrs.rs
index fa6c809..4808f2e 100644
--- a/syntax/attrs.rs
+++ b/syntax/attrs.rs
@@ -4,7 +4,7 @@
 use crate::syntax::{Derive, Doc, ForeignName};
 use proc_macro2::{Ident, TokenStream};
 use quote::ToTokens;
-use syn::parse::{Nothing, Parse, ParseStream, Parser as _};
+use syn::parse::{ParseStream, Parser as _};
 use syn::{Attribute, Error, LitStr, Path, Result, Token};
 
 // Intended usage:
@@ -33,7 +33,6 @@
     pub namespace: Option<&'a mut Namespace>,
     pub cxx_name: Option<&'a mut Option<ForeignName>>,
     pub rust_name: Option<&'a mut Option<Ident>>,
-    pub variants_from_header: Option<&'a mut Option<Attribute>>,
 
     // Suppress clippy needless_update lint ("struct update has no effect, all
     // the fields in the struct have already been specified") when preemptively
@@ -122,14 +121,6 @@
                     break;
                 }
             }
-        } else if attr.path.is_ident("variants_from_header") && cfg!(feature = "experimental") {
-            if let Err(err) = Nothing::parse.parse2(attr.tokens.clone()) {
-                cx.push(err);
-            }
-            if let Some(variants_from_header) = &mut parser.variants_from_header {
-                **variants_from_header = Some(attr);
-                continue;
-            }
         } else if attr.path.is_ident("allow")
             || attr.path.is_ident("warn")
             || attr.path.is_ident("deny")
@@ -233,19 +224,7 @@
 impl ToTokens for OtherAttrs {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         for attr in &self.0 {
-            let Attribute {
-                pound_token,
-                style,
-                bracket_token,
-                path,
-                tokens: attr_tokens,
-            } = attr;
-            pound_token.to_tokens(tokens);
-            let _ = style; // ignore; render outer and inner attrs both as outer
-            bracket_token.surround(tokens, |tokens| {
-                path.to_tokens(tokens);
-                attr_tokens.to_tokens(tokens);
-            });
+            attr.to_tokens(tokens);
         }
     }
 }
diff --git a/syntax/check.rs b/syntax/check.rs
index 698782f..bab2dec 100644
--- a/syntax/check.rs
+++ b/syntax/check.rs
@@ -2,40 +2,24 @@
 use crate::syntax::report::Errors;
 use crate::syntax::visit::{self, Visit};
 use crate::syntax::{
-    error, ident, trivial, Api, Array, Enum, ExternFn, ExternType, Impl, Lang, Lifetimes,
-    NamedType, Ptr, Receiver, Ref, Signature, SliceRef, Struct, Trait, Ty1, Type, TypeAlias, Types,
+    error, ident, trivial, Api, Array, Enum, ExternFn, ExternType, Impl, Lang, NamedType, Ptr,
+    Receiver, Ref, Signature, SliceRef, Struct, Trait, Ty1, Type, TypeAlias, Types,
 };
 use proc_macro2::{Delimiter, Group, Ident, TokenStream};
 use quote::{quote, ToTokens};
 use std::fmt::Display;
-use syn::{GenericParam, Generics, Lifetime};
 
 pub(crate) struct Check<'a> {
     apis: &'a [Api],
     types: &'a Types<'a>,
     errors: &'a mut Errors,
-    generator: Generator,
 }
 
-pub(crate) enum Generator {
-    // cxx-build crate, cxxbridge cli, cxx-gen.
-    #[allow(dead_code)]
-    Build,
-    // cxxbridge-macro. This is relevant in that the macro output is going to
-    // get fed straight to rustc, so for errors that rustc already contains
-    // logic to catch (probably with a better diagnostic than what the proc
-    // macro API is able to produce), we avoid duplicating them in our own
-    // diagnostics.
-    #[allow(dead_code)]
-    Macro,
-}
-
-pub(crate) fn typecheck(cx: &mut Errors, apis: &[Api], types: &Types, generator: Generator) {
+pub(crate) fn typecheck(cx: &mut Errors, apis: &[Api], types: &Types) {
     do_typecheck(&mut Check {
         apis,
         types,
         errors: cx,
-        generator,
     });
 }
 
@@ -266,9 +250,7 @@
 fn check_type_slice_ref(cx: &mut Check, ty: &SliceRef) {
     let supported = !is_unsized(cx, &ty.inner)
         || match &ty.inner {
-            Type::Ident(ident) => {
-                cx.types.rust.contains(&ident.rust) || cx.types.aliases.contains_key(&ident.rust)
-            }
+            Type::Ident(ident) => cx.types.rust.contains(&ident.rust),
             _ => false,
         };
 
@@ -312,7 +294,6 @@
 fn check_api_struct(cx: &mut Check, strct: &Struct) {
     let name = &strct.name;
     check_reserved_name(cx, &name.rust);
-    check_lifetimes(cx, &strct.generics);
 
     if strct.fields.is_empty() {
         let span = span_for_struct_error(strct);
@@ -349,9 +330,8 @@
 
 fn check_api_enum(cx: &mut Check, enm: &Enum) {
     check_reserved_name(cx, &enm.name.rust);
-    check_lifetimes(cx, &enm.generics);
 
-    if enm.variants.is_empty() && !enm.explicit_repr && !enm.variants_from_header {
+    if enm.variants.is_empty() && !enm.explicit_repr {
         let span = span_for_enum_error(enm);
         cx.error(
             span,
@@ -369,7 +349,6 @@
 
 fn check_api_type(cx: &mut Check, ety: &ExternType) {
     check_reserved_name(cx, &ety.name.rust);
-    check_lifetimes(cx, &ety.generics);
 
     for derive in &ety.derives {
         if derive.what == Trait::ExternType && ety.lang == Lang::Rust {
@@ -421,8 +400,6 @@
         }
     }
 
-    check_generics(cx, &efn.sig.generics);
-
     if let Some(receiver) = &efn.receiver {
         let ref span = span_for_receiver_error(receiver);
 
@@ -495,8 +472,6 @@
 }
 
 fn check_api_type_alias(cx: &mut Check, alias: &TypeAlias) {
-    check_lifetimes(cx, &alias.generics);
-
     for derive in &alias.derives {
         let msg = format!("derive({}) on extern type alias is not supported", derive);
         cx.error(derive, msg);
@@ -506,8 +481,6 @@
 fn check_api_impl(cx: &mut Check, imp: &Impl) {
     let ty = &imp.ty;
 
-    check_lifetimes(cx, &imp.impl_generics);
-
     if let Some(negative) = imp.negative_token {
         let span = quote!(#negative #ty);
         cx.error(span, "negative impl is not supported yet");
@@ -610,31 +583,6 @@
     }
 }
 
-fn check_reserved_lifetime(cx: &mut Check, lifetime: &Lifetime) {
-    if lifetime.ident == "static" {
-        match cx.generator {
-            Generator::Macro => { /* rustc already reports this */ }
-            Generator::Build => {
-                cx.error(lifetime, error::RESERVED_LIFETIME);
-            }
-        }
-    }
-}
-
-fn check_lifetimes(cx: &mut Check, generics: &Lifetimes) {
-    for lifetime in &generics.lifetimes {
-        check_reserved_lifetime(cx, lifetime);
-    }
-}
-
-fn check_generics(cx: &mut Check, generics: &Generics) {
-    for generic_param in &generics.params {
-        if let GenericParam::Lifetime(def) = generic_param {
-            check_reserved_lifetime(cx, &def.lifetime);
-        }
-    }
-}
-
 fn is_unsized(cx: &mut Check, ty: &Type) -> bool {
     match ty {
         Type::Ident(ident) => {
diff --git a/syntax/discriminant.rs b/syntax/discriminant.rs
index fff8f75..80f7c0b 100644
--- a/syntax/discriminant.rs
+++ b/syntax/discriminant.rs
@@ -150,7 +150,7 @@
 }
 
 impl Discriminant {
-    pub const fn zero() -> Self {
+    const fn zero() -> Self {
         Discriminant {
             sign: Sign::Positive,
             magnitude: 0,
@@ -179,28 +179,6 @@
             magnitude: i.wrapping_abs() as u64,
         }
     }
-
-    pub const fn checked_succ(self) -> Option<Self> {
-        match self.sign {
-            Sign::Negative => {
-                if self.magnitude == 1 {
-                    Some(Discriminant::zero())
-                } else {
-                    Some(Discriminant {
-                        sign: Sign::Negative,
-                        magnitude: self.magnitude - 1,
-                    })
-                }
-            }
-            Sign::Positive => match self.magnitude.checked_add(1) {
-                Some(magnitude) => Some(Discriminant {
-                    sign: Sign::Positive,
-                    magnitude,
-                }),
-                None => None,
-            },
-        }
-    }
 }
 
 impl Display for Discriminant {
@@ -208,7 +186,7 @@
         if self.sign == Sign::Negative {
             f.write_str("-")?;
         }
-        write!(f, "{}", self.magnitude)
+        Display::fmt(&self.magnitude, f)
     }
 }
 
diff --git a/syntax/doc.rs b/syntax/doc.rs
index cd764fa..60bb4da 100644
--- a/syntax/doc.rs
+++ b/syntax/doc.rs
@@ -17,10 +17,6 @@
         self.fragments.push(lit);
     }
 
-    pub fn is_empty(&self) -> bool {
-        self.fragments.is_empty()
-    }
-
     pub fn to_string(&self) -> String {
         let mut doc = String::new();
         for lit in &self.fragments {
diff --git a/syntax/error.rs b/syntax/error.rs
index f40c4a8..a672329 100644
--- a/syntax/error.rs
+++ b/syntax/error.rs
@@ -21,7 +21,6 @@
     DISCRIMINANT_OVERFLOW,
     DOT_INCLUDE,
     DOUBLE_UNDERSCORE,
-    RESERVED_LIFETIME,
     RUST_TYPE_BY_VALUE,
     UNSUPPORTED_TYPE,
     USE_NOT_ALLOWED,
@@ -69,12 +68,6 @@
     note: Some("identifiers containing double underscore are reserved in C++"),
 };
 
-pub static RESERVED_LIFETIME: Error = Error {
-    msg: "invalid lifetime parameter name: `'static`",
-    label: Some("'static is a reserved lifetime name"),
-    note: None,
-};
-
 pub static RUST_TYPE_BY_VALUE: Error = Error {
     msg: "opaque Rust type by value is not supported",
     label: None,
diff --git a/syntax/file.rs b/syntax/file.rs
index 99466b8..fd6dd98 100644
--- a/syntax/file.rs
+++ b/syntax/file.rs
@@ -91,32 +91,17 @@
 
         let item = input.parse()?;
         match item {
-            RustItem::Struct(mut item) => {
-                item.attrs.splice(..0, attrs);
-                Ok(Item::Struct(item))
-            }
-            RustItem::Enum(mut item) => {
-                item.attrs.splice(..0, attrs);
-                Ok(Item::Enum(item))
-            }
-            RustItem::ForeignMod(mut item) => {
-                item.attrs.splice(..0, attrs);
-                Ok(Item::ForeignMod(ItemForeignMod {
-                    attrs: item.attrs,
-                    unsafety,
-                    abi: item.abi,
-                    brace_token: item.brace_token,
-                    items: item.items,
-                }))
-            }
-            RustItem::Impl(mut item) => {
-                item.attrs.splice(..0, attrs);
-                Ok(Item::Impl(item))
-            }
-            RustItem::Use(mut item) => {
-                item.attrs.splice(..0, attrs);
-                Ok(Item::Use(item))
-            }
+            RustItem::Struct(item) => Ok(Item::Struct(ItemStruct { attrs, ..item })),
+            RustItem::Enum(item) => Ok(Item::Enum(ItemEnum { attrs, ..item })),
+            RustItem::ForeignMod(item) => Ok(Item::ForeignMod(ItemForeignMod {
+                attrs,
+                unsafety,
+                abi: item.abi,
+                brace_token: item.brace_token,
+                items: item.items,
+            })),
+            RustItem::Impl(item) => Ok(Item::Impl(ItemImpl { attrs, ..item })),
+            RustItem::Use(item) => Ok(Item::Use(ItemUse { attrs, ..item })),
             other => Ok(Item::Other(other)),
         }
     }
diff --git a/syntax/impls.rs b/syntax/impls.rs
index 06d68dc..8b0743b 100644
--- a/syntax/impls.rs
+++ b/syntax/impls.rs
@@ -339,7 +339,6 @@
                     attrs: _,
                     visibility: _,
                     name: _,
-                    colon_token: _,
                     ty,
                 } = arg;
                 let Var {
@@ -347,7 +346,6 @@
                     attrs: _,
                     visibility: _,
                     name: _,
-                    colon_token: _,
                     ty: ty2,
                 } = arg2;
                 ty == ty2
@@ -376,7 +374,6 @@
                 attrs: _,
                 visibility: _,
                 name: _,
-                colon_token: _,
                 ty,
             } = arg;
             ty.hash(state);
@@ -396,7 +393,6 @@
             lifetime,
             mutable,
             var: _,
-            colon_token: _,
             ty,
             shorthand: _,
             pin_tokens: _,
@@ -408,7 +404,6 @@
             lifetime: lifetime2,
             mutable: mutable2,
             var: _,
-            colon_token: _,
             ty: ty2,
             shorthand: _,
             pin_tokens: _,
@@ -426,7 +421,6 @@
             lifetime,
             mutable,
             var: _,
-            colon_token: _,
             ty,
             shorthand: _,
             pin_tokens: _,
diff --git a/syntax/mod.rs b/syntax/mod.rs
index 1d98634..3d56293 100644
--- a/syntax/mod.rs
+++ b/syntax/mod.rs
@@ -30,17 +30,17 @@
 mod visit;
 
 use self::attrs::OtherAttrs;
+use self::discriminant::Discriminant;
 use self::namespace::Namespace;
 use self::parse::kw;
 use self::symbol::Symbol;
 use proc_macro2::{Ident, Span};
 use syn::punctuated::Punctuated;
 use syn::token::{Brace, Bracket, Paren};
-use syn::{Attribute, Expr, Generics, Lifetime, LitInt, Path, Token, Type as RustType};
+use syn::{Expr, Generics, Lifetime, LitInt, Token, Type as RustType};
 
 pub use self::atom::Atom;
 pub use self::derive::{Derive, Trait};
-pub use self::discriminant::Discriminant;
 pub use self::doc::Doc;
 pub use self::names::ForeignName;
 pub use self::parse::parse_items;
@@ -111,17 +111,11 @@
     pub generics: Lifetimes,
     pub brace_token: Brace,
     pub variants: Vec<Variant>,
-    pub variants_from_header: bool,
-    pub variants_from_header_attr: Option<Attribute>,
-    pub repr: EnumRepr,
+    pub repr: Atom,
+    pub repr_type: Type,
     pub explicit_repr: bool,
 }
 
-pub enum EnumRepr {
-    Native { atom: Atom, repr_type: Type },
-    Foreign { rust_type: Path },
-}
-
 pub struct ExternFn {
     pub lang: Lang,
     pub doc: Doc,
@@ -180,7 +174,6 @@
     pub attrs: OtherAttrs,
     pub visibility: Token![pub],
     pub name: Pair,
-    pub colon_token: Token![:],
     pub ty: Type,
 }
 
@@ -191,7 +184,6 @@
     pub mutable: bool,
     pub var: Token![self],
     pub ty: NamedType,
-    pub colon_token: Token![:],
     pub shorthand: bool,
     pub pin_tokens: Option<(kw::Pin, Token![<], Token![>])>,
     pub mutability: Option<Token![mut]>,
diff --git a/syntax/names.rs b/syntax/names.rs
index 7a125ae..cb6ace5 100644
--- a/syntax/names.rs
+++ b/syntax/names.rs
@@ -9,6 +9,7 @@
 #[derive(Clone)]
 pub struct ForeignName {
     text: String,
+    span: Span,
 }
 
 impl Pair {
@@ -55,7 +56,7 @@
         match syn::parse_str::<Ident>(text) {
             Ok(ident) => {
                 let text = ident.to_string();
-                Ok(ForeignName { text })
+                Ok(ForeignName { text, span })
             }
             Err(err) => Err(Error::new(span, err)),
         }
@@ -67,9 +68,3 @@
         formatter.write_str(&self.text)
     }
 }
-
-impl PartialEq<str> for ForeignName {
-    fn eq(&self, rhs: &str) -> bool {
-        self.text == rhs
-    }
-}
diff --git a/syntax/parse.rs b/syntax/parse.rs
index 32d36eb..d792076 100644
--- a/syntax/parse.rs
+++ b/syntax/parse.rs
@@ -4,9 +4,9 @@
 use crate::syntax::report::Errors;
 use crate::syntax::Atom::*;
 use crate::syntax::{
-    attrs, error, Api, Array, Derive, Doc, Enum, EnumRepr, ExternFn, ExternType, ForeignName, Impl,
-    Include, IncludeKind, Lang, Lifetimes, NamedType, Namespace, Pair, Ptr, Receiver, Ref,
-    Signature, SliceRef, Struct, Ty1, Type, TypeAlias, Var, Variant,
+    attrs, error, Api, Array, Derive, Doc, Enum, ExternFn, ExternType, ForeignName, Impl, Include,
+    IncludeKind, Lang, Lifetimes, NamedType, Namespace, Pair, Ptr, Receiver, Ref, Signature,
+    SliceRef, Struct, Ty1, Type, TypeAlias, Var, Variant,
 };
 use proc_macro2::{Delimiter, Group, Span, TokenStream, TokenTree};
 use quote::{format_ident, quote, quote_spanned};
@@ -146,13 +146,11 @@
         };
         let visibility = visibility_pub(&field.vis, ident.span());
         let name = pair(Namespace::default(), &ident, cxx_name, rust_name);
-        let colon_token = field.colon_token.unwrap();
         fields.push(Var {
             doc,
             attrs,
             visibility,
             name,
-            colon_token,
             ty,
         });
     }
@@ -187,7 +185,6 @@
     let mut namespace = namespace.clone();
     let mut cxx_name = None;
     let mut rust_name = None;
-    let mut variants_from_header = None;
     let attrs = attrs::parse(
         cx,
         item.attrs,
@@ -198,7 +195,6 @@
             namespace: Some(&mut namespace),
             cxx_name: Some(&mut cxx_name),
             rust_name: Some(&mut rust_name),
-            variants_from_header: Some(&mut variants_from_header),
             ..Default::default()
         },
     );
@@ -241,17 +237,11 @@
     let name = pair(namespace, &item.ident, cxx_name, rust_name);
     let repr_ident = Ident::new(repr.as_ref(), Span::call_site());
     let repr_type = Type::Ident(NamedType::new(repr_ident));
-    let repr = EnumRepr::Native {
-        atom: repr,
-        repr_type,
-    };
     let generics = Lifetimes {
         lt_token: None,
         lifetimes: Punctuated::new(),
         gt_token: None,
     };
-    let variants_from_header_attr = variants_from_header;
-    let variants_from_header = variants_from_header_attr.is_some();
 
     Api::Enum(Enum {
         doc,
@@ -263,9 +253,8 @@
         generics,
         brace_token,
         variants,
-        variants_from_header,
-        variants_from_header_attr,
         repr,
+        repr_type,
         explicit_repr,
     })
 }
@@ -571,7 +560,6 @@
                         lifetime: lifetime.clone(),
                         mutable: arg.mutability.is_some(),
                         var: arg.self_token,
-                        colon_token: Token![:](arg.self_token.span),
                         ty: NamedType::new(Ident::new("Self", arg.self_token.span)),
                         shorthand: true,
                         pin_tokens: None,
@@ -595,13 +583,11 @@
                     let attrs = OtherAttrs::none();
                     let visibility = Token![pub](ident.span());
                     let name = pair(Namespace::default(), &ident, None, None);
-                    let colon_token = arg.colon_token;
                     args.push_value(Var {
                         doc,
                         attrs,
                         visibility,
                         name,
-                        colon_token,
                         ty,
                     });
                     if let Some(comma) = comma {
@@ -617,7 +603,6 @@
                             lifetime: reference.lifetime,
                             mutable: reference.mutable,
                             var: Token![self](ident.rust.span()),
-                            colon_token: arg.colon_token,
                             ty: ident,
                             shorthand: false,
                             pin_tokens: reference.pin_tokens,
@@ -1287,16 +1272,11 @@
         .iter()
         .enumerate()
         .map(|(i, arg)| {
-            let (ident, colon_token) = match &arg.name {
-                Some((ident, colon_token)) => (ident.clone(), *colon_token),
-                None => {
-                    let fn_span = ty.paren_token.span;
-                    let ident = format_ident!("arg{}", i, span = fn_span);
-                    let colon_token = Token![:](fn_span);
-                    (ident, colon_token)
-                }
-            };
             let ty = parse_type(&arg.ty)?;
+            let ident = match &arg.name {
+                Some(ident) => ident.0.clone(),
+                None => format_ident!("arg{}", i),
+            };
             let doc = Doc::new();
             let attrs = OtherAttrs::none();
             let visibility = Token![pub](ident.span());
@@ -1306,7 +1286,6 @@
                 attrs,
                 visibility,
                 name,
-                colon_token,
                 ty,
             })
         })
diff --git a/syntax/tokens.rs b/syntax/tokens.rs
index 33f20fa..c1a06a2 100644
--- a/syntax/tokens.rs
+++ b/syntax/tokens.rs
@@ -1,7 +1,7 @@
 use crate::syntax::atom::Atom::*;
 use crate::syntax::{
-    Array, Atom, Derive, Enum, EnumRepr, ExternFn, ExternType, Impl, Lifetimes, NamedType, Ptr,
-    Receiver, Ref, Signature, SliceRef, Struct, Ty1, Type, TypeAlias, Var,
+    Array, Atom, Derive, Enum, ExternFn, ExternType, Impl, Lifetimes, NamedType, Ptr, Receiver,
+    Ref, Signature, SliceRef, Struct, Ty1, Type, TypeAlias, Var,
 };
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{quote_spanned, ToTokens};
@@ -43,7 +43,6 @@
             attrs: _,
             visibility: _,
             name,
-            colon_token: _,
             ty,
         } = self;
         name.rust.to_tokens(tokens);
@@ -280,15 +279,6 @@
     }
 }
 
-impl ToTokens for EnumRepr {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        match self {
-            EnumRepr::Native { atom, repr_type: _ } => atom.to_tokens(tokens),
-            EnumRepr::Foreign { rust_type } => rust_type.to_tokens(tokens),
-        }
-    }
-}
-
 impl ToTokens for NamedType {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let NamedType { rust, generics } = self;
@@ -320,7 +310,6 @@
             lifetime,
             mutable: _,
             var: _,
-            colon_token: _,
             ty,
             shorthand: _,
             pin_tokens,
@@ -348,7 +337,6 @@
             lifetime,
             mutable: _,
             var: _,
-            colon_token: _,
             ty,
             shorthand: _,
             pin_tokens,
diff --git a/syntax/trivial.rs b/syntax/trivial.rs
index 067e2d7..fe95e2b 100644
--- a/syntax/trivial.rs
+++ b/syntax/trivial.rs
@@ -11,7 +11,6 @@
     FunctionReturn(&'a ExternFn),
     BoxTarget,
     VecElement,
-    SliceElement { mutable: bool },
     UnpinnedMut(&'a ExternFn),
 }
 
@@ -106,14 +105,6 @@
                     insist_extern_types_are_trivial(ident, reason);
                 }
             }
-            Type::SliceRef(ty) => {
-                if let Type::Ident(ident) = &ty.inner {
-                    let reason = TrivialReason::SliceElement {
-                        mutable: ty.mutable,
-                    };
-                    insist_extern_types_are_trivial(ident, reason);
-                }
-            }
             _ => {}
         }
     }
@@ -137,8 +128,6 @@
             let mut return_of = Set::new();
             let mut box_target = false;
             let mut vec_element = false;
-            let mut slice_shared_element = false;
-            let mut slice_mut_element = false;
             let mut unpinned_mut = Set::new();
 
             for reason in self.reasons {
@@ -154,13 +143,6 @@
                     }
                     TrivialReason::BoxTarget => box_target = true,
                     TrivialReason::VecElement => vec_element = true,
-                    TrivialReason::SliceElement { mutable } => {
-                        if *mutable {
-                            slice_mut_element = true;
-                        } else {
-                            slice_shared_element = true;
-                        }
-                    }
                     TrivialReason::UnpinnedMut(efn) => {
                         unpinned_mut.insert(&efn.name.rust);
                     }
@@ -203,15 +185,6 @@
                     param: self.name,
                 });
             }
-            if slice_shared_element || slice_mut_element {
-                clauses.push(Clause::Slice {
-                    article: "a",
-                    desc: "slice element in",
-                    shared: slice_shared_element,
-                    mutable: slice_mut_element,
-                    param: self.name,
-                });
-            }
             if !unpinned_mut.is_empty() {
                 clauses.push(Clause::Set {
                     article: "a",
@@ -246,21 +219,12 @@
             desc: &'a str,
             param: &'a Pair,
         },
-        Slice {
-            article: &'a str,
-            desc: &'a str,
-            shared: bool,
-            mutable: bool,
-            param: &'a Pair,
-        },
     }
 
     impl<'a> Clause<'a> {
         fn article(&self) -> &'a str {
             match self {
-                Clause::Set { article, .. }
-                | Clause::Ty1 { article, .. }
-                | Clause::Slice { article, .. } => article,
+                Clause::Set { article, .. } | Clause::Ty1 { article, .. } => article,
             }
         }
 
@@ -285,25 +249,6 @@
                     desc,
                     param,
                 } => write!(f, "{}<{}>", desc, param.rust),
-                Clause::Slice {
-                    article: _,
-                    desc,
-                    shared,
-                    mutable,
-                    param,
-                } => {
-                    write!(f, "{} ", desc)?;
-                    if *shared {
-                        write!(f, "&[{}]", param.rust)?;
-                    }
-                    if *shared && *mutable {
-                        write!(f, " and ")?;
-                    }
-                    if *mutable {
-                        write!(f, "&mut [{}]", param.rust)?;
-                    }
-                    Ok(())
-                }
             }
         }
     }
diff --git a/syntax/types.rs b/syntax/types.rs
index c54682b..af7916d 100644
--- a/syntax/types.rs
+++ b/syntax/types.rs
@@ -7,7 +7,7 @@
 use crate::syntax::trivial::{self, TrivialReason};
 use crate::syntax::visit::{self, Visit};
 use crate::syntax::{
-    toposort, Api, Atom, Enum, EnumRepr, ExternType, Impl, Lifetimes, Pair, Struct, Type, TypeAlias,
+    toposort, Api, Atom, Enum, ExternType, Impl, Lifetimes, Pair, Struct, Type, TypeAlias,
 };
 use proc_macro2::Ident;
 use quote::ToTokens;
@@ -88,12 +88,7 @@
                     add_resolution(&strct.name, &strct.generics);
                 }
                 Api::Enum(enm) => {
-                    match &enm.repr {
-                        EnumRepr::Native { atom: _, repr_type } => {
-                            all.insert(repr_type);
-                        }
-                        EnumRepr::Foreign { rust_type: _ } => {}
-                    }
+                    all.insert(&enm.repr_type);
                     let ident = &enm.name.rust;
                     if !type_names.insert(ident)
                         && (!cxx.contains(ident)
@@ -106,11 +101,6 @@
                         duplicate_name(cx, enm, ident);
                     }
                     enums.insert(ident, enm);
-                    if enm.variants_from_header {
-                        // #![variants_from_header] enums are implicitly extern
-                        // C++ type.
-                        cxx.insert(&enm.name.rust);
-                    }
                     add_resolution(&enm.name, &enm.generics);
                 }
                 Api::CxxType(ety) => {
@@ -260,14 +250,6 @@
             ImproperCtype::Depends(ident) => self.struct_improper_ctypes.contains(ident),
         }
     }
-
-    // Types which we need to assume could possibly exist by value on the Rust
-    // side.
-    pub fn is_maybe_trivial(&self, ty: &Ident) -> bool {
-        self.structs.contains_key(ty)
-            || self.enums.contains_key(ty)
-            || self.aliases.contains_key(ty)
-    }
 }
 
 impl<'t, 'a> IntoIterator for &'t Types<'a> {
diff --git a/tests/BUILD b/tests/BUILD
index d4af3af..7886e4f 100644
--- a/tests/BUILD
+++ b/tests/BUILD
@@ -1,5 +1,5 @@
 load("@rules_cc//cc:defs.bzl", "cc_library")
-load("@rules_rust//rust:rust.bzl", "rust_library", "rust_test")
+load("//tools/bazel:rust.bzl", "rust_library", "rust_test")
 load("//tools/bazel:rust_cxx_bridge.bzl", "rust_cxx_bridge")
 
 rust_test(
diff --git a/tests/ffi/lib.rs b/tests/ffi/lib.rs
index 25b4ccd..fcbe153 100644
--- a/tests/ffi/lib.rs
+++ b/tests/ffi/lib.rs
@@ -157,10 +157,6 @@
         fn c_take_ref_rust_vec_copy(v: &Vec<u8>);
         fn c_take_ref_shared_string(s: &SharedString) -> &SharedString;
         fn c_take_callback(callback: fn(String) -> usize);
-        fn c_take_callback_ref(callback: fn(&String));
-        #[cxx_name = "c_take_callback_ref"]
-        fn c_take_callback_ref_lifetime<'a>(callback: fn(&'a String));
-        fn c_take_callback_mut(callback: fn(&mut String));
         fn c_take_enum(e: Enum);
         fn c_take_ns_enum(e: AEnum);
         fn c_take_nested_ns_enum(e: ABEnum);
@@ -326,7 +322,6 @@
     }
 
     impl Box<Shared> {}
-    impl CxxVector<SharedString> {}
 }
 
 mod other {
diff --git a/tests/ffi/tests.cc b/tests/ffi/tests.cc
index df7ded0..ba12ed4 100644
--- a/tests/ffi/tests.cc
+++ b/tests/ffi/tests.cc
@@ -336,13 +336,13 @@
 }
 
 void c_take_unique_ptr_vector_u8(std::unique_ptr<std::vector<uint8_t>> v) {
-  if (v->size() == 3) {
+  if (v->size() == 4) {
     cxx_test_suite_set_correct();
   }
 }
 
 void c_take_unique_ptr_vector_f64(std::unique_ptr<std::vector<double>> v) {
-  if (v->size() == 5) {
+  if (v->size() == 4) {
     cxx_test_suite_set_correct();
   }
 }
@@ -354,7 +354,7 @@
 }
 
 void c_take_unique_ptr_vector_shared(std::unique_ptr<std::vector<Shared>> v) {
-  if (v->size() == 3) {
+  if (v->size() == 2) {
     cxx_test_suite_set_correct();
   }
 }
@@ -494,16 +494,6 @@
   callback("2020");
 }
 
-void c_take_callback_ref(rust::Fn<void(const rust::String &)> callback) {
-  const rust::String string = "2020";
-  callback(string);
-}
-
-void c_take_callback_mut(rust::Fn<void(rust::String &)> callback) {
-  rust::String string = "2020";
-  callback(string);
-}
-
 void c_take_enum(Enum e) {
   if (e == Enum::AVal) {
     cxx_test_suite_set_correct();
@@ -835,24 +825,12 @@
   ASSERT(cstring == "foo");
   ASSERT(other_cstring == "test");
 
-  ASSERT(cstring.capacity() == 3);
-  cstring.reserve(2);
-  ASSERT(cstring.capacity() == 3);
-  cstring.reserve(5);
-  ASSERT(cstring.capacity() >= 5);
-
   rust::Str cstr = "test";
   rust::Str other_cstr = "foo";
   swap(cstr, other_cstr);
   ASSERT(cstr == "foo");
   ASSERT(other_cstr == "test");
 
-  const char *utf8_literal = u8"Test string";
-  const char16_t *utf16_literal = u"Test string";
-  rust::String utf8_rstring = utf8_literal;
-  rust::String utf16_rstring = utf16_literal;
-  ASSERT(utf8_rstring == utf16_rstring);
-
   rust::Vec<int> vec1{1, 2};
   rust::Vec<int> vec2{3, 4};
   swap(vec1, vec2);
diff --git a/tests/ffi/tests.h b/tests/ffi/tests.h
index b624d39..74acbf4 100644
--- a/tests/ffi/tests.h
+++ b/tests/ffi/tests.h
@@ -160,8 +160,6 @@
 void c_take_ref_rust_vec_copy(const rust::Vec<uint8_t> &v);
 const SharedString &c_take_ref_shared_string(const SharedString &s);
 void c_take_callback(rust::Fn<size_t(rust::String)> callback);
-void c_take_callback_ref(rust::Fn<void(const rust::String &)> callback);
-void c_take_callback_mut(rust::Fn<void(rust::String &)> callback);
 void c_take_enum(Enum e);
 void c_take_ns_enum(::A::AEnum e);
 void c_take_nested_ns_enum(::A::B::ABEnum e);
diff --git a/tests/test.rs b/tests/test.rs
index 1f0b166..32b8e83 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -150,15 +150,15 @@
     check!(ffi::c_take_unique_ptr_string(
         ffi::c_return_unique_ptr_string()
     ));
-    let mut vector = ffi::c_return_unique_ptr_vector_u8();
-    assert_eq!(vector.pin_mut().pop(), Some(9));
-    check!(ffi::c_take_unique_ptr_vector_u8(vector));
-    let mut vector = ffi::c_return_unique_ptr_vector_f64();
-    vector.pin_mut().push(9.0);
-    check!(ffi::c_take_unique_ptr_vector_f64(vector));
-    let mut vector = ffi::c_return_unique_ptr_vector_shared();
-    vector.pin_mut().push(ffi::Shared { z: 9 });
-    check!(ffi::c_take_unique_ptr_vector_shared(vector));
+    check!(ffi::c_take_unique_ptr_vector_u8(
+        ffi::c_return_unique_ptr_vector_u8()
+    ));
+    check!(ffi::c_take_unique_ptr_vector_f64(
+        ffi::c_return_unique_ptr_vector_f64()
+    ));
+    check!(ffi::c_take_unique_ptr_vector_shared(
+        ffi::c_return_unique_ptr_vector_shared()
+    ));
     check!(ffi::c_take_ref_vector(&ffi::c_return_unique_ptr_vector_u8()));
     let test_vec = [86_u8, 75_u8, 30_u8, 9_u8].to_vec();
     check!(ffi::c_take_rust_vec(test_vec.clone()));
@@ -204,23 +204,7 @@
         0
     }
 
-    #[allow(clippy::ptr_arg)]
-    fn callback_ref(s: &String) {
-        if s == "2020" {
-            cxx_test_suite_set_correct();
-        }
-    }
-
-    fn callback_mut(s: &mut String) {
-        if s == "2020" {
-            cxx_test_suite_set_correct();
-        }
-    }
-
     check!(ffi::c_take_callback(callback));
-    check!(ffi::c_take_callback_ref(callback_ref));
-    check!(ffi::c_take_callback_ref_lifetime(callback_ref));
-    check!(ffi::c_take_callback_mut(callback_mut));
 }
 
 #[test]
diff --git a/tests/ui/array_len_suffix.stderr b/tests/ui/array_len_suffix.stderr
index 143bcb0..b72fc02 100644
--- a/tests/ui/array_len_suffix.stderr
+++ b/tests/ui/array_len_suffix.stderr
@@ -7,4 +7,4 @@
 help: change the type of the numeric literal from `u16` to `usize`
   |
 4 |         fn array() -> [String; 12usize];
-  |                                  ~~~~~
+  |                                ^^^^^^^
diff --git a/tests/ui/derive_nonclone.rs b/tests/ui/derive_nonclone.rs
new file mode 100644
index 0000000..5811028
--- /dev/null
+++ b/tests/ui/derive_nonclone.rs
@@ -0,0 +1,13 @@
+#[cxx::bridge]
+mod ffi {
+    #[derive(Clone)]
+    struct TryClone {
+        other: Other,
+    }
+
+    struct Other {
+        x: usize,
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/derive_nonclone.stderr b/tests/ui/derive_nonclone.stderr
new file mode 100644
index 0000000..04eae4f
--- /dev/null
+++ b/tests/ui/derive_nonclone.stderr
@@ -0,0 +1,7 @@
+error[E0277]: the trait bound `ffi::Other: Clone` is not satisfied
+ --> $DIR/derive_nonclone.rs:5:9
+  |
+5 |         other: Other,
+  |         ^^^^^^^^^^^^ the trait `Clone` is not implemented for `ffi::Other`
+  |
+  = note: required by `clone`
diff --git a/tests/ui/expected_named.stderr b/tests/ui/expected_named.stderr
index dab3b5a..4676401 100644
--- a/tests/ui/expected_named.stderr
+++ b/tests/ui/expected_named.stderr
@@ -8,4 +8,4 @@
 help: consider using the `'static` lifetime
   |
 5 |         fn borrowed() -> UniquePtr<Borrowed<'static>>;
-  |                                    ~~~~~~~~~~~~~~~~~
+  |                                    ^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/opaque_autotraits.stderr b/tests/ui/opaque_autotraits.stderr
index 15a2b64..4f469ef 100644
--- a/tests/ui/opaque_autotraits.stderr
+++ b/tests/ui/opaque_autotraits.stderr
@@ -1,59 +1,40 @@
-error[E0277]: `*const cxx::void` cannot be sent between threads safely
+error[E0277]: `*const u8` cannot be sent between threads safely
   --> $DIR/opaque_autotraits.rs:13:5
    |
-13 |     assert_send::<ffi::Opaque>();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ `*const cxx::void` cannot be sent between threads safely
-   |
-   = help: within `ffi::Opaque`, the trait `Send` is not implemented for `*const cxx::void`
-   = note: required because it appears within the type `[*const cxx::void; 0]`
-   = note: required because it appears within the type `cxx::private::Opaque`
-note: required because it appears within the type `ffi::Opaque`
-  --> $DIR/opaque_autotraits.rs:4:14
-   |
-4  |         type Opaque;
-   |              ^^^^^^
-note: required by a bound in `assert_send`
-  --> $DIR/opaque_autotraits.rs:8:19
-   |
 8  | fn assert_send<T: Send>() {}
-   |                   ^^^^ required by this bound in `assert_send`
+   |                   ---- required by this bound in `assert_send`
+...
+13 |     assert_send::<ffi::Opaque>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ `*const u8` cannot be sent between threads safely
+   |
+   = help: within `ffi::Opaque`, the trait `Send` is not implemented for `*const u8`
+   = note: required because it appears within the type `[*const u8; 0]`
+   = note: required because it appears within the type `cxx::private::Opaque`
+   = note: required because it appears within the type `ffi::Opaque`
 
-error[E0277]: `*const cxx::void` cannot be shared between threads safely
+error[E0277]: `*const u8` cannot be shared between threads safely
   --> $DIR/opaque_autotraits.rs:14:5
    |
-14 |     assert_sync::<ffi::Opaque>();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ `*const cxx::void` cannot be shared between threads safely
-   |
-   = help: within `ffi::Opaque`, the trait `Sync` is not implemented for `*const cxx::void`
-   = note: required because it appears within the type `[*const cxx::void; 0]`
-   = note: required because it appears within the type `cxx::private::Opaque`
-note: required because it appears within the type `ffi::Opaque`
-  --> $DIR/opaque_autotraits.rs:4:14
-   |
-4  |         type Opaque;
-   |              ^^^^^^
-note: required by a bound in `assert_sync`
-  --> $DIR/opaque_autotraits.rs:9:19
-   |
 9  | fn assert_sync<T: Sync>() {}
-   |                   ^^^^ required by this bound in `assert_sync`
+   |                   ---- required by this bound in `assert_sync`
+...
+14 |     assert_sync::<ffi::Opaque>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ `*const u8` cannot be shared between threads safely
+   |
+   = help: within `ffi::Opaque`, the trait `Sync` is not implemented for `*const u8`
+   = note: required because it appears within the type `[*const u8; 0]`
+   = note: required because it appears within the type `cxx::private::Opaque`
+   = note: required because it appears within the type `ffi::Opaque`
 
 error[E0277]: `PhantomPinned` cannot be unpinned
   --> $DIR/opaque_autotraits.rs:15:5
    |
+10 | fn assert_unpin<T: Unpin>() {}
+   |                    ----- required by this bound in `assert_unpin`
+...
 15 |     assert_unpin::<ffi::Opaque>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `ffi::Opaque`, the trait `Unpin` is not implemented for `PhantomPinned`
    |
-   = note: consider using `Box::pin`
    = note: required because it appears within the type `PhantomData<PhantomPinned>`
    = note: required because it appears within the type `cxx::private::Opaque`
-note: required because it appears within the type `ffi::Opaque`
-  --> $DIR/opaque_autotraits.rs:4:14
-   |
-4  |         type Opaque;
-   |              ^^^^^^
-note: required by a bound in `assert_unpin`
-  --> $DIR/opaque_autotraits.rs:10:20
-   |
-10 | fn assert_unpin<T: Unpin>() {}
-   |                    ^^^^^ required by this bound in `assert_unpin`
+   = note: required because it appears within the type `ffi::Opaque`
diff --git a/tests/ui/opaque_not_sized.stderr b/tests/ui/opaque_not_sized.stderr
index b50a269..9818e44 100644
--- a/tests/ui/opaque_not_sized.stderr
+++ b/tests/ui/opaque_not_sized.stderr
@@ -2,16 +2,10 @@
  --> $DIR/opaque_not_sized.rs:4:14
   |
 4 |         type TypeR;
-  |              ^^^^^ doesn't have a size known at compile-time
+  |         -----^^^^^-
+  |         |    |
+  |         |    doesn't have a size known at compile-time
+  |         required by this bound in `__AssertSized`
   |
   = help: within `TypeR`, the trait `Sized` is not implemented for `str`
-note: required because it appears within the type `TypeR`
- --> $DIR/opaque_not_sized.rs:8:8
-  |
-8 | struct TypeR(str);
-  |        ^^^^^
-note: required by a bound in `__AssertSized`
- --> $DIR/opaque_not_sized.rs:4:9
-  |
-4 |         type TypeR;
-  |         ^^^^^^^^^^^ required by this bound in `__AssertSized`
+  = note: required because it appears within the type `TypeR`
diff --git a/tests/ui/reserved_lifetime.rs b/tests/ui/reserved_lifetime.rs
deleted file mode 100644
index 179a4db..0000000
--- a/tests/ui/reserved_lifetime.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#[cxx::bridge]
-mod ffi {
-    unsafe extern "C++" {
-        type Logger;
-
-        fn logger<'static>() -> Pin<&'static Logger>;
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/reserved_lifetime.stderr b/tests/ui/reserved_lifetime.stderr
deleted file mode 100644
index 723572d..0000000
--- a/tests/ui/reserved_lifetime.stderr
+++ /dev/null
@@ -1,5 +0,0 @@
-error[E0262]: invalid lifetime parameter name: `'static`
- --> $DIR/reserved_lifetime.rs:6:19
-  |
-6 |         fn logger<'static>() -> Pin<&'static Logger>;
-  |                   ^^^^^^^ 'static is a reserved lifetime name
diff --git a/tests/ui/rust_pinned.stderr b/tests/ui/rust_pinned.stderr
index 8857681..f16f9d5 100644
--- a/tests/ui/rust_pinned.stderr
+++ b/tests/ui/rust_pinned.stderr
@@ -1,17 +1,10 @@
 error[E0277]: `PhantomPinned` cannot be unpinned
-  --> $DIR/rust_pinned.rs:6:14
-   |
-6  |         type Pinned;
-   |              ^^^^^^ within `Pinned`, the trait `Unpin` is not implemented for `PhantomPinned`
-   |
-   = note: consider using `Box::pin`
-note: required because it appears within the type `Pinned`
-  --> $DIR/rust_pinned.rs:10:12
-   |
-10 | pub struct Pinned {
-   |            ^^^^^^
-note: required by a bound in `__AssertUnpin`
-  --> $DIR/rust_pinned.rs:6:9
-   |
-6  |         type Pinned;
-   |         ^^^^^^^^^^^^ required by this bound in `__AssertUnpin`
+ --> $DIR/rust_pinned.rs:6:14
+  |
+6 |         type Pinned;
+  |         -----^^^^^^-
+  |         |    |
+  |         |    within `Pinned`, the trait `Unpin` is not implemented for `PhantomPinned`
+  |         required by this bound in `__AssertUnpin`
+  |
+  = note: required because it appears within the type `Pinned`
diff --git a/tests/ui/slice_of_type_alias.rs b/tests/ui/slice_of_type_alias.rs
deleted file mode 100644
index a7bbc11..0000000
--- a/tests/ui/slice_of_type_alias.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use cxx::{type_id, ExternType};
-
-#[repr(C)]
-struct ElementTrivial(usize);
-
-#[repr(C)]
-struct ElementOpaque(usize);
-
-#[cxx::bridge]
-mod ffi {
-    unsafe extern "C++" {
-        type ElementTrivial = crate::ElementTrivial;
-        type ElementOpaque = crate::ElementOpaque;
-
-        fn f(slice: &mut [ElementTrivial]);
-        fn g(slice: &[ElementOpaque]);
-    }
-}
-
-unsafe impl ExternType for ElementTrivial {
-    type Id = type_id!("ElementTrivial");
-    type Kind = cxx::kind::Trivial;
-}
-
-unsafe impl ExternType for ElementOpaque {
-    type Id = type_id!("ElementOpaque");
-    type Kind = cxx::kind::Opaque;
-}
-
-fn main() {}
diff --git a/tests/ui/slice_of_type_alias.stderr b/tests/ui/slice_of_type_alias.stderr
deleted file mode 100644
index aff06f8..0000000
--- a/tests/ui/slice_of_type_alias.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error[E0271]: type mismatch resolving `<ElementOpaque as ExternType>::Kind == Trivial`
-   --> $DIR/slice_of_type_alias.rs:13:9
-    |
-13  |         type ElementOpaque = crate::ElementOpaque;
-    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `Trivial`, found enum `cxx::kind::Opaque`
-    |
-note: required by a bound in `verify_extern_kind`
-   --> $DIR/extern_type.rs:186:41
-    |
-186 | pub fn verify_extern_kind<T: ExternType<Kind = Kind>, Kind: self::Kind>() {}
-    |                                         ^^^^^^^^^^^ required by this bound in `verify_extern_kind`
diff --git a/tests/ui/slice_unsupported.stderr b/tests/ui/slice_unsupported.stderr
index 2cbd26d..787076f 100644
--- a/tests/ui/slice_unsupported.stderr
+++ b/tests/ui/slice_unsupported.stderr
@@ -3,9 +3,3 @@
   |
 6 |         fn f(_: &mut [Opaque]);
   |                 ^^^^^^^^^^^^^
-
-error: needs a cxx::ExternType impl in order to be used as a slice element in &mut [Opaque]
- --> $DIR/slice_unsupported.rs:4:9
-  |
-4 |         type Opaque;
-  |         ^^^^^^^^^^^
diff --git a/tests/ui/unique_ptr_to_opaque.stderr b/tests/ui/unique_ptr_to_opaque.stderr
index 28e45cf..19d76a3 100644
--- a/tests/ui/unique_ptr_to_opaque.stderr
+++ b/tests/ui/unique_ptr_to_opaque.stderr
@@ -4,10 +4,4 @@
 22 |     cxx::UniquePtr::new(outside::C { a: 4 });
    |     ^^^^^^^^^^^^^^^^^^^ expected enum `Trivial`, found enum `cxx::kind::Opaque`
    |
-note: required by `UniquePtr::<T>::new`
-  --> $DIR/unique_ptr.rs:38:5
-   |
-38 | /     pub fn new(value: T) -> Self
-39 | |     where
-40 | |         T: ExternType<Kind = Trivial>,
-   | |______________________________________^
+   = note: required by `UniquePtr::<T>::new`
diff --git a/tests/ui/unsupported_elided.stderr b/tests/ui/unsupported_elided.stderr
index 8e8a986..932076d 100644
--- a/tests/ui/unsupported_elided.stderr
+++ b/tests/ui/unsupported_elided.stderr
@@ -3,8 +3,6 @@
   |
 6 |         type T;
   |              ^- help: indicate the anonymous lifetime: `<'_>`
-  |
-  = note: assuming a `'static` lifetime...
 
 error[E0106]: missing lifetime specifier
  --> $DIR/unsupported_elided.rs:8:24
@@ -16,4 +14,4 @@
 help: consider introducing a named lifetime parameter
   |
 8 |         fn f<'a>(t: &'a T) -> &'a str;
-  |             ++++     ++        ++
+  |             ^^^^    ^^^^^     ^^^
diff --git a/tests/ui/vec_opaque.stderr b/tests/ui/vec_opaque.stderr
index 3f208fe..b8dad91 100644
--- a/tests/ui/vec_opaque.stderr
+++ b/tests/ui/vec_opaque.stderr
@@ -16,8 +16,7 @@
 22  |         type Job = crate::handle::Job;
     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `Trivial`, found enum `cxx::kind::Opaque`
     |
-note: required by a bound in `verify_extern_kind`
-   --> $DIR/extern_type.rs:186:41
+   ::: $WORKSPACE/src/extern_type.rs
     |
-186 | pub fn verify_extern_kind<T: ExternType<Kind = Kind>, Kind: self::Kind>() {}
-    |                                         ^^^^^^^^^^^ required by this bound in `verify_extern_kind`
+    | pub fn verify_extern_kind<T: ExternType<Kind = Kind>, Kind: self::Kind>() {}
+    |                                         ----------- required by this bound in `verify_extern_kind`
diff --git a/tests/ui/vector_autotraits.rs b/tests/ui/vector_autotraits.rs
deleted file mode 100644
index cc918d5..0000000
--- a/tests/ui/vector_autotraits.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use cxx::CxxVector;
-
-#[cxx::bridge]
-mod ffi {
-    extern "C++" {
-        type ThreadSafe;
-        type NotThreadSafe;
-    }
-
-    impl CxxVector<ThreadSafe> {}
-    impl CxxVector<NotThreadSafe> {}
-}
-
-unsafe impl Send for ffi::ThreadSafe {}
-
-fn assert_send<T: Send>() {}
-
-fn main() {
-    assert_send::<CxxVector<ffi::ThreadSafe>>();
-    assert_send::<CxxVector<ffi::NotThreadSafe>>();
-}
diff --git a/tests/ui/vector_autotraits.stderr b/tests/ui/vector_autotraits.stderr
deleted file mode 100644
index 52fd2a4..0000000
--- a/tests/ui/vector_autotraits.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error[E0277]: `*const cxx::void` cannot be sent between threads safely
-  --> $DIR/vector_autotraits.rs:20:5
-   |
-20 |     assert_send::<CxxVector<ffi::NotThreadSafe>>();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `*const cxx::void` cannot be sent between threads safely
-   |
-   = help: within `CxxVector<NotThreadSafe>`, the trait `Send` is not implemented for `*const cxx::void`
-   = note: required because it appears within the type `[*const cxx::void; 0]`
-   = note: required because it appears within the type `cxx::private::Opaque`
-note: required because it appears within the type `NotThreadSafe`
-  --> $DIR/vector_autotraits.rs:7:14
-   |
-7  |         type NotThreadSafe;
-   |              ^^^^^^^^^^^^^
-   = note: required because it appears within the type `[NotThreadSafe]`
-   = note: required because it appears within the type `PhantomData<[NotThreadSafe]>`
-   = note: required because it appears within the type `CxxVector<NotThreadSafe>`
-note: required by a bound in `assert_send`
-  --> $DIR/vector_autotraits.rs:16:19
-   |
-16 | fn assert_send<T: Send>() {}
-   |                   ^^^^ required by this bound in `assert_send`
diff --git a/tests/ui/wrong_type_id.stderr b/tests/ui/wrong_type_id.stderr
index b66bb26..2d8e50a 100644
--- a/tests/ui/wrong_type_id.stderr
+++ b/tests/ui/wrong_type_id.stderr
@@ -4,10 +4,10 @@
 11  |         type ByteRange = crate::here::StringPiece;
     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected a tuple with 15 elements, found one with 17 elements
     |
+   ::: $WORKSPACE/src/extern_type.rs
+    |
+    | pub fn verify_extern_type<T: ExternType<Id = Id>, Id>() {}
+    |                                         ------- required by this bound in `verify_extern_type`
+    |
     = note: expected tuple `(f, o, l, l, y, (), B, y, t, e, R, a, n, g, e)`
                found tuple `(f, o, l, l, y, (), S, t, r, i, n, g, P, i, e, c, e)`
-note: required by a bound in `verify_extern_type`
-   --> $DIR/extern_type.rs:183:41
-    |
-183 | pub fn verify_extern_type<T: ExternType<Id = Id>, Id>() {}
-    |                                         ^^^^^^^ required by this bound in `verify_extern_type`
diff --git a/third-party/BUCK b/third-party/BUCK
index 2633da8..84a5e18 100644
--- a/third-party/BUCK
+++ b/third-party/BUCK
@@ -1,15 +1,13 @@
 # To be generated by Facebook's `reindeer` tool once that is open source.
 
-load("//tools/buck:rust_library.bzl", "rust_library")
-
 rust_library(
     name = "bitflags",
-    srcs = glob(["vendor/bitflags-1.3.2/src/**"]),
+    srcs = glob(["vendor/bitflags-1.2.1/src/**"]),
 )
 
 rust_library(
     name = "cc",
-    srcs = glob(["vendor/cc-1.0.69/src/**"]),
+    srcs = glob(["vendor/cc-1.0.67/src/**"]),
     visibility = ["PUBLIC"],
 )
 
@@ -43,21 +41,25 @@
 
 rust_library(
     name = "proc-macro2",
-    srcs = glob(["vendor/proc-macro2-1.0.28/src/**"]),
-    build_script = "vendor/proc-macro2-1.0.28/build.rs",
+    srcs = glob(["vendor/proc-macro2-1.0.26/src/**"]),
+    visibility = ["PUBLIC"],
     features = [
         "proc-macro",
         "span-locations",
     ],
-    visibility = ["PUBLIC"],
+    rustc_flags = [
+        "--cfg=span_locations",
+        "--cfg=use_proc_macro",
+        "--cfg=wrap_proc_macro",
+    ],
     deps = [":unicode-xid"],
 )
 
 rust_library(
     name = "quote",
     srcs = glob(["vendor/quote-1.0.9/src/**"]),
-    features = ["proc-macro"],
     visibility = ["PUBLIC"],
+    features = ["proc-macro"],
     deps = [":proc-macro2"],
 )
 
@@ -70,8 +72,8 @@
 
 rust_library(
     name = "syn",
-    srcs = glob(["vendor/syn-1.0.75/src/**"]),
-    build_script = "vendor/syn-1.0.75/build.rs",
+    srcs = glob(["vendor/syn-1.0.68/src/**"]),
+    visibility = ["PUBLIC"],
     features = [
         "clone-impls",
         "derive",
@@ -80,7 +82,6 @@
         "printing",
         "proc-macro",
     ],
-    visibility = ["PUBLIC"],
     deps = [
         ":proc-macro2",
         ":quote",
@@ -106,5 +107,5 @@
 
 rust_library(
     name = "unicode-xid",
-    srcs = glob(["vendor/unicode-xid-0.2.2/src/**"]),
+    srcs = glob(["vendor/unicode-xid-0.2.1/src/**"]),
 )
diff --git a/third-party/BUILD b/third-party/BUILD
index 1760b70..cf1a288 100644
--- a/third-party/BUILD
+++ b/third-party/BUILD
@@ -1,18 +1,17 @@
 load(
-    "//tools/bazel:third_party.bzl",
-    cargo_build_script = "third_party_cargo_build_script",
+    "//tools/bazel:rust.bzl",
     glob = "third_party_glob",
     rust_library = "third_party_rust_library",
 )
 
 rust_library(
     name = "bitflags",
-    srcs = glob(["vendor/bitflags-1.3.2/src/**"]),
+    srcs = glob(["vendor/bitflags-1.2.1/src/**"]),
 )
 
 rust_library(
     name = "cc",
-    srcs = glob(["vendor/cc-1.0.69/src/**"]),
+    srcs = glob(["vendor/cc-1.0.67/src/**"]),
     visibility = ["//visibility:public"],
 )
 
@@ -46,26 +45,18 @@
 
 rust_library(
     name = "proc-macro2",
-    srcs = glob(["vendor/proc-macro2-1.0.28/src/**"]),
+    srcs = glob(["vendor/proc-macro2-1.0.26/src/**"]),
     crate_features = [
         "proc-macro",
         "span-locations",
     ],
+    rustc_flags = [
+        "--cfg=span_locations",
+        "--cfg=use_proc_macro",
+        "--cfg=wrap_proc_macro",
+    ],
     visibility = ["//visibility:public"],
-    deps = [
-        ":proc-macro2@build",
-        ":unicode-xid",
-    ],
-)
-
-cargo_build_script(
-    name = "proc-macro2@build",
-    srcs = ["vendor/proc-macro2-1.0.28/build.rs"],
-    crate_features = [
-        "proc-macro",
-        "span-locations",
-    ],
-    crate_name = "build",
+    deps = [":unicode-xid"],
 )
 
 rust_library(
@@ -85,7 +76,7 @@
 
 rust_library(
     name = "syn",
-    srcs = glob(["vendor/syn-1.0.75/src/**"]),
+    srcs = glob(["vendor/syn-1.0.68/src/**"]),
     crate_features = [
         "clone-impls",
         "derive",
@@ -98,25 +89,10 @@
     deps = [
         ":proc-macro2",
         ":quote",
-        ":syn@build",
         ":unicode-xid",
     ],
 )
 
-cargo_build_script(
-    name = "syn@build",
-    srcs = ["vendor/syn-1.0.75/build.rs"],
-    crate_features = [
-        "clone-impls",
-        "derive",
-        "full",
-        "parsing",
-        "printing",
-        "proc-macro",
-    ],
-    crate_name = "build",
-)
-
 rust_library(
     name = "termcolor",
     srcs = glob(["vendor/termcolor-1.1.2/src/**"]),
@@ -135,5 +111,5 @@
 
 rust_library(
     name = "unicode-xid",
-    srcs = glob(["vendor/unicode-xid-0.2.2/src/**"]),
+    srcs = glob(["vendor/unicode-xid-0.2.1/src/**"]),
 )
diff --git a/third-party/Cargo.lock b/third-party/Cargo.lock
index 0a3d543..a95e737 100644
--- a/third-party/Cargo.lock
+++ b/third-party/Cargo.lock
@@ -3,12 +3,6 @@
 version = 3
 
 [[package]]
-name = "adler"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
-
-[[package]]
 name = "ansi_term"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -29,42 +23,21 @@
 ]
 
 [[package]]
-name = "autocfg"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
-
-[[package]]
 name = "bitflags"
-version = "1.3.2"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
 
 [[package]]
 name = "cc"
-version = "1.0.69"
+version = "1.0.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2"
+checksum = "e3c69b077ad434294d3ce9f1f6143a2a4b89a8a2d54ef813d85003a4fd1137fd"
 dependencies = [
  "jobserver",
 ]
 
 [[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "clang-ast"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eed6681036a96f9855a75b08a9f14199e212017508a967d1d1e868f575f7d8e9"
-dependencies = [
- "serde",
-]
-
-[[package]]
 name = "clap"
 version = "2.33.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -90,17 +63,8 @@
 ]
 
 [[package]]
-name = "crc32fast"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81156fece84ab6a9f2afdb109ce3ae577e42b1228441eded99bd77f627953b1a"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
 name = "cxx"
-version = "1.0.54"
+version = "1.0.42"
 dependencies = [
  "cc",
  "cxx-build",
@@ -115,7 +79,7 @@
 
 [[package]]
 name = "cxx-build"
-version = "1.0.54"
+version = "1.0.42"
 dependencies = [
  "cc",
  "codespan-reporting",
@@ -130,7 +94,7 @@
 
 [[package]]
 name = "cxx-gen"
-version = "0.7.54"
+version = "0.7.42"
 dependencies = [
  "cc",
  "codespan-reporting",
@@ -150,7 +114,7 @@
 
 [[package]]
 name = "cxxbridge-cmd"
-version = "1.0.54"
+version = "1.0.42"
 dependencies = [
  "clap",
  "codespan-reporting",
@@ -161,20 +125,15 @@
 
 [[package]]
 name = "cxxbridge-flags"
-version = "1.0.54"
+version = "1.0.42"
 
 [[package]]
 name = "cxxbridge-macro"
-version = "1.0.54"
+version = "1.0.42"
 dependencies = [
- "clang-ast",
  "cxx",
- "flate2",
- "memmap",
  "proc-macro2",
  "quote",
- "serde",
- "serde_json",
  "syn",
 ]
 
@@ -193,18 +152,6 @@
 checksum = "fc4b29f4b9bb94bf267d57269fd0706d343a160937108e9619fe380645428abb"
 
 [[package]]
-name = "flate2"
-version = "1.0.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd3aec53de10fe96d7d8c565eb17f2c687bb5518a2ec453b5b1252964526abe0"
-dependencies = [
- "cfg-if",
- "crc32fast",
- "libc",
- "miniz_oxide",
-]
-
-[[package]]
 name = "glob"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -212,24 +159,24 @@
 
 [[package]]
 name = "hermit-abi"
-version = "0.1.19"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "itoa"
-version = "0.4.8"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
+checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
 
 [[package]]
 name = "jobserver"
-version = "0.1.24"
+version = "0.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af25a77299a7f711a01975c35a6a424eb6862092cc2d6c72c4ed6cbc56dfc1fa"
+checksum = "5c71313ebb9439f74b00d9d2dcec36440beaf57a6aa0623068441dd7cd81a7f2"
 dependencies = [
  "libc",
 ]
@@ -242,9 +189,9 @@
 
 [[package]]
 name = "libc"
-version = "0.2.101"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cb00336871be5ed2c8ed44b60ae9959dc5b9f08539422ed43f09e34ecaeba21"
+checksum = "56d855069fafbb9b344c0f962150cd2c1187975cb1c22c1522c240d8c4986714"
 
 [[package]]
 name = "link-cplusplus"
@@ -256,26 +203,6 @@
 ]
 
 [[package]]
-name = "memmap"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6585fd95e7bb50d6cc31e20d4cf9afb4e2ba16c5846fc76793f11218da9c475b"
-dependencies = [
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "miniz_oxide"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a92518e98c078586bc6c934028adcca4c92a53d6a958196de835170a01d84e4b"
-dependencies = [
- "adler",
- "autocfg",
-]
-
-[[package]]
 name = "pkg-config"
 version = "0.3.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -283,9 +210,9 @@
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.28"
+version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c7ed8b8c7b886ea3ed7dde405212185f423ab44682667c8c6dd14aa1d9f6612"
+checksum = "a152013215dca273577e18d2bf00fa862b89b24169fb78c4c95aeb07992c9cec"
 dependencies = [
  "unicode-xid",
 ]
@@ -301,9 +228,9 @@
 
 [[package]]
 name = "rustversion"
-version = "1.0.5"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61b3909d758bb75c79f23d4736fac9433868679d3ad2ea7a61e3c25cfda9a088"
+checksum = "cb5d2a036dc6d2d8fd16fde3498b04306e29bd193bf306a57427019b823d5acd"
 
 [[package]]
 name = "ryu"
@@ -319,18 +246,18 @@
 
 [[package]]
 name = "serde"
-version = "1.0.129"
+version = "1.0.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1f72836d2aa753853178eda473a3b9d8e4eefdaf20523b919677e6de489f8f1"
+checksum = "558dc50e1a5a5fa7112ca2ce4effcb321b0300c0d4ccf0776a9f60cd89031171"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.129"
+version = "1.0.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e57ae87ad533d9a56427558b516d0adac283614e347abf85b0dc0cbbf0a249f3"
+checksum = "b093b7a2bb58203b5da3056c05b4ec1fed827dcfdb37347a8841695263b3d06d"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -339,9 +266,9 @@
 
 [[package]]
 name = "serde_json"
-version = "1.0.66"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "336b10da19a12ad094b59d870ebde26a45402e5b470add4b5fd03c5048a32127"
+checksum = "799e97dc9fdae36a5c8b8f2cae9ce2ee9fdce2058c57a93e6099d919fd982f79"
 dependencies = [
  "itoa",
  "ryu",
@@ -356,9 +283,9 @@
 
 [[package]]
 name = "syn"
-version = "1.0.75"
+version = "1.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7f58f7e8eaa0009c5fec437aabf511bd9933e4b2d7407bd05273c01a8906ea7"
+checksum = "3ce15dd3ed8aa2f8eeac4716d6ef5ab58b6b9256db41d7e1a0224c2788e8fd87"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -394,9 +321,9 @@
 
 [[package]]
 name = "trybuild"
-version = "1.0.45"
+version = "1.0.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bdaf2a1d317f3d58b44b31c7f6436b9b9acafe7bddfeace50897c2b804d7792"
+checksum = "99471a206425fba51842a9186315f32d91c56eadc21ea4c21f847b59cf778f8b"
 dependencies = [
  "dissimilar",
  "glob",
@@ -415,9 +342,9 @@
 
 [[package]]
 name = "unicode-xid"
-version = "0.2.2"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
 
 [[package]]
 name = "vec_map"
diff --git a/tools/bazel/rust.bzl b/tools/bazel/rust.bzl
new file mode 100644
index 0000000..9f71923
--- /dev/null
+++ b/tools/bazel/rust.bzl
@@ -0,0 +1,29 @@
+"""A module wrapping the core rules of `rules_rust`"""
+
+load(
+    "@rules_rust//rust:rust.bzl",
+    _rust_binary = "rust_binary",
+    _rust_library = "rust_library",
+    _rust_test = "rust_test",
+)
+load("@third-party//:vendor.bzl", "vendored")
+
+def third_party_glob(include):
+    return vendored and native.glob(include)
+
+def rust_binary(edition = "2018", **kwargs):
+    _rust_binary(edition = edition, **kwargs)
+
+def third_party_rust_binary(rustc_flags = [], **kwargs):
+    rustc_flags = rustc_flags + ["--cap-lints=allow"]
+    rust_binary(rustc_flags = rustc_flags, **kwargs)
+
+def rust_library(edition = "2018", **kwargs):
+    _rust_library(edition = edition, **kwargs)
+
+def third_party_rust_library(rustc_flags = [], **kwargs):
+    rustc_flags = rustc_flags + ["--cap-lints=allow"]
+    rust_library(rustc_flags = rustc_flags, **kwargs)
+
+def rust_test(edition = "2018", **kwargs):
+    _rust_test(edition = edition, **kwargs)
diff --git a/tools/bazel/third_party.bzl b/tools/bazel/third_party.bzl
deleted file mode 100644
index 7f51c46..0000000
--- a/tools/bazel/third_party.bzl
+++ /dev/null
@@ -1,18 +0,0 @@
-load("@rules_rust//cargo:cargo_build_script.bzl", "cargo_build_script")
-load("@rules_rust//rust:rust.bzl", "rust_binary", "rust_library")
-load("@third-party//:vendor.bzl", "vendored")
-
-def third_party_glob(include):
-    return vendored and native.glob(include)
-
-def third_party_cargo_build_script(rustc_flags = [], **kwargs):
-    rustc_flags = rustc_flags + ["--cap-lints=allow"]
-    cargo_build_script(rustc_flags = rustc_flags, **kwargs)
-
-def third_party_rust_binary(rustc_flags = [], **kwargs):
-    rustc_flags = rustc_flags + ["--cap-lints=allow"]
-    rust_binary(rustc_flags = rustc_flags, **kwargs)
-
-def third_party_rust_library(rustc_flags = [], **kwargs):
-    rustc_flags = rustc_flags + ["--cap-lints=allow"]
-    rust_library(rustc_flags = rustc_flags, **kwargs)
diff --git a/tools/bazel/vendor.bzl b/tools/bazel/vendor.bzl
index e51adb7..e404ad9 100644
--- a/tools/bazel/vendor.bzl
+++ b/tools/bazel/vendor.bzl
@@ -2,8 +2,6 @@
 of a crate in the current workspace.
 """
 
-load("@rules_rust//rust:repositories.bzl", "DEFAULT_RUST_VERSION", "load_arbitrary_tool")
-
 def _impl(repository_ctx):
     # Link cxx repository into @third-party.
     lockfile = repository_ctx.path(repository_ctx.attr.lockfile)
@@ -16,27 +14,8 @@
     root_lockfile = repository_ctx.path("workspace/Cargo.lock")
     _copy_file(repository_ctx, src = vendor_lockfile, dst = root_lockfile)
 
-    # Figure out which version of cargo to use.
-    if repository_ctx.attr.target_triple:
-        target_triple = repository_ctx.attr.target_triple
-    elif "mac" in repository_ctx.os.name:
-        target_triple = "x86_64-apple-darwin"
-    elif "windows" in repository_ctx.os.name:
-        target_triple = "x86_64-pc-windows-msvc"
-    else:
-        target_triple = "x86_64-unknown-linux-gnu"
-
-    # Download cargo.
-    load_arbitrary_tool(
-        ctx = repository_ctx,
-        tool_name = "cargo",
-        tool_subdirectories = ["cargo"],
-        version = repository_ctx.attr.cargo_version,
-        iso_date = repository_ctx.attr.cargo_iso_date,
-        target_triple = target_triple,
-    )
-
-    cmd = ["{}/bin/cargo".format(repository_ctx.path(".")), "vendor", "--versioned-dirs", "third-party/vendor"]
+    # Execute cargo vendor.
+    cmd = ["cargo", "vendor", "--versioned-dirs", "third-party/vendor"]
     result = repository_ctx.execute(
         cmd,
         quiet = True,
@@ -75,16 +54,6 @@
 vendor = repository_rule(
     doc = "A rule used to vendor the dependencies of a crate in the current workspace",
     attrs = {
-        "cargo_version": attr.string(
-            doc = "The version of cargo to use",
-            default = DEFAULT_RUST_VERSION,
-        ),
-        "cargo_iso_date": attr.string(
-            doc = "The date of the tool (or None, if the version is a specific version)",
-        ),
-        "target_triple": attr.string(
-            doc = "The target triple of the cargo binary to download",
-        ),
         "lockfile": attr.label(
             doc = "A lockfile providing the set of crates to vendor",
         ),
diff --git a/tools/buck/rust_library.bzl b/tools/buck/rust_library.bzl
deleted file mode 100644
index 67ec2ac..0000000
--- a/tools/buck/rust_library.bzl
+++ /dev/null
@@ -1,34 +0,0 @@
-load("//tools/buck:genrule.bzl", "genrule")
-
-def rust_library(
-        name,
-        srcs,
-        features = [],
-        rustc_flags = [],
-        build_script = None,
-        **kwargs):
-    if build_script:
-        rust_binary(
-            name = "%s@build" % name,
-            srcs = srcs + [build_script],
-            crate = "build",
-            crate_root = build_script,
-            features = features,
-            rustc_flags = rustc_flags,
-        )
-
-        genrule(
-            name = "%s@cfg" % name,
-            out = "output",
-            cmd = "env RUSTC=rustc TARGET= $(exe :%s@build) | sed -n s/^cargo:rustc-cfg=/--cfg=/p > ${OUT}" % name,
-        )
-
-        rustc_flags = rustc_flags + ["@$(location :%s@cfg)" % name]
-
-    native.rust_library(
-        name = name,
-        srcs = srcs,
-        features = features,
-        rustc_flags = rustc_flags,
-        **kwargs
-    )