Bump namespace to 05
diff --git a/Cargo.toml b/Cargo.toml
index d8b93f1..54c968f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,7 +3,7 @@
version = "0.4.7" # remember to update html_root_url
authors = ["David Tolnay <dtolnay@gmail.com>"]
edition = "2018"
-links = "cxxbridge04"
+links = "cxxbridge05"
license = "MIT OR Apache-2.0"
description = "Safe interop between Rust and C++"
repository = "https://github.com/dtolnay/cxx"
diff --git a/build.rs b/build.rs
index 688b5b7..57b3e52 100644
--- a/build.rs
+++ b/build.rs
@@ -7,7 +7,7 @@
.cpp(true)
.cpp_link_stdlib(None) // linked via link-cplusplus crate
.flag_if_supported(cxxbridge_flags::STD)
- .compile("cxxbridge04");
+ .compile("cxxbridge05");
println!("cargo:rerun-if-changed=src/cxx.cc");
println!("cargo:rerun-if-changed=include/cxx.h");
println!("cargo:rustc-cfg=built_with_cargo");
diff --git a/gen/build/src/lib.rs b/gen/build/src/lib.rs
index 135833b..7148d7b 100644
--- a/gen/build/src/lib.rs
+++ b/gen/build/src/lib.rs
@@ -263,7 +263,7 @@
let include_dir = prj.out_dir.join("cxxbridge").join("include");
let cxx_h = include_dir.join("rust").join("cxx.h");
let ref shared_cxx_h = prj.shared_dir.join("rust").join("cxx.h");
- if let Some(ref original) = env::var_os("DEP_CXXBRIDGE04_HEADER") {
+ if let Some(ref original) = env::var_os("DEP_CXXBRIDGE05_HEADER") {
out::symlink_file(original, cxx_h)?;
out::symlink_file(original, shared_cxx_h)?;
} else {
diff --git a/gen/src/write.rs b/gen/src/write.rs
index 1048272..9e6a297 100644
--- a/gen/src/write.rs
+++ b/gen/src/write.rs
@@ -245,7 +245,7 @@
}
out.begin_block("namespace rust");
- out.begin_block("inline namespace cxxbridge04");
+ out.begin_block("inline namespace cxxbridge05");
if needs_panic
|| needs_rust_string
@@ -263,22 +263,22 @@
writeln!(out, "// #include \"rust/cxx.h\"");
}
- include::write(out, needs_panic, "CXXBRIDGE04_PANIC");
+ include::write(out, needs_panic, "CXXBRIDGE05_PANIC");
if needs_rust_string {
out.next_section();
writeln!(out, "struct unsafe_bitcopy_t;");
}
- include::write(out, needs_rust_string, "CXXBRIDGE04_RUST_STRING");
- include::write(out, needs_rust_str, "CXXBRIDGE04_RUST_STR");
- include::write(out, needs_rust_slice, "CXXBRIDGE04_RUST_SLICE");
- include::write(out, needs_rust_box, "CXXBRIDGE04_RUST_BOX");
- include::write(out, needs_unsafe_bitcopy, "CXXBRIDGE04_RUST_BITCOPY");
- include::write(out, needs_rust_vec, "CXXBRIDGE04_RUST_VEC");
- include::write(out, needs_rust_fn, "CXXBRIDGE04_RUST_FN");
- include::write(out, needs_rust_error, "CXXBRIDGE04_RUST_ERROR");
- include::write(out, needs_rust_isize, "CXXBRIDGE04_RUST_ISIZE");
+ include::write(out, needs_rust_string, "CXXBRIDGE05_RUST_STRING");
+ include::write(out, needs_rust_str, "CXXBRIDGE05_RUST_STR");
+ include::write(out, needs_rust_slice, "CXXBRIDGE05_RUST_SLICE");
+ include::write(out, needs_rust_box, "CXXBRIDGE05_RUST_BOX");
+ include::write(out, needs_unsafe_bitcopy, "CXXBRIDGE05_RUST_BITCOPY");
+ include::write(out, needs_rust_vec, "CXXBRIDGE05_RUST_VEC");
+ include::write(out, needs_rust_fn, "CXXBRIDGE05_RUST_FN");
+ include::write(out, needs_rust_error, "CXXBRIDGE05_RUST_ERROR");
+ include::write(out, needs_rust_isize, "CXXBRIDGE05_RUST_ISIZE");
if needs_manually_drop {
out.next_section();
@@ -304,7 +304,7 @@
writeln!(out, "}};");
}
- out.end_block("namespace cxxbridge04");
+ out.end_block("namespace cxxbridge05");
if needs_trycatch {
out.begin_block("namespace behavior");
@@ -333,7 +333,7 @@
}
fn write_struct(out: &mut OutFile, strct: &Struct) {
- let guard = format!("CXXBRIDGE04_STRUCT_{}{}", out.namespace, strct.ident);
+ let guard = format!("CXXBRIDGE05_STRUCT_{}{}", out.namespace, strct.ident);
writeln!(out, "#ifndef {}", guard);
writeln!(out, "#define {}", guard);
for line in strct.doc.to_string().lines() {
@@ -358,7 +358,7 @@
}
fn write_struct_with_methods(out: &mut OutFile, ety: &ExternType, methods: &[&ExternFn]) {
- let guard = format!("CXXBRIDGE04_STRUCT_{}{}", out.namespace, ety.ident);
+ let guard = format!("CXXBRIDGE05_STRUCT_{}{}", out.namespace, ety.ident);
writeln!(out, "#ifndef {}", guard);
writeln!(out, "#define {}", guard);
for line in ety.doc.to_string().lines() {
@@ -379,7 +379,7 @@
}
fn write_enum(out: &mut OutFile, enm: &Enum) {
- let guard = format!("CXXBRIDGE04_ENUM_{}{}", out.namespace, enm.ident);
+ let guard = format!("CXXBRIDGE05_ENUM_{}{}", out.namespace, enm.ident);
writeln!(out, "#ifndef {}", guard);
writeln!(out, "#define {}", guard);
for line in enm.doc.to_string().lines() {
@@ -465,7 +465,7 @@
out.next_section();
writeln!(
out,
- "const char *cxxbridge04$exception(const char *, size_t);",
+ "const char *cxxbridge05$exception(const char *, size_t);",
);
}
}
@@ -610,7 +610,7 @@
writeln!(out, " throw$.len = ::std::strlen(catch$);");
writeln!(
out,
- " throw$.ptr = cxxbridge04$exception(catch$, throw$.len);",
+ " throw$.ptr = cxxbridge05$exception(catch$, throw$.len);",
);
writeln!(out, " }});");
writeln!(out, " return throw$;");
@@ -1089,7 +1089,7 @@
out.end_block("extern \"C\"");
out.begin_block("namespace rust");
- out.begin_block("inline namespace cxxbridge04");
+ out.begin_block("inline namespace cxxbridge05");
for ty in types {
if let Type::RustBox(ty) = ty {
if let Type::Ident(inner) = &ty.inner {
@@ -1103,7 +1103,7 @@
}
}
}
- out.end_block("namespace cxxbridge04");
+ out.end_block("namespace cxxbridge05");
out.end_block("namespace rust");
}
@@ -1116,19 +1116,19 @@
inner += &ident.to_string();
let instance = inner.replace("::", "$");
- writeln!(out, "#ifndef CXXBRIDGE04_RUST_BOX_{}", instance);
- writeln!(out, "#define CXXBRIDGE04_RUST_BOX_{}", instance);
+ writeln!(out, "#ifndef CXXBRIDGE05_RUST_BOX_{}", instance);
+ writeln!(out, "#define CXXBRIDGE05_RUST_BOX_{}", instance);
writeln!(
out,
- "void cxxbridge04$box${}$uninit(::rust::Box<{}> *ptr) noexcept;",
+ "void cxxbridge05$box${}$uninit(::rust::Box<{}> *ptr) noexcept;",
instance, inner,
);
writeln!(
out,
- "void cxxbridge04$box${}$drop(::rust::Box<{}> *ptr) noexcept;",
+ "void cxxbridge05$box${}$drop(::rust::Box<{}> *ptr) noexcept;",
instance, inner,
);
- writeln!(out, "#endif // CXXBRIDGE04_RUST_BOX_{}", instance);
+ writeln!(out, "#endif // CXXBRIDGE05_RUST_BOX_{}", instance);
}
fn write_rust_vec_extern(out: &mut OutFile, element: &Ident) {
@@ -1136,34 +1136,34 @@
let inner = to_typename(&out.namespace, &element);
let instance = to_mangled(&out.namespace, &element);
- writeln!(out, "#ifndef CXXBRIDGE04_RUST_VEC_{}", instance);
- writeln!(out, "#define CXXBRIDGE04_RUST_VEC_{}", instance);
+ writeln!(out, "#ifndef CXXBRIDGE05_RUST_VEC_{}", instance);
+ writeln!(out, "#define CXXBRIDGE05_RUST_VEC_{}", instance);
writeln!(
out,
- "void cxxbridge04$rust_vec${}$new(const ::rust::Vec<{}> *ptr) noexcept;",
+ "void cxxbridge05$rust_vec${}$new(const ::rust::Vec<{}> *ptr) noexcept;",
instance, inner,
);
writeln!(
out,
- "void cxxbridge04$rust_vec${}$drop(::rust::Vec<{}> *ptr) noexcept;",
+ "void cxxbridge05$rust_vec${}$drop(::rust::Vec<{}> *ptr) noexcept;",
instance, inner,
);
writeln!(
out,
- "size_t cxxbridge04$rust_vec${}$len(const ::rust::Vec<{}> *ptr) noexcept;",
+ "size_t cxxbridge05$rust_vec${}$len(const ::rust::Vec<{}> *ptr) noexcept;",
instance, inner,
);
writeln!(
out,
- "const {} *cxxbridge04$rust_vec${}$data(const ::rust::Vec<{0}> *ptr) noexcept;",
+ "const {} *cxxbridge05$rust_vec${}$data(const ::rust::Vec<{0}> *ptr) noexcept;",
inner, instance,
);
writeln!(
out,
- "size_t cxxbridge04$rust_vec${}$stride() noexcept;",
+ "size_t cxxbridge05$rust_vec${}$stride() noexcept;",
instance,
);
- writeln!(out, "#endif // CXXBRIDGE04_RUST_VEC_{}", instance);
+ writeln!(out, "#endif // CXXBRIDGE05_RUST_VEC_{}", instance);
}
fn write_rust_box_impl(out: &mut OutFile, ident: &Ident) {
@@ -1177,12 +1177,12 @@
writeln!(out, "template <>");
writeln!(out, "void Box<{}>::uninit() noexcept {{", inner);
- writeln!(out, " cxxbridge04$box${}$uninit(this);", instance);
+ writeln!(out, " cxxbridge05$box${}$uninit(this);", instance);
writeln!(out, "}}");
writeln!(out, "template <>");
writeln!(out, "void Box<{}>::drop() noexcept {{", inner);
- writeln!(out, " cxxbridge04$box${}$drop(this);", instance);
+ writeln!(out, " cxxbridge05$box${}$drop(this);", instance);
writeln!(out, "}}");
}
@@ -1193,35 +1193,35 @@
writeln!(out, "template <>");
writeln!(out, "Vec<{}>::Vec() noexcept {{", inner);
- writeln!(out, " cxxbridge04$rust_vec${}$new(this);", instance);
+ writeln!(out, " cxxbridge05$rust_vec${}$new(this);", instance);
writeln!(out, "}}");
writeln!(out, "template <>");
writeln!(out, "void Vec<{}>::drop() noexcept {{", inner);
writeln!(
out,
- " return cxxbridge04$rust_vec${}$drop(this);",
+ " return cxxbridge05$rust_vec${}$drop(this);",
instance,
);
writeln!(out, "}}");
writeln!(out, "template <>");
writeln!(out, "size_t Vec<{}>::size() const noexcept {{", inner);
- writeln!(out, " return cxxbridge04$rust_vec${}$len(this);", instance);
+ writeln!(out, " return cxxbridge05$rust_vec${}$len(this);", instance);
writeln!(out, "}}");
writeln!(out, "template <>");
writeln!(out, "const {} *Vec<{0}>::data() const noexcept {{", inner);
writeln!(
out,
- " return cxxbridge04$rust_vec${}$data(this);",
+ " return cxxbridge05$rust_vec${}$data(this);",
instance,
);
writeln!(out, "}}");
writeln!(out, "template <>");
writeln!(out, "size_t Vec<{}>::stride() noexcept {{", inner);
- writeln!(out, " return cxxbridge04$rust_vec${}$stride();", instance);
+ writeln!(out, " return cxxbridge05$rust_vec${}$stride();", instance);
writeln!(out, "}}");
}
@@ -1229,12 +1229,12 @@
let ty = Type::Ident(ident.clone());
let instance = to_mangled(&out.namespace, &ty);
- writeln!(out, "#ifndef CXXBRIDGE04_UNIQUE_PTR_{}", instance);
- writeln!(out, "#define CXXBRIDGE04_UNIQUE_PTR_{}", instance);
+ writeln!(out, "#ifndef CXXBRIDGE05_UNIQUE_PTR_{}", instance);
+ writeln!(out, "#define CXXBRIDGE05_UNIQUE_PTR_{}", instance);
write_unique_ptr_common(out, &ty, types);
- writeln!(out, "#endif // CXXBRIDGE04_UNIQUE_PTR_{}", instance);
+ writeln!(out, "#endif // CXXBRIDGE05_UNIQUE_PTR_{}", instance);
}
// Shared by UniquePtr<T> and UniquePtr<CxxVector<T>>.
@@ -1261,7 +1261,7 @@
);
writeln!(
out,
- "void cxxbridge04$unique_ptr${}$null(::std::unique_ptr<{}> *ptr) noexcept {{",
+ "void cxxbridge05$unique_ptr${}$null(::std::unique_ptr<{}> *ptr) noexcept {{",
instance, inner,
);
writeln!(out, " new (ptr) ::std::unique_ptr<{}>();", inner);
@@ -1269,7 +1269,7 @@
if can_construct_from_value {
writeln!(
out,
- "void cxxbridge04$unique_ptr${}$new(::std::unique_ptr<{}> *ptr, {} *value) noexcept {{",
+ "void cxxbridge05$unique_ptr${}$new(::std::unique_ptr<{}> *ptr, {} *value) noexcept {{",
instance, inner, inner,
);
writeln!(
@@ -1281,28 +1281,28 @@
}
writeln!(
out,
- "void cxxbridge04$unique_ptr${}$raw(::std::unique_ptr<{}> *ptr, {} *raw) noexcept {{",
+ "void cxxbridge05$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 {} *cxxbridge04$unique_ptr${}$get(const ::std::unique_ptr<{}>& ptr) noexcept {{",
+ "const {} *cxxbridge05$unique_ptr${}$get(const ::std::unique_ptr<{}>& ptr) noexcept {{",
inner, instance, inner,
);
writeln!(out, " return ptr.get();");
writeln!(out, "}}");
writeln!(
out,
- "{} *cxxbridge04$unique_ptr${}$release(::std::unique_ptr<{}>& ptr) noexcept {{",
+ "{} *cxxbridge05$unique_ptr${}$release(::std::unique_ptr<{}>& ptr) noexcept {{",
inner, instance, inner,
);
writeln!(out, " return ptr.release();");
writeln!(out, "}}");
writeln!(
out,
- "void cxxbridge04$unique_ptr${}$drop(::std::unique_ptr<{}> *ptr) noexcept {{",
+ "void cxxbridge05$unique_ptr${}$drop(::std::unique_ptr<{}> *ptr) noexcept {{",
instance, inner,
);
writeln!(out, " ptr->~unique_ptr();");
@@ -1314,18 +1314,18 @@
let inner = to_typename(&out.namespace, &element);
let instance = to_mangled(&out.namespace, &element);
- writeln!(out, "#ifndef CXXBRIDGE04_VECTOR_{}", instance);
- writeln!(out, "#define CXXBRIDGE04_VECTOR_{}", instance);
+ writeln!(out, "#ifndef CXXBRIDGE05_VECTOR_{}", instance);
+ writeln!(out, "#define CXXBRIDGE05_VECTOR_{}", instance);
writeln!(
out,
- "size_t cxxbridge04$std$vector${}$size(const ::std::vector<{}> &s) noexcept {{",
+ "size_t cxxbridge05$std$vector${}$size(const ::std::vector<{}> &s) noexcept {{",
instance, inner,
);
writeln!(out, " return s.size();");
writeln!(out, "}}");
writeln!(
out,
- "const {} *cxxbridge04$std$vector${}$get_unchecked(const ::std::vector<{}> &s, size_t pos) noexcept {{",
+ "const {} *cxxbridge05$std$vector${}$get_unchecked(const ::std::vector<{}> &s, size_t pos) noexcept {{",
inner, instance, inner,
);
writeln!(out, " return &s[pos];");
@@ -1333,5 +1333,5 @@
write_unique_ptr_common(out, vector_ty, types);
- writeln!(out, "#endif // CXXBRIDGE04_VECTOR_{}", instance);
+ writeln!(out, "#endif // CXXBRIDGE05_VECTOR_{}", instance);
}
diff --git a/include/cxx.h b/include/cxx.h
index b2e0eee..0373a38 100644
--- a/include/cxx.h
+++ b/include/cxx.h
@@ -15,12 +15,12 @@
#endif
namespace rust {
-inline namespace cxxbridge04 {
+inline namespace cxxbridge05 {
struct unsafe_bitcopy_t;
-#ifndef CXXBRIDGE04_RUST_STRING
-#define CXXBRIDGE04_RUST_STRING
+#ifndef CXXBRIDGE05_RUST_STRING
+#define CXXBRIDGE05_RUST_STRING
class String final {
public:
String() noexcept;
@@ -49,10 +49,10 @@
// Size and alignment statically verified by rust_string.rs.
std::array<uintptr_t, 3> repr;
};
-#endif // CXXBRIDGE04_RUST_STRING
+#endif // CXXBRIDGE05_RUST_STRING
-#ifndef CXXBRIDGE04_RUST_STR
-#define CXXBRIDGE04_RUST_STR
+#ifndef CXXBRIDGE05_RUST_STR
+#define CXXBRIDGE05_RUST_STR
class Str final {
public:
Str() noexcept;
@@ -86,9 +86,9 @@
private:
Repr repr;
};
-#endif // CXXBRIDGE04_RUST_STR
+#endif // CXXBRIDGE05_RUST_STR
-#ifndef CXXBRIDGE04_RUST_SLICE
+#ifndef CXXBRIDGE05_RUST_SLICE
template <typename T>
class Slice final {
public:
@@ -117,9 +117,9 @@
private:
Repr repr;
};
-#endif // CXXBRIDGE04_RUST_SLICE
+#endif // CXXBRIDGE05_RUST_SLICE
-#ifndef CXXBRIDGE04_RUST_BOX
+#ifndef CXXBRIDGE05_RUST_BOX
template <typename T>
class Box final {
public:
@@ -158,9 +158,9 @@
void drop() noexcept;
T *ptr;
};
-#endif // CXXBRIDGE04_RUST_BOX
+#endif // CXXBRIDGE05_RUST_BOX
-#ifndef CXXBRIDGE04_RUST_VEC
+#ifndef CXXBRIDGE05_RUST_VEC
template <typename T>
class Vec final {
public:
@@ -218,10 +218,10 @@
// Size and alignment statically verified by rust_vec.rs.
std::array<uintptr_t, 3> repr;
};
-#endif // CXXBRIDGE04_RUST_VEC
+#endif // CXXBRIDGE05_RUST_VEC
-#ifndef CXXBRIDGE04_RUST_FN
-#define CXXBRIDGE04_RUST_FN
+#ifndef CXXBRIDGE05_RUST_FN
+#define CXXBRIDGE05_RUST_FN
template <typename Signature, bool Throws = false>
class Fn;
@@ -238,10 +238,10 @@
template <typename Signature>
using TryFn = Fn<Signature, true>;
-#endif // CXXBRIDGE04_RUST_FN
+#endif // CXXBRIDGE05_RUST_FN
-#ifndef CXXBRIDGE04_RUST_ERROR
-#define CXXBRIDGE04_RUST_ERROR
+#ifndef CXXBRIDGE05_RUST_ERROR
+#define CXXBRIDGE05_RUST_ERROR
class Error final : public std::exception {
public:
Error(const Error &);
@@ -253,16 +253,16 @@
private:
Str::Repr msg;
};
-#endif // CXXBRIDGE04_RUST_ERROR
+#endif // CXXBRIDGE05_RUST_ERROR
-#ifndef CXXBRIDGE04_RUST_ISIZE
-#define CXXBRIDGE04_RUST_ISIZE
+#ifndef CXXBRIDGE05_RUST_ISIZE
+#define CXXBRIDGE05_RUST_ISIZE
#if defined(_WIN32)
using isize = SSIZE_T;
#else
using isize = ssize_t;
#endif
-#endif // CXXBRIDGE04_RUST_ISIZE
+#endif // CXXBRIDGE05_RUST_ISIZE
std::ostream &operator<<(std::ostream &, const String &);
std::ostream &operator<<(std::ostream &, const Str &);
@@ -287,11 +287,11 @@
////////////////////////////////////////////////////////////////////////////////
/// end public API, begin implementation details
-#ifndef CXXBRIDGE04_PANIC
-#define CXXBRIDGE04_PANIC
+#ifndef CXXBRIDGE05_PANIC
+#define CXXBRIDGE05_PANIC
template <typename Exception>
void panic [[noreturn]] (const char *msg);
-#endif // CXXBRIDGE04_PANIC
+#endif // CXXBRIDGE05_PANIC
template <typename Ret, typename... Args, bool Throws>
Ret Fn<Ret(Args...), Throws>::operator()(Args... args) const noexcept(!Throws) {
@@ -303,17 +303,17 @@
return *this;
}
-#ifndef CXXBRIDGE04_RUST_BITCOPY
-#define CXXBRIDGE04_RUST_BITCOPY
+#ifndef CXXBRIDGE05_RUST_BITCOPY
+#define CXXBRIDGE05_RUST_BITCOPY
struct unsafe_bitcopy_t {
explicit unsafe_bitcopy_t() = default;
};
constexpr unsafe_bitcopy_t unsafe_bitcopy{};
-#endif // CXXBRIDGE04_RUST_BITCOPY
+#endif // CXXBRIDGE05_RUST_BITCOPY
-#ifndef CXXBRIDGE04_RUST_SLICE
-#define CXXBRIDGE04_RUST_SLICE
+#ifndef CXXBRIDGE05_RUST_SLICE
+#define CXXBRIDGE05_RUST_SLICE
template <typename T>
Slice<T>::Slice() noexcept : repr(Repr{reinterpret_cast<const T *>(this), 0}) {}
@@ -351,10 +351,10 @@
Slice<T>::operator Repr() noexcept {
return this->repr;
}
-#endif // CXXBRIDGE04_RUST_SLICE
+#endif // CXXBRIDGE05_RUST_SLICE
-#ifndef CXXBRIDGE04_RUST_BOX
-#define CXXBRIDGE04_RUST_BOX
+#ifndef CXXBRIDGE05_RUST_BOX
+#define CXXBRIDGE05_RUST_BOX
template <typename T>
Box<T>::Box(const Box &other) : Box(*other) {}
@@ -450,10 +450,10 @@
template <typename T>
Box<T>::Box() noexcept {}
-#endif // CXXBRIDGE04_RUST_BOX
+#endif // CXXBRIDGE05_RUST_BOX
-#ifndef CXXBRIDGE04_RUST_VEC
-#define CXXBRIDGE04_RUST_VEC
+#ifndef CXXBRIDGE05_RUST_VEC
+#define CXXBRIDGE05_RUST_VEC
template <typename T>
Vec<T>::Vec(Vec &&other) noexcept {
this->repr = other.repr;
@@ -558,7 +558,7 @@
// Internal API only intended for the cxxbridge code generator.
template <typename T>
Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
-#endif // CXXBRIDGE04_RUST_VEC
+#endif // CXXBRIDGE05_RUST_VEC
-} // namespace cxxbridge04
+} // namespace cxxbridge05
} // namespace rust
diff --git a/macro/src/expand.rs b/macro/src/expand.rs
index dd5350f..20f166f 100644
--- a/macro/src/expand.rs
+++ b/macro/src/expand.rs
@@ -727,7 +727,7 @@
}
fn expand_rust_box(namespace: &Namespace, ident: &Ident) -> TokenStream {
- let link_prefix = format!("cxxbridge04$box${}{}$", namespace, ident);
+ let link_prefix = format!("cxxbridge05$box${}{}$", namespace, ident);
let link_uninit = format!("{}uninit", link_prefix);
let link_drop = format!("{}drop", link_prefix);
@@ -756,7 +756,7 @@
}
fn expand_rust_vec(namespace: &Namespace, elem: &Ident) -> TokenStream {
- let link_prefix = format!("cxxbridge04$rust_vec${}{}$", namespace, elem);
+ let link_prefix = format!("cxxbridge05$rust_vec${}{}$", namespace, elem);
let link_new = format!("{}new", link_prefix);
let link_drop = format!("{}drop", link_prefix);
let link_len = format!("{}len", link_prefix);
@@ -807,7 +807,7 @@
explicit_impl: Option<&Impl>,
) -> TokenStream {
let name = ident.to_string();
- let prefix = format!("cxxbridge04$unique_ptr${}{}$", namespace, ident);
+ let prefix = format!("cxxbridge05$unique_ptr${}{}$", namespace, ident);
let link_null = format!("{}null", prefix);
let link_new = format!("{}new", prefix);
let link_raw = format!("{}raw", prefix);
@@ -890,10 +890,10 @@
) -> TokenStream {
let _ = explicit_impl;
let name = elem.to_string();
- let prefix = format!("cxxbridge04$std$vector${}{}$", namespace, elem);
+ let prefix = format!("cxxbridge05$std$vector${}{}$", namespace, elem);
let link_size = format!("{}size", prefix);
let link_get_unchecked = format!("{}get_unchecked", prefix);
- let unique_ptr_prefix = format!("cxxbridge04$unique_ptr$std$vector${}{}$", namespace, elem);
+ let unique_ptr_prefix = format!("cxxbridge05$unique_ptr$std$vector${}{}$", namespace, elem);
let link_unique_ptr_null = format!("{}null", unique_ptr_prefix);
let link_unique_ptr_raw = format!("{}raw", unique_ptr_prefix);
let link_unique_ptr_get = format!("{}get", unique_ptr_prefix);
diff --git a/src/cxx.cc b/src/cxx.cc
index cd75162..715e0ce 100644
--- a/src/cxx.cc
+++ b/src/cxx.cc
@@ -7,30 +7,30 @@
#include <vector>
extern "C" {
-const char *cxxbridge04$cxx_string$data(const std::string &s) noexcept {
+const char *cxxbridge05$cxx_string$data(const std::string &s) noexcept {
return s.data();
}
-size_t cxxbridge04$cxx_string$length(const std::string &s) noexcept {
+size_t cxxbridge05$cxx_string$length(const std::string &s) noexcept {
return s.length();
}
// rust::String
-void cxxbridge04$string$new(rust::String *self) noexcept;
-void cxxbridge04$string$clone(rust::String *self,
+void cxxbridge05$string$new(rust::String *self) noexcept;
+void cxxbridge05$string$clone(rust::String *self,
const rust::String &other) noexcept;
-bool cxxbridge04$string$from(rust::String *self, const char *ptr,
+bool cxxbridge05$string$from(rust::String *self, const char *ptr,
size_t len) noexcept;
-void cxxbridge04$string$drop(rust::String *self) noexcept;
-const char *cxxbridge04$string$ptr(const rust::String *self) noexcept;
-size_t cxxbridge04$string$len(const rust::String *self) noexcept;
+void cxxbridge05$string$drop(rust::String *self) noexcept;
+const char *cxxbridge05$string$ptr(const rust::String *self) noexcept;
+size_t cxxbridge05$string$len(const rust::String *self) noexcept;
// rust::Str
-bool cxxbridge04$str$valid(const char *ptr, size_t len) noexcept;
+bool cxxbridge05$str$valid(const char *ptr, size_t len) noexcept;
} // extern "C"
namespace rust {
-inline namespace cxxbridge04 {
+inline namespace cxxbridge05 {
template <typename Exception>
void panic [[noreturn]] (const char *msg) {
@@ -44,42 +44,42 @@
template void panic<std::out_of_range>[[noreturn]] (const char *msg);
-String::String() noexcept { cxxbridge04$string$new(this); }
+String::String() noexcept { cxxbridge05$string$new(this); }
String::String(const String &other) noexcept {
- cxxbridge04$string$clone(this, other);
+ cxxbridge05$string$clone(this, other);
}
String::String(String &&other) noexcept {
this->repr = other.repr;
- cxxbridge04$string$new(&other);
+ cxxbridge05$string$new(&other);
}
-String::~String() noexcept { cxxbridge04$string$drop(this); }
+String::~String() noexcept { cxxbridge05$string$drop(this); }
String::String(const std::string &s) : String(s.data(), s.length()) {}
String::String(const char *s) : String(s, std::strlen(s)) {}
String::String(const char *s, size_t len) {
- if (!cxxbridge04$string$from(this, s, len)) {
+ if (!cxxbridge05$string$from(this, s, len)) {
panic<std::invalid_argument>("data for rust::String is not utf-8");
}
}
String &String::operator=(const String &other) noexcept {
if (this != &other) {
- cxxbridge04$string$drop(this);
- cxxbridge04$string$clone(this, other);
+ cxxbridge05$string$drop(this);
+ cxxbridge05$string$clone(this, other);
}
return *this;
}
String &String::operator=(String &&other) noexcept {
if (this != &other) {
- cxxbridge04$string$drop(this);
+ cxxbridge05$string$drop(this);
this->repr = other.repr;
- cxxbridge04$string$new(&other);
+ cxxbridge05$string$new(&other);
}
return *this;
}
@@ -89,12 +89,12 @@
}
const char *String::data() const noexcept {
- return cxxbridge04$string$ptr(this);
+ return cxxbridge05$string$ptr(this);
}
-size_t String::size() const noexcept { return cxxbridge04$string$len(this); }
+size_t String::size() const noexcept { return cxxbridge05$string$len(this); }
-size_t String::length() const noexcept { return cxxbridge04$string$len(this); }
+size_t String::length() const noexcept { return cxxbridge05$string$len(this); }
String::String(unsafe_bitcopy_t, const String &bits) noexcept
: repr(bits.repr) {}
@@ -113,7 +113,7 @@
Str::Str(const char *s) : Str(s, std::strlen(s)) {}
Str::Str(const char *s, size_t len) : repr(Repr{s, len}) {
- if (!cxxbridge04$str$valid(this->repr.ptr, this->repr.len)) {
+ if (!cxxbridge05$str$valid(this->repr.ptr, this->repr.len)) {
panic<std::invalid_argument>("data for rust::Str is not utf-8");
}
}
@@ -143,7 +143,7 @@
}
extern "C" {
-const char *cxxbridge04$error(const char *ptr, size_t len) {
+const char *cxxbridge05$error(const char *ptr, size_t len) {
char *copy = new char[len];
strncpy(copy, ptr, len);
return copy;
@@ -153,7 +153,7 @@
Error::Error(Str::Repr msg) noexcept : msg(msg) {}
Error::Error(const Error &other) {
- this->msg.ptr = cxxbridge04$error(other.msg.ptr, other.msg.len);
+ this->msg.ptr = cxxbridge05$error(other.msg.ptr, other.msg.len);
this->msg.len = other.msg.len;
}
@@ -168,96 +168,96 @@
const char *Error::what() const noexcept { return this->msg.ptr; }
-} // namespace cxxbridge04
+} // namespace cxxbridge05
} // namespace rust
extern "C" {
-void cxxbridge04$unique_ptr$std$string$null(
+void cxxbridge05$unique_ptr$std$string$null(
std::unique_ptr<std::string> *ptr) noexcept {
new (ptr) std::unique_ptr<std::string>();
}
-void cxxbridge04$unique_ptr$std$string$raw(std::unique_ptr<std::string> *ptr,
+void cxxbridge05$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 *cxxbridge04$unique_ptr$std$string$get(
+const std::string *cxxbridge05$unique_ptr$std$string$get(
const std::unique_ptr<std::string> &ptr) noexcept {
return ptr.get();
}
-std::string *cxxbridge04$unique_ptr$std$string$release(
+std::string *cxxbridge05$unique_ptr$std$string$release(
std::unique_ptr<std::string> &ptr) noexcept {
return ptr.release();
}
-void cxxbridge04$unique_ptr$std$string$drop(
+void cxxbridge05$unique_ptr$std$string$drop(
std::unique_ptr<std::string> *ptr) noexcept {
ptr->~unique_ptr();
}
} // extern "C"
#define STD_VECTOR_OPS(RUST_TYPE, CXX_TYPE) \
- size_t cxxbridge04$std$vector$##RUST_TYPE##$size( \
+ size_t cxxbridge05$std$vector$##RUST_TYPE##$size( \
const std::vector<CXX_TYPE> &s) noexcept { \
return s.size(); \
} \
- const CXX_TYPE *cxxbridge04$std$vector$##RUST_TYPE##$get_unchecked( \
+ const CXX_TYPE *cxxbridge05$std$vector$##RUST_TYPE##$get_unchecked( \
const std::vector<CXX_TYPE> &s, size_t pos) noexcept { \
return &s[pos]; \
} \
- void cxxbridge04$unique_ptr$std$vector$##RUST_TYPE##$null( \
+ void cxxbridge05$unique_ptr$std$vector$##RUST_TYPE##$null( \
std::unique_ptr<std::vector<CXX_TYPE>> *ptr) noexcept { \
new (ptr) std::unique_ptr<std::vector<CXX_TYPE>>(); \
} \
- void cxxbridge04$unique_ptr$std$vector$##RUST_TYPE##$raw( \
+ void cxxbridge05$unique_ptr$std$vector$##RUST_TYPE##$raw( \
std::unique_ptr<std::vector<CXX_TYPE>> *ptr, \
std::vector<CXX_TYPE> *raw) noexcept { \
new (ptr) std::unique_ptr<std::vector<CXX_TYPE>>(raw); \
} \
const std::vector<CXX_TYPE> \
- *cxxbridge04$unique_ptr$std$vector$##RUST_TYPE##$get( \
+ *cxxbridge05$unique_ptr$std$vector$##RUST_TYPE##$get( \
const std::unique_ptr<std::vector<CXX_TYPE>> &ptr) noexcept { \
return ptr.get(); \
} \
std::vector<CXX_TYPE> \
- *cxxbridge04$unique_ptr$std$vector$##RUST_TYPE##$release( \
+ *cxxbridge05$unique_ptr$std$vector$##RUST_TYPE##$release( \
std::unique_ptr<std::vector<CXX_TYPE>> &ptr) noexcept { \
return ptr.release(); \
} \
- void cxxbridge04$unique_ptr$std$vector$##RUST_TYPE##$drop( \
+ void cxxbridge05$unique_ptr$std$vector$##RUST_TYPE##$drop( \
std::unique_ptr<std::vector<CXX_TYPE>> *ptr) noexcept { \
ptr->~unique_ptr(); \
}
#define RUST_VEC_EXTERNS(RUST_TYPE, CXX_TYPE) \
- void cxxbridge04$rust_vec$##RUST_TYPE##$new( \
+ void cxxbridge05$rust_vec$##RUST_TYPE##$new( \
rust::Vec<CXX_TYPE> *ptr) noexcept; \
- void cxxbridge04$rust_vec$##RUST_TYPE##$drop( \
+ void cxxbridge05$rust_vec$##RUST_TYPE##$drop( \
rust::Vec<CXX_TYPE> *ptr) noexcept; \
- size_t cxxbridge04$rust_vec$##RUST_TYPE##$len( \
+ size_t cxxbridge05$rust_vec$##RUST_TYPE##$len( \
const rust::Vec<CXX_TYPE> *ptr) noexcept; \
- const CXX_TYPE *cxxbridge04$rust_vec$##RUST_TYPE##$data( \
+ const CXX_TYPE *cxxbridge05$rust_vec$##RUST_TYPE##$data( \
const rust::Vec<CXX_TYPE> *ptr) noexcept; \
- size_t cxxbridge04$rust_vec$##RUST_TYPE##$stride() noexcept;
+ size_t cxxbridge05$rust_vec$##RUST_TYPE##$stride() noexcept;
#define RUST_VEC_OPS(RUST_TYPE, CXX_TYPE) \
template <> \
Vec<CXX_TYPE>::Vec() noexcept { \
- cxxbridge04$rust_vec$##RUST_TYPE##$new(this); \
+ cxxbridge05$rust_vec$##RUST_TYPE##$new(this); \
} \
template <> \
void Vec<CXX_TYPE>::drop() noexcept { \
- return cxxbridge04$rust_vec$##RUST_TYPE##$drop(this); \
+ return cxxbridge05$rust_vec$##RUST_TYPE##$drop(this); \
} \
template <> \
size_t Vec<CXX_TYPE>::size() const noexcept { \
- return cxxbridge04$rust_vec$##RUST_TYPE##$len(this); \
+ return cxxbridge05$rust_vec$##RUST_TYPE##$len(this); \
} \
template <> \
const CXX_TYPE *Vec<CXX_TYPE>::data() const noexcept { \
- return cxxbridge04$rust_vec$##RUST_TYPE##$data(this); \
+ return cxxbridge05$rust_vec$##RUST_TYPE##$data(this); \
} \
template <> \
size_t Vec<CXX_TYPE>::stride() noexcept { \
- return cxxbridge04$rust_vec$##RUST_TYPE##$stride(); \
+ return cxxbridge05$rust_vec$##RUST_TYPE##$stride(); \
}
// Usize and isize are the same type as one of the below.
@@ -290,7 +290,7 @@
} // extern "C"
namespace rust {
-inline namespace cxxbridge04 {
+inline namespace cxxbridge05 {
FOR_EACH_RUST_VEC(RUST_VEC_OPS)
-} // namespace cxxbridge04
+} // namespace cxxbridge05
} // namespace rust
diff --git a/src/cxx_string.rs b/src/cxx_string.rs
index 2c712f1..7b47feb 100644
--- a/src/cxx_string.rs
+++ b/src/cxx_string.rs
@@ -5,9 +5,9 @@
use core::str::{self, Utf8Error};
extern "C" {
- #[link_name = "cxxbridge04$cxx_string$data"]
+ #[link_name = "cxxbridge05$cxx_string$data"]
fn string_data(_: &CxxString) -> *const u8;
- #[link_name = "cxxbridge04$cxx_string$length"]
+ #[link_name = "cxxbridge05$cxx_string$length"]
fn string_length(_: &CxxString) -> usize;
}
diff --git a/src/cxx_vector.rs b/src/cxx_vector.rs
index a5fe536..5fb0807 100644
--- a/src/cxx_vector.rs
+++ b/src/cxx_vector.rs
@@ -157,7 +157,7 @@
fn __vector_size(v: &CxxVector<$ty>) -> usize {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge04$std$vector$", $segment, "$size")]
+ #[link_name = concat!("cxxbridge05$std$vector$", $segment, "$size")]
fn __vector_size(_: &CxxVector<$ty>) -> usize;
}
}
@@ -166,7 +166,7 @@
unsafe fn __get_unchecked(v: &CxxVector<$ty>, pos: usize) -> *const $ty {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge04$std$vector$", $segment, "$get_unchecked")]
+ #[link_name = concat!("cxxbridge05$std$vector$", $segment, "$get_unchecked")]
fn __get_unchecked(_: &CxxVector<$ty>, _: usize) -> *const $ty;
}
}
@@ -175,7 +175,7 @@
fn __unique_ptr_null() -> *mut c_void {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge04$unique_ptr$std$vector$", $segment, "$null")]
+ #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$null")]
fn __unique_ptr_null(this: *mut *mut c_void);
}
}
@@ -186,7 +186,7 @@
unsafe fn __unique_ptr_raw(raw: *mut CxxVector<Self>) -> *mut c_void {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge04$unique_ptr$std$vector$", $segment, "$raw")]
+ #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$raw")]
fn __unique_ptr_raw(this: *mut *mut c_void, raw: *mut CxxVector<$ty>);
}
}
@@ -197,7 +197,7 @@
unsafe fn __unique_ptr_get(repr: *mut c_void) -> *const CxxVector<Self> {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge04$unique_ptr$std$vector$", $segment, "$get")]
+ #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$get")]
fn __unique_ptr_get(this: *const *mut c_void) -> *const CxxVector<$ty>;
}
}
@@ -206,7 +206,7 @@
unsafe fn __unique_ptr_release(mut repr: *mut c_void) -> *mut CxxVector<Self> {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge04$unique_ptr$std$vector$", $segment, "$release")]
+ #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$release")]
fn __unique_ptr_release(this: *mut *mut c_void) -> *mut CxxVector<$ty>;
}
}
@@ -215,7 +215,7 @@
unsafe fn __unique_ptr_drop(mut repr: *mut c_void) {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge04$unique_ptr$std$vector$", $segment, "$drop")]
+ #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$drop")]
fn __unique_ptr_drop(this: *mut *mut c_void);
}
}
diff --git a/src/result.rs b/src/result.rs
index 296d4a2..fcced76 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -34,7 +34,7 @@
let len = msg.len();
extern "C" {
- #[link_name = "cxxbridge04$error"]
+ #[link_name = "cxxbridge05$error"]
fn error(ptr: *const u8, len: usize) -> *const u8;
}
diff --git a/src/symbols/exception.rs b/src/symbols/exception.rs
index da1c3f9..b408f25 100644
--- a/src/symbols/exception.rs
+++ b/src/symbols/exception.rs
@@ -2,7 +2,7 @@
use alloc::string::String;
use core::slice;
-#[export_name = "cxxbridge04$exception"]
+#[export_name = "cxxbridge05$exception"]
unsafe extern "C" fn exception(ptr: *const u8, len: usize) -> *const u8 {
let slice = slice::from_raw_parts(ptr, len);
let boxed = String::from_utf8_lossy(slice).into_owned().into_boxed_str();
diff --git a/src/symbols/rust_str.rs b/src/symbols/rust_str.rs
index 823173a..b655381 100644
--- a/src/symbols/rust_str.rs
+++ b/src/symbols/rust_str.rs
@@ -1,7 +1,7 @@
use core::slice;
use core::str;
-#[export_name = "cxxbridge04$str$valid"]
+#[export_name = "cxxbridge05$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/symbols/rust_string.rs b/src/symbols/rust_string.rs
index 774b824..e5ab9ea 100644
--- a/src/symbols/rust_string.rs
+++ b/src/symbols/rust_string.rs
@@ -5,17 +5,17 @@
use core::slice;
use core::str;
-#[export_name = "cxxbridge04$string$new"]
+#[export_name = "cxxbridge05$string$new"]
unsafe extern "C" fn string_new(this: &mut MaybeUninit<String>) {
ptr::write(this.as_mut_ptr(), String::new());
}
-#[export_name = "cxxbridge04$string$clone"]
+#[export_name = "cxxbridge05$string$clone"]
unsafe extern "C" fn string_clone(this: &mut MaybeUninit<String>, other: &String) {
ptr::write(this.as_mut_ptr(), other.clone());
}
-#[export_name = "cxxbridge04$string$from"]
+#[export_name = "cxxbridge05$string$from"]
unsafe extern "C" fn string_from(
this: &mut MaybeUninit<String>,
ptr: *const u8,
@@ -31,17 +31,17 @@
}
}
-#[export_name = "cxxbridge04$string$drop"]
+#[export_name = "cxxbridge05$string$drop"]
unsafe extern "C" fn string_drop(this: &mut ManuallyDrop<String>) {
ManuallyDrop::drop(this);
}
-#[export_name = "cxxbridge04$string$ptr"]
+#[export_name = "cxxbridge05$string$ptr"]
unsafe extern "C" fn string_ptr(this: &String) -> *const u8 {
this.as_ptr()
}
-#[export_name = "cxxbridge04$string$len"]
+#[export_name = "cxxbridge05$string$len"]
unsafe extern "C" fn string_len(this: &String) -> usize {
this.len()
}
diff --git a/src/symbols/rust_vec.rs b/src/symbols/rust_vec.rs
index 2304abf..00a7f16 100644
--- a/src/symbols/rust_vec.rs
+++ b/src/symbols/rust_vec.rs
@@ -11,31 +11,31 @@
const _: () = {
attr! {
- #[export_name = concat!("cxxbridge04$rust_vec$", $segment, "$new")]
+ #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$new")]
unsafe extern "C" fn __new(this: *mut RustVec<$ty>) {
ptr::write(this, RustVec { repr: Vec::new() });
}
}
attr! {
- #[export_name = concat!("cxxbridge04$rust_vec$", $segment, "$drop")]
+ #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$drop")]
unsafe extern "C" fn __drop(this: *mut RustVec<$ty>) {
ptr::drop_in_place(this);
}
}
attr! {
- #[export_name = concat!("cxxbridge04$rust_vec$", $segment, "$len")]
+ #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$len")]
unsafe extern "C" fn __len(this: *const RustVec<$ty>) -> usize {
(*this).repr.len()
}
}
attr! {
- #[export_name = concat!("cxxbridge04$rust_vec$", $segment, "$data")]
+ #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$data")]
unsafe extern "C" fn __data(this: *const RustVec<$ty>) -> *const $ty {
(*this).repr.as_ptr()
}
}
attr! {
- #[export_name = concat!("cxxbridge04$rust_vec$", $segment, "$stride")]
+ #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$stride")]
unsafe extern "C" fn __stride() -> usize {
mem::size_of::<$ty>()
}
diff --git a/src/unique_ptr.rs b/src/unique_ptr.rs
index 7408d40..477c716 100644
--- a/src/unique_ptr.rs
+++ b/src/unique_ptr.rs
@@ -174,15 +174,15 @@
}
extern "C" {
- #[link_name = "cxxbridge04$unique_ptr$std$string$null"]
+ #[link_name = "cxxbridge05$unique_ptr$std$string$null"]
fn unique_ptr_std_string_null(this: *mut *mut c_void);
- #[link_name = "cxxbridge04$unique_ptr$std$string$raw"]
+ #[link_name = "cxxbridge05$unique_ptr$std$string$raw"]
fn unique_ptr_std_string_raw(this: *mut *mut c_void, raw: *mut CxxString);
- #[link_name = "cxxbridge04$unique_ptr$std$string$get"]
+ #[link_name = "cxxbridge05$unique_ptr$std$string$get"]
fn unique_ptr_std_string_get(this: *const *mut c_void) -> *const CxxString;
- #[link_name = "cxxbridge04$unique_ptr$std$string$release"]
+ #[link_name = "cxxbridge05$unique_ptr$std$string$release"]
fn unique_ptr_std_string_release(this: *mut *mut c_void) -> *mut CxxString;
- #[link_name = "cxxbridge04$unique_ptr$std$string$drop"]
+ #[link_name = "cxxbridge05$unique_ptr$std$string$drop"]
fn unique_ptr_std_string_drop(this: *mut *mut c_void);
}
diff --git a/syntax/mangle.rs b/syntax/mangle.rs
index 1c8c917..72233b3 100644
--- a/syntax/mangle.rs
+++ b/syntax/mangle.rs
@@ -3,7 +3,7 @@
use crate::syntax::ExternFn;
use proc_macro2::Ident;
-const CXXBRIDGE: &str = "cxxbridge04";
+const CXXBRIDGE: &str = "cxxbridge05";
macro_rules! join {
($($segment:expr),*) => {
diff --git a/syntax/symbol.rs b/syntax/symbol.rs
index c8500b9..1e5b513 100644
--- a/syntax/symbol.rs
+++ b/syntax/symbol.rs
@@ -4,7 +4,7 @@
use std::fmt::{self, Display, Write};
// A mangled symbol consisting of segments separated by '$'.
-// For example: cxxbridge04$string$new
+// For example: cxxbridge05$string$new
pub struct Symbol(String);
impl Display for Symbol {
diff --git a/tests/cxx_gen.rs b/tests/cxx_gen.rs
index 139950e..527d709 100644
--- a/tests/cxx_gen.rs
+++ b/tests/cxx_gen.rs
@@ -18,7 +18,7 @@
let output = str::from_utf8(&generated.implementation).unwrap();
// To avoid continual breakage we won't test every byte.
// Let's look for the major features.
- assert!(output.contains("void cxxbridge04$do_cpp_thing(::rust::Str::Repr foo)"));
+ assert!(output.contains("void cxxbridge05$do_cpp_thing(::rust::Str::Repr foo)"));
}
#[test]
@@ -28,5 +28,5 @@
let source = BRIDGE0.parse().unwrap();
let generated = generate_header_and_cc(source, &opt).unwrap();
let output = str::from_utf8(&generated.implementation).unwrap();
- assert!(output.contains("ANNOTATION void cxxbridge04$do_cpp_thing(::rust::Str::Repr foo)"));
+ assert!(output.contains("ANNOTATION void cxxbridge05$do_cpp_thing(::rust::Str::Repr foo)"));
}