Release 0.1.0

14 files changed, 99 insertions, 99 deletions

diff --git a/Cargo.toml b/Cargo.toml
index a6d34cc8..d111367d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
 name = "cxx"
-version = "0.0.0"
+version = "0.1.0"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 edition = "2018"
-links = "cxxbridge00"
+links = "cxxbridge01"
 license = "MIT OR Apache-2.0"
 description = "Safe interop between Rust and C++"
 repository = "https://github.com/dtolnay/cxx"
@@ -18,7 +18,7 @@ anyhow = "1.0"
 cc = "1.0.49"
 codespan = "0.7"
 codespan-reporting = "0.7"
-cxxbridge-macro = { version = "0.0", path = "macro" }
+cxxbridge-macro = { version = "0.1", path = "macro" }
 proc-macro2 = { version = "1.0", features = ["span-locations"] }
 quote = "1.0"
 syn = { version = "1.0", features = ["full"] }
diff --git a/README.md b/README.md
index 5ea03ee5..a978e969 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@ using bindgen or cbindgen to generate unsafe C-style bindings.
 
 ```toml
 [dependencies]
-cxx = "0.0"
+cxx = "0.1"
 ```
 
 *Compiler support: requires rustc 1.42+ (beta on January 30, stable on March
@@ -294,9 +294,9 @@ of functions.
 <tr><th>name in Rust</th><th>name in C++</th><th>restrictions</th></tr>
 <tr><td>String</td><td>cxxbridge::RustString</td><td></td></tr>
 <tr><td>&amp;str</td><td>cxxbridge::RustStr</td><td></td></tr>
-<tr><td><a href="https://docs.rs/cxx/0.0/cxx/struct.CxxString.html">CxxString</a></td><td>std::string</td><td><sup><i>cannot be passed by value</i></sup></td></tr>
+<tr><td><a href="https://docs.rs/cxx/0.1/cxx/struct.CxxString.html">CxxString</a></td><td>std::string</td><td><sup><i>cannot be passed by value</i></sup></td></tr>
 <tr><td>Box&lt;T&gt;</td><td>cxxbridge::RustBox&lt;T&gt;</td><td><sup><i>cannot hold opaque C++ type</i></sup></td></tr>
-<tr><td><a href="https://docs.rs/cxx/0.0/cxx/struct.UniquePtr.html">UniquePtr&lt;T&gt;</a></td><td>std::unique_ptr&lt;T&gt;</td><td><sup><i>cannot hold opaque Rust type</i></sup></td></tr>
+<tr><td><a href="https://docs.rs/cxx/0.1/cxx/struct.UniquePtr.html">UniquePtr&lt;T&gt;</a></td><td>std::unique_ptr&lt;T&gt;</td><td><sup><i>cannot hold opaque Rust type</i></sup></td></tr>
 <tr><td></td><td></td><td></td></tr>
 </table>
 
diff --git a/build.rs b/build.rs
index 4d8292e7..f16f265a 100644
--- a/build.rs
+++ b/build.rs
@@ -2,7 +2,7 @@ fn main() {
     cc::Build::new()
         .file("src/cxxbridge.cc")
         .flag("-std=c++11")
-        .compile("cxxbridge00");
+        .compile("cxxbridge01");
     println!("cargo:rustc-flags=-l dylib=stdc++");
     println!("cargo:rerun-if-changed=src/cxxbridge.cc");
     println!("cargo:rerun-if-changed=include/cxxbridge.h");
diff --git a/cmd/Cargo.toml b/cmd/Cargo.toml
index b3f77194..0cfe8832 100644
--- a/cmd/Cargo.toml
+++ b/cmd/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cxxbridge-cmd"
-version = "0.0.0"
+version = "0.1.0"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
diff --git a/gen/write.rs b/gen/write.rs
index fd92d501..81f26b81 100644
--- a/gen/write.rs
+++ b/gen/write.rs
@@ -124,10 +124,10 @@ fn write_include_cxxbridge(out: &mut OutFile, types: &Types) {
         }
     }
 
-    out.begin_block("namespace cxxbridge00");
+    out.begin_block("namespace cxxbridge01");
     if needs_rust_box {
         writeln!(out, "// #include \"cxxbridge.h\"");
-        for line in include::get("CXXBRIDGE00_RUST_BOX").lines() {
+        for line in include::get("CXXBRIDGE01_RUST_BOX").lines() {
             if !line.trim_start().starts_with("//") {
                 writeln!(out, "{}", line);
             }
@@ -146,7 +146,7 @@ fn write_namespace_alias(out: &mut OutFile, types: &Types) {
     }
 
     if needs_namespace_alias {
-        writeln!(out, "namespace cxxbridge = cxxbridge00;");
+        writeln!(out, "namespace cxxbridge = cxxbridge01;");
     }
 }
 
@@ -176,7 +176,7 @@ fn write_cxx_function_shim(out: &mut OutFile, efn: &ExternFn, types: &Types) {
     for name in out.namespace.clone() {
         write!(out, "{}$", name);
     }
-    write!(out, "cxxbridge00${}(", efn.ident);
+    write!(out, "cxxbridge01${}(", efn.ident);
     for (i, arg) in efn.args.iter().enumerate() {
         if i > 0 {
             write!(out, ", ");
@@ -244,7 +244,7 @@ fn write_rust_function_decl(out: &mut OutFile, efn: &ExternFn, types: &Types) {
     for name in out.namespace.clone() {
         write!(out, "{}$", name);
     }
-    write!(out, "cxxbridge00${}(", efn.ident);
+    write!(out, "cxxbridge01${}(", efn.ident);
     for (i, arg) in efn.args.iter().enumerate() {
         if i > 0 {
             write!(out, ", ");
@@ -299,7 +299,7 @@ fn write_rust_function_shim(out: &mut OutFile, efn: &ExternFn, types: &Types) {
         for name in out.namespace.clone() {
             write!(out, "{}$", name);
         }
-        write!(out, "cxxbridge00${}(", efn.ident);
+        write!(out, "cxxbridge01${}(", efn.ident);
         for (i, arg) in efn.args.iter().enumerate() {
             if i > 0 {
                 write!(out, ", ");
@@ -435,7 +435,7 @@ fn write_generic_instantiations(out: &mut OutFile, types: &Types) {
     }
     out.end_block();
 
-    out.begin_block("namespace cxxbridge00");
+    out.begin_block("namespace cxxbridge01");
     for ty in types {
         if let Type::RustBox(ty) = ty {
             if let Type::Ident(inner) = &ty.inner {
@@ -455,34 +455,34 @@ fn write_rust_box_extern(out: &mut OutFile, ident: &Ident) {
     inner += &ident.to_string();
     let instance = inner.replace("::", "$");
 
-    writeln!(out, "#ifndef CXXBRIDGE00_RUST_BOX_{}", instance);
-    writeln!(out, "#define CXXBRIDGE00_RUST_BOX_{}", instance);
+    writeln!(out, "#ifndef CXXBRIDGE01_RUST_BOX_{}", instance);
+    writeln!(out, "#define CXXBRIDGE01_RUST_BOX_{}", instance);
     writeln!(
         out,
-        "void cxxbridge00$rust_box${}$uninit(cxxbridge::RustBox<{}> *ptr) noexcept;",
+        "void cxxbridge01$rust_box${}$uninit(cxxbridge::RustBox<{}> *ptr) noexcept;",
         instance, inner,
     );
     writeln!(
         out,
-        "void cxxbridge00$rust_box${}$set_raw(cxxbridge::RustBox<{}> *ptr, {} *raw) noexcept;",
+        "void cxxbridge01$rust_box${}$set_raw(cxxbridge::RustBox<{}> *ptr, {} *raw) noexcept;",
         instance, inner, inner
     );
     writeln!(
         out,
-        "void cxxbridge00$rust_box${}$drop(cxxbridge::RustBox<{}> *ptr) noexcept;",
+        "void cxxbridge01$rust_box${}$drop(cxxbridge::RustBox<{}> *ptr) noexcept;",
         instance, inner,
     );
     writeln!(
         out,
-        "const {} *cxxbridge00$rust_box${}$deref(const cxxbridge::RustBox<{}> *ptr) noexcept;",
+        "const {} *cxxbridge01$rust_box${}$deref(const cxxbridge::RustBox<{}> *ptr) noexcept;",
         inner, instance, inner,
     );
     writeln!(
         out,
-        "{} *cxxbridge00$rust_box${}$deref_mut(cxxbridge::RustBox<{}> *ptr) noexcept;",
+        "{} *cxxbridge01$rust_box${}$deref_mut(cxxbridge::RustBox<{}> *ptr) noexcept;",
         inner, instance, inner,
     );
-    writeln!(out, "#endif // CXXBRIDGE00_RUST_BOX_{}", instance);
+    writeln!(out, "#endif // CXXBRIDGE01_RUST_BOX_{}", instance);
 }
 
 fn write_rust_box_impl(out: &mut OutFile, ident: &Ident) {
@@ -498,7 +498,7 @@ fn write_rust_box_impl(out: &mut OutFile, ident: &Ident) {
     writeln!(out, "void RustBox<{}>::uninit() noexcept {{", inner);
     writeln!(
         out,
-        "  return cxxbridge00$rust_box${}$uninit(this);",
+        "  return cxxbridge01$rust_box${}$uninit(this);",
         instance
     );
     writeln!(out, "}}");
@@ -511,7 +511,7 @@ fn write_rust_box_impl(out: &mut OutFile, ident: &Ident) {
     );
     writeln!(
         out,
-        "  return cxxbridge00$rust_box${}$set_raw(this, raw);",
+        "  return cxxbridge01$rust_box${}$set_raw(this, raw);",
         instance
     );
     writeln!(out, "}}");
@@ -520,7 +520,7 @@ fn write_rust_box_impl(out: &mut OutFile, ident: &Ident) {
     writeln!(out, "void RustBox<{}>::drop() noexcept {{", inner);
     writeln!(
         out,
-        "  return cxxbridge00$rust_box${}$drop(this);",
+        "  return cxxbridge01$rust_box${}$drop(this);",
         instance
     );
     writeln!(out, "}}");
@@ -533,7 +533,7 @@ fn write_rust_box_impl(out: &mut OutFile, ident: &Ident) {
     );
     writeln!(
         out,
-        "  return cxxbridge00$rust_box${}$deref(this);",
+        "  return cxxbridge01$rust_box${}$deref(this);",
         instance
     );
     writeln!(out, "}}");
@@ -546,7 +546,7 @@ fn write_rust_box_impl(out: &mut OutFile, ident: &Ident) {
     );
     writeln!(
         out,
-        "  return cxxbridge00$rust_box${}$deref_mut(this);",
+        "  return cxxbridge01$rust_box${}$deref_mut(this);",
         instance
     );
     writeln!(out, "}}");
@@ -561,8 +561,8 @@ fn write_unique_ptr(out: &mut OutFile, ident: &Ident) {
     inner += &ident.to_string();
     let instance = inner.replace("::", "$");
 
-    writeln!(out, "#ifndef CXXBRIDGE00_UNIQUE_PTR_{}", instance);
-    writeln!(out, "#define CXXBRIDGE00_UNIQUE_PTR_{}", instance);
+    writeln!(out, "#ifndef CXXBRIDGE01_UNIQUE_PTR_{}", instance);
+    writeln!(out, "#define CXXBRIDGE01_UNIQUE_PTR_{}", instance);
     writeln!(
         out,
         "static_assert(sizeof(std::unique_ptr<{}>) == sizeof(void *), \"\");",
@@ -575,14 +575,14 @@ fn write_unique_ptr(out: &mut OutFile, ident: &Ident) {
     );
     writeln!(
         out,
-        "void cxxbridge00$unique_ptr${}$null(std::unique_ptr<{}> *ptr) noexcept {{",
+        "void cxxbridge01$unique_ptr${}$null(std::unique_ptr<{}> *ptr) noexcept {{",
         instance, inner,
     );
     writeln!(out, "  new (ptr) std::unique_ptr<{}>();", inner);
     writeln!(out, "}}");
     writeln!(
         out,
-        "void cxxbridge00$unique_ptr${}$new(std::unique_ptr<{}> *ptr, {} *value) noexcept {{",
+        "void cxxbridge01$unique_ptr${}$new(std::unique_ptr<{}> *ptr, {} *value) noexcept {{",
         instance, inner, inner,
     );
     writeln!(
@@ -593,31 +593,31 @@ fn write_unique_ptr(out: &mut OutFile, ident: &Ident) {
     writeln!(out, "}}");
     writeln!(
         out,
-        "void cxxbridge00$unique_ptr${}$raw(std::unique_ptr<{}> *ptr, {} *raw) noexcept {{",
+        "void cxxbridge01$unique_ptr${}$raw(std::unique_ptr<{}> *ptr, {} *raw) noexcept {{",
         instance, inner, inner,
     );
     writeln!(out, "  new (ptr) std::unique_ptr<{}>(raw);", inner);
     writeln!(out, "}}");
     writeln!(
         out,
-        "const {} *cxxbridge00$unique_ptr${}$get(const std::unique_ptr<{}>& ptr) noexcept {{",
+        "const {} *cxxbridge01$unique_ptr${}$get(const std::unique_ptr<{}>& ptr) noexcept {{",
         inner, instance, inner,
     );
     writeln!(out, "  return ptr.get();");
     writeln!(out, "}}");
     writeln!(
         out,
-        "{} *cxxbridge00$unique_ptr${}$release(std::unique_ptr<{}>& ptr) noexcept {{",
+        "{} *cxxbridge01$unique_ptr${}$release(std::unique_ptr<{}>& ptr) noexcept {{",
         inner, instance, inner,
     );
     writeln!(out, "  return ptr.release();");
     writeln!(out, "}}");
     writeln!(
         out,
-        "void cxxbridge00$unique_ptr${}$drop(std::unique_ptr<{}> *ptr) noexcept {{",
+        "void cxxbridge01$unique_ptr${}$drop(std::unique_ptr<{}> *ptr) noexcept {{",
         instance, inner,
     );
     writeln!(out, "  ptr->~unique_ptr();");
     writeln!(out, "}}");
-    writeln!(out, "#endif // CXXBRIDGE00_UNIQUE_PTR_{}", instance);
+    writeln!(out, "#endif // CXXBRIDGE01_UNIQUE_PTR_{}", instance);
 }
diff --git a/include/cxxbridge.h b/include/cxxbridge.h
index 31350927..a0d9dbb6 100644
--- a/include/cxxbridge.h
+++ b/include/cxxbridge.h
@@ -4,7 +4,7 @@
 #include <iostream>
 #include <string>
 
-namespace cxxbridge00 {
+namespace cxxbridge01 {
 
 class RustString final {
 public:
@@ -58,8 +58,8 @@ private:
   Repr repr;
 };
 
-#ifndef CXXBRIDGE00_RUST_BOX
-#define CXXBRIDGE00_RUST_BOX
+#ifndef CXXBRIDGE01_RUST_BOX
+#define CXXBRIDGE01_RUST_BOX
 template <typename T> class RustBox final {
 public:
   RustBox(const RustBox &other) : RustBox(*other) {}
@@ -122,11 +122,11 @@ private:
   T *deref_mut() noexcept;
   uintptr_t repr;
 };
-#endif // CXXBRIDGE00_RUST_BOX
+#endif // CXXBRIDGE01_RUST_BOX
 
 std::ostream &operator<<(std::ostream &os, const RustString &s);
 std::ostream &operator<<(std::ostream &os, const RustStr &s);
 
-} // namespace cxxbridge00
+} // namespace cxxbridge01
 
-namespace cxxbridge = cxxbridge00;
+namespace cxxbridge = cxxbridge01;
diff --git a/macro/Cargo.toml b/macro/Cargo.toml
index f7256e0e..2d14527f 100644
--- a/macro/Cargo.toml
+++ b/macro/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cxxbridge-macro"
-version = "0.0.0"
+version = "0.1.0"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
@@ -19,4 +19,4 @@ quote = "1.0"
 syn = { version = "1.0", features = ["full"] }
 
 [dev-dependencies]
-cxx = { version = "0.0", path = ".." }
+cxx = { version = "0.1", path = ".." }
diff --git a/macro/src/expand.rs b/macro/src/expand.rs
index 63f70322..e631e676 100644
--- a/macro/src/expand.rs
+++ b/macro/src/expand.rs
@@ -128,7 +128,7 @@ fn expand_cxx_function_decl(namespace: &Namespace, efn: &ExternFn, types: &Types
         let ret = expand_extern_type(efn.ret.as_ref().unwrap());
         outparam = Some(quote!(__return: *mut #ret));
     }
-    let link_name = format!("{}cxxbridge00${}", namespace, ident);
+    let link_name = format!("{}cxxbridge01${}", namespace, ident);
     let local_name = format_ident!("__{}", ident);
     quote! {
         #[link_name = #link_name]
@@ -266,7 +266,7 @@ fn expand_rust_function_shim(namespace: &Namespace, efn: &ExternFn, types: &Type
         expr = quote!(::std::ptr::write(__return, #expr));
     }
     let ret = expand_extern_return_type(&efn.ret, types);
-    let link_name = format!("{}cxxbridge00${}", namespace, ident);
+    let link_name = format!("{}cxxbridge01${}", namespace, ident);
     let local_name = format_ident!("__{}", ident);
     let catch_unwind_label = format!("::{}", ident);
     quote! {
@@ -280,7 +280,7 @@ fn expand_rust_function_shim(namespace: &Namespace, efn: &ExternFn, types: &Type
 }
 
 fn expand_rust_box(namespace: &Namespace, ident: &Ident) -> TokenStream {
-    let link_prefix = format!("cxxbridge00$rust_box${}{}$", namespace, ident);
+    let link_prefix = format!("cxxbridge01$rust_box${}{}$", namespace, ident);
     let link_uninit = format!("{}uninit", link_prefix);
     let link_set_raw = format!("{}set_raw", link_prefix);
     let link_drop = format!("{}drop", link_prefix);
@@ -337,7 +337,7 @@ fn expand_rust_box(namespace: &Namespace, ident: &Ident) -> TokenStream {
 }
 
 fn expand_unique_ptr(namespace: &Namespace, ident: &Ident) -> TokenStream {
-    let prefix = format!("cxxbridge00$unique_ptr${}{}$", namespace, ident);
+    let prefix = format!("cxxbridge01$unique_ptr${}{}$", namespace, ident);
     let link_null = format!("{}null", prefix);
     let link_new = format!("{}new", prefix);
     let link_raw = format!("{}raw", prefix);
diff --git a/src/cxx_string.rs b/src/cxx_string.rs
index c1697976..40a17316 100644
--- a/src/cxx_string.rs
+++ b/src/cxx_string.rs
@@ -4,9 +4,9 @@ use std::slice;
 use std::str::{self, Utf8Error};
 
 extern "C" {
-    #[link_name = "cxxbridge00$cxx_string$data"]
+    #[link_name = "cxxbridge01$cxx_string$data"]
     fn string_data(_: &CxxString) -> *const u8;
-    #[link_name = "cxxbridge00$cxx_string$length"]
+    #[link_name = "cxxbridge01$cxx_string$length"]
     fn string_length(_: &CxxString) -> usize;
 }
 
diff --git a/src/cxxbridge.cc b/src/cxxbridge.cc
index 3d1a9027..a502d20c 100644
--- a/src/cxxbridge.cc
+++ b/src/cxxbridge.cc
@@ -3,48 +3,48 @@
 #include <memory>
 #include <stdexcept>
 
-namespace cxxbridge = cxxbridge00;
+namespace cxxbridge = cxxbridge01;
 
 extern "C" {
-const char *cxxbridge00$cxx_string$data(const std::string &s) noexcept {
+const char *cxxbridge01$cxx_string$data(const std::string &s) noexcept {
   return s.data();
 }
 
-size_t cxxbridge00$cxx_string$length(const std::string &s) noexcept {
+size_t cxxbridge01$cxx_string$length(const std::string &s) noexcept {
   return s.length();
 }
 
 // RustString
-void cxxbridge00$rust_string$new(cxxbridge::RustString *self) noexcept;
-void cxxbridge00$rust_string$clone(cxxbridge::RustString *self,
+void cxxbridge01$rust_string$new(cxxbridge::RustString *self) noexcept;
+void cxxbridge01$rust_string$clone(cxxbridge::RustString *self,
                                    const cxxbridge::RustString &other) noexcept;
-bool cxxbridge00$rust_string$from(cxxbridge::RustString *self, const char *ptr,
+bool cxxbridge01$rust_string$from(cxxbridge::RustString *self, const char *ptr,
                                   size_t len) noexcept;
-void cxxbridge00$rust_string$drop(cxxbridge::RustString *self) noexcept;
+void cxxbridge01$rust_string$drop(cxxbridge::RustString *self) noexcept;
 const char *
-cxxbridge00$rust_string$ptr(const cxxbridge::RustString *self) noexcept;
-size_t cxxbridge00$rust_string$len(const cxxbridge::RustString *self) noexcept;
+cxxbridge01$rust_string$ptr(const cxxbridge::RustString *self) noexcept;
+size_t cxxbridge01$rust_string$len(const cxxbridge::RustString *self) noexcept;
 
 // RustStr
-bool cxxbridge00$rust_str$valid(const char *ptr, size_t len) noexcept;
+bool cxxbridge01$rust_str$valid(const char *ptr, size_t len) noexcept;
 } // extern "C"
 
-namespace cxxbridge00 {
+namespace cxxbridge01 {
 
-RustString::RustString() noexcept { cxxbridge00$rust_string$new(this); }
+RustString::RustString() noexcept { cxxbridge01$rust_string$new(this); }
 
 RustString::RustString(const RustString &other) noexcept {
-  cxxbridge00$rust_string$clone(this, other);
+  cxxbridge01$rust_string$clone(this, other);
 }
 
 RustString::RustString(RustString &&other) noexcept {
   this->repr = other.repr;
-  cxxbridge00$rust_string$new(&other);
+  cxxbridge01$rust_string$new(&other);
 }
 
 RustString::RustString(const char *s) {
   auto len = strlen(s);
-  if (!cxxbridge00$rust_string$from(this, s, len)) {
+  if (!cxxbridge01$rust_string$from(this, s, len)) {
     throw std::invalid_argument("data for RustString is not utf-8");
   }
 }
@@ -52,12 +52,12 @@ RustString::RustString(const char *s) {
 RustString::RustString(const std::string &s) {
   auto ptr = s.data();
   auto len = s.length();
-  if (!cxxbridge00$rust_string$from(this, ptr, len)) {
+  if (!cxxbridge01$rust_string$from(this, ptr, len)) {
     throw std::invalid_argument("data for RustString is not utf-8");
   }
 }
 
-RustString::~RustString() noexcept { cxxbridge00$rust_string$drop(this); }
+RustString::~RustString() noexcept { cxxbridge01$rust_string$drop(this); }
 
 RustString::operator std::string() const {
   return std::string(this->data(), this->size());
@@ -65,31 +65,31 @@ RustString::operator std::string() const {
 
 RustString &RustString::operator=(const RustString &other) noexcept {
   if (this != &other) {
-    cxxbridge00$rust_string$drop(this);
-    cxxbridge00$rust_string$clone(this, other);
+    cxxbridge01$rust_string$drop(this);
+    cxxbridge01$rust_string$clone(this, other);
   }
   return *this;
 }
 
 RustString &RustString::operator=(RustString &&other) noexcept {
   if (this != &other) {
-    cxxbridge00$rust_string$drop(this);
+    cxxbridge01$rust_string$drop(this);
     this->repr = other.repr;
-    cxxbridge00$rust_string$new(&other);
+    cxxbridge01$rust_string$new(&other);
   }
   return *this;
 }
 
 const char *RustString::data() const noexcept {
-  return cxxbridge00$rust_string$ptr(this);
+  return cxxbridge01$rust_string$ptr(this);
 }
 
 size_t RustString::size() const noexcept {
-  return cxxbridge00$rust_string$len(this);
+  return cxxbridge01$rust_string$len(this);
 }
 
 size_t RustString::length() const noexcept {
-  return cxxbridge00$rust_string$len(this);
+  return cxxbridge01$rust_string$len(this);
 }
 
 std::ostream &operator<<(std::ostream &os, const RustString &s) {
@@ -101,13 +101,13 @@ RustStr::RustStr() noexcept
     : repr(Repr{reinterpret_cast<const char *>(this), 0}) {}
 
 RustStr::RustStr(const char *s) : repr(Repr{s, strlen(s)}) {
-  if (!cxxbridge00$rust_str$valid(this->repr.ptr, this->repr.len)) {
+  if (!cxxbridge01$rust_str$valid(this->repr.ptr, this->repr.len)) {
     throw std::invalid_argument("data for RustStr is not utf-8");
   }
 }
 
 RustStr::RustStr(const std::string &s) : repr(Repr{s.data(), s.length()}) {
-  if (!cxxbridge00$rust_str$valid(this->repr.ptr, this->repr.len)) {
+  if (!cxxbridge01$rust_str$valid(this->repr.ptr, this->repr.len)) {
     throw std::invalid_argument("data for RustStr is not utf-8");
   }
 }
@@ -138,30 +138,30 @@ std::ostream &operator<<(std::ostream &os, const RustStr &s) {
   return os;
 }
 
-} // namespace cxxbridge00
+} // namespace cxxbridge01
 
 extern "C" {
-void cxxbridge00$unique_ptr$std$string$null(
+void cxxbridge01$unique_ptr$std$string$null(
     std::unique_ptr<std::string> *ptr) noexcept {
   new (ptr) std::unique_ptr<std::string>();
 }
-void cxxbridge00$unique_ptr$std$string$new(std::unique_ptr<std::string> *ptr,
+void cxxbridge01$unique_ptr$std$string$new(std::unique_ptr<std::string> *ptr,
                                            std::string *value) noexcept {
   new (ptr) std::unique_ptr<std::string>(new std::string(std::move(*value)));
 }
-void cxxbridge00$unique_ptr$std$string$raw(std::unique_ptr<std::string> *ptr,
+void cxxbridge01$unique_ptr$std$string$raw(std::unique_ptr<std::string> *ptr,
                                            std::string *raw) noexcept {
   new (ptr) std::unique_ptr<std::string>(raw);
 }
-const std::string *cxxbridge00$unique_ptr$std$string$get(
+const std::string *cxxbridge01$unique_ptr$std$string$get(
     const std::unique_ptr<std::string> &ptr) noexcept {
   return ptr.get();
 }
-std::string *cxxbridge00$unique_ptr$std$string$release(
+std::string *cxxbridge01$unique_ptr$std$string$release(
     std::unique_ptr<std::string> &ptr) noexcept {
   return ptr.release();
 }
-void cxxbridge00$unique_ptr$std$string$drop(
+void cxxbridge01$unique_ptr$std$string$drop(
     std::unique_ptr<std::string> *ptr) noexcept {
   ptr->~unique_ptr();
 }
diff --git a/src/lib.rs b/src/lib.rs
index 8ed95722..5c018c2e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -298,9 +298,9 @@
 //! <tr><th>name in Rust</th><th>name in C++</th><th>restrictions</th></tr>
 //! <tr><td>String</td><td>cxxbridge::RustString</td><td></td></tr>
 //! <tr><td>&amp;str</td><td>cxxbridge::RustStr</td><td></td></tr>
-//! <tr><td><a href="https://docs.rs/cxx/0.0/cxx/struct.CxxString.html">CxxString</a></td><td>std::string</td><td><sup><i>cannot be passed by value</i></sup></td></tr>
+//! <tr><td><a href="https://docs.rs/cxx/0.1/cxx/struct.CxxString.html">CxxString</a></td><td>std::string</td><td><sup><i>cannot be passed by value</i></sup></td></tr>
 //! <tr><td>Box&lt;T&gt;</td><td>cxxbridge::RustBox&lt;T&gt;</td><td><sup><i>cannot hold opaque C++ type</i></sup></td></tr>
-//! <tr><td><a href="https://docs.rs/cxx/0.0/cxx/struct.UniquePtr.html">UniquePtr&lt;T&gt;</a></td><td>std::unique_ptr&lt;T&gt;</td><td><sup><i>cannot hold opaque Rust type</i></sup></td></tr>
+//! <tr><td><a href="https://docs.rs/cxx/0.1/cxx/struct.UniquePtr.html">UniquePtr&lt;T&gt;</a></td><td>std::unique_ptr&lt;T&gt;</td><td><sup><i>cannot hold opaque Rust type</i></sup></td></tr>
 //! <tr><td></td><td></td><td></td></tr>
 //! </table>
 //!
diff --git a/src/rust_str.rs b/src/rust_str.rs
index 5aeac282..59a77843 100644
--- a/src/rust_str.rs
+++ b/src/rust_str.rs
@@ -23,7 +23,7 @@ impl RustStr {
     }
 }
 
-#[export_name = "cxxbridge00$rust_str$valid"]
+#[export_name = "cxxbridge01$rust_str$valid"]
 unsafe extern "C" fn str_valid(ptr: *const u8, len: usize) -> bool {
     let slice = slice::from_raw_parts(ptr, len);
     str::from_utf8(slice).is_ok()
diff --git a/src/rust_string.rs b/src/rust_string.rs
index 5756efad..250a46f3 100644
--- a/src/rust_string.rs
+++ b/src/rust_string.rs
@@ -26,17 +26,17 @@ impl RustString {
     }
 }
 
-#[export_name = "cxxbridge00$rust_string$new"]
+#[export_name = "cxxbridge01$rust_string$new"]
 unsafe extern "C" fn string_new(this: &mut MaybeUninit<String>) {
     ptr::write(this.as_mut_ptr(), String::new());
 }
 
-#[export_name = "cxxbridge00$rust_string$clone"]
+#[export_name = "cxxbridge01$rust_string$clone"]
 unsafe extern "C" fn string_clone(this: &mut MaybeUninit<String>, other: &String) {
     ptr::write(this.as_mut_ptr(), other.clone());
 }
 
-#[export_name = "cxxbridge00$rust_string$from"]
+#[export_name = "cxxbridge01$rust_string$from"]
 unsafe extern "C" fn string_from(
     this: &mut MaybeUninit<String>,
     ptr: *const u8,
@@ -52,17 +52,17 @@ unsafe extern "C" fn string_from(
     }
 }
 
-#[export_name = "cxxbridge00$rust_string$drop"]
+#[export_name = "cxxbridge01$rust_string$drop"]
 unsafe extern "C" fn string_drop(this: &mut ManuallyDrop<String>) {
     ManuallyDrop::drop(this);
 }
 
-#[export_name = "cxxbridge00$rust_string$ptr"]
+#[export_name = "cxxbridge01$rust_string$ptr"]
 unsafe extern "C" fn string_ptr(this: &String) -> *const u8 {
     this.as_ptr()
 }
 
-#[export_name = "cxxbridge00$rust_string$len"]
+#[export_name = "cxxbridge01$rust_string$len"]
 unsafe extern "C" fn string_len(this: &String) -> usize {
     this.len()
 }
diff --git a/src/unique_ptr.rs b/src/unique_ptr.rs
index f6d2e863..19718bb8 100644
--- a/src/unique_ptr.rs
+++ b/src/unique_ptr.rs
@@ -130,17 +130,17 @@ pub unsafe trait UniquePtrTarget {
 }
 
 extern "C" {
-    #[link_name = "cxxbridge00$unique_ptr$std$string$null"]
+    #[link_name = "cxxbridge01$unique_ptr$std$string$null"]
     fn unique_ptr_std_string_null(this: *mut *mut c_void);
-    #[link_name = "cxxbridge00$unique_ptr$std$string$new"]
+    #[link_name = "cxxbridge01$unique_ptr$std$string$new"]
     fn unique_ptr_std_string_new(this: *mut *mut c_void, value: *mut CxxString);
-    #[link_name = "cxxbridge00$unique_ptr$std$string$raw"]
+    #[link_name = "cxxbridge01$unique_ptr$std$string$raw"]
     fn unique_ptr_std_string_raw(this: *mut *mut c_void, raw: *mut CxxString);
-    #[link_name = "cxxbridge00$unique_ptr$std$string$get"]
+    #[link_name = "cxxbridge01$unique_ptr$std$string$get"]
     fn unique_ptr_std_string_get(this: *const *mut c_void) -> *const CxxString;
-    #[link_name = "cxxbridge00$unique_ptr$std$string$release"]
+    #[link_name = "cxxbridge01$unique_ptr$std$string$release"]
     fn unique_ptr_std_string_release(this: *mut *mut c_void) -> *mut CxxString;
-    #[link_name = "cxxbridge00$unique_ptr$std$string$drop"]
+    #[link_name = "cxxbridge01$unique_ptr$std$string$drop"]
     fn unique_ptr_std_string_drop(this: *mut *mut c_void);
 }