✓ Uses Rust 2018 edition
|new 0.5.5||Jul 12, 2020|
|0.5.4||Sep 6, 2019|
|0.5.3||Jul 17, 2019|
|0.5.1||Oct 3, 2018|
|0.0.12||Nov 19, 2015|
#6 in FFI
9,615 downloads per month
Used in 28 crates (22 directly)
rust-cpp is a build tool & macro which enables you to write C++ code inline in
your rust code.
This crate's interface is still very unstable, however, thanks to custom derive, it now has one of the first potentially stable interfaces. The current macro interface should either remain fairly stable, meaning that programs built with it will likely build with minimal, or no, changes when updating to new versions.
For usage information and in-depth documentation, see
cpp crate module level documentation.
The build phase cannot identify and parse the information found in
which are generated with rust's macro system. These blocks will attempt to
generate rust code, but will not generate the corresponding C++ code. The
procedural macro tries to avoid allowing the build to succeed if the
block is generated, but this is not guaranteed. Do not create
cpp! blocks with
macros to avoid this.
rust-cpp has had multiple different implementations. The code for these old
implementations is still present in the tree today.
rust-cpp started life as a unstable compiler plugin. This code no longer
builds on modern nightly rusts, but it had some features which are still
unavailable on more recent versions of
rust-cpp, as it was able to take
advantage of the rust compiler's type inference by abusing a lint pass to
collect type information.
Development on the original version ceased for 2 major reasons:
The rustc internal libraries changed very often, meaning that constant maintenance work was required to keep it working on the latest nightly versions.
The plugin had no support for stable rust, which is undesirable because the majority of crates are not built with the latest nightly compiler, and requiring unstable features is a deal breaker for them.
These limitations led to the development of the next phase of
The next phase in
rust-cpp's lifetime was when it was rewritten as a
syntex is an extraction of the rust compiler's
syntax library, and has support for performing procedural macro
expansions by rewriting rust source files.
Performing a full rewrite of the source tree was very unfortunate, as it would
mean that all compiler errors in crates which use the plugin would be reported
in a generated file instead of at the original source location. Instead, this
rust-cpp used a stable
macro_rules! macro to perform the rust
code generation, and a build step based on
syntex to perform the c++ code
generation and compilation.
Unfortunately this architecture meant that one of the neatest features,
closures, was not available in this version of
that feature required some form of procedural code generation on the rust
side, which was not possible in rust at that time without performing full text
rewrites of the source code.
This is the current implementation of
rustc 1.15, the first
form of procedural macros, custom derive, was stabilized. Alongside this,
syn, which was a small,
fast to compile, crate for parsing rust code.
rust-cpp uses a fork of
for its rust code parsing.
rust-cpp now internally uses a custom derive to implement the procedural
components of the rust code generation, which means that closures are available
again! It also builds much more quickly than the previous version as it no
longer depends on
syntex which could take a long time to build.
The fork of
rust-cpp uses differs from
syn in that it keeps track of source location
information for each AST node. This feature has not been landed into
as it is a breaking change, and none of
syn's other consumers would make use
of it yet.