Merge "Mark ab/6881855 as merged" into stage-aosp-master
diff --git a/.buckconfig b/.buckconfig
index 33c15ec..5c6c995 100644
--- a/.buckconfig
+++ b/.buckconfig
@@ -4,9 +4,20 @@
# required downstream.
allow_symlinks = allow
+ # Hide BUCK files under target/package/ from `buck build ...`. Otherwise:
+ # $ buck build ...
+ # //target/package/cxx-0.3.0/tests:ffi references non-existing file or directory 'target/package/cxx-0.3.0/tests/ffi/lib.rs'
+ ignore = target
+
[cxx]
cxxflags = -std=c++11
[rust]
default_edition = 2018
- rustc_flags = -Crelocation-model=dynamic-no-pic --cap-lints=allow
+ rustc_flags = \
+ -Clink-arg=-fuse-ld=lld \
+ -Crelocation-model=dynamic-no-pic \
+ --cap-lints=allow
+
+[defaults.rust_library]
+ type = check
diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
new file mode 100644
index 0000000..93cfc05
--- /dev/null
+++ b/.devcontainer/Dockerfile
@@ -0,0 +1 @@
+FROM dtolnay/devcontainer:latest
diff --git a/.devcontainer/README.md b/.devcontainer/README.md
new file mode 100644
index 0000000..b30aebc
--- /dev/null
+++ b/.devcontainer/README.md
@@ -0,0 +1,4 @@
+This directory contains the container setup used when developing CXX inside of
+GitHub [Codespaces].
+
+[Codespaces]: https://github.com/features/codespaces
diff --git a/.devcontainer/build.Dockerfile b/.devcontainer/build.Dockerfile
new file mode 100644
index 0000000..6085459
--- /dev/null
+++ b/.devcontainer/build.Dockerfile
@@ -0,0 +1,18 @@
+FROM mcr.microsoft.com/vscode/devcontainers/rust:1
+
+RUN apt-get update \
+ && export DEBIAN_FRONTEND=noninteractive \
+ && apt-get -y install --no-install-recommends openjdk-11-jdk lld \
+ && rustup default nightly 2>&1 \
+ && rustup component add rust-analyzer-preview rustfmt clippy 2>&1 \
+ && wget -q -O bin/install-bazel https://github.com/bazelbuild/bazel/releases/download/2.1.1/bazel-2.1.1-installer-linux-x86_64.sh \
+ && wget -q -O bin/buck https://jitpack.io/com/github/facebook/buck/a5f0342ae3/buck-a5f0342ae3-java11.pex \
+ && wget -q -O bin/buildifier https://github.com/bazelbuild/buildtools/releases/latest/download/buildifier \
+ && wget -q -O tmp/watchman.zip https://github.com/facebook/watchman/releases/download/v2020.09.21.00/watchman-v2020.09.21.00-linux.zip \
+ && chmod +x bin/install-bazel bin/buck bin/buildifier \
+ && bin/install-bazel \
+ && unzip tmp/watchman.zip -d tmp \
+ && mv tmp/watchman-v2020.09.21.00-linux/bin/watchman bin \
+ && mv tmp/watchman-v2020.09.21.00-linux/lib/* /usr/local/lib \
+ && mkdir -p /usr/local/var/run/watchman \
+ && rm tmp/watchman.zip
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
new file mode 100644
index 0000000..b8deba2
--- /dev/null
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,20 @@
+{
+ "name": "Rust",
+ "build": {
+ "dockerfile": "Dockerfile"
+ },
+ "runArgs": ["--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined"],
+ "settings": {
+ "terminal.integrated.shell.linux": "/bin/bash",
+ "lldb.executable": "/usr/bin/lldb",
+ "files.watcherExclude": {
+ "**/target/**": true
+ }
+ },
+ "extensions": [
+ "BazelBuild.vscode-bazel",
+ "matklad.rust-analyzer",
+ "ms-vscode.cpptools",
+ "vadimcn.vscode-lldb"
+ ]
+}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f0ca230..26b2722 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -34,16 +34,17 @@
- uses: dtolnay/rust-toolchain@master
with:
toolchain: ${{matrix.rust}}
- - run: cargo run --manifest-path demo-rs/Cargo.toml
- - run: cargo test
-
- msrv:
- name: Rust 1.42.0
- runs-on: ubuntu-latest
- steps:
- - uses: actions/checkout@v2
- - uses: dtolnay/rust-toolchain@1.42.0
- - run: cargo run --manifest-path demo-rs/Cargo.toml
+ - name: Determine test suite subset
+ # Our Windows and macOS jobs are the longest running, so exclude the
+ # relatively slow compiletest from them to speed up end-to-end CI time,
+ # except during cron builds when no human is presumably waiting on the
+ # build. The extra coverage is not particularly valuable and we can
+ # still ensure the test is kept passing on the basis of the scheduled
+ # builds.
+ if: matrix.os && github.event_name != 'schedule'
+ run: echo '::set-env name=RUSTFLAGS::--cfg skip_ui_tests'
+ - run: cargo run --manifest-path demo/Cargo.toml
+ - run: cargo test --workspace --exclude cxx-test-suite
buck:
name: Buck
@@ -53,20 +54,22 @@
- uses: dtolnay/rust-toolchain@stable
- uses: actions/setup-java@v1
with:
- java-version: 8
+ java-version: 11
java-package: jre
- name: Install Buck
run: |
mkdir bin
- wget -q -O bin/buck https://jitpack.io/com/github/facebook/buck/v2019.10.17.01/buck-v2019.10.17.01.pex
+ wget -q -O bin/buck https://jitpack.io/com/github/facebook/buck/a5f0342ae3/buck-a5f0342ae3-java11.pex # dev branch from 2020.10.11
chmod +x bin/buck
- echo ::add-path::bin
+ echo bin >> $GITHUB_PATH
+ - name: Install lld
+ run: sudo apt install lld
- name: Vendor dependencies
run: |
cp third-party/Cargo.lock .
cargo vendor --versioned-dirs --locked third-party/vendor
- run: buck build :cxx#check --verbose=0
- - run: buck run demo-rs --verbose=0
+ - run: buck run demo --verbose=0
- run: buck test ... --verbose=0
bazel:
@@ -79,10 +82,14 @@
wget -q -O install.sh https://github.com/bazelbuild/bazel/releases/download/2.1.1/bazel-2.1.1-installer-linux-x86_64.sh
chmod +x install.sh
./install.sh --user
- echo ::add-path::$HOME/bin
- - name: Vendor dependencies
- run: |
- cp third-party/Cargo.lock .
- cargo vendor --versioned-dirs --locked third-party/vendor
- - run: bazel run demo-rs --verbose_failures --noshow_progress
+ echo $HOME/bin >> $GITHUB_PATH
+ - run: bazel run demo --verbose_failures --noshow_progress
- run: bazel test ... --verbose_failures --noshow_progress
+
+ clippy:
+ name: Clippy
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v2
+ - uses: dtolnay/rust-toolchain@clippy
+ - run: cargo clippy --workspace --tests -- -Dclippy::all
diff --git a/.github/workflows/site.yml b/.github/workflows/site.yml
new file mode 100644
index 0000000..73b8186
--- /dev/null
+++ b/.github/workflows/site.yml
@@ -0,0 +1,39 @@
+name: Deploy
+
+on:
+ push:
+ branches:
+ - master
+ paths:
+ - book/**
+
+jobs:
+ deploy:
+ name: Deploy
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v2
+
+ - name: Get mdBook
+ working-directory: book
+ run: |
+ export MDBOOK_VERSION="v0.4.4"
+ export MDBOOK_TARBALL="mdbook-${MDBOOK_VERSION}-x86_64-unknown-linux-gnu.tar.gz"
+ export MDBOOK_URL="https://github.com/rust-lang/mdBook/releases/download/${MDBOOK_VERSION}/${MDBOOK_TARBALL}"
+ curl -Lf "${MDBOOK_URL}" | tar -xz
+
+ - name: Build
+ working-directory: book
+ run: ./mdbook build
+
+ - name: Push to gh-pages
+ working-directory: book/build
+ run: |
+ REV=$(git rev-parse --short HEAD)
+ git init
+ git remote add upstream https://x-access-token:${{secrets.GITHUB_TOKEN}}@github.com/dtolnay/cxx
+ git config user.name "CXX"
+ git config user.email "dtolnay+cxx@gmail.com"
+ git add -A .
+ git commit -qm "Website @ ${{github.repository}}@${REV}"
+ git push -q upstream HEAD:refs/heads/gh-pages --force
diff --git a/.gitignore b/.gitignore
index e7499e5..b036b6f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,7 +4,7 @@
/bazel-out
/bazel-testlogs
/buck-out
-/Cargo.lock
/expand.cc
/expand.rs
-/target
+Cargo.lock
+target
diff --git a/.vscode/README.md b/.vscode/README.md
new file mode 100644
index 0000000..5ed5b27
--- /dev/null
+++ b/.vscode/README.md
@@ -0,0 +1,4 @@
+VS Code actions and configuration. Applicable when developing CXX inside of
+GitHub [Codespaces].
+
+[Codespaces]: https://github.com/features/codespaces
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000..244f5c4
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,17 @@
+{
+ "version": "0.2.0",
+ "configurations": [
+ {
+ "name": "Run cxx demo",
+ "type": "lldb",
+ "request": "launch",
+ "cargo": {
+ "args": ["build", "--manifest-path", "demo/Cargo.toml"],
+ "filter": {
+ "name": "demo",
+ "kind": "bin"
+ }
+ }
+ }
+ ]
+}
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..8a1c2c1
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,5 @@
+{
+ "search.exclude": {
+ "**/target": true
+ }
+}
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
new file mode 100644
index 0000000..44a2ab7
--- /dev/null
+++ b/.vscode/tasks.json
@@ -0,0 +1,30 @@
+{
+ "version": "2.0.0",
+ "tasks": [
+ {
+ "label": "Cargo test",
+ "type": "shell",
+ "command": "cargo test",
+ "group": "test"
+ },
+ {
+ "label": "Bazel test",
+ "type": "shell",
+ "command": "bazel test ...",
+ "group": "test",
+ "dependsOn": ["Vendor"]
+ },
+ {
+ "label": "Buck test",
+ "type": "shell",
+ "command": "buck test ...",
+ "group": "test",
+ "dependsOn": ["Vendor"]
+ },
+ {
+ "label": "Vendor",
+ "type": "shell",
+ "command": "cp third-party/Cargo.lock . && cargo vendor --versioned-dirs --locked third-party/vendor"
+ }
+ ]
+}
diff --git a/Android.bp b/Android.bp
index 9d57757..985b8e2 100644
--- a/Android.bp
+++ b/Android.bp
@@ -26,9 +26,8 @@
cc_library_static {
host_supported: true,
- name: "libcxx-demo-cxx",
- srcs: ["demo-cxx/demo.cc"],
- local_include_dirs: ["demo-cxx"],
+ name: "libcxx-demo-blobstore",
+ srcs: ["demo/src/blobstore.cc"],
generated_headers: ["cxx-demo-bridge-header", "cxx-bridge-header"],
generated_sources: ["cxx-demo-bridge-code"],
}
diff --git a/BUCK b/BUCK
index 241d7b3..da6fcb2 100644
--- a/BUCK
+++ b/BUCK
@@ -1,12 +1,10 @@
rust_library(
name = "cxx",
- srcs = glob(["src/**"], exclude = ["src/symbols/**"]),
+ srcs = glob(["src/**"]),
visibility = ["PUBLIC"],
- rustc_flags = ["--cfg", "no_export_symbols"],
deps = [
":core",
":macro",
- "//third-party:link-cplusplus",
],
)
@@ -16,11 +14,10 @@
crate = "cxxbridge",
visibility = ["PUBLIC"],
deps = [
- "//third-party:anyhow",
+ "//third-party:clap",
"//third-party:codespan-reporting",
"//third-party:proc-macro2",
"//third-party:quote",
- "//third-party:structopt",
"//third-party:syn",
],
)
@@ -34,13 +31,6 @@
"cxx.h": "include/cxx.h",
},
exported_linker_flags = ["-lstdc++"],
- deps = [":symbols"],
-)
-
-rust_library(
- name = "symbols",
- srcs = glob(["src/macros/**", "src/symbols/**"]),
- crate_root = "src/symbols/symbols.rs",
)
rust_library(
@@ -60,7 +50,21 @@
srcs = glob(["gen/build/src/**"]),
visibility = ["PUBLIC"],
deps = [
- "//third-party:anyhow",
+ "//third-party:cc",
+ "//third-party:codespan-reporting",
+ "//third-party:lazy_static",
+ "//third-party:proc-macro2",
+ "//third-party:quote",
+ "//third-party:scratch",
+ "//third-party:syn",
+ ],
+)
+
+rust_library(
+ name = "lib",
+ srcs = glob(["gen/lib/src/**"]),
+ visibility = ["PUBLIC"],
+ deps = [
"//third-party:cc",
"//third-party:codespan-reporting",
"//third-party:proc-macro2",
diff --git a/BUILD b/BUILD
index 4d2b33a..24a1c8b 100644
--- a/BUILD
+++ b/BUILD
@@ -1,3 +1,4 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
load("//tools/bazel:rust.bzl", "rust_binary", "rust_library")
rust_library(
@@ -7,10 +8,7 @@
":cxxbridge-macro",
],
visibility = ["//visibility:public"],
- deps = [
- ":core-lib",
- "//third-party:link-cplusplus",
- ],
+ deps = [":core-lib"],
)
rust_binary(
@@ -19,11 +17,10 @@
data = ["gen/cmd/src/gen/include/cxx.h"],
visibility = ["//visibility:public"],
deps = [
- "//third-party:anyhow",
+ "//third-party:clap",
"//third-party:codespan-reporting",
"//third-party:proc-macro2",
"//third-party:quote",
- "//third-party:structopt",
"//third-party:syn",
],
)
@@ -59,7 +56,22 @@
data = ["gen/build/src/gen/include/cxx.h"],
visibility = ["//visibility:public"],
deps = [
- "//third-party:anyhow",
+ "//third-party:cc",
+ "//third-party:codespan-reporting",
+ "//third-party:lazy_static",
+ "//third-party:proc-macro2",
+ "//third-party:quote",
+ "//third-party:scratch",
+ "//third-party:syn",
+ ],
+)
+
+rust_library(
+ name = "lib",
+ srcs = glob(["gen/lib/src/**/*.rs"]),
+ data = ["gen/lib/src/gen/include/cxx.h"],
+ visibility = ["//visibility:public"],
+ deps = [
"//third-party:cc",
"//third-party:codespan-reporting",
"//third-party:proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 6a8c1a4..f0692ae 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,38 +1,41 @@
[package]
name = "cxx"
-version = "0.3.4" # remember to update html_root_url
+version = "0.5.9" # remember to update html_root_url
authors = ["David Tolnay <dtolnay@gmail.com>"]
edition = "2018"
-links = "cxxbridge03"
+links = "cxxbridge05"
license = "MIT OR Apache-2.0"
description = "Safe interop between Rust and C++"
repository = "https://github.com/dtolnay/cxx"
documentation = "https://docs.rs/cxx"
readme = "README.md"
-exclude = ["/demo-cxx", "/gen", "/syntax", "/third-party"]
+exclude = ["/demo", "/gen", "/syntax", "/third-party"]
keywords = ["ffi"]
categories = ["development-tools::ffi", "api-bindings"]
[features]
-default = [] # c++11
-"c++14" = []
-"c++17" = []
+default = ["cxxbridge-flags/default"] # c++11
+"c++14" = ["cxxbridge-flags/c++14"]
+"c++17" = ["cxxbridge-flags/c++17"]
+"c++20" = ["cxxbridge-flags/c++20"]
[dependencies]
-cxxbridge-macro = { version = "=0.3.4", path = "macro" }
+cxxbridge-macro = { version = "=0.5.9", path = "macro" }
link-cplusplus = "1.0"
[build-dependencies]
cc = "1.0.49"
+cxxbridge-flags = { version = "=0.5.9", path = "flags", default-features = false }
[dev-dependencies]
-cxx-build = { version = "=0.3.4", path = "gen/build" }
+cxx-build = { version = "=0.5.9", path = "gen/build" }
+cxx-gen = { version = "0.6", path = "gen/lib" }
cxx-test-suite = { version = "0", path = "tests/ffi" }
rustversion = "1.0"
-trybuild = { version = "1.0.27", features = ["diff"] }
+trybuild = { version = "1.0.33", features = ["diff"] }
[workspace]
-members = ["demo-rs", "gen/build", "gen/cmd", "macro", "tests/ffi"]
+members = ["demo", "flags", "gen/build", "gen/cmd", "gen/lib", "macro", "tests/ffi"]
[package.metadata.docs.rs]
targets = ["x86_64-unknown-linux-gnu"]
diff --git a/README.md b/README.md
index 260c272..9c0289b 100644
--- a/README.md
+++ b/README.md
@@ -18,10 +18,13 @@
```toml
[dependencies]
-cxx = "0.3"
+cxx = "0.5"
+
+[build-dependencies]
+cxx-build = "0.5"
```
-*Compiler support: requires rustc 1.42+ and c++11 or newer*<br>
+*Compiler support: requires rustc 1.43+ and c++11 or newer*<br>
*[Release notes](https://github.com/dtolnay/cxx/releases)*
<br>
@@ -60,57 +63,62 @@
## Example
-A runnable version of this example is provided under the *demo-rs* directory of
-this repo (with the C++ side of the implementation in the *demo-cxx* directory).
-To try it out, jump into demo-rs and run `cargo run`.
+In this example we are writing a Rust application that wishes to take advantage
+of an existing C++ client for a large-file blobstore service. The blobstore
+supports a `put` operation for a discontiguous buffer upload. For example we
+might be uploading snapshots of a circular buffer which would tend to consist of
+2 chunks, or fragments of a file spread across memory for some other reason.
+
+A runnable version of this example is provided under the *demo* directory of
+this repo. To try it out, run `cargo run` from that directory.
```rust
#[cxx::bridge]
mod ffi {
// Any shared structs, whose fields will be visible to both languages.
- struct SharedThing {
- z: i32,
- y: Box<ThingR>,
- x: UniquePtr<ThingC>,
- }
-
- extern "C" {
- // One or more headers with the matching C++ declarations. Our code
- // generators don't read it but it gets #include'd and used in static
- // assertions to ensure our picture of the FFI boundary is accurate.
- include!("demo-cxx/demo.h");
-
- // Zero or more opaque types which both languages can pass around but
- // only C++ can see the fields.
- type ThingC;
-
- // Functions implemented in C++.
- fn make_demo(appname: &str) -> UniquePtr<ThingC>;
- fn get_name(thing: &ThingC) -> &CxxString;
- fn do_thing(state: SharedThing);
+ struct BlobMetadata {
+ size: usize,
+ tags: Vec<String>,
}
extern "Rust" {
// Zero or more opaque types which both languages can pass around but
// only Rust can see the fields.
- type ThingR;
+ type MultiBuf;
// Functions implemented in Rust.
- fn print_r(r: &ThingR);
+ fn next_chunk(buf: &mut MultiBuf) -> &[u8];
+ }
+
+ extern "C++" {
+ // One or more headers with the matching C++ declarations. Our code
+ // generators don't read it but it gets #include'd and used in static
+ // assertions to ensure our picture of the FFI boundary is accurate.
+ include!("demo/include/blobstore.h");
+
+ // Zero or more opaque types which both languages can pass around but
+ // only C++ can see the fields.
+ type BlobstoreClient;
+
+ // Functions implemented in C++.
+ fn new_blobstore_client() -> UniquePtr<BlobstoreClient>;
+ fn put(&self, parts: &mut MultiBuf) -> u64;
+ fn tag(&self, blobid: u64, tag: &str);
+ fn metadata(&self, blobid: u64) -> BlobMetadata;
}
}
```
-Now we simply provide C++ definitions of all the things in the `extern "C"`
-block and Rust definitions of all the things in the `extern "Rust"` block, and
-get to call back and forth safely.
+Now we simply provide Rust definitions of all the things in the `extern "Rust"`
+block and C++ definitions of all the things in the `extern "C++"` block, and get
+to call back and forth safely.
Here are links to the complete set of source files involved in the demo:
-- [demo-rs/src/main.rs](demo-rs/src/main.rs)
-- [demo-rs/build.rs](demo-rs/build.rs)
-- [demo-cxx/demo.h](demo-cxx/demo.h)
-- [demo-cxx/demo.cc](demo-cxx/demo.cc)
+- [demo/src/main.rs](demo/src/main.rs)
+- [demo/build.rs](demo/build.rs)
+- [demo/include/blobstore.h](demo/include/blobstore.h)
+- [demo/src/blobstore.cc](demo/src/blobstore.cc)
To look at the code generated in both languages for the example by the CXX code
generators:
@@ -118,10 +126,10 @@
```console
# run Rust code generator and print to stdout
# (requires https://github.com/dtolnay/cargo-expand)
-$ cargo expand --manifest-path demo-rs/Cargo.toml
+$ cargo expand --manifest-path demo/Cargo.toml
# run C++ code generator and print to stdout
-$ cargo run --manifest-path gen/cmd/Cargo.toml -- demo-rs/src/main.rs
+$ cargo run --manifest-path gen/cmd/Cargo.toml -- demo/src/main.rs
```
<br>
@@ -220,7 +228,7 @@
# Cargo.toml
[build-dependencies]
-cxx-build = "0.3"
+cxx-build = "0.5"
```
```rust
@@ -228,13 +236,13 @@
fn main() {
cxx_build::bridge("src/main.rs") // returns a cc::Build
- .file("../demo-cxx/demo.cc")
+ .file("src/demo.cc")
.flag_if_supported("-std=c++11")
.compile("cxxbridge-demo");
println!("cargo:rerun-if-changed=src/main.rs");
- println!("cargo:rerun-if-changed=../demo-cxx/demo.h");
- println!("cargo:rerun-if-changed=../demo-cxx/demo.cc");
+ println!("cargo:rerun-if-changed=src/demo.cc");
+ println!("cargo:rerun-if-changed=include/demo.h");
}
```
@@ -245,7 +253,7 @@
For use in non-Cargo builds like Bazel or Buck, CXX provides an alternate way of
invoking the C++ code generator as a standalone command line tool. The tool is
packaged as the `cxxbridge-cmd` crate on crates.io or can be built from the
-*cmd* directory of this repo.
+*gen/cmd* directory of this repo.
```bash
$ cargo install cxxbridge-cmd
@@ -308,11 +316,11 @@
<tr><td>String</td><td>rust::String</td><td></td></tr>
<tr><td>&str</td><td>rust::Str</td><td></td></tr>
<tr><td>&[u8]</td><td>rust::Slice<uint8_t></td><td><sup><i>arbitrary &[T] not implemented yet</i></sup></td></tr>
-<tr><td><a href="https://docs.rs/cxx/0.3/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.5/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<T></td><td>rust::Box<T></td><td><sup><i>cannot hold opaque C++ type</i></sup></td></tr>
-<tr><td><a href="https://docs.rs/cxx/0.3/cxx/struct.UniquePtr.html">UniquePtr<T></a></td><td>std::unique_ptr<T></td><td><sup><i>cannot hold opaque Rust type</i></sup></td></tr>
+<tr><td><a href="https://docs.rs/cxx/0.5/cxx/struct.UniquePtr.html">UniquePtr<T></a></td><td>std::unique_ptr<T></td><td><sup><i>cannot hold opaque Rust type</i></sup></td></tr>
<tr><td>Vec<T></td><td>rust::Vec<T></td><td><sup><i>cannot hold opaque C++ type</i></sup></td></tr>
-<tr><td><a href="https://docs.rs/cxx/0.3/cxx/struct.CxxVector.html">CxxVector<T></a></td><td>std::vector<T></td><td><sup><i>cannot be passed by value, cannot hold opaque Rust type</i></sup></td></tr>
+<tr><td><a href="https://docs.rs/cxx/0.5/cxx/struct.CxxVector.html">CxxVector<T></a></td><td>std::vector<T></td><td><sup><i>cannot be passed by value, cannot hold opaque Rust type</i></sup></td></tr>
<tr><td>fn(T, U) -> V</td><td>rust::Fn<V(T, U)></td><td><sup><i>only passing from Rust to C++ is implemented so far</i></sup></td></tr>
<tr><td>Result<T></td><td>throw/catch</td><td><sup><i>allowed as return type only</i></sup></td></tr>
</table>
@@ -330,6 +338,7 @@
<tr><td>BTreeMap<K, V></td><td><sup><i>tbd</i></sup></td></tr>
<tr><td>HashMap<K, V></td><td><sup><i>tbd</i></sup></td></tr>
<tr><td>Arc<T></td><td><sup><i>tbd</i></sup></td></tr>
+<tr><td>Option<T></td><td><sup><i>tbd</i></sup></td></tr>
<tr><td><sup><i>tbd</i></sup></td><td>std::map<K, V></td></tr>
<tr><td><sup><i>tbd</i></sup></td><td>std::unordered_map<K, V></td></tr>
<tr><td><sup><i>tbd</i></sup></td><td>std::shared_ptr<T></td></tr>
@@ -343,10 +352,9 @@
to collect feedback on the direction and invite collaborators. Please check the
open issues.
-On the build side, I don't have much experience with the `cc` crate so I expect
-there may be someone who can suggest ways to make that aspect of this crate
-friendlier or more robust. Please report issues if you run into trouble building
-or linking any of this stuff.
+Especially please report issues if you run into trouble building or linking any
+of this stuff. I'm sure there are ways to make the build aspects friendlier or
+more robust.
Finally, I know more about Rust library design than C++ library design so I
would appreciate help making the C++ APIs in this project more idiomatic where
diff --git a/WORKSPACE b/WORKSPACE
index cd2a2e8..6093eee 100644
--- a/WORKSPACE
+++ b/WORKSPACE
@@ -1,4 +1,5 @@
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("//tools/bazel:vendor.bzl", "vendor")
http_archive(
name = "io_bazel_rules_rust",
@@ -24,13 +25,18 @@
load("@io_bazel_rules_rust//rust:repositories.bzl", "rust_repository_set")
rust_repository_set(
- name = "rust_1_44_linux",
+ name = "rust_1_47_linux",
exec_triple = "x86_64-unknown-linux-gnu",
- version = "1.44.0",
+ version = "1.47.0",
)
rust_repository_set(
- name = "rust_1_44_darwin",
+ name = "rust_1_47_darwin",
exec_triple = "x86_64-apple-darwin",
- version = "1.44.0",
+ version = "1.47.0",
+)
+
+vendor(
+ name = "third-party",
+ lockfile = "//third-party:Cargo.lock",
)
diff --git a/book/.gitignore b/book/.gitignore
new file mode 100644
index 0000000..690b5b8
--- /dev/null
+++ b/book/.gitignore
@@ -0,0 +1,2 @@
+/build
+/mdbook
diff --git a/book/README.md b/book/README.md
new file mode 100644
index 0000000..e4916e0
--- /dev/null
+++ b/book/README.md
@@ -0,0 +1,9 @@
+Published automatically to https://cxx.rs from master branch.
+
+To build and view locally:
+
+- Install [mdBook]: `cargo install mdbook`.
+- Run `mdbook build` in this directory.
+- Open the generated *build/index.html*.
+
+[mdBook]: https://github.com/rust-lang/mdBook
diff --git a/book/book.toml b/book/book.toml
new file mode 100644
index 0000000..d3187e0
--- /dev/null
+++ b/book/book.toml
@@ -0,0 +1,14 @@
+[book]
+title = "CXX"
+authors = ["David Tolnay"]
+description = "Guide for the `cxx` crate, a safe approach to FFI between Rust and C++."
+
+[rust]
+edition = "2018"
+
+[build]
+build-dir = "build"
+
+[output.html]
+cname = "cxx.rs"
+git-repository-url = "https://github.com/dtolnay/cxx"
diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md
new file mode 100644
index 0000000..f3fa924
--- /dev/null
+++ b/book/src/SUMMARY.md
@@ -0,0 +1,3 @@
+# Summary
+
+[Rust ❤️ C++](about.md)
diff --git a/book/src/about.md b/book/src/about.md
new file mode 100644
index 0000000..6e63bf5
--- /dev/null
+++ b/book/src/about.md
@@ -0,0 +1 @@
+### Coming soon
diff --git a/build.rs b/build.rs
index a412dbd..57b3e52 100644
--- a/build.rs
+++ b/build.rs
@@ -1,16 +1,18 @@
+use std::env;
+use std::path::Path;
+
fn main() {
cc::Build::new()
.file("src/cxx.cc")
.cpp(true)
.cpp_link_stdlib(None) // linked via link-cplusplus crate
- .flag_if_supported(if cfg!(feature = "c++17") {
- "-std=c++17"
- } else if cfg!(feature = "c++14") {
- "-std=c++14"
- } else {
- "-std=c++11"
- })
- .compile("cxxbridge03");
+ .flag_if_supported(cxxbridge_flags::STD)
+ .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");
+ if let Some(manifest_dir) = env::var_os("CARGO_MANIFEST_DIR") {
+ let cxx_h = Path::new(&manifest_dir).join("include").join("cxx.h");
+ println!("cargo:HEADER={}", cxx_h.to_string_lossy());
+ }
}
diff --git a/demo-cxx/BUCK b/demo-cxx/BUCK
deleted file mode 100644
index f60200b..0000000
--- a/demo-cxx/BUCK
+++ /dev/null
@@ -1,17 +0,0 @@
-cxx_library(
- name = "demo-cxx",
- srcs = ["demo.cc"],
- compiler_flags = ["-std=c++14"],
- visibility = ["PUBLIC"],
- deps = [
- ":include",
- "//demo-rs:include",
- ],
-)
-
-cxx_library(
- name = "include",
- exported_headers = ["demo.h"],
- visibility = ["PUBLIC"],
- deps = ["//:core"],
-)
diff --git a/demo-cxx/BUILD b/demo-cxx/BUILD
deleted file mode 100644
index 7b1860a..0000000
--- a/demo-cxx/BUILD
+++ /dev/null
@@ -1,17 +0,0 @@
-cc_library(
- name = "demo-cxx",
- srcs = ["demo.cc"],
- copts = ["-std=c++14"],
- visibility = ["//visibility:public"],
- deps = [
- ":include",
- "//demo-rs:include",
- ],
-)
-
-cc_library(
- name = "include",
- hdrs = ["demo.h"],
- visibility = ["//visibility:public"],
- deps = ["//:core"],
-)
diff --git a/demo-cxx/demo.cc b/demo-cxx/demo.cc
deleted file mode 100644
index 21bdad4..0000000
--- a/demo-cxx/demo.cc
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "demo-cxx/demo.h"
-#include "demo-rs/src/main.rs.h"
-#include <iostream>
-
-namespace org {
-namespace example {
-
-ThingC::ThingC(std::string appname) : appname(std::move(appname)) {}
-
-ThingC::~ThingC() { std::cout << "done with ThingC" << std::endl; }
-
-std::unique_ptr<ThingC> make_demo(rust::Str appname) {
- return std::make_unique<ThingC>(std::string(appname));
-}
-
-const std::string &get_name(const ThingC &thing) { return thing.appname; }
-
-void do_thing(SharedThing state) { print_r(*state.y); }
-
-} // namespace example
-} // namespace org
diff --git a/demo-cxx/demo.h b/demo-cxx/demo.h
deleted file mode 100644
index fafc474..0000000
--- a/demo-cxx/demo.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-#include "rust/cxx.h"
-#include <memory>
-#include <string>
-
-namespace org {
-namespace example {
-
-class ThingC {
-public:
- ThingC(std::string appname);
- ~ThingC();
-
- std::string appname;
-};
-
-struct SharedThing;
-
-std::unique_ptr<ThingC> make_demo(rust::Str appname);
-const std::string &get_name(const ThingC &thing);
-void do_thing(SharedThing state);
-
-} // namespace example
-} // namespace org
diff --git a/demo-rs/BUCK b/demo-rs/BUCK
deleted file mode 100644
index d4164d3..0000000
--- a/demo-rs/BUCK
+++ /dev/null
@@ -1,42 +0,0 @@
-rust_binary(
- name = "demo-rs",
- srcs = glob(["src/**"]),
- deps = [
- ":gen",
- "//:cxx",
- "//demo-cxx:demo-cxx",
- ],
-)
-
-cxx_library(
- name = "gen",
- srcs = [":gen-source"],
- deps = [
- ":include",
- "//demo-cxx:include",
- ],
-)
-
-genrule(
- name = "gen-header",
- srcs = ["src/main.rs"],
- cmd = "$(exe //:codegen) --header ${SRCS} > ${OUT}",
- type = "cxxbridge",
- out = "generated.h",
-)
-
-genrule(
- name = "gen-source",
- srcs = ["src/main.rs"],
- cmd = "$(exe //:codegen) ${SRCS} > ${OUT}",
- type = "cxxbridge",
- out = "generated.cc",
-)
-
-cxx_library(
- name = "include",
- exported_headers = {
- "src/main.rs.h": ":gen-header",
- },
- visibility = ["PUBLIC"],
-)
diff --git a/demo-rs/BUILD b/demo-rs/BUILD
deleted file mode 100644
index e3ebb96..0000000
--- a/demo-rs/BUILD
+++ /dev/null
@@ -1,43 +0,0 @@
-load("//tools/bazel:rust.bzl", "rust_binary", "rust_library")
-
-rust_binary(
- name = "demo-rs",
- srcs = glob(["src/**"]),
- deps = [
- ":gen",
- "//:cxx",
- "//demo-cxx",
- ],
-)
-
-cc_library(
- name = "gen",
- srcs = [":gen-source"],
- deps = [
- ":include",
- "//demo-cxx:include",
- ],
-)
-
-genrule(
- name = "gen-header",
- srcs = ["src/main.rs"],
- outs = ["main.rs.h"],
- cmd = "$(location //:codegen) --header $< > $@",
- tools = ["//:codegen"],
-)
-
-genrule(
- name = "gen-source",
- srcs = ["src/main.rs"],
- outs = ["generated.cc"],
- cmd = "$(location //:codegen) $< > $@",
- tools = ["//:codegen"],
-)
-
-cc_library(
- name = "include",
- hdrs = [":gen-header"],
- include_prefix = "demo-rs/src",
- visibility = ["//visibility:public"],
-)
diff --git a/demo-rs/build.rs b/demo-rs/build.rs
deleted file mode 100644
index f32b8ef..0000000
--- a/demo-rs/build.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-fn main() {
- cxx_build::bridge("src/main.rs")
- .file("../demo-cxx/demo.cc")
- .flag_if_supported("-std=c++14")
- .compile("cxxbridge-demo");
-
- println!("cargo:rerun-if-changed=src/main.rs");
- println!("cargo:rerun-if-changed=../demo-cxx/demo.h");
- println!("cargo:rerun-if-changed=../demo-cxx/demo.cc");
-}
diff --git a/demo-rs/src/main.rs b/demo-rs/src/main.rs
deleted file mode 100644
index 66dfc79..0000000
--- a/demo-rs/src/main.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-#[cxx::bridge(namespace = org::example)]
-mod ffi {
- struct SharedThing {
- z: i32,
- y: Box<ThingR>,
- x: UniquePtr<ThingC>,
- }
-
- extern "C" {
- include!("demo-cxx/demo.h");
-
- type ThingC;
- fn make_demo(appname: &str) -> UniquePtr<ThingC>;
- fn get_name(thing: &ThingC) -> &CxxString;
- fn do_thing(state: SharedThing);
- }
-
- extern "Rust" {
- type ThingR;
- fn print_r(r: &ThingR);
- }
-}
-
-pub struct ThingR(usize);
-
-fn print_r(r: &ThingR) {
- println!("called back with r={}", r.0);
-}
-
-fn main() {
- let x = ffi::make_demo("demo of cxx::bridge");
- println!("this is a {}", ffi::get_name(x.as_ref().unwrap()));
-
- ffi::do_thing(ffi::SharedThing {
- z: 222,
- y: Box::new(ThingR(333)),
- x,
- });
-}
diff --git a/demo-rs/Android.bp b/demo/Android.bp
similarity index 78%
rename from demo-rs/Android.bp
rename to demo/Android.bp
index 2fcdf6f..fabfaa7 100644
--- a/demo-rs/Android.bp
+++ b/demo/Android.bp
@@ -3,7 +3,7 @@
tools: ["cxxbridge"],
cmd: "$(location cxxbridge) $(in) --header > $(out)",
srcs: ["src/main.rs"],
- out: ["demo-rs/src/main.rs.h"],
+ out: ["demo/src/main.rs.h"],
}
genrule {
@@ -11,12 +11,12 @@
tools: ["cxxbridge"],
cmd: "$(location cxxbridge) $(in) >> $(out)",
srcs: ["src/main.rs"],
- out: ["demo-rs/generated.cc"],
+ out: ["demo/generated.cc"],
}
rust_binary {
name: "cxx-demo-rs",
srcs: ["src/main.rs"],
rlibs: ["libcxx"],
- static_libs: ["libcxx-demo-cxx"],
+ static_libs: ["libcxx-demo-blobstore"],
}
diff --git a/demo/BUCK b/demo/BUCK
new file mode 100644
index 0000000..43b83aa
--- /dev/null
+++ b/demo/BUCK
@@ -0,0 +1,33 @@
+load("//tools/buck:rust_cxx_bridge.bzl", "rust_cxx_bridge")
+
+rust_binary(
+ name = "demo",
+ srcs = glob(["src/**/*.rs"]),
+ deps = [
+ ":blobstore-sys",
+ ":bridge",
+ "//:cxx",
+ ],
+)
+
+rust_cxx_bridge(
+ name = "bridge",
+ src = "src/main.rs",
+ deps = [":blobstore-include"],
+)
+
+cxx_library(
+ name = "blobstore-sys",
+ srcs = ["src/blobstore.cc"],
+ compiler_flags = ["-std=c++14"],
+ deps = [
+ ":blobstore-include",
+ ":bridge/include",
+ ],
+)
+
+cxx_library(
+ name = "blobstore-include",
+ exported_headers = ["include/blobstore.h"],
+ deps = ["//:core"],
+)
diff --git a/demo/BUILD b/demo/BUILD
new file mode 100644
index 0000000..cce8119
--- /dev/null
+++ b/demo/BUILD
@@ -0,0 +1,35 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+load("//tools/bazel:rust.bzl", "rust_binary")
+load("//tools/bazel:rust_cxx_bridge.bzl", "rust_cxx_bridge")
+
+rust_binary(
+ name = "demo",
+ srcs = glob(["src/**/*.rs"]),
+ deps = [
+ ":blobstore-sys",
+ ":bridge",
+ "//:cxx",
+ ],
+)
+
+rust_cxx_bridge(
+ name = "bridge",
+ src = "src/main.rs",
+ deps = [":blobstore-include"],
+)
+
+cc_library(
+ name = "blobstore-sys",
+ srcs = ["src/blobstore.cc"],
+ copts = ["-std=c++14"],
+ deps = [
+ ":blobstore-include",
+ ":bridge/include",
+ ],
+)
+
+cc_library(
+ name = "blobstore-include",
+ hdrs = ["include/blobstore.h"],
+ deps = ["//:core"],
+)
diff --git a/demo-rs/Cargo.toml b/demo/Cargo.toml
similarity index 89%
rename from demo-rs/Cargo.toml
rename to demo/Cargo.toml
index d2147ab..dc94861 100644
--- a/demo-rs/Cargo.toml
+++ b/demo/Cargo.toml
@@ -1,5 +1,5 @@
[package]
-name = "cxxbridge-demo"
+name = "demo"
version = "0.0.0"
authors = ["David Tolnay <dtolnay@gmail.com>"]
edition = "2018"
diff --git a/demo/build.rs b/demo/build.rs
new file mode 100644
index 0000000..c1b55cc
--- /dev/null
+++ b/demo/build.rs
@@ -0,0 +1,10 @@
+fn main() {
+ cxx_build::bridge("src/main.rs")
+ .file("src/blobstore.cc")
+ .flag_if_supported("-std=c++14")
+ .compile("cxxbridge-demo");
+
+ println!("cargo:rerun-if-changed=src/main.rs");
+ println!("cargo:rerun-if-changed=src/blobstore.cc");
+ println!("cargo:rerun-if-changed=include/blobstore.h");
+}
diff --git a/demo/include/blobstore.h b/demo/include/blobstore.h
new file mode 100644
index 0000000..68a7fc2
--- /dev/null
+++ b/demo/include/blobstore.h
@@ -0,0 +1,26 @@
+#pragma once
+#include "rust/cxx.h"
+#include <memory>
+
+namespace org {
+namespace blobstore {
+
+struct MultiBuf;
+struct BlobMetadata;
+
+class BlobstoreClient {
+public:
+ BlobstoreClient();
+ uint64_t put(MultiBuf &buf) const;
+ void tag(uint64_t blobid, rust::Str tag) const;
+ BlobMetadata metadata(uint64_t blobid) const;
+
+private:
+ class Impl;
+ std::shared_ptr<Impl> impl;
+};
+
+std::unique_ptr<BlobstoreClient> new_blobstore_client();
+
+} // namespace blobstore
+} // namespace org
diff --git a/demo/src/blobstore.cc b/demo/src/blobstore.cc
new file mode 100644
index 0000000..0036a32
--- /dev/null
+++ b/demo/src/blobstore.cc
@@ -0,0 +1,71 @@
+#include "demo/include/blobstore.h"
+#include "demo/src/main.rs.h"
+#include <algorithm>
+#include <functional>
+#include <set>
+#include <string>
+#include <unordered_map>
+
+namespace org {
+namespace blobstore {
+
+// Toy implementation of an in-memory blobstore.
+//
+// In reality the implementation of BlobstoreClient could be a large complex C++
+// library.
+class BlobstoreClient::Impl {
+ friend BlobstoreClient;
+ using Blob = struct {
+ std::string data;
+ std::set<std::string> tags;
+ };
+ std::unordered_map<uint64_t, Blob> blobs;
+};
+
+BlobstoreClient::BlobstoreClient() : impl(new BlobstoreClient::Impl) {}
+
+// Upload a new blob and return a blobid that serves as a handle to the blob.
+uint64_t BlobstoreClient::put(MultiBuf &buf) const {
+ std::string contents;
+
+ // Traverse the caller's chunk iterator.
+ //
+ // In reality there might be sophisticated batching of chunks and/or parallel
+ // upload implemented by the blobstore's C++ client.
+ while (true) {
+ auto chunk = next_chunk(buf);
+ if (chunk.size() == 0) {
+ break;
+ }
+ contents.append(reinterpret_cast<const char *>(chunk.data()), chunk.size());
+ }
+
+ // Insert into map and provide caller the handle.
+ auto blobid = std::hash<std::string>{}(contents);
+ impl->blobs[blobid] = {std::move(contents), {}};
+ return blobid;
+}
+
+// Add tag to an existing blob.
+void BlobstoreClient::tag(uint64_t blobid, rust::Str tag) const {
+ impl->blobs[blobid].tags.emplace(tag);
+}
+
+// Retrieve metadata about a blob.
+BlobMetadata BlobstoreClient::metadata(uint64_t blobid) const {
+ BlobMetadata metadata{};
+ auto blob = impl->blobs.find(blobid);
+ if (blob != impl->blobs.end()) {
+ metadata.size = blob->second.data.size();
+ std::for_each(blob->second.tags.begin(), blob->second.tags.end(),
+ [&](auto &t) { metadata.tags.emplace_back(t); });
+ }
+ return metadata;
+}
+
+std::unique_ptr<BlobstoreClient> new_blobstore_client() {
+ return std::make_unique<BlobstoreClient>();
+}
+
+} // namespace blobstore
+} // namespace org
diff --git a/demo/src/main.rs b/demo/src/main.rs
new file mode 100644
index 0000000..10f57e5
--- /dev/null
+++ b/demo/src/main.rs
@@ -0,0 +1,59 @@
+#[cxx::bridge(namespace = "org::blobstore")]
+mod ffi {
+ // Shared structs with fields visible to both languages.
+ struct BlobMetadata {
+ size: usize,
+ tags: Vec<String>,
+ }
+
+ // Rust types and signatures exposed to C++.
+ extern "Rust" {
+ type MultiBuf;
+
+ fn next_chunk(buf: &mut MultiBuf) -> &[u8];
+ }
+
+ // C++ types and signatures exposed to Rust.
+ extern "C++" {
+ include!("demo/include/blobstore.h");
+
+ type BlobstoreClient;
+
+ fn new_blobstore_client() -> UniquePtr<BlobstoreClient>;
+ fn put(&self, parts: &mut MultiBuf) -> u64;
+ fn tag(&self, blobid: u64, tag: &str);
+ fn metadata(&self, blobid: u64) -> BlobMetadata;
+ }
+}
+
+// An iterator over contiguous chunks of a discontiguous file object.
+//
+// Toy implementation uses a Vec<Vec<u8>> but in reality this might be iterating
+// over some more complex Rust data structure like a rope, or maybe loading
+// chunks lazily from somewhere.
+pub struct MultiBuf {
+ chunks: Vec<Vec<u8>>,
+ pos: usize,
+}
+pub fn next_chunk(buf: &mut MultiBuf) -> &[u8] {
+ let next = buf.chunks.get(buf.pos);
+ buf.pos += 1;
+ next.map(Vec::as_slice).unwrap_or(&[])
+}
+
+fn main() {
+ let client = ffi::new_blobstore_client();
+
+ // Upload a blob.
+ let chunks = vec![b"fearless".to_vec(), b"concurrency".to_vec()];
+ let mut buf = MultiBuf { chunks, pos: 0 };
+ let blobid = client.put(&mut buf);
+ println!("blobid = {}", blobid);
+
+ // Add a tag.
+ client.tag(blobid, "rust");
+
+ // Read back the tags.
+ let metadata = client.metadata(blobid);
+ println!("tags = {:?}", metadata.tags);
+}
diff --git a/flags/Cargo.toml b/flags/Cargo.toml
new file mode 100644
index 0000000..cc5f230
--- /dev/null
+++ b/flags/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "cxxbridge-flags"
+version = "0.5.9"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+edition = "2018"
+license = "MIT OR Apache-2.0"
+description = "Compiler configuration of the `cxx` crate (implementation detail)"
+repository = "https://github.com/dtolnay/cxx"
+
+[features]
+default = [] # c++11
+"c++14" = []
+"c++17" = []
+"c++20" = []
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
diff --git a/flags/src/impl.rs b/flags/src/impl.rs
new file mode 100644
index 0000000..4f7b8fb
--- /dev/null
+++ b/flags/src/impl.rs
@@ -0,0 +1,20 @@
+#[allow(unused_assignments, unused_mut, unused_variables)]
+pub const STD: &str = {
+ let mut flags = ["-std=c++11", "/std:c++11"];
+
+ #[cfg(feature = "c++14")]
+ (flags = ["-std=c++14", "/std:c++14"]);
+
+ #[cfg(feature = "c++17")]
+ (flags = ["-std=c++17", "/std:c++17"]);
+
+ #[cfg(feature = "c++20")]
+ (flags = ["-std=c++20", "/std:c++20"]);
+
+ let [mut flag, msvc_flag] = flags;
+
+ #[cfg(target_env = "msvc")]
+ (flag = msvc_flag);
+
+ flag
+};
diff --git a/flags/src/lib.rs b/flags/src/lib.rs
new file mode 100644
index 0000000..55172b2
--- /dev/null
+++ b/flags/src/lib.rs
@@ -0,0 +1,7 @@
+//! This crate is an implementation detail of the `cxx` and `cxx-build` crates,
+//! and does not expose any public API.
+
+mod r#impl;
+
+#[doc(hidden)]
+pub use r#impl::*;
diff --git a/gen/README.md b/gen/README.md
index 9786911..d00b98f 100644
--- a/gen/README.md
+++ b/gen/README.md
@@ -2,3 +2,6 @@
public frontends, one a command-line application (binary) in the *cmd* directory
and the other a library intended to be used from a build.rs in the *build*
directory.
+
+There's also a 'lib' frontend which is intended to allow higher level code
+generators to embed cxx. This is not yet recommended for general use.
diff --git a/gen/build/Cargo.toml b/gen/build/Cargo.toml
index b43a37e..3f7b0ea 100644
--- a/gen/build/Cargo.toml
+++ b/gen/build/Cargo.toml
@@ -1,21 +1,27 @@
[package]
name = "cxx-build"
-version = "0.3.4"
+version = "0.5.9"
authors = ["David Tolnay <dtolnay@gmail.com>"]
edition = "2018"
license = "MIT OR Apache-2.0"
description = "C++ code generator for integrating `cxx` crate into a Cargo build."
repository = "https://github.com/dtolnay/cxx"
+exclude = ["build.rs"]
keywords = ["ffi"]
categories = ["development-tools::ffi"]
[dependencies]
-anyhow = "1.0"
cc = "1.0.49"
codespan-reporting = "0.9"
+lazy_static = "1.4"
proc-macro2 = { version = "1.0.17", default-features = false, features = ["span-locations"] }
quote = { version = "1.0", default-features = false }
+scratch = "1.0"
syn = { version = "1.0.20", default-features = false, features = ["parsing", "printing", "clone-impls", "full"] }
+[dev-dependencies]
+cxx-gen = { version = "0.6", path = "../lib" }
+pkg-config = "0.3"
+
[package.metadata.docs.rs]
targets = ["x86_64-unknown-linux-gnu"]
diff --git a/gen/build/build.rs b/gen/build/build.rs
new file mode 100644
index 0000000..c53bef7
--- /dev/null
+++ b/gen/build/build.rs
@@ -0,0 +1 @@
+include!("../../tools/cargo/build.rs");
diff --git a/gen/build/src/cfg.rs b/gen/build/src/cfg.rs
new file mode 100644
index 0000000..c15a173
--- /dev/null
+++ b/gen/build/src/cfg.rs
@@ -0,0 +1,407 @@
+use std::fmt::{self, Debug};
+use std::marker::PhantomData;
+use std::path::Path;
+
+/// Build configuration. See [CFG].
+pub struct Cfg<'a> {
+ /// See [`CFG.include_prefix`][CFG#cfginclude_prefix].
+ pub include_prefix: &'a str,
+ /// See [`CFG.exported_header_dirs`][CFG#cfgexported_header_dirs].
+ pub exported_header_dirs: Vec<&'a Path>,
+ /// See [`CFG.exported_header_prefixes`][CFG#cfgexported_header_prefixes].
+ pub exported_header_prefixes: Vec<&'a str>,
+ /// See [`CFG.exported_header_links`][CFG#cfgexported_header_links].
+ pub exported_header_links: Vec<&'a str>,
+ marker: PhantomData<*const ()>, // !Send + !Sync
+}
+
+/// Global configuration of the current build.
+///
+/// <br>
+///
+/// <div style="float:right;margin:22px 50px 0;font-size:1.15em;color:#444"><strong>&str</strong></div>
+///
+/// ## **`CFG.include_prefix`**
+///
+/// The prefix at which C++ code from your crate as well as directly dependent
+/// crates can access the code generated during this build.
+///
+/// By default, the `include_prefix` is equal to the name of the current crate.
+/// That means if your crate is called `demo` and has Rust source files in a
+/// *src/* directory and maybe some handwritten C++ header files in an
+/// *include/* directory, then the current crate as well as downstream crates
+/// might include them as follows:
+///
+/// ```
+/// # const _: &str = stringify! {
+/// // include one of the handwritten headers:
+/// #include "demo/include/wow.h"
+///
+/// // include a header generated from Rust cxx::bridge:
+/// #include "demo/src/lib.rs.h"
+/// # };
+/// ```
+///
+/// By modifying `CFG.include_prefix` we can substitute a prefix that is
+/// different from the crate name if desired. Here we'll change it to
+/// `"path/to"` which will make import paths take the form
+/// `"path/to/include/wow.h"` and `"path/to/src/lib.rs.h"`.
+///
+/// ```no_run
+/// // build.rs
+///
+/// use cxx_build::CFG;
+///
+/// fn main() {
+/// CFG.include_prefix = "path/to";
+///
+/// cxx_build::bridge("src/lib.rs")
+/// .file("src/demo.cc") // probably contains `#include "path/to/src/lib.rs.h"`
+/// /* ... */
+/// .compile("demo");
+/// }
+/// ```
+///
+/// Note that cross-crate imports are only made available between **direct
+/// dependencies**. Another crate must directly depend on your crate in order to
+/// #include its headers; a transitive dependency is not sufficient.
+/// Additionally, headers from a direct dependency are only importable if the
+/// dependency's Cargo.toml manifest contains a `links` key. If not, its headers
+/// will not be importable from outside of the same crate.
+///
+/// <br>
+///
+/// <div style="float:right;margin:22px 50px 0;font-size:1.15em;color:#444"><strong>Vec<&Path></strong></div>
+///
+/// ## **`CFG.exported_header_dirs`**
+///
+/// A vector of absolute paths. The current crate, directly dependent crates,
+/// and further crates to which this crate's headers are exported (see below)
+/// will be able to `#include` headers from these directories.
+///
+/// Adding a directory to `exported_header_dirs` is similar to adding it to the
+/// current build via the `cc` crate's [`Build::include`][cc::Build::include],
+/// but *also* makes the directory available to downstream crates that want to
+/// `#include` one of the headers from your crate. If the dir were added only
+/// using `Build::include`, the downstream crate including your header would
+/// need to manually add the same directory to their own build as well.
+///
+/// When using `exported_header_dirs`, your crate must also set a `links` key
+/// for itself in Cargo.toml. See [*the `links` manifest key*][links]. The
+/// reason is that Cargo imposes no ordering on the execution of build scripts
+/// without a `links` key, which means the downstream crate's build script might
+/// execute before yours decides what to put into `exported_header_dirs`.
+///
+/// [links]: https://doc.rust-lang.org/cargo/reference/build-scripts.html#the-links-manifest-key
+///
+/// ### Example
+///
+/// One of your crate's headers wants to include a system library, such as
+/// `#include "Python.h"`.
+///
+/// ```no_run
+/// // build.rs
+///
+/// use cxx_build::CFG;
+/// use std::path::PathBuf;
+///
+/// fn main() {
+/// let python3 = pkg_config::probe_library("python3").unwrap();
+/// let python_include_paths = python3.include_paths.iter().map(PathBuf::as_path);
+/// CFG.exported_header_dirs.extend(python_include_paths);
+///
+/// cxx_build::bridge("src/bridge.rs").compile("demo");
+/// }
+/// ```
+///
+/// ### Example
+///
+/// Your crate wants to rearrange the headers that it exports vs how they're
+/// laid out locally inside the crate's source directory.
+///
+/// Suppose the crate as published contains a file at `./include/myheader.h` but
+/// wants it available to downstream crates as `#include "foo/v1/public.h"`.
+///
+/// ```no_run
+/// // build.rs
+///
+/// use cxx_build::CFG;
+/// use std::path::Path;
+/// use std::{env, fs};
+///
+/// fn main() {
+/// let out_dir = env::var_os("OUT_DIR").unwrap();
+/// let headers = Path::new(&out_dir).join("headers");
+/// CFG.exported_header_dirs.push(&headers);
+///
+/// // We contain `include/myheader.h` locally, but
+/// // downstream will use `#include "foo/v1/public.h"`
+/// let foo = headers.join("foo").join("v1");
+/// fs::create_dir_all(&foo).unwrap();
+/// fs::copy("include/myheader.h", foo.join("public.h")).unwrap();
+///
+/// cxx_build::bridge("src/bridge.rs").compile("demo");
+/// }
+/// ```
+///
+/// <p style="margin:0"><br><br></p>
+///
+/// <div style="float:right;margin:22px 50px 0;font-size:1.15em;color:#444"><strong>Vec<&str></strong></div>
+///
+/// ## **`CFG.exported_header_prefixes`**
+///
+/// Vector of strings. These each refer to the `include_prefix` of one of your
+/// direct dependencies, or a prefix thereof. They describe which of your
+/// dependencies participate in your crate's C++ public API, as opposed to
+/// private use by your crate's implementation.
+///
+/// As a general rule, if one of your headers `#include`s something from one of
+/// your dependencies, you need to put that dependency's `include_prefix` into
+/// `CFG.exported_header_prefixes` (*or* their `links` key into
+/// `CFG.exported_header_links`; see below). On the other hand if only your C++
+/// implementation files and *not* your headers are importing from the
+/// dependency, you do not export that dependency.
+///
+/// The significance of exported headers is that if downstream code (crate 𝒜)
+/// contains an `#include` of a header from your crate (ℬ) and your header
+/// contains an `#include` of something from your dependency (𝒞), the exported
+/// dependency 𝒞 becomes available during the downstream crate 𝒜's build.
+/// Otherwise the downstream crate 𝒜 doesn't know about 𝒞 and wouldn't be able
+/// to find what header your header is referring to, and would fail to build.
+///
+/// When using `exported_header_prefixes`, your crate must also set a `links`
+/// key for itself in Cargo.toml.
+///
+/// ### Example
+///
+/// Suppose you have a crate with 5 direct dependencies and the `include_prefix`
+/// for each one are:
+///
+/// - "crate0"
+/// - "group/api/crate1"
+/// - "group/api/crate2"
+/// - "group/api/contrib/crate3"
+/// - "detail/crate4"
+///
+/// Your header involves types from the first four so we re-export those as part
+/// of your public API, while crate4 is only used internally by your cc file not
+/// your header, so we do not export:
+///
+/// ```no_run
+/// // build.rs
+///
+/// use cxx_build::CFG;
+///
+/// fn main() {
+/// CFG.exported_header_prefixes = vec!["crate0", "group/api"];
+///
+/// cxx_build::bridge("src/bridge.rs")
+/// .file("src/impl.cc")
+/// .compile("demo");
+/// }
+/// ```
+///
+/// <p style="margin:0"><br><br></p>
+///
+/// <div style="float:right;margin:22px 50px 0;font-size:1.15em;color:#444"><strong>Vec<&str></strong></div>
+///
+/// ## **`CFG.exported_header_links`**
+///
+/// Vector of strings. These each refer to the `links` attribute ([*the `links`
+/// manifest key*][links]) of one of your crate's direct dependencies.
+///
+/// This achieves an equivalent result to `CFG.exported_header_prefixes` by
+/// re-exporting a dependency as part of your crate's public API, except with
+/// finer grained control for cases when multiple crates might be sharing the
+/// same `include_prefix` and you'd like to export some but not others. Links
+/// attributes are guaranteed to be unique identifiers by Cargo.
+///
+/// When using `exported_header_links`, your crate must also set a `links` key
+/// for itself in Cargo.toml.
+///
+/// ### Example
+///
+/// ```no_run
+/// // build.rs
+///
+/// use cxx_build::CFG;
+///
+/// fn main() {
+/// CFG.exported_header_links.push("git2");
+///
+/// cxx_build::bridge("src/bridge.rs").compile("demo");
+/// }
+/// ```
+#[cfg(doc)]
+pub static mut CFG: Cfg = Cfg {
+ include_prefix: "",
+ exported_header_dirs: Vec::new(),
+ exported_header_prefixes: Vec::new(),
+ exported_header_links: Vec::new(),
+ marker: PhantomData,
+};
+
+impl<'a> Debug for Cfg<'a> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let Self {
+ include_prefix,
+ exported_header_dirs,
+ exported_header_prefixes,
+ exported_header_links,
+ marker: _,
+ } = self;
+ formatter
+ .debug_struct("Cfg")
+ .field("include_prefix", include_prefix)
+ .field("exported_header_dirs", exported_header_dirs)
+ .field("exported_header_prefixes", exported_header_prefixes)
+ .field("exported_header_links", exported_header_links)
+ .finish()
+ }
+}
+
+#[cfg(not(doc))]
+pub use self::r#impl::Cfg::CFG;
+
+#[cfg(not(doc))]
+mod r#impl {
+ use crate::intern::{intern, InternedString};
+ use crate::vec::{self, InternedVec as _};
+ use lazy_static::lazy_static;
+ use std::cell::RefCell;
+ use std::collections::HashMap;
+ use std::fmt::{self, Debug};
+ use std::marker::PhantomData;
+ use std::ops::{Deref, DerefMut};
+ use std::sync::{PoisonError, RwLock};
+
+ struct CurrentCfg {
+ include_prefix: InternedString,
+ exported_header_dirs: Vec<InternedString>,
+ exported_header_prefixes: Vec<InternedString>,
+ exported_header_links: Vec<InternedString>,
+ }
+
+ impl CurrentCfg {
+ fn default() -> Self {
+ let include_prefix = crate::env_os("CARGO_PKG_NAME")
+ .map(|pkg| intern(&pkg.to_string_lossy()))
+ .unwrap_or_default();
+ let exported_header_dirs = Vec::new();
+ let exported_header_prefixes = Vec::new();
+ let exported_header_links = Vec::new();
+ CurrentCfg {
+ include_prefix,
+ exported_header_dirs,
+ exported_header_prefixes,
+ exported_header_links,
+ }
+ }
+ }
+
+ lazy_static! {
+ static ref CURRENT: RwLock<CurrentCfg> = RwLock::new(CurrentCfg::default());
+ }
+
+ thread_local! {
+ // FIXME: If https://github.com/rust-lang/rust/issues/77425 is resolved,
+ // we can delete this thread local side table and instead make each CFG
+ // instance directly own the associated super::Cfg.
+ //
+ // #[allow(const_item_mutation)]
+ // pub const CFG: Cfg = Cfg {
+ // cfg: AtomicPtr::new(ptr::null_mut()),
+ // };
+ // pub struct Cfg {
+ // cfg: AtomicPtr<super::Cfg>,
+ // }
+ //
+ static CONST_DEREFS: RefCell<HashMap<Handle, Box<super::Cfg<'static>>>> = RefCell::default();
+ }
+
+ #[derive(Eq, PartialEq, Hash)]
+ struct Handle(*const Cfg<'static>);
+
+ impl<'a> Cfg<'a> {
+ fn current() -> super::Cfg<'a> {
+ let current = CURRENT.read().unwrap_or_else(PoisonError::into_inner);
+ let include_prefix = current.include_prefix.str();
+ let exported_header_dirs = current.exported_header_dirs.vec();
+ let exported_header_prefixes = current.exported_header_prefixes.vec();
+ let exported_header_links = current.exported_header_links.vec();
+ super::Cfg {
+ include_prefix,
+ exported_header_dirs,
+ exported_header_prefixes,
+ exported_header_links,
+ marker: PhantomData,
+ }
+ }
+
+ const fn handle(self: &Cfg<'a>) -> Handle {
+ Handle(<*const Cfg>::cast(self))
+ }
+ }
+
+ // Since super::Cfg is !Send and !Sync, all Cfg are thread local and will
+ // drop on the same thread where they were created.
+ pub enum Cfg<'a> {
+ Mut(super::Cfg<'a>),
+ CFG,
+ }
+
+ impl<'a> Debug for Cfg<'a> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ if let Cfg::Mut(cfg) = self {
+ Debug::fmt(cfg, formatter)
+ } else {
+ Debug::fmt(&Cfg::current(), formatter)
+ }
+ }
+ }
+
+ impl<'a> Deref for Cfg<'a> {
+ type Target = super::Cfg<'a>;
+
+ fn deref(&self) -> &Self::Target {
+ if let Cfg::Mut(cfg) = self {
+ cfg
+ } else {
+ let cfg = CONST_DEREFS.with(|derefs| -> *mut super::Cfg {
+ &mut **derefs
+ .borrow_mut()
+ .entry(self.handle())
+ .or_insert_with(|| Box::new(Cfg::current()))
+ });
+ unsafe { &mut *cfg }
+ }
+ }
+ }
+
+ impl<'a> DerefMut for Cfg<'a> {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ if let Cfg::CFG = self {
+ CONST_DEREFS.with(|derefs| derefs.borrow_mut().remove(&self.handle()));
+ *self = Cfg::Mut(Cfg::current());
+ }
+ match self {
+ Cfg::Mut(cfg) => cfg,
+ Cfg::CFG => unreachable!(),
+ }
+ }
+ }
+
+ impl<'a> Drop for Cfg<'a> {
+ fn drop(&mut self) {
+ if let Cfg::Mut(cfg) = self {
+ let mut current = CURRENT.write().unwrap_or_else(PoisonError::into_inner);
+ current.include_prefix = intern(cfg.include_prefix);
+ current.exported_header_dirs = vec::intern(&cfg.exported_header_dirs);
+ current.exported_header_prefixes = vec::intern(&cfg.exported_header_prefixes);
+ current.exported_header_links = vec::intern(&cfg.exported_header_links);
+ } else {
+ CONST_DEREFS.with(|derefs| derefs.borrow_mut().remove(&self.handle()));
+ }
+ }
+ }
+}
diff --git a/gen/build/src/deps.rs b/gen/build/src/deps.rs
new file mode 100644
index 0000000..fb80072
--- /dev/null
+++ b/gen/build/src/deps.rs
@@ -0,0 +1,107 @@
+use std::collections::BTreeMap;
+use std::env;
+use std::ffi::OsString;
+use std::path::PathBuf;
+
+#[derive(Default)]
+pub struct Crate {
+ pub include_prefix: Option<PathBuf>,
+ pub links: Option<OsString>,
+ pub header_dirs: Vec<HeaderDir>,
+}
+
+pub struct HeaderDir {
+ pub exported: bool,
+ pub path: PathBuf,
+}
+
+impl Crate {
+ pub fn print_to_cargo(&self) {
+ if let Some(include_prefix) = &self.include_prefix {
+ println!(
+ "cargo:CXXBRIDGE_PREFIX={}",
+ include_prefix.to_string_lossy(),
+ );
+ }
+ if let Some(links) = &self.links {
+ println!("cargo:CXXBRIDGE_LINKS={}", links.to_string_lossy());
+ }
+ for (i, header_dir) in self.header_dirs.iter().enumerate() {
+ if header_dir.exported {
+ println!(
+ "cargo:CXXBRIDGE_DIR{}={}",
+ i,
+ header_dir.path.to_string_lossy(),
+ );
+ }
+ }
+ }
+}
+
+pub fn direct_dependencies() -> Vec<Crate> {
+ let mut crates: BTreeMap<String, Crate> = BTreeMap::new();
+ let mut exported_header_dirs: BTreeMap<String, Vec<(usize, PathBuf)>> = BTreeMap::new();
+
+ // Only variables set from a build script of direct dependencies are
+ // observable. That's exactly what we want! Your crate needs to declare a
+ // direct dependency on the other crate in order to be able to #include its
+ // headers.
+ //
+ // Also, they're only observable if the dependency's manifest contains a
+ // `links` key. This is important because Cargo imposes no ordering on the
+ // execution of build scripts without a `links` key. When exposing a
+ // generated header for the current crate to #include, we need to be sure
+ // the dependency's build script has already executed and emitted that
+ // generated header.
+ //
+ // References:
+ // - https://doc.rust-lang.org/cargo/reference/build-scripts.html#the-links-manifest-key
+ // - https://doc.rust-lang.org/cargo/reference/build-script-examples.html#using-another-sys-crate
+ for (k, v) in env::vars_os() {
+ let mut k = k.to_string_lossy().into_owned();
+ if !k.starts_with("DEP_") {
+ continue;
+ }
+
+ if k.ends_with("_CXXBRIDGE_PREFIX") {
+ k.truncate(k.len() - "_CXXBRIDGE_PREFIX".len());
+ crates.entry(k).or_default().include_prefix = Some(PathBuf::from(v));
+ continue;
+ }
+
+ if k.ends_with("_CXXBRIDGE_LINKS") {
+ k.truncate(k.len() - "_CXXBRIDGE_LINKS".len());
+ crates.entry(k).or_default().links = Some(v);
+ continue;
+ }
+
+ let without_counter = k.trim_end_matches(|ch: char| ch.is_ascii_digit());
+ let counter_len = k.len() - without_counter.len();
+ if counter_len == 0 || !without_counter.ends_with("_CXXBRIDGE_DIR") {
+ continue;
+ }
+
+ let sort_key = k[k.len() - counter_len..]
+ .parse::<usize>()
+ .unwrap_or(usize::MAX);
+ k.truncate(k.len() - counter_len - "_CXXBRIDGE_DIR".len());
+ exported_header_dirs
+ .entry(k)
+ .or_default()
+ .push((sort_key, PathBuf::from(v)));
+ }
+
+ for (k, mut dirs) in exported_header_dirs {
+ dirs.sort_by_key(|(sort_key, _dir)| *sort_key);
+ crates
+ .entry(k)
+ .or_default()
+ .header_dirs
+ .extend(dirs.into_iter().map(|(_sort_key, dir)| HeaderDir {
+ exported: true,
+ path: dir,
+ }));
+ }
+
+ crates.into_iter().map(|entry| entry.1).collect()
+}
diff --git a/gen/build/src/error.rs b/gen/build/src/error.rs
index 740ab94..99d7a30 100644
--- a/gen/build/src/error.rs
+++ b/gen/build/src/error.rs
@@ -1,22 +1,83 @@
+use crate::cfg::CFG;
+use crate::gen::fs;
use std::error::Error as StdError;
+use std::ffi::OsString;
use std::fmt::{self, Display};
-use std::io;
+use std::path::Path;
pub(super) type Result<T, E = Error> = std::result::Result<T, E>;
#[derive(Debug)]
pub(super) enum Error {
- MissingOutDir,
- TargetDir,
- Io(io::Error),
+ NoEnv(OsString),
+ Fs(fs::Error),
+ ExportedDirNotAbsolute(&'static Path),
+ ExportedEmptyPrefix,
+ ExportedDirsWithoutLinks,
+ ExportedPrefixesWithoutLinks,
+ ExportedLinksWithoutLinks,
+ UnusedExportedPrefix(&'static str),
+ UnusedExportedLinks(&'static str),
}
+macro_rules! expr {
+ ($expr:expr) => {{
+ let _ = $expr; // ensure it doesn't fall out of sync with CFG definition
+ stringify!($expr)
+ }};
+}
+
+const LINKS_DOCUMENTATION: &str =
+ "https://doc.rust-lang.org/cargo/reference/build-scripts.html#the-links-manifest-key";
+
impl Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
- Error::MissingOutDir => write!(f, "missing OUT_DIR environment variable"),
- Error::TargetDir => write!(f, "failed to locate target dir"),
- Error::Io(err) => err.fmt(f),
+ Error::NoEnv(var) => {
+ write!(f, "missing {} environment variable", var.to_string_lossy())
+ }
+ Error::Fs(err) => err.fmt(f),
+ Error::ExportedDirNotAbsolute(path) => write!(
+ f,
+ "element of {} must be absolute path, but was: {:?}",
+ expr!(CFG.exported_header_dirs),
+ path,
+ ),
+ Error::ExportedEmptyPrefix => write!(
+ f,
+ "element of {} must not be empty string",
+ expr!(CFG.exported_header_prefixes),
+ ),
+ Error::ExportedDirsWithoutLinks => write!(
+ f,
+ "if {} is nonempty then `links` needs to be set in Cargo.toml; see {}",
+ expr!(CFG.exported_header_dirs),
+ LINKS_DOCUMENTATION,
+ ),
+ Error::ExportedPrefixesWithoutLinks => write!(
+ f,
+ "if {} is nonempty then `links` needs to be set in Cargo.toml; see {}",
+ expr!(CFG.exported_header_prefixes),
+ LINKS_DOCUMENTATION,
+ ),
+ Error::ExportedLinksWithoutLinks => write!(
+ f,
+ "if {} is nonempty then `links` needs to be set in Cargo.toml; see {}",
+ expr!(CFG.exported_header_links),
+ LINKS_DOCUMENTATION,
+ ),
+ Error::UnusedExportedPrefix(unused) => write!(
+ f,
+ "unused element in {}: {:?} does not match the include prefix of any direct dependency",
+ expr!(CFG.exported_header_prefixes),
+ unused,
+ ),
+ Error::UnusedExportedLinks(unused) => write!(
+ f,
+ "unused element in {}: {:?} does not match the `links` attribute any direct dependency",
+ expr!(CFG.exported_header_links),
+ unused,
+ ),
}
}
}
@@ -24,14 +85,14 @@
impl StdError for Error {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
match self {
- Error::Io(err) => Some(err),
+ Error::Fs(err) => err.source(),
_ => None,
}
}
}
-impl From<io::Error> for Error {
- fn from(err: io::Error) -> Self {
- Error::Io(err)
+impl From<fs::Error> for Error {
+ fn from(err: fs::Error) -> Self {
+ Error::Fs(err)
}
}
diff --git a/gen/build/src/intern.rs b/gen/build/src/intern.rs
new file mode 100644
index 0000000..51bc07c
--- /dev/null
+++ b/gen/build/src/intern.rs
@@ -0,0 +1,28 @@
+use lazy_static::lazy_static;
+use std::collections::HashSet;
+use std::sync::{Mutex, PoisonError};
+
+#[derive(Copy, Clone, Default)]
+pub struct InternedString(&'static str);
+
+impl InternedString {
+ pub fn str(self) -> &'static str {
+ self.0
+ }
+}
+
+pub fn intern(s: &str) -> InternedString {
+ lazy_static! {
+ static ref INTERN: Mutex<HashSet<&'static str>> = Mutex::new(HashSet::new());
+ }
+
+ let mut set = INTERN.lock().unwrap_or_else(PoisonError::into_inner);
+ InternedString(match set.get(s) {
+ Some(interned) => *interned,
+ None => {
+ let interned = Box::leak(Box::from(s));
+ set.insert(interned);
+ interned
+ }
+ })
+}
diff --git a/gen/build/src/lib.rs b/gen/build/src/lib.rs
index 14683b6..db15335 100644
--- a/gen/build/src/lib.rs
+++ b/gen/build/src/lib.rs
@@ -15,18 +15,18 @@
//!
//! fn main() {
//! cxx_build::bridge("src/main.rs")
-//! .file("../demo-cxx/demo.cc")
+//! .file("src/demo.cc")
//! .flag_if_supported("-std=c++11")
//! .compile("cxxbridge-demo");
//!
//! println!("cargo:rerun-if-changed=src/main.rs");
-//! println!("cargo:rerun-if-changed=../demo-cxx/demo.h");
-//! println!("cargo:rerun-if-changed=../demo-cxx/demo.cc");
+//! println!("cargo:rerun-if-changed=src/demo.cc");
+//! println!("cargo:rerun-if-changed=include/demo.h");
//! }
//! ```
//!
-//! A runnable working setup with this build script is shown in the
-//! *demo-rs* and *demo-cxx* directories of [https://github.com/dtolnay/cxx].
+//! A runnable working setup with this build script is shown in the *demo*
+//! directory of [https://github.com/dtolnay/cxx].
//!
//! [https://github.com/dtolnay/cxx]: https://github.com/dtolnay/cxx
//!
@@ -46,33 +46,50 @@
//! ```
#![allow(
+ clippy::drop_copy,
clippy::inherent_to_string,
clippy::needless_doctest_main,
clippy::new_without_default,
+ clippy::or_fun_call,
clippy::toplevel_ref_arg
)]
+mod cfg;
+mod deps;
mod error;
mod gen;
+mod intern;
+mod out;
mod paths;
mod syntax;
+mod target;
+mod vec;
-use crate::error::Result;
+use crate::deps::{Crate, HeaderDir};
+use crate::error::{Error, Result};
+use crate::gen::error::report;
use crate::gen::Opt;
-use anyhow::anyhow;
-use std::fs;
+use crate::paths::PathExt;
+use crate::target::TargetDir;
+use cc::Build;
+use std::collections::btree_map::Entry;
+use std::collections::{BTreeMap, BTreeSet};
+use std::env;
+use std::ffi::{OsStr, OsString};
use std::io::{self, Write};
use std::iter;
-use std::path::Path;
+use std::path::{Path, PathBuf};
use std::process;
+pub use crate::cfg::{Cfg, CFG};
+
/// This returns a [`cc::Build`] on which you should continue to set up any
/// additional source files or compiler flags, and lastly call its [`compile`]
/// method to execute the C++ build.
///
/// [`compile`]: https://docs.rs/cc/1.0.49/cc/struct.Build.html#method.compile
#[must_use]
-pub fn bridge(rust_source_file: impl AsRef<Path>) -> cc::Build {
+pub fn bridge(rust_source_file: impl AsRef<Path>) -> Build {
bridges(iter::once(rust_source_file))
}
@@ -82,41 +99,301 @@
/// ```no_run
/// let source_files = vec!["src/main.rs", "src/path/to/other.rs"];
/// cxx_build::bridges(source_files)
-/// .file("../demo-cxx/demo.cc")
+/// .file("src/demo.cc")
/// .flag_if_supported("-std=c++11")
/// .compile("cxxbridge-demo");
/// ```
-pub fn bridges(rust_source_files: impl IntoIterator<Item = impl AsRef<Path>>) -> cc::Build {
- let mut build = paths::cc_build();
+#[must_use]
+pub fn bridges(rust_source_files: impl IntoIterator<Item = impl AsRef<Path>>) -> Build {
+ let ref mut rust_source_files = rust_source_files.into_iter();
+ build(rust_source_files).unwrap_or_else(|err| {
+ let _ = writeln!(io::stderr(), "\n\ncxxbridge error: {}\n\n", report(err));
+ process::exit(1);
+ })
+}
+
+struct Project {
+ include_prefix: PathBuf,
+ manifest_dir: PathBuf,
+ // The `links = "..."` value from Cargo.toml.
+ links_attribute: Option<OsString>,
+ // Output directory as received from Cargo.
+ out_dir: PathBuf,
+ // Directory into which to symlink all generated code.
+ //
+ // This is *not* used for an #include path, only as a debugging convenience.
+ // Normally available at target/cxxbridge/ if we are able to know where the
+ // target dir is, otherwise under a common scratch dir.
+ //
+ // The reason this isn't the #include dir is that we do not want builds to
+ // have access to headers from arbitrary other parts of the dependency
+ // graph. Using a global directory for all builds would be both a race
+ // condition depending on what order Cargo randomly executes the build
+ // scripts, as well as semantically undesirable for builds not to have to
+ // declare their real dependencies.
+ shared_dir: PathBuf,
+}
+
+impl Project {
+ fn init() -> Result<Self> {
+ let include_prefix = Path::new(CFG.include_prefix);
+ assert!(include_prefix.is_relative());
+ let include_prefix = include_prefix.components().collect();
+
+ let links_attribute = env::var_os("CARGO_MANIFEST_LINKS");
+
+ let manifest_dir = paths::manifest_dir()?;
+ let out_dir = paths::out_dir()?;
+
+ let shared_dir = match target::find_target_dir(&out_dir) {
+ TargetDir::Path(target_dir) => target_dir.join("cxxbridge"),
+ TargetDir::Unknown => scratch::path("cxxbridge"),
+ };
+
+ Ok(Project {
+ include_prefix,
+ manifest_dir,
+ links_attribute,
+ out_dir,
+ shared_dir,
+ })
+ }
+}
+
+// We lay out the OUT_DIR as follows. Everything is namespaced under a cxxbridge
+// subdirectory to avoid stomping on other things that the caller's build script
+// might be doing inside OUT_DIR.
+//
+// $OUT_DIR/
+// cxxbridge/
+// crate/
+// $CARGO_PKG_NAME -> $CARGO_MANIFEST_DIR
+// include/
+// rust/
+// cxx.h
+// $CARGO_PKG_NAME/
+// .../
+// lib.rs.h
+// sources/
+// $CARGO_PKG_NAME/
+// .../
+// lib.rs.cc
+//
+// The crate/ and include/ directories are placed on the #include path for the
+// current build as well as for downstream builds that have a direct dependency
+// on the current crate.
+fn build(rust_source_files: &mut dyn Iterator<Item = impl AsRef<Path>>) -> Result<Build> {
+ let ref prj = Project::init()?;
+ validate_cfg(prj)?;
+ let this_crate = make_this_crate(prj)?;
+ this_crate.print_to_cargo();
+
+ let mut build = Build::new();
build.cpp(true);
build.cpp_link_stdlib(None); // linked via link-cplusplus crate
for path in rust_source_files {
- if let Err(err) = try_generate_bridge(&mut build, path.as_ref()) {
- let _ = writeln!(io::stderr(), "\n\ncxxbridge error: {:?}\n\n", anyhow!(err));
- process::exit(1);
+ generate_bridge(prj, &mut build, path.as_ref())?;
+ }
+
+ eprintln!("\nCXX include path:");
+ for header_dir in this_crate.header_dirs {
+ build.include(&header_dir.path);
+ if header_dir.exported {
+ eprintln!(" {}", header_dir.path.display());
+ } else {
+ eprintln!(" {} (private)", header_dir.path.display());
}
}
- build
+ Ok(build)
}
-fn try_generate_bridge(build: &mut cc::Build, rust_source_file: &Path) -> Result<()> {
- let header = gen::do_generate_header(rust_source_file, Opt::default());
- let header_path = paths::out_with_extension(rust_source_file, ".h")?;
- fs::create_dir_all(header_path.parent().unwrap())?;
- fs::write(&header_path, header)?;
- paths::symlink_header(&header_path, rust_source_file);
+fn validate_cfg(prj: &Project) -> Result<()> {
+ for exported_dir in &CFG.exported_header_dirs {
+ if !exported_dir.is_absolute() {
+ return Err(Error::ExportedDirNotAbsolute(exported_dir));
+ }
+ }
- let bridge = gen::do_generate_bridge(rust_source_file, Opt::default());
- let bridge_path = paths::out_with_extension(rust_source_file, ".cc")?;
- fs::write(&bridge_path, bridge)?;
- build.file(&bridge_path);
+ for prefix in &CFG.exported_header_prefixes {
+ if prefix.is_empty() {
+ return Err(Error::ExportedEmptyPrefix);
+ }
+ }
- let ref cxx_h = paths::include_dir()?.join("rust").join("cxx.h");
- let _ = fs::create_dir_all(cxx_h.parent().unwrap());
- let _ = fs::remove_file(cxx_h);
- let _ = fs::write(cxx_h, gen::include::HEADER);
+ if prj.links_attribute.is_none() {
+ if !CFG.exported_header_dirs.is_empty() {
+ return Err(Error::ExportedDirsWithoutLinks);
+ }
+ if !CFG.exported_header_prefixes.is_empty() {
+ return Err(Error::ExportedPrefixesWithoutLinks);
+ }
+ if !CFG.exported_header_links.is_empty() {
+ return Err(Error::ExportedLinksWithoutLinks);
+ }
+ }
Ok(())
}
+
+fn make_this_crate(prj: &Project) -> Result<Crate> {
+ let crate_dir = make_crate_dir(prj);
+ let include_dir = make_include_dir(prj)?;
+
+ let mut this_crate = Crate {
+ include_prefix: Some(prj.include_prefix.clone()),
+ links: prj.links_attribute.clone(),
+ header_dirs: Vec::new(),
+ };
+
+ // The generated code directory (include_dir) is placed in front of
+ // crate_dir on the include line so that `#include "path/to/file.rs"` from
+ // C++ "magically" works and refers to the API generated from that Rust
+ // source file.
+ this_crate.header_dirs.push(HeaderDir {
+ exported: true,
+ path: include_dir,
+ });
+
+ if let Some(crate_dir) = crate_dir {
+ this_crate.header_dirs.push(HeaderDir {
+ exported: true,
+ path: crate_dir,
+ });
+ }
+
+ for exported_dir in &CFG.exported_header_dirs {
+ this_crate.header_dirs.push(HeaderDir {
+ exported: true,
+ path: PathBuf::from(exported_dir),
+ });
+ }
+
+ let mut header_dirs_index = BTreeMap::new();
+ let mut used_header_links = BTreeSet::new();
+ let mut used_header_prefixes = BTreeSet::new();
+ for krate in deps::direct_dependencies() {
+ let mut is_link_exported = || match &krate.links {
+ None => false,
+ Some(links_attribute) => CFG.exported_header_links.iter().any(|&exported| {
+ let matches = links_attribute == exported;
+ if matches {
+ used_header_links.insert(exported);
+ }
+ matches
+ }),
+ };
+
+ let mut is_prefix_exported = || match &krate.include_prefix {
+ None => false,
+ Some(include_prefix) => CFG.exported_header_prefixes.iter().any(|&exported| {
+ let matches = include_prefix.starts_with(exported);
+ if matches {
+ used_header_prefixes.insert(exported);
+ }
+ matches
+ }),
+ };
+
+ let exported = is_link_exported() || is_prefix_exported();
+
+ for dir in krate.header_dirs {
+ // Deduplicate dirs reachable via multiple transitive dependencies.
+ match header_dirs_index.entry(dir.path.clone()) {
+ Entry::Vacant(entry) => {
+ entry.insert(this_crate.header_dirs.len());
+ this_crate.header_dirs.push(HeaderDir {
+ exported,
+ path: dir.path,
+ });
+ }
+ Entry::Occupied(entry) => {
+ let index = *entry.get();
+ this_crate.header_dirs[index].exported |= exported;
+ }
+ }
+ }
+ }
+
+ if let Some(unused) = CFG
+ .exported_header_links
+ .iter()
+ .find(|&exported| !used_header_links.contains(exported))
+ {
+ return Err(Error::UnusedExportedLinks(unused));
+ }
+
+ if let Some(unused) = CFG
+ .exported_header_prefixes
+ .iter()
+ .find(|&exported| !used_header_prefixes.contains(exported))
+ {
+ return Err(Error::UnusedExportedPrefix(unused));
+ }
+
+ Ok(this_crate)
+}
+
+fn make_crate_dir(prj: &Project) -> Option<PathBuf> {
+ if prj.include_prefix.as_os_str().is_empty() {
+ return Some(prj.manifest_dir.clone());
+ }
+ let crate_dir = prj.out_dir.join("cxxbridge").join("crate");
+ let link = crate_dir.join(&prj.include_prefix);
+ if out::symlink_dir(&prj.manifest_dir, link).is_ok() {
+ Some(crate_dir)
+ } else {
+ None
+ }
+}
+
+fn make_include_dir(prj: &Project) -> Result<PathBuf> {
+ 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_CXXBRIDGE05_HEADER") {
+ out::symlink_file(original, cxx_h)?;
+ out::symlink_file(original, shared_cxx_h)?;
+ } else {
+ out::write(shared_cxx_h, gen::include::HEADER.as_bytes())?;
+ out::symlink_file(shared_cxx_h, cxx_h)?;
+ }
+ Ok(include_dir)
+}
+
+fn generate_bridge(prj: &Project, build: &mut Build, rust_source_file: &Path) -> Result<()> {
+ let opt = Opt {
+ allow_dot_includes: false,
+ ..Opt::default()
+ };
+ let generated = gen::generate_from_path(rust_source_file, &opt);
+ let ref rel_path = paths::local_relative_path(rust_source_file);
+
+ let cxxbridge = prj.out_dir.join("cxxbridge");
+ let include_dir = cxxbridge.join("include").join(&prj.include_prefix);
+ let sources_dir = cxxbridge.join("sources").join(&prj.include_prefix);
+
+ let ref rel_path_h = rel_path.with_appended_extension(".h");
+ let ref header_path = include_dir.join(rel_path_h);
+ out::write(header_path, &generated.header)?;
+
+ let ref link_path = include_dir.join(rel_path);
+ let _ = out::symlink_file(header_path, link_path);
+
+ let ref rel_path_cc = rel_path.with_appended_extension(".cc");
+ let ref implementation_path = sources_dir.join(rel_path_cc);
+ out::write(implementation_path, &generated.implementation)?;
+ build.file(implementation_path);
+
+ let shared_h = prj.shared_dir.join(&prj.include_prefix).join(rel_path_h);
+ let shared_cc = prj.shared_dir.join(&prj.include_prefix).join(rel_path_cc);
+ let _ = out::symlink_file(header_path, shared_h);
+ let _ = out::symlink_file(implementation_path, shared_cc);
+ Ok(())
+}
+
+fn env_os(key: impl AsRef<OsStr>) -> Result<OsString> {
+ let key = key.as_ref();
+ env::var_os(key).ok_or_else(|| Error::NoEnv(key.to_owned()))
+}
diff --git a/gen/build/src/out.rs b/gen/build/src/out.rs
new file mode 100644
index 0000000..b97e992
--- /dev/null
+++ b/gen/build/src/out.rs
@@ -0,0 +1,69 @@
+use crate::error::{Error, Result};
+use crate::gen::fs;
+use crate::paths;
+use std::path::Path;
+
+pub(crate) fn write(path: impl AsRef<Path>, content: &[u8]) -> Result<()> {
+ let path = path.as_ref();
+
+ let mut create_dir_error = None;
+ if path.exists() {
+ if let Ok(existing) = fs::read(path) {
+ if existing == content {
+ // Avoid bumping modified time with unchanged contents.
+ return Ok(());
+ }
+ }
+ let _ = fs::remove_file(path);
+ } else {
+ let parent = path.parent().unwrap();
+ create_dir_error = fs::create_dir_all(parent).err();
+ }
+
+ match fs::write(path, content) {
+ // As long as write succeeded, ignore any create_dir_all error.
+ Ok(()) => Ok(()),
+ // If create_dir_all and write both failed, prefer the first error.
+ Err(err) => Err(Error::Fs(create_dir_error.unwrap_or(err))),
+ }
+}
+
+pub(crate) fn symlink_file(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> Result<()> {
+ let src = src.as_ref();
+ let dst = dst.as_ref();
+
+ let mut create_dir_error = None;
+ if dst.exists() {
+ let _ = fs::remove_file(dst).unwrap();
+ } else {
+ let parent = dst.parent().unwrap();
+ create_dir_error = fs::create_dir_all(parent).err();
+ }
+
+ match paths::symlink_or_copy(src, dst) {
+ // As long as symlink_or_copy succeeded, ignore any create_dir_all error.
+ Ok(()) => Ok(()),
+ // If create_dir_all and symlink_or_copy both failed, prefer the first error.
+ Err(err) => Err(Error::Fs(create_dir_error.unwrap_or(err))),
+ }
+}
+
+pub(crate) fn symlink_dir(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> Result<()> {
+ let src = src.as_ref();
+ let dst = dst.as_ref();
+
+ let mut create_dir_error = None;
+ if dst.exists() {
+ let _ = paths::remove_symlink_dir(dst).unwrap();
+ } else {
+ let parent = dst.parent().unwrap();
+ create_dir_error = fs::create_dir_all(parent).err();
+ }
+
+ match paths::symlink_dir(src, dst) {
+ // As long as symlink_dir succeeded, ignore any create_dir_all error.
+ Ok(()) => Ok(()),
+ // If create_dir_all and symlink_dir both failed, prefer the first error.
+ Err(err) => Err(Error::Fs(create_dir_error.unwrap_or(err))),
+ }
+}
diff --git a/gen/build/src/paths.rs b/gen/build/src/paths.rs
index ca183d9..4459363 100644
--- a/gen/build/src/paths.rs
+++ b/gen/build/src/paths.rs
@@ -1,116 +1,74 @@
-use crate::error::{Error, Result};
-use std::env;
-use std::fs;
-use std::path::{Path, PathBuf};
+use crate::error::Result;
+use crate::gen::fs;
+use std::ffi::OsStr;
+use std::path::{Component, Path, PathBuf};
-fn out_dir() -> Result<PathBuf> {
- env::var_os("OUT_DIR")
- .map(PathBuf::from)
- .ok_or(Error::MissingOutDir)
+pub(crate) fn manifest_dir() -> Result<PathBuf> {
+ crate::env_os("CARGO_MANIFEST_DIR").map(PathBuf::from)
}
-pub(crate) fn cc_build() -> cc::Build {
- try_cc_build().unwrap_or_default()
+pub(crate) fn out_dir() -> Result<PathBuf> {
+ crate::env_os("OUT_DIR").map(PathBuf::from)
}
-fn try_cc_build() -> Result<cc::Build> {
- let mut build = cc::Build::new();
- build.include(include_dir()?);
- build.include(target_dir()?.parent().unwrap());
- Ok(build)
-}
-
-// Symlink the header file into a predictable place. The header generated from
-// path/to/mod.rs gets linked to targets/cxxbridge/path/to/mod.rs.h.
-pub(crate) fn symlink_header(path: &Path, original: &Path) {
- let _ = try_symlink_header(path, original);
-}
-
-fn try_symlink_header(path: &Path, original: &Path) -> Result<()> {
- let suffix = relative_to_parent_of_target_dir(original)?;
- let ref dst = include_dir()?.join(suffix);
-
- fs::create_dir_all(dst.parent().unwrap())?;
- let _ = fs::remove_file(dst);
- symlink_or_copy(path, dst)?;
-
- let mut file_name = dst.file_name().unwrap().to_os_string();
- file_name.push(".h");
- let ref dst2 = dst.with_file_name(file_name);
- symlink_or_copy(path, dst2)?;
-
- Ok(())
-}
-
-fn relative_to_parent_of_target_dir(original: &Path) -> Result<PathBuf> {
- let target_dir = target_dir()?;
- let mut outer = target_dir.parent().unwrap();
- let original = canonicalize(original)?;
- loop {
- if let Ok(suffix) = original.strip_prefix(outer) {
- return Ok(suffix.to_owned());
- }
- match outer.parent() {
- Some(parent) => outer = parent,
- None => return Ok(original.components().skip(1).collect()),
+// Given a path provided by the user, determines where generated files related
+// to that path should go in our out dir. In particular we don't want to
+// accidentally write generated code upward of our out dir, even if the user
+// passed a path containing lots of `..` or an absolute path.
+pub(crate) fn local_relative_path(path: &Path) -> PathBuf {
+ let mut rel_path = PathBuf::new();
+ for component in path.components() {
+ match component {
+ Component::Prefix(_) | Component::RootDir | Component::CurDir => {}
+ Component::ParentDir => drop(rel_path.pop()), // noop if empty
+ Component::Normal(name) => rel_path.push(name),
}
}
+ rel_path
}
-pub(crate) fn out_with_extension(path: &Path, ext: &str) -> Result<PathBuf> {
- let mut file_name = path.file_name().unwrap().to_owned();
- file_name.push(ext);
-
- let out_dir = out_dir()?;
- let rel = relative_to_parent_of_target_dir(path)?;
- Ok(out_dir.join(rel).with_file_name(file_name))
+pub(crate) trait PathExt {
+ fn with_appended_extension(&self, suffix: impl AsRef<OsStr>) -> PathBuf;
}
-pub(crate) fn include_dir() -> Result<PathBuf> {
- let target_dir = target_dir()?;
- Ok(target_dir.join("cxxbridge"))
-}
-
-fn target_dir() -> Result<PathBuf> {
- let mut dir = out_dir().and_then(canonicalize)?;
- loop {
- if dir.ends_with("target") {
- return Ok(dir);
- }
- if !dir.pop() {
- return Err(Error::TargetDir);
- }
+impl PathExt for Path {
+ fn with_appended_extension(&self, suffix: impl AsRef<OsStr>) -> PathBuf {
+ let mut file_name = self.file_name().unwrap().to_owned();
+ file_name.push(suffix);
+ self.with_file_name(file_name)
}
}
-#[cfg(not(windows))]
-fn canonicalize(path: impl AsRef<Path>) -> Result<PathBuf> {
- Ok(fs::canonicalize(path)?)
-}
-
-#[cfg(windows)]
-fn canonicalize(path: impl AsRef<Path>) -> Result<PathBuf> {
- // Real fs::canonicalize on Windows produces UNC paths which cl.exe is
- // unable to handle in includes. Use a poor approximation instead.
- // https://github.com/rust-lang/rust/issues/42869
- // https://github.com/alexcrichton/cc-rs/issues/169
- Ok(env::current_dir()?.join(path))
-}
-
#[cfg(unix)]
-use std::os::unix::fs::symlink as symlink_or_copy;
+pub(crate) use self::fs::symlink_file as symlink_or_copy;
#[cfg(windows)]
-fn symlink_or_copy(src: &Path, dst: &Path) -> Result<()> {
- use std::os::windows::fs::symlink_file;
-
+pub(crate) fn symlink_or_copy(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> fs::Result<()> {
// Pre-Windows 10, symlinks require admin privileges. Since Windows 10, they
// require Developer Mode. If it fails, fall back to copying the file.
- if symlink_file(src, dst).is_err() {
+ let src = src.as_ref();
+ let dst = dst.as_ref();
+ if fs::symlink_file(src, dst).is_err() {
fs::copy(src, dst)?;
}
Ok(())
}
#[cfg(not(any(unix, windows)))]
-use std::fs::copy as symlink_or_copy;
+pub(crate) use self::fs::copy as symlink_or_copy;
+
+#[cfg(any(unix, windows))]
+pub(crate) use self::fs::symlink_dir;
+
+#[cfg(not(any(unix, windows)))]
+pub(crate) fn symlink_dir(_src: impl AsRef<Path>, _dst: impl AsRef<Path>) -> fs::Result<()> {
+ Ok(())
+}
+
+#[cfg(not(windows))]
+pub(crate) use self::fs::remove_file as remove_symlink_dir;
+
+// On Windows, trying to use remove_file to remove a symlink which points to a
+// directory fails with "Access is denied".
+#[cfg(windows)]
+pub(crate) use self::fs::remove_dir as remove_symlink_dir;
diff --git a/gen/build/src/target.rs b/gen/build/src/target.rs
new file mode 100644
index 0000000..58ada3a
--- /dev/null
+++ b/gen/build/src/target.rs
@@ -0,0 +1,42 @@
+use std::env;
+use std::path::{Path, PathBuf};
+
+pub(crate) enum TargetDir {
+ Path(PathBuf),
+ Unknown,
+}
+
+pub(crate) fn find_target_dir(out_dir: &Path) -> TargetDir {
+ if let Some(target_dir) = env::var_os("CARGO_TARGET_DIR") {
+ let target_dir = PathBuf::from(target_dir);
+ if target_dir.is_absolute() {
+ return TargetDir::Path(target_dir);
+ } else {
+ return TargetDir::Unknown;
+ };
+ }
+
+ // fs::canonicalize on Windows produces UNC paths which cl.exe is unable to
+ // handle in includes.
+ // https://github.com/rust-lang/rust/issues/42869
+ // https://github.com/alexcrichton/cc-rs/issues/169
+ let mut also_try_canonical = cfg!(not(windows));
+
+ let mut dir = out_dir.to_owned();
+ loop {
+ if dir.join(".rustc_info.json").exists() || dir.join("CACHEDIR.TAG").exists() {
+ return TargetDir::Path(dir);
+ }
+ if dir.pop() {
+ continue;
+ }
+ if also_try_canonical {
+ if let Ok(canonical_dir) = out_dir.canonicalize() {
+ dir = canonical_dir;
+ also_try_canonical = false;
+ continue;
+ }
+ }
+ return TargetDir::Unknown;
+ }
+}
diff --git a/gen/build/src/vec.rs b/gen/build/src/vec.rs
new file mode 100644
index 0000000..ac9235e
--- /dev/null
+++ b/gen/build/src/vec.rs
@@ -0,0 +1,50 @@
+use crate::intern::{self, InternedString};
+use std::path::Path;
+
+pub trait InternedVec<T>
+where
+ T: ?Sized,
+{
+ fn vec(&self) -> Vec<&'static T>;
+}
+
+impl<T> InternedVec<T> for Vec<InternedString>
+where
+ T: ?Sized + Element,
+{
+ fn vec(&self) -> Vec<&'static T> {
+ self.iter().copied().map(Element::unintern).collect()
+ }
+}
+
+pub fn intern<T>(elements: &[&T]) -> Vec<InternedString>
+where
+ T: ?Sized + Element,
+{
+ elements.iter().copied().map(Element::intern).collect()
+}
+
+pub trait Element {
+ fn intern(&self) -> InternedString;
+ fn unintern(_: InternedString) -> &'static Self;
+}
+
+impl Element for str {
+ fn intern(&self) -> InternedString {
+ intern::intern(self)
+ }
+
+ fn unintern(interned: InternedString) -> &'static Self {
+ interned.str()
+ }
+}
+
+impl Element for Path {
+ fn intern(&self) -> InternedString {
+ intern::intern(&self.to_string_lossy())
+ }
+
+ fn unintern(interned: InternedString) -> &'static Self {
+ Path::new(interned.str())
+ }
+}
diff --git a/gen/cmd/Android.bp b/gen/cmd/Android.bp
index 30d13e3..14e48e9 100644
--- a/gen/cmd/Android.bp
+++ b/gen/cmd/Android.bp
@@ -6,12 +6,11 @@
srcs: ["src/main.rs"],
edition: "2018",
rustlibs: [
- "libanyhow",
+ "libclap",
"libcodespan_reporting",
"libcxxbridge_cmd",
"libproc_macro2",
"libquote",
- "libstructopt",
"libsyn",
],
compile_multilib: "first",
@@ -23,11 +22,10 @@
srcs: ["src/lib.rs"],
edition: "2018",
rustlibs: [
- "libanyhow",
+ "libclap",
"libcodespan_reporting",
"libproc_macro2",
"libquote",
- "libstructopt",
"libsyn",
],
compile_multilib: "first",
@@ -35,26 +33,17 @@
// dependent_library ["feature_list"]
// ansi_term-0.11.0
-// anyhow-1.0.32 "default,std"
// atty-0.2.14
// bitflags-1.2.1 "default"
-// clap-2.33.1 "ansi_term,atty,color,default,strsim,suggestions,vec_map"
+// clap-2.33.3 "ansi_term,atty,color,default,strsim,suggestions,vec_map"
// codespan-reporting-0.9.5
-// heck-0.3.1
-// lazy_static-1.4.0
-// libc-0.2.74
-// proc-macro-error-1.0.4 "default,syn,syn-error"
-// proc-macro-error-attr-1.0.4
-// proc-macro2-1.0.19 "default,proc-macro,span-locations"
-// quote-1.0.7 "default,proc-macro"
+// libc-0.2.80
+// proc-macro2-1.0.24 "span-locations"
+// quote-1.0.7
// strsim-0.8.0
-// structopt-0.3.15 "default"
-// structopt-derive-0.4.8
-// syn-1.0.36 "clone-impls,default,derive,full,parsing,printing,proc-macro,quote"
-// termcolor-1.1.0
+// syn-1.0.50 "clone-impls,full,parsing,printing,quote"
+// termcolor-1.1.2
// textwrap-0.11.0
-// unicode-segmentation-1.6.0
// unicode-width-0.1.8 "default"
// unicode-xid-0.2.1 "default"
// vec_map-0.8.2
-// version_check-0.9.2
diff --git a/gen/cmd/Cargo.toml b/gen/cmd/Cargo.toml
index 7a80a2f..f3bdebf 100644
--- a/gen/cmd/Cargo.toml
+++ b/gen/cmd/Cargo.toml
@@ -1,11 +1,12 @@
[package]
name = "cxxbridge-cmd"
-version = "0.3.4"
+version = "0.5.9"
authors = ["David Tolnay <dtolnay@gmail.com>"]
edition = "2018"
license = "MIT OR Apache-2.0"
description = "C++ code generator for integrating `cxx` crate into a non-Cargo build."
repository = "https://github.com/dtolnay/cxx"
+exclude = ["build.rs"]
keywords = ["ffi"]
categories = ["development-tools::ffi"]
@@ -14,11 +15,10 @@
path = "src/main.rs"
[dependencies]
-anyhow = "1.0"
+clap = "2.33"
codespan-reporting = "0.9"
proc-macro2 = { version = "1.0.17", default-features = false, features = ["span-locations"] }
quote = { version = "1.0", default-features = false }
-structopt = "0.3"
syn = { version = "1.0.20", default-features = false, features = ["parsing", "printing", "clone-impls", "full"] }
[package.metadata.docs.rs]
diff --git a/gen/cmd/build.rs b/gen/cmd/build.rs
new file mode 100644
index 0000000..c53bef7
--- /dev/null
+++ b/gen/cmd/build.rs
@@ -0,0 +1 @@
+include!("../../tools/cargo/build.rs");
diff --git a/gen/cmd/src/app.rs b/gen/cmd/src/app.rs
new file mode 100644
index 0000000..e2945a1
--- /dev/null
+++ b/gen/cmd/src/app.rs
@@ -0,0 +1,171 @@
+#[cfg(test)]
+#[path = "test.rs"]
+mod test;
+
+use super::{Opt, Output};
+use crate::gen::include::Include;
+use crate::syntax::IncludeKind;
+use clap::AppSettings;
+use std::ffi::{OsStr, OsString};
+use std::path::PathBuf;
+
+type App = clap::App<'static, 'static>;
+type Arg = clap::Arg<'static, 'static>;
+
+const USAGE: &str = "\
+ cxxbridge <input>.rs Emit .cc file for bridge to stdout
+ cxxbridge <input>.rs --header Emit .h file for bridge to stdout
+ cxxbridge --header Emit \"rust/cxx.h\" header to stdout\
+";
+
+const TEMPLATE: &str = "\
+{bin} {version}
+David Tolnay <dtolnay@gmail.com>
+https://github.com/dtolnay/cxx
+
+USAGE:
+ {usage}
+
+ARGS:
+{positionals}
+OPTIONS:
+{unified}\
+";
+
+fn app() -> App {
+ let mut app = App::new("cxxbridge")
+ .usage(USAGE)
+ .template(TEMPLATE)
+ .setting(AppSettings::NextLineHelp)
+ .arg(arg_input())
+ .arg(arg_cxx_impl_annotations())
+ .arg(arg_header())
+ .arg(arg_include())
+ .arg(arg_output())
+ .help_message("Print help information.")
+ .version_message("Print version information.");
+ if let Some(version) = option_env!("CARGO_PKG_VERSION") {
+ app = app.version(version);
+ }
+ app
+}
+
+const INPUT: &str = "input";
+const CXX_IMPL_ANNOTATIONS: &str = "cxx-impl-annotations";
+const HEADER: &str = "header";
+const INCLUDE: &str = "include";
+const OUTPUT: &str = "output";
+
+pub(super) fn from_args() -> Opt {
+ let matches = app().get_matches();
+
+ let input = matches.value_of_os(INPUT).map(PathBuf::from);
+ let cxx_impl_annotations = matches.value_of(CXX_IMPL_ANNOTATIONS).map(str::to_owned);
+ let header = matches.is_present(HEADER);
+ let include = matches
+ .values_of(INCLUDE)
+ .unwrap_or_default()
+ .map(|include| {
+ if include.starts_with('<') && include.ends_with('>') {
+ Include {
+ path: include[1..include.len() - 1].to_owned(),
+ kind: IncludeKind::Bracketed,
+ }
+ } else {
+ Include {
+ path: include.to_owned(),
+ kind: IncludeKind::Quoted,
+ }
+ }
+ })
+ .collect();
+
+ let mut outputs = Vec::new();
+ for path in matches.values_of_os(OUTPUT).unwrap_or_default() {
+ outputs.push(if path == "-" {
+ Output::Stdout
+ } else {
+ Output::File(PathBuf::from(path))
+ });
+ }
+ if outputs.is_empty() {
+ outputs.push(Output::Stdout);
+ }
+
+ Opt {
+ input,
+ cxx_impl_annotations,
+ header,
+ include,
+ outputs,
+ }
+}
+
+fn validate_utf8(arg: &OsStr) -> Result<(), OsString> {
+ if arg.to_str().is_some() {
+ Ok(())
+ } else {
+ Err(OsString::from("invalid utf-8 sequence"))
+ }
+}
+
+fn arg_input() -> Arg {
+ Arg::with_name(INPUT)
+ .help("Input Rust source file containing #[cxx::bridge].")
+ .required_unless(HEADER)
+}
+
+fn arg_cxx_impl_annotations() -> Arg {
+ const HELP: &str = "\
+Optional annotation for implementations of C++ function wrappers
+that may be exposed to Rust. You may for example need to provide
+__declspec(dllexport) or __attribute__((visibility(\"default\")))
+if Rust code from one shared object or executable depends on
+these C++ functions in another.
+ ";
+ Arg::with_name(CXX_IMPL_ANNOTATIONS)
+ .long(CXX_IMPL_ANNOTATIONS)
+ .takes_value(true)
+ .value_name("annotation")
+ .validator_os(validate_utf8)
+ .help(HELP)
+}
+
+fn arg_header() -> Arg {
+ const HELP: &str = "\
+Emit header with declarations only. Optional if using `-o` with
+a path ending in `.h`.
+ ";
+ Arg::with_name(HEADER).long(HEADER).help(HELP)
+}
+
+fn arg_include() -> Arg {
+ const HELP: &str = "\
+Any additional headers to #include. The cxxbridge tool does not
+parse or even require the given paths to exist; they simply go
+into the generated C++ code as #include lines.
+ ";
+ Arg::with_name(INCLUDE)
+ .long(INCLUDE)
+ .short("i")
+ .takes_value(true)
+ .multiple(true)
+ .number_of_values(1)
+ .validator_os(validate_utf8)
+ .help(HELP)
+}
+
+fn arg_output() -> Arg {
+ const HELP: &str = "\
+Path of file to write as output. Output goes to stdout if -o is
+not specified.
+ ";
+ Arg::with_name(OUTPUT)
+ .long(OUTPUT)
+ .short("o")
+ .takes_value(true)
+ .multiple(true)
+ .number_of_values(1)
+ .validator_os(validate_utf8)
+ .help(HELP)
+}
diff --git a/gen/cmd/src/main.rs b/gen/cmd/src/main.rs
index 701f77f..c723039 100644
--- a/gen/cmd/src/main.rs
+++ b/gen/cmd/src/main.rs
@@ -3,68 +3,89 @@
clippy::inherent_to_string,
clippy::large_enum_variant,
clippy::new_without_default,
+ clippy::or_fun_call,
clippy::toplevel_ref_arg
)]
+mod app;
mod gen;
+mod output;
mod syntax;
-use gen::include;
+use crate::gen::error::{report, Result};
+use crate::gen::fs;
+use crate::gen::include::{self, Include};
+use crate::output::Output;
use std::io::{self, Write};
use std::path::PathBuf;
-use structopt::StructOpt;
+use std::process;
-#[derive(StructOpt, Debug)]
-#[structopt(
- name = "cxxbridge",
- author = "David Tolnay <dtolnay@gmail.com>",
- about = "https://github.com/dtolnay/cxx",
- usage = "\
- cxxbridge <input>.rs Emit .cc file for bridge to stdout
- cxxbridge <input>.rs --header Emit .h file for bridge to stdout
- cxxbridge --header Emit rust/cxx.h header to stdout",
- help_message = "Print help information",
- version_message = "Print version information"
-)]
+#[derive(Debug)]
struct Opt {
- /// Input Rust source file containing #[cxx::bridge]
- #[structopt(parse(from_os_str), required_unless = "header")]
input: Option<PathBuf>,
-
- /// Emit header with declarations only
- #[structopt(long)]
header: bool,
-
- /// Optional annotation for implementations of C++ function
- /// wrappers that may be exposed to Rust. You may for example
- /// need to provide __declspec(dllexport) or
- /// __attribute__((visibility("default"))) if Rust code from
- /// one shared object or executable depends on these C++ functions
- /// in another.
- #[structopt(long)]
cxx_impl_annotations: Option<String>,
-
- /// Any additional headers to #include
- #[structopt(short, long)]
- include: Vec<String>,
-}
-
-fn write(content: impl AsRef<[u8]>) {
- let _ = io::stdout().lock().write_all(content.as_ref());
+ include: Vec<Include>,
+ outputs: Vec<Output>,
}
fn main() {
- let opt = Opt::from_args();
+ if let Err(err) = try_main() {
+ let _ = writeln!(io::stderr(), "cxxbridge: {}", report(err));
+ process::exit(1);
+ }
+}
+
+enum Kind {
+ GeneratedHeader,
+ GeneratedImplementation,
+ Header,
+}
+
+fn try_main() -> Result<()> {
+ let opt = app::from_args();
+
+ let mut outputs = Vec::new();
+ let mut gen_header = false;
+ let mut gen_implementation = false;
+ for output in opt.outputs {
+ let kind = if opt.input.is_none() {
+ Kind::Header
+ } else if opt.header || output.ends_with(".h") {
+ gen_header = true;
+ Kind::GeneratedHeader
+ } else {
+ gen_implementation = true;
+ Kind::GeneratedImplementation
+ };
+ outputs.push((output, kind));
+ }
let gen = gen::Opt {
include: opt.include,
cxx_impl_annotations: opt.cxx_impl_annotations,
+ gen_header,
+ gen_implementation,
+ ..Default::default()
};
- match (opt.input, opt.header) {
- (Some(input), true) => write(gen::do_generate_header(&input, gen)),
- (Some(input), false) => write(gen::do_generate_bridge(&input, gen)),
- (None, true) => write(include::HEADER),
- (None, false) => unreachable!(), // enforced by required_unless
+ let generated_code = if let Some(input) = opt.input {
+ gen::generate_from_path(&input, &gen)
+ } else {
+ Default::default()
+ };
+
+ for (output, kind) in outputs {
+ let content = match kind {
+ Kind::GeneratedHeader => &generated_code.header,
+ Kind::GeneratedImplementation => &generated_code.implementation,
+ Kind::Header => include::HEADER.as_bytes(),
+ };
+ match output {
+ Output::Stdout => drop(io::stdout().write_all(content)),
+ Output::File(path) => fs::write(path, content)?,
+ }
}
+
+ Ok(())
}
diff --git a/gen/cmd/src/output.rs b/gen/cmd/src/output.rs
new file mode 100644
index 0000000..a46581b
--- /dev/null
+++ b/gen/cmd/src/output.rs
@@ -0,0 +1,16 @@
+use std::path::PathBuf;
+
+#[derive(Debug)]
+pub(crate) enum Output {
+ Stdout,
+ File(PathBuf),
+}
+
+impl Output {
+ pub(crate) fn ends_with(&self, suffix: &str) -> bool {
+ match self {
+ Output::Stdout => false,
+ Output::File(path) => path.to_string_lossy().ends_with(suffix),
+ }
+ }
+}
diff --git a/gen/cmd/src/test.rs b/gen/cmd/src/test.rs
new file mode 100644
index 0000000..17023e4
--- /dev/null
+++ b/gen/cmd/src/test.rs
@@ -0,0 +1,52 @@
+const EXPECTED: &str = "\
+cxxbridge $VERSION
+David Tolnay <dtolnay@gmail.com>
+https://github.com/dtolnay/cxx
+
+USAGE:
+ cxxbridge <input>.rs Emit .cc file for bridge to stdout
+ cxxbridge <input>.rs --header Emit .h file for bridge to stdout
+ cxxbridge --header Emit \"rust/cxx.h\" header to stdout
+
+ARGS:
+ <input>
+ Input Rust source file containing #[cxx::bridge].
+
+OPTIONS:
+ --cxx-impl-annotations <annotation>
+ Optional annotation for implementations of C++ function wrappers
+ that may be exposed to Rust. You may for example need to provide
+ __declspec(dllexport) or __attribute__((visibility(\"default\")))
+ if Rust code from one shared object or executable depends on
+ these C++ functions in another.
+ \x20
+ -h, --help
+ Print help information.
+
+ --header
+ Emit header with declarations only. Optional if using `-o` with
+ a path ending in `.h`.
+ \x20
+ -i, --include <include>...
+ Any additional headers to #include. The cxxbridge tool does not
+ parse or even require the given paths to exist; they simply go
+ into the generated C++ code as #include lines.
+ \x20
+ -o, --output <output>...
+ Path of file to write as output. Output goes to stdout if -o is
+ not specified.
+ \x20
+ -V, --version
+ Print version information.
+";
+
+#[test]
+fn test_help() {
+ let mut app = super::app();
+ let mut out = Vec::new();
+ app.write_long_help(&mut out).unwrap();
+ let help = String::from_utf8(out).unwrap();
+ let version = option_env!("CARGO_PKG_VERSION").unwrap_or_default();
+ let expected = EXPECTED.replace("$VERSION", version);
+ assert_eq!(help, expected);
+}
diff --git a/gen/lib/Cargo.toml b/gen/lib/Cargo.toml
new file mode 100644
index 0000000..2de0f28
--- /dev/null
+++ b/gen/lib/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "cxx-gen"
+version = "0.6.6"
+authors = ["Adrian Taylor <adetaylor@chromium.org>"]
+edition = "2018"
+license = "MIT OR Apache-2.0"
+description = "C++ code generator for integrating `cxx` crate into higher level tools."
+repository = "https://github.com/dtolnay/cxx"
+exclude = ["build.rs"]
+keywords = ["ffi"]
+categories = ["development-tools::ffi"]
+
+[dependencies]
+cc = "1.0.49"
+codespan-reporting = "0.9"
+proc-macro2 = { version = "1.0.17", default-features = false, features = ["span-locations"] }
+quote = { version = "1.0", default-features = false }
+syn = { version = "1.0.20", default-features = false, features = ["parsing", "printing", "clone-impls", "full"] }
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
diff --git a/gen/lib/LICENSE-APACHE b/gen/lib/LICENSE-APACHE
new file mode 120000
index 0000000..1cd601d
--- /dev/null
+++ b/gen/lib/LICENSE-APACHE
@@ -0,0 +1 @@
+../../LICENSE-APACHE
\ No newline at end of file
diff --git a/gen/lib/LICENSE-MIT b/gen/lib/LICENSE-MIT
new file mode 120000
index 0000000..b2cfbdc
--- /dev/null
+++ b/gen/lib/LICENSE-MIT
@@ -0,0 +1 @@
+../../LICENSE-MIT
\ No newline at end of file
diff --git a/gen/lib/build.rs b/gen/lib/build.rs
new file mode 100644
index 0000000..c53bef7
--- /dev/null
+++ b/gen/lib/build.rs
@@ -0,0 +1 @@
+include!("../../tools/cargo/build.rs");
diff --git a/gen/lib/src/error.rs b/gen/lib/src/error.rs
new file mode 100644
index 0000000..26249be
--- /dev/null
+++ b/gen/lib/src/error.rs
@@ -0,0 +1,33 @@
+// We can expose more detail on the error as the need arises, but start with an
+// opaque error type for now.
+
+use std::error::Error as StdError;
+use std::fmt::{self, Debug, Display};
+
+pub struct Error {
+ pub(crate) err: crate::gen::Error,
+}
+
+impl From<crate::gen::Error> for Error {
+ fn from(err: crate::gen::Error) -> Self {
+ Error { err }
+ }
+}
+
+impl Display for Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ Display::fmt(&self.err, f)
+ }
+}
+
+impl Debug for Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ Debug::fmt(&self.err, f)
+ }
+}
+
+impl StdError for Error {
+ fn source(&self) -> Option<&(dyn StdError + 'static)> {
+ self.err.source()
+ }
+}
diff --git a/gen/lib/src/gen b/gen/lib/src/gen
new file mode 120000
index 0000000..929cb3d
--- /dev/null
+++ b/gen/lib/src/gen
@@ -0,0 +1 @@
+../../src
\ No newline at end of file
diff --git a/gen/lib/src/lib.rs b/gen/lib/src/lib.rs
new file mode 100644
index 0000000..963e870
--- /dev/null
+++ b/gen/lib/src/lib.rs
@@ -0,0 +1,35 @@
+//! The CXX code generator for constructing and compiling C++ code.
+//!
+//! This is intended as a mechanism for embedding the `cxx` crate into
+//! higher-level code generators. See [dtolnay/cxx#235] and
+//! [https://github.com/google/autocxx].
+//!
+//! [dtolnay/cxx#235]: https://github.com/dtolnay/cxx/issues/235
+//! [https://github.com/google/autocxx]: https://github.com/google/autocxx
+
+#![allow(dead_code)]
+#![allow(
+ clippy::inherent_to_string,
+ clippy::new_without_default,
+ clippy::or_fun_call,
+ clippy::toplevel_ref_arg
+)]
+
+mod error;
+mod gen;
+mod syntax;
+
+pub use crate::error::Error;
+pub use crate::gen::include::{Include, HEADER};
+pub use crate::gen::{GeneratedCode, Opt};
+pub use crate::syntax::IncludeKind;
+use proc_macro2::TokenStream;
+
+/// Generate C++ bindings code from a Rust token stream. This should be a Rust
+/// token stream which somewhere contains a `#[cxx::bridge] mod {}`.
+pub fn generate_header_and_cc(rust_source: TokenStream, opt: &Opt) -> Result<GeneratedCode, Error> {
+ let syntax = syn::parse2(rust_source)
+ .map_err(crate::gen::Error::from)
+ .map_err(Error::from)?;
+ gen::generate(syntax, opt).map_err(Error::from)
+}
diff --git a/gen/lib/src/syntax b/gen/lib/src/syntax
new file mode 120000
index 0000000..a6fe06c
--- /dev/null
+++ b/gen/lib/src/syntax
@@ -0,0 +1 @@
+../../../syntax
\ No newline at end of file
diff --git a/gen/lib/tests/test.rs b/gen/lib/tests/test.rs
new file mode 100644
index 0000000..73a25f3
--- /dev/null
+++ b/gen/lib/tests/test.rs
@@ -0,0 +1,28 @@
+use cxx_gen::Opt;
+use quote::quote;
+
+#[test]
+fn test_positive() {
+ let rs = quote! {
+ #[cxx::bridge]
+ mod ffi {
+ extern "C" {
+ fn in_C();
+ }
+ extern "Rust" {
+ fn in_rs();
+ }
+ }
+ };
+ let opt = Opt::default();
+ let code = cxx_gen::generate_header_and_cc(rs, &opt).unwrap();
+ assert!(!code.header.is_empty());
+ assert!(!code.implementation.is_empty());
+}
+
+#[test]
+fn test_negative() {
+ let rs = quote! {};
+ let opt = Opt::default();
+ assert!(cxx_gen::generate_header_and_cc(rs, &opt).is_err())
+}
diff --git a/gen/src/block.rs b/gen/src/block.rs
new file mode 100644
index 0000000..96a9a6e
--- /dev/null
+++ b/gen/src/block.rs
@@ -0,0 +1,45 @@
+use proc_macro2::Ident;
+
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum Block<'a> {
+ AnonymousNamespace,
+ Namespace(&'static str),
+ UserDefinedNamespace(&'a Ident),
+ InlineNamespace(&'static str),
+ ExternC,
+}
+
+impl<'a> Block<'a> {
+ pub fn write_begin(self, out: &mut String) {
+ if let Block::InlineNamespace(_) = self {
+ out.push_str("inline ");
+ }
+ self.write_common(out);
+ out.push_str(" {\n");
+ }
+
+ pub fn write_end(self, out: &mut String) {
+ out.push_str("} // ");
+ self.write_common(out);
+ out.push('\n');
+ }
+
+ fn write_common(self, out: &mut String) {
+ match self {
+ Block::AnonymousNamespace => out.push_str("namespace"),
+ Block::Namespace(name) => {
+ out.push_str("namespace ");
+ out.push_str(name);
+ }
+ Block::UserDefinedNamespace(name) => {
+ out.push_str("namespace ");
+ out.push_str(&name.to_string());
+ }
+ Block::InlineNamespace(name) => {
+ out.push_str("namespace ");
+ out.push_str(name);
+ }
+ Block::ExternC => out.push_str("extern \"C\""),
+ }
+ }
+}
diff --git a/gen/src/builtin.rs b/gen/src/builtin.rs
new file mode 100644
index 0000000..41d037a
--- /dev/null
+++ b/gen/src/builtin.rs
@@ -0,0 +1,259 @@
+use crate::gen::block::Block;
+use crate::gen::ifndef;
+use crate::gen::out::{Content, OutFile};
+
+#[derive(Default, PartialEq)]
+pub struct Builtins<'a> {
+ pub panic: bool,
+ pub rust_string: bool,
+ pub rust_str: bool,
+ pub rust_slice: bool,
+ pub rust_box: bool,
+ pub rust_vec: bool,
+ pub rust_fn: bool,
+ pub rust_isize: bool,
+ pub unsafe_bitcopy: bool,
+ pub rust_error: bool,
+ pub manually_drop: bool,
+ pub maybe_uninit: bool,
+ pub trycatch: bool,
+ pub ptr_len: bool,
+ pub rust_str_new_unchecked: bool,
+ pub rust_str_repr: bool,
+ pub rust_slice_new: bool,
+ pub rust_slice_repr: bool,
+ pub exception: bool,
+ pub relocatable: bool,
+ pub friend_impl: bool,
+ pub content: Content<'a>,
+}
+
+impl<'a> Builtins<'a> {
+ pub fn new() -> Self {
+ Builtins::default()
+ }
+}
+
+pub(super) fn write(out: &mut OutFile) {
+ if out.builtin == Default::default() {
+ return;
+ }
+
+ let include = &mut out.include;
+ let builtin = &mut out.builtin;
+ let out = &mut builtin.content;
+
+ if builtin.rust_string {
+ include.array = true;
+ include.cstdint = true;
+ include.string = true;
+ }
+
+ if builtin.rust_str {
+ include.cstdint = true;
+ include.string = true;
+ builtin.friend_impl = true;
+ }
+
+ if builtin.rust_slice {
+ builtin.friend_impl = true;
+ }
+
+ if builtin.rust_box {
+ include.new = true;
+ include.type_traits = true;
+ include.utility = true;
+ }
+
+ if builtin.rust_vec {
+ include.array = true;
+ include.new = true;
+ include.type_traits = true;
+ include.utility = true;
+ builtin.panic = true;
+ builtin.unsafe_bitcopy = true;
+ }
+
+ if builtin.rust_fn {
+ include.utility = true;
+ }
+
+ if builtin.rust_error {
+ include.exception = true;
+ builtin.friend_impl = true;
+ }
+
+ if builtin.rust_isize {
+ include.basetsd = true;
+ }
+
+ if builtin.relocatable {
+ include.type_traits = true;
+ }
+
+ out.begin_block(Block::Namespace("rust"));
+ out.begin_block(Block::InlineNamespace("cxxbridge05"));
+ writeln!(out, "// #include \"rust/cxx.h\"");
+
+ ifndef::write(out, builtin.panic, "CXXBRIDGE05_PANIC");
+
+ if builtin.rust_string {
+ out.next_section();
+ writeln!(out, "struct unsafe_bitcopy_t;");
+ }
+
+ if builtin.friend_impl {
+ out.begin_block(Block::AnonymousNamespace);
+ writeln!(out, "template <typename T>");
+ writeln!(out, "class impl;");
+ out.end_block(Block::AnonymousNamespace);
+ }
+
+ ifndef::write(out, builtin.rust_string, "CXXBRIDGE05_RUST_STRING");
+ ifndef::write(out, builtin.rust_str, "CXXBRIDGE05_RUST_STR");
+ ifndef::write(out, builtin.rust_slice, "CXXBRIDGE05_RUST_SLICE");
+ ifndef::write(out, builtin.rust_box, "CXXBRIDGE05_RUST_BOX");
+ ifndef::write(out, builtin.unsafe_bitcopy, "CXXBRIDGE05_RUST_BITCOPY");
+ ifndef::write(out, builtin.rust_vec, "CXXBRIDGE05_RUST_VEC");
+ ifndef::write(out, builtin.rust_fn, "CXXBRIDGE05_RUST_FN");
+ ifndef::write(out, builtin.rust_error, "CXXBRIDGE05_RUST_ERROR");
+ ifndef::write(out, builtin.rust_isize, "CXXBRIDGE05_RUST_ISIZE");
+ ifndef::write(out, builtin.relocatable, "CXXBRIDGE05_RELOCATABLE");
+
+ if builtin.manually_drop {
+ out.next_section();
+ include.utility = true;
+ writeln!(out, "template <typename T>");
+ writeln!(out, "union ManuallyDrop {{");
+ writeln!(out, " T value;");
+ writeln!(
+ out,
+ " ManuallyDrop(T &&value) : value(::std::move(value)) {{}}",
+ );
+ writeln!(out, " ~ManuallyDrop() {{}}");
+ writeln!(out, "}};");
+ }
+
+ if builtin.maybe_uninit {
+ out.next_section();
+ writeln!(out, "template <typename T>");
+ writeln!(out, "union MaybeUninit {{");
+ writeln!(out, " T value;");
+ writeln!(out, " MaybeUninit() {{}}");
+ writeln!(out, " ~MaybeUninit() {{}}");
+ writeln!(out, "}};");
+ }
+
+ out.begin_block(Block::AnonymousNamespace);
+
+ if builtin.ptr_len {
+ out.begin_block(Block::Namespace("repr"));
+ writeln!(out, "struct PtrLen final {{");
+ writeln!(out, " const void *ptr;");
+ writeln!(out, " size_t len;");
+ writeln!(out, "}};");
+ out.end_block(Block::Namespace("repr"));
+ }
+
+ if builtin.rust_str_new_unchecked || builtin.rust_str_repr {
+ out.next_section();
+ writeln!(out, "template <>");
+ writeln!(out, "class impl<Str> final {{");
+ writeln!(out, "public:");
+ if builtin.rust_str_new_unchecked {
+ writeln!(
+ out,
+ " static Str new_unchecked(repr::PtrLen repr) noexcept {{",
+ );
+ writeln!(out, " Str str;");
+ writeln!(out, " str.ptr = static_cast<const char *>(repr.ptr);");
+ writeln!(out, " str.len = repr.len;");
+ writeln!(out, " return str;");
+ writeln!(out, " }}");
+ }
+ if builtin.rust_str_repr {
+ writeln!(out, " static repr::PtrLen repr(Str str) noexcept {{");
+ writeln!(out, " return repr::PtrLen{{str.ptr, str.len}};");
+ writeln!(out, " }}");
+ }
+ writeln!(out, "}};");
+ }
+
+ if builtin.rust_slice_new || builtin.rust_slice_repr {
+ out.next_section();
+ writeln!(out, "template <typename T>");
+ writeln!(out, "class impl<Slice<T>> final {{");
+ writeln!(out, "public:");
+ if builtin.rust_slice_new {
+ writeln!(
+ out,
+ " static Slice<T> slice(repr::PtrLen repr) noexcept {{",
+ );
+ writeln!(
+ out,
+ " return {{static_cast<const T *>(repr.ptr), repr.len}};",
+ );
+ writeln!(out, " }}");
+ }
+ if builtin.rust_slice_repr {
+ writeln!(
+ out,
+ " static repr::PtrLen repr(Slice<T> slice) noexcept {{",
+ );
+ writeln!(out, " return repr::PtrLen{{slice.ptr, slice.len}};");
+ writeln!(out, " }}");
+ }
+ writeln!(out, "}};");
+ }
+
+ if builtin.rust_error {
+ out.next_section();
+ writeln!(out, "template <>");
+ writeln!(out, "class impl<Error> final {{");
+ writeln!(out, "public:");
+ writeln!(out, " static Error error(repr::PtrLen repr) noexcept {{");
+ writeln!(out, " Error error;");
+ writeln!(out, " error.msg = static_cast<const char *>(repr.ptr);");
+ writeln!(out, " error.len = repr.len;");
+ writeln!(out, " return error;");
+ writeln!(out, " }}");
+ writeln!(out, "}};");
+ }
+
+ out.end_block(Block::AnonymousNamespace);
+ out.end_block(Block::InlineNamespace("cxxbridge05"));
+
+ if builtin.trycatch {
+ out.begin_block(Block::Namespace("behavior"));
+ include.exception = true;
+ include.type_traits = true;
+ include.utility = true;
+ writeln!(out, "class missing {{}};");
+ writeln!(out, "missing trycatch(...);");
+ writeln!(out);
+ writeln!(out, "template <typename Try, typename Fail>");
+ writeln!(out, "static typename ::std::enable_if<");
+ writeln!(
+ out,
+ " ::std::is_same<decltype(trycatch(::std::declval<Try>(), ::std::declval<Fail>())),",
+ );
+ writeln!(out, " missing>::value>::type");
+ writeln!(out, "trycatch(Try &&func, Fail &&fail) noexcept try {{");
+ writeln!(out, " func();");
+ writeln!(out, "}} catch (const ::std::exception &e) {{");
+ writeln!(out, " fail(e.what());");
+ writeln!(out, "}}");
+ out.end_block(Block::Namespace("behavior"));
+ }
+
+ out.end_block(Block::Namespace("rust"));
+
+ if builtin.exception {
+ out.begin_block(Block::ExternC);
+ writeln!(
+ out,
+ "const char *cxxbridge05$exception(const char *, size_t);",
+ );
+ out.end_block(Block::ExternC);
+ }
+}
diff --git a/gen/src/check.rs b/gen/src/check.rs
new file mode 100644
index 0000000..35929ad
--- /dev/null
+++ b/gen/src/check.rs
@@ -0,0 +1,27 @@
+use crate::gen::Opt;
+use crate::syntax::report::Errors;
+use crate::syntax::{error, Api};
+use quote::{quote, quote_spanned};
+use std::path::{Component, Path};
+
+pub(super) use crate::syntax::check::typecheck;
+
+pub(super) fn precheck(cx: &mut Errors, apis: &[Api], opt: &Opt) {
+ if !opt.allow_dot_includes {
+ check_dot_includes(cx, apis);
+ }
+}
+
+fn check_dot_includes(cx: &mut Errors, apis: &[Api]) {
+ for api in apis {
+ if let Api::Include(include) = api {
+ let first_component = Path::new(&include.path).components().next();
+ if let Some(Component::CurDir) | Some(Component::ParentDir) = first_component {
+ let begin = quote_spanned!(include.begin_span=> .);
+ let end = quote_spanned!(include.end_span=> .);
+ let span = quote!(#begin #end);
+ cx.error(span, error::DOT_INCLUDE.msg);
+ }
+ }
+ }
+}
diff --git a/gen/src/error.rs b/gen/src/error.rs
index 51dbbe7..2335d43 100644
--- a/gen/src/error.rs
+++ b/gen/src/error.rs
@@ -1,23 +1,25 @@
+use crate::gen::fs;
use crate::syntax;
-use anyhow::anyhow;
use codespan_reporting::diagnostic::{Diagnostic, Label};
use codespan_reporting::files::SimpleFiles;
use codespan_reporting::term::termcolor::{ColorChoice, StandardStream, WriteColor};
use codespan_reporting::term::{self, Config};
+use std::borrow::Cow;
use std::error::Error as StdError;
use std::fmt::{self, Display};
use std::io::{self, Write};
use std::ops::Range;
-use std::path::Path;
+use std::path::{Path, PathBuf};
use std::process;
+use std::str::Utf8Error;
-pub(super) type Result<T, E = Error> = std::result::Result<T, E>;
+pub(crate) type Result<T, E = Error> = std::result::Result<T, E>;
#[derive(Debug)]
-pub(super) enum Error {
+pub(crate) enum Error {
NoBridgeMod,
- OutOfLineMod,
- Io(io::Error),
+ Fs(fs::Error),
+ Utf8(PathBuf, Utf8Error),
Syn(syn::Error),
}
@@ -25,8 +27,8 @@
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Error::NoBridgeMod => write!(f, "no #[cxx::bridge] module found"),
- Error::OutOfLineMod => write!(f, "#[cxx::bridge] module must have inline contents"),
- Error::Io(err) => err.fmt(f),
+ Error::Fs(err) => err.fmt(f),
+ Error::Utf8(path, _) => write!(f, "Failed to read file `{}`", path.display()),
Error::Syn(err) => err.fmt(f),
}
}
@@ -35,16 +37,17 @@
impl StdError for Error {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
match self {
- Error::Io(err) => Some(err),
- Error::Syn(err) => Some(err),
+ Error::Fs(err) => err.source(),
+ Error::Utf8(_, err) => Some(err),
+ Error::Syn(err) => err.source(),
_ => None,
}
}
}
-impl From<io::Error> for Error {
- fn from(err: io::Error) -> Self {
- Error::Io(err)
+impl From<fs::Error> for Error {
+ fn from(err: fs::Error) -> Self {
+ Error::Fs(err)
}
}
@@ -65,11 +68,34 @@
display_syn_error(stderr, path, source, error);
}
}
- _ => eprintln!("cxxbridge: {:?}", anyhow!(error)),
+ _ => {
+ let _ = writeln!(io::stderr(), "cxxbridge: {}", report(error));
+ }
}
process::exit(1);
}
+pub(crate) fn report(error: impl StdError) -> impl Display {
+ struct Report<E>(E);
+
+ impl<E: StdError> Display for Report<E> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ Display::fmt(&self.0, formatter)?;
+ let mut error: &dyn StdError = &self.0;
+
+ while let Some(cause) = error.source() {
+ formatter.write_str("\n\nCaused by:\n ")?;
+ Display::fmt(cause, formatter)?;
+ error = cause;
+ }
+
+ Ok(())
+ }
+ }
+
+ Report(error)
+}
+
fn sort_syn_errors(error: syn::Error) -> Vec<syn::Error> {
let mut errors: Vec<_> = error.into_iter().collect();
errors.sort_by_key(|e| {
@@ -109,8 +135,13 @@
.map(char::len_utf8)
.sum::<usize>();
+ let mut path = path.to_string_lossy();
+ if path == "-" {
+ path = Cow::Borrowed(if cfg!(unix) { "/dev/stdin" } else { "stdin" });
+ }
+
let mut files = SimpleFiles::new();
- let file = files.add(path.to_string_lossy(), source);
+ let file = files.add(path, source);
let diagnostic = diagnose(file, start_offset..end_offset, error);
diff --git a/gen/src/file.rs b/gen/src/file.rs
new file mode 100644
index 0000000..46616fb
--- /dev/null
+++ b/gen/src/file.rs
@@ -0,0 +1,72 @@
+use crate::syntax::file::Module;
+use crate::syntax::namespace::Namespace;
+use syn::parse::discouraged::Speculative;
+use syn::parse::{Error, Parse, ParseStream, Result};
+use syn::{braced, Attribute, Ident, Item, Token, Visibility};
+
+pub struct File {
+ pub modules: Vec<Module>,
+}
+
+impl Parse for File {
+ fn parse(input: ParseStream) -> Result<Self> {
+ let mut modules = Vec::new();
+ input.call(Attribute::parse_inner)?;
+ parse(input, &mut modules)?;
+ Ok(File { modules })
+ }
+}
+
+fn parse(input: ParseStream, modules: &mut Vec<Module>) -> Result<()> {
+ while !input.is_empty() {
+ let mut cxx_bridge = false;
+ let mut namespace = Namespace::ROOT;
+ let mut attrs = input.call(Attribute::parse_outer)?;
+ for attr in &attrs {
+ let path = &attr.path.segments;
+ if path.len() == 2 && path[0].ident == "cxx" && path[1].ident == "bridge" {
+ cxx_bridge = true;
+ namespace = parse_args(attr)?;
+ break;
+ }
+ }
+
+ let ahead = input.fork();
+ ahead.parse::<Visibility>()?;
+ ahead.parse::<Option<Token![unsafe]>>()?;
+ if !ahead.peek(Token![mod]) {
+ let item: Item = input.parse()?;
+ if cxx_bridge {
+ return Err(Error::new_spanned(item, "expected a module"));
+ }
+ continue;
+ }
+
+ if cxx_bridge {
+ let mut module: Module = input.parse()?;
+ module.namespace = namespace;
+ attrs.extend(module.attrs);
+ module.attrs = attrs;
+ modules.push(module);
+ } else {
+ input.advance_to(&ahead);
+ input.parse::<Token![mod]>()?;
+ input.parse::<Ident>()?;
+ let semi: Option<Token![;]> = input.parse()?;
+ if semi.is_none() {
+ let content;
+ braced!(content in input);
+ parse(&content, modules)?;
+ }
+ }
+ }
+ Ok(())
+}
+
+fn parse_args(attr: &Attribute) -> Result<Namespace> {
+ if attr.tokens.is_empty() {
+ Ok(Namespace::ROOT)
+ } else {
+ attr.parse_args_with(Namespace::parse_bridge_attr_namespace)
+ }
+}
diff --git a/gen/src/find.rs b/gen/src/find.rs
deleted file mode 100644
index 86e1dc7..0000000
--- a/gen/src/find.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-use crate::gen::{Error, Input, Result};
-use crate::syntax::namespace::Namespace;
-use quote::quote;
-use syn::{Attribute, File, Item};
-
-pub(super) fn find_bridge_mod(syntax: File) -> Result<Input> {
- match scan(syntax.items)? {
- Some(input) => Ok(input),
- None => Err(Error::NoBridgeMod),
- }
-}
-
-fn scan(items: Vec<Item>) -> Result<Option<Input>> {
- for item in items {
- if let Item::Mod(item) = item {
- for attr in &item.attrs {
- let path = &attr.path;
- if quote!(#path).to_string() == "cxx :: bridge" {
- let module = match item.content {
- Some(module) => module.1,
- None => {
- return Err(Error::Syn(syn::Error::new_spanned(
- item,
- Error::OutOfLineMod,
- )));
- }
- };
- let namespace = parse_args(attr)?;
- return Ok(Some(Input { namespace, module }));
- }
- }
- if let Some(module) = item.content {
- if let Some(input) = scan(module.1)? {
- return Ok(Some(input));
- }
- }
- }
- }
- Ok(None)
-}
-
-fn parse_args(attr: &Attribute) -> syn::Result<Namespace> {
- if attr.tokens.is_empty() {
- Ok(Namespace::none())
- } else {
- attr.parse_args()
- }
-}
diff --git a/gen/src/fs.rs b/gen/src/fs.rs
new file mode 100644
index 0000000..8f94f00
--- /dev/null
+++ b/gen/src/fs.rs
@@ -0,0 +1,142 @@
+#![allow(dead_code)]
+
+use std::error::Error as StdError;
+use std::fmt::{self, Display};
+use std::io::{self, Read};
+use std::path::{Path, PathBuf};
+
+pub(crate) type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug)]
+pub(crate) struct Error {
+ source: io::Error,
+ message: String,
+}
+
+impl Display for Error {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str(&self.message)
+ }
+}
+
+impl StdError for Error {
+ fn source(&self) -> Option<&(dyn StdError + 'static)> {
+ Some(&self.source)
+ }
+}
+
+macro_rules! err {
+ ($io_error:expr, $fmt:expr $(, $path:expr)* $(,)?) => {
+ Err(Error {
+ source: $io_error,
+ message: format!($fmt $(, $path.display())*),
+ })
+ }
+}
+
+pub(crate) fn copy(from: impl AsRef<Path>, to: impl AsRef<Path>) -> Result<u64> {
+ let from = from.as_ref();
+ let to = to.as_ref();
+ match std::fs::copy(from, to) {
+ Ok(n) => Ok(n),
+ Err(e) => err!(e, "Failed to copy `{}` -> `{}`", from, to),
+ }
+}
+
+pub(crate) fn create_dir_all(path: impl AsRef<Path>) -> Result<()> {
+ let path = path.as_ref();
+ match std::fs::create_dir_all(path) {
+ Ok(()) => Ok(()),
+ Err(e) => err!(e, "Failed to create directory `{}`", path),
+ }
+}
+
+pub(crate) fn current_dir() -> Result<PathBuf> {
+ match std::env::current_dir() {
+ Ok(dir) => Ok(dir),
+ Err(e) => err!(e, "Failed to determine current directory"),
+ }
+}
+
+pub(crate) fn read(path: impl AsRef<Path>) -> Result<Vec<u8>> {
+ let path = path.as_ref();
+ match std::fs::read(path) {
+ Ok(string) => Ok(string),
+ Err(e) => err!(e, "Failed to read file `{}`", path),
+ }
+}
+
+pub(crate) fn read_stdin() -> Result<Vec<u8>> {
+ let mut bytes = Vec::new();
+ match io::stdin().read_to_end(&mut bytes) {
+ Ok(_len) => Ok(bytes),
+ Err(e) => err!(e, "Failed to read input from stdin"),
+ }
+}
+
+pub(crate) fn remove_file(path: impl AsRef<Path>) -> Result<()> {
+ let path = path.as_ref();
+ match std::fs::remove_file(path) {
+ Ok(()) => Ok(()),
+ Err(e) => err!(e, "Failed to remove file `{}`", path),
+ }
+}
+
+pub(crate) fn remove_dir(path: impl AsRef<Path>) -> Result<()> {
+ let path = path.as_ref();
+ match std::fs::remove_dir(path) {
+ Ok(()) => Ok(()),
+ Err(e) => err!(e, "Failed to remove directory `{}`", path),
+ }
+}
+
+fn symlink<'a>(
+ src: &'a Path,
+ dst: &'a Path,
+ fun: fn(&'a Path, &'a Path) -> io::Result<()>,
+) -> Result<()> {
+ match fun(src, dst) {
+ Ok(()) => Ok(()),
+ Err(e) => err!(
+ e,
+ "Failed to create symlink `{}` pointing to `{}`",
+ dst,
+ src,
+ ),
+ }
+}
+
+#[cfg(unix)]
+#[allow(unused_imports)]
+pub(crate) use self::symlink_file as symlink_dir;
+
+#[cfg(unix)]
+pub(crate) fn symlink_file(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> Result<()> {
+ symlink(src.as_ref(), dst.as_ref(), std::os::unix::fs::symlink)
+}
+
+#[cfg(windows)]
+pub(crate) fn symlink_file(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> Result<()> {
+ symlink(
+ src.as_ref(),
+ dst.as_ref(),
+ std::os::windows::fs::symlink_file,
+ )
+}
+
+#[cfg(windows)]
+pub(crate) fn symlink_dir(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> Result<()> {
+ symlink(
+ src.as_ref(),
+ dst.as_ref(),
+ std::os::windows::fs::symlink_dir,
+ )
+}
+
+pub(crate) fn write(path: impl AsRef<Path>, contents: impl AsRef<[u8]>) -> Result<()> {
+ let path = path.as_ref();
+ match std::fs::write(path, contents) {
+ Ok(()) => Ok(()),
+ Err(e) => err!(e, "Failed to write file `{}`", path),
+ }
+}
diff --git a/gen/src/ifndef.rs b/gen/src/ifndef.rs
new file mode 100644
index 0000000..b436266
--- /dev/null
+++ b/gen/src/ifndef.rs
@@ -0,0 +1,46 @@
+use crate::gen::include::HEADER;
+use crate::gen::out::Content;
+
+pub(super) fn write(out: &mut Content, needed: bool, guard: &str) {
+ let ifndef = format!("#ifndef {}", guard);
+ let define = format!("#define {}", guard);
+ let endif = format!("#endif // {}", guard);
+
+ let mut offset = 0;
+ loop {
+ let begin = find_line(offset, &ifndef);
+ let end = find_line(offset, &endif);
+ if let (Some(begin), Some(end)) = (begin, end) {
+ if !needed {
+ return;
+ }
+ out.next_section();
+ if offset == 0 {
+ writeln!(out, "{}", ifndef);
+ writeln!(out, "{}", define);
+ }
+ for line in HEADER[begin + ifndef.len()..end].trim().lines() {
+ if line != define && !line.trim_start().starts_with("//") {
+ writeln!(out, "{}", line);
+ }
+ }
+ offset = end + endif.len();
+ } else if offset == 0 {
+ panic!("not found in cxx.h header: {}", guard)
+ } else {
+ writeln!(out, "{}", endif);
+ return;
+ }
+ }
+}
+
+fn find_line(mut offset: usize, line: &str) -> Option<usize> {
+ loop {
+ offset += HEADER[offset..].find(line)?;
+ let rest = &HEADER[offset + line.len()..];
+ if rest.starts_with('\n') || rest.starts_with('\r') {
+ return Some(offset);
+ }
+ offset += line.len();
+ }
+}
diff --git a/gen/src/include.rs b/gen/src/include.rs
index 4309c9c..cf718da 100644
--- a/gen/src/include.rs
+++ b/gen/src/include.rs
@@ -1,55 +1,26 @@
-use crate::gen::out::OutFile;
-use std::fmt::{self, Display};
+use crate::gen::out::{Content, OutFile};
+use crate::syntax::{self, IncludeKind};
+use std::ops::{Deref, DerefMut};
+/// The complete contents of the "rust/cxx.h" header.
pub static HEADER: &str = include_str!("include/cxx.h");
-pub(super) fn write(out: &mut OutFile, needed: bool, guard: &str) {
- let ifndef = format!("#ifndef {}", guard);
- let define = format!("#define {}", guard);
- let endif = format!("#endif // {}", guard);
-
- let mut offset = 0;
- loop {
- let begin = find_line(offset, &ifndef);
- let end = find_line(offset, &endif);
- if let (Some(begin), Some(end)) = (begin, end) {
- if !needed {
- return;
- }
- out.next_section();
- if offset == 0 {
- writeln!(out, "{}", ifndef);
- writeln!(out, "{}", define);
- }
- for line in HEADER[begin + ifndef.len()..end].trim().lines() {
- if line != define && !line.trim_start().starts_with("//") {
- writeln!(out, "{}", line);
- }
- }
- offset = end + endif.len();
- } else if offset == 0 {
- panic!("not found in cxx.h header: {}", guard)
- } else {
- writeln!(out, "{}", endif);
- return;
- }
- }
-}
-
-fn find_line(mut offset: usize, line: &str) -> Option<usize> {
- loop {
- offset += HEADER[offset..].find(line)?;
- let rest = &HEADER[offset + line.len()..];
- if rest.starts_with('\n') || rest.starts_with('\r') {
- return Some(offset);
- }
- offset += line.len();
- }
+/// A header to #include.
+///
+/// The cxxbridge tool does not parse or even require the given paths to exist;
+/// they simply go into the generated C++ code as #include lines.
+#[derive(Clone, PartialEq, Debug)]
+pub struct Include {
+ /// The header's path, not including the enclosing quotation marks or angle
+ /// brackets.
+ pub path: String,
+ /// Whether to emit `#include "path"` or `#include <path>`.
+ pub kind: IncludeKind,
}
#[derive(Default, PartialEq)]
-pub struct Includes {
- custom: Vec<String>,
+pub struct Includes<'a> {
+ pub custom: Vec<Include>,
pub array: bool,
pub cstddef: bool,
pub cstdint: bool,
@@ -61,75 +32,105 @@
pub type_traits: bool,
pub utility: bool,
pub vector: bool,
- pub base_tsd: bool,
+ pub basetsd: bool,
+ pub content: Content<'a>,
}
-impl Includes {
+impl<'a> Includes<'a> {
pub fn new() -> Self {
Includes::default()
}
- pub fn insert(&mut self, include: impl AsRef<str>) {
- self.custom.push(include.as_ref().to_owned());
+ pub fn insert(&mut self, include: impl Into<Include>) {
+ self.custom.push(include.into());
}
}
-impl Extend<String> for Includes {
- fn extend<I: IntoIterator<Item = String>>(&mut self, iter: I) {
- self.custom.extend(iter);
- }
-}
+pub(super) fn write(out: &mut OutFile) {
+ let header = out.header;
+ let include = &mut out.include;
+ let out = &mut include.content;
-impl Display for Includes {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- for include in &self.custom {
- if include.starts_with('<') && include.ends_with('>') {
- writeln!(f, "#include {}", include)?;
- } else {
- writeln!(f, "#include \"{}\"", include.escape_default())?;
+ if header {
+ writeln!(out, "#pragma once");
+ }
+
+ for include in &include.custom {
+ match include.kind {
+ IncludeKind::Quoted => {
+ writeln!(out, "#include \"{}\"", include.path.escape_default());
+ }
+ IncludeKind::Bracketed => {
+ writeln!(out, "#include <{}>", include.path);
}
}
- if self.array {
- writeln!(f, "#include <array>")?;
+ }
+
+ if include.array {
+ writeln!(out, "#include <array>");
+ }
+ if include.cstddef {
+ writeln!(out, "#include <cstddef>");
+ }
+ if include.cstdint {
+ writeln!(out, "#include <cstdint>");
+ }
+ if include.cstring {
+ writeln!(out, "#include <cstring>");
+ }
+ if include.exception {
+ writeln!(out, "#include <exception>");
+ }
+ if include.memory {
+ writeln!(out, "#include <memory>");
+ }
+ if include.new {
+ writeln!(out, "#include <new>");
+ }
+ if include.string {
+ writeln!(out, "#include <string>");
+ }
+ if include.type_traits {
+ writeln!(out, "#include <type_traits>");
+ }
+ if include.utility {
+ writeln!(out, "#include <utility>");
+ }
+ if include.vector {
+ writeln!(out, "#include <vector>");
+ }
+ if include.basetsd {
+ writeln!(out, "#if defined(_WIN32)");
+ writeln!(out, "#include <basetsd.h>");
+ writeln!(out, "#endif");
+ }
+}
+
+impl<'i, 'a> Extend<&'i Include> for Includes<'a> {
+ fn extend<I: IntoIterator<Item = &'i Include>>(&mut self, iter: I) {
+ self.custom.extend(iter.into_iter().cloned());
+ }
+}
+
+impl<'i> From<&'i syntax::Include> for Include {
+ fn from(include: &syntax::Include) -> Self {
+ Include {
+ path: include.path.clone(),
+ kind: include.kind,
}
- if self.cstddef {
- writeln!(f, "#include <cstddef>")?;
- }
- if self.cstdint {
- writeln!(f, "#include <cstdint>")?;
- }
- if self.cstring {
- writeln!(f, "#include <cstring>")?;
- }
- if self.exception {
- writeln!(f, "#include <exception>")?;
- }
- if self.memory {
- writeln!(f, "#include <memory>")?;
- }
- if self.new {
- writeln!(f, "#include <new>")?;
- }
- if self.string {
- writeln!(f, "#include <string>")?;
- }
- if self.type_traits {
- writeln!(f, "#include <type_traits>")?;
- }
- if self.utility {
- writeln!(f, "#include <utility>")?;
- }
- if self.vector {
- writeln!(f, "#include <vector>")?;
- }
- if self.base_tsd {
- writeln!(f, "#if defined(_WIN32)")?;
- writeln!(f, "#include <BaseTsd.h>")?;
- writeln!(f, "#endif")?;
- }
- if *self != Self::default() {
- writeln!(f)?;
- }
- Ok(())
+ }
+}
+
+impl<'a> Deref for Includes<'a> {
+ type Target = Content<'a>;
+
+ fn deref(&self) -> &Self::Target {
+ &self.content
+ }
+}
+
+impl<'a> DerefMut for Includes<'a> {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.content
}
}
diff --git a/gen/src/mod.rs b/gen/src/mod.rs
index 710bca2..3d12c71 100644
--- a/gen/src/mod.rs
+++ b/gen/src/mod.rs
@@ -1,69 +1,150 @@
// Functionality that is shared between the cxx_build::bridge entry point and
// the cxxbridge CLI command.
-mod error;
-mod find;
+mod block;
+mod builtin;
+mod check;
+pub(super) mod error;
+mod file;
+pub(super) mod fs;
+mod ifndef;
pub(super) mod include;
+mod namespace;
+mod nested;
pub(super) mod out;
mod write;
-#[cfg(test)]
-mod tests;
-
-use self::error::{format_err, Error, Result};
-use crate::syntax::namespace::Namespace;
+pub(super) use self::error::Error;
+use self::error::{format_err, Result};
+use self::file::File;
+use self::include::Include;
use crate::syntax::report::Errors;
-use crate::syntax::{self, check, Types};
-use std::fs;
+use crate::syntax::{self, Types};
use std::path::Path;
-use syn::Item;
-struct Input {
- namespace: Namespace,
- module: Vec<Item>,
-}
-
-#[derive(Default)]
-pub(super) struct Opt {
- /// Any additional headers to #include
- pub include: Vec<String>,
- /// Whether to set __attribute__((visibility("default")))
- /// or similar annotations on function implementations.
+/// Options for C++ code generation.
+///
+/// We expect options to be added over time, so this is a non-exhaustive struct.
+/// To instantiate one you need to crate a default value and mutate those fields
+/// that you want to modify.
+///
+/// ```
+/// # use cxx_gen::Opt;
+/// #
+/// let impl_annotations = r#"__attribute__((visibility("default")))"#.to_owned();
+///
+/// let mut opt = Opt::default();
+/// opt.cxx_impl_annotations = Some(impl_annotations);
+/// ```
+#[non_exhaustive]
+pub struct Opt {
+ /// Any additional headers to #include. The cxxbridge tool does not parse or
+ /// even require the given paths to exist; they simply go into the generated
+ /// C++ code as #include lines.
+ pub include: Vec<Include>,
+ /// Optional annotation for implementations of C++ function wrappers that
+ /// may be exposed to Rust. You may for example need to provide
+ /// `__declspec(dllexport)` or `__attribute__((visibility("default")))` if
+ /// Rust code from one shared object or executable depends on these C++
+ /// functions in another.
pub cxx_impl_annotations: Option<String>,
+
+ pub(super) gen_header: bool,
+ pub(super) gen_implementation: bool,
+ pub(super) allow_dot_includes: bool,
}
-pub(super) fn do_generate_bridge(path: &Path, opt: Opt) -> Vec<u8> {
- let header = false;
- generate_from_path(path, opt, header)
+/// Results of code generation.
+#[derive(Default)]
+pub struct GeneratedCode {
+ /// The bytes of a C++ header file.
+ pub header: Vec<u8>,
+ /// The bytes of a C++ implementation file (e.g. .cc, cpp etc.)
+ pub implementation: Vec<u8>,
}
-pub(super) fn do_generate_header(path: &Path, opt: Opt) -> Vec<u8> {
- let header = true;
- generate_from_path(path, opt, header)
+impl Default for Opt {
+ fn default() -> Self {
+ Opt {
+ include: Vec::new(),
+ cxx_impl_annotations: None,
+ gen_header: true,
+ gen_implementation: true,
+ allow_dot_includes: true,
+ }
+ }
}
-fn generate_from_path(path: &Path, opt: Opt, header: bool) -> Vec<u8> {
- let source = match fs::read_to_string(path) {
+pub(super) fn generate_from_path(path: &Path, opt: &Opt) -> GeneratedCode {
+ let source = match read_to_string(path) {
Ok(source) => source,
- Err(err) => format_err(path, "", Error::Io(err)),
+ Err(err) => format_err(path, "", err),
};
- match generate(&source, opt, header) {
+ match generate_from_string(&source, opt) {
Ok(out) => out,
Err(err) => format_err(path, &source, err),
}
}
-fn generate(source: &str, opt: Opt, header: bool) -> Result<Vec<u8>> {
+fn read_to_string(path: &Path) -> Result<String> {
+ let bytes = if path == Path::new("-") {
+ fs::read_stdin()
+ } else {
+ fs::read(path)
+ }?;
+ match String::from_utf8(bytes) {
+ Ok(string) => Ok(string),
+ Err(err) => Err(Error::Utf8(path.to_owned(), err.utf8_error())),
+ }
+}
+
+fn generate_from_string(source: &str, opt: &Opt) -> Result<GeneratedCode> {
+ let mut source = source;
+ if source.starts_with("#!") && !source.starts_with("#![") {
+ let shebang_end = source.find('\n').unwrap_or(source.len());
+ source = &source[shebang_end..];
+ }
proc_macro2::fallback::force();
+ let syntax: File = syn::parse_str(source)?;
+ generate(syntax, opt)
+}
+
+pub(super) fn generate(syntax: File, opt: &Opt) -> Result<GeneratedCode> {
+ if syntax.modules.is_empty() {
+ return Err(Error::NoBridgeMod);
+ }
+
+ let ref mut apis = Vec::new();
let ref mut errors = Errors::new();
- let syntax = syn::parse_file(&source)?;
- let bridge = find::find_bridge_mod(syntax)?;
- let ref namespace = bridge.namespace;
- let ref apis = syntax::parse_items(errors, bridge.module);
+ for bridge in syntax.modules {
+ let ref namespace = bridge.namespace;
+ let trusted = bridge.unsafety.is_some();
+ apis.extend(syntax::parse_items(
+ errors,
+ bridge.content,
+ trusted,
+ namespace,
+ ));
+ }
+
let ref types = Types::collect(errors, apis);
+ check::precheck(errors, apis, opt);
errors.propagate()?;
- check::typecheck(errors, namespace, apis, types);
+ check::typecheck(errors, apis, types);
errors.propagate()?;
- let out = write::gen(namespace, apis, types, opt, header);
- Ok(out.content())
+
+ // Some callers may wish to generate both header and implementation from the
+ // same token stream to avoid parsing twice. Others only need to generate
+ // one or the other.
+ let (mut header, mut implementation) = Default::default();
+ if opt.gen_header {
+ header = write::gen(apis, types, opt, true);
+ }
+ if opt.gen_implementation {
+ implementation = write::gen(apis, types, opt, false);
+ }
+ Ok(GeneratedCode {
+ header,
+ implementation,
+ })
}
diff --git a/gen/src/namespace.rs b/gen/src/namespace.rs
new file mode 100644
index 0000000..b79c38f
--- /dev/null
+++ b/gen/src/namespace.rs
@@ -0,0 +1,14 @@
+use crate::syntax::namespace::Namespace;
+use crate::syntax::Api;
+
+impl Api {
+ pub fn namespace(&self) -> &Namespace {
+ match self {
+ Api::CxxFunction(efn) | Api::RustFunction(efn) => &efn.name.namespace,
+ Api::CxxType(ety) | Api::RustType(ety) => &ety.name.namespace,
+ Api::Enum(enm) => &enm.name.namespace,
+ Api::Struct(strct) => &strct.name.namespace,
+ Api::Impl(_) | Api::Include(_) | Api::TypeAlias(_) => Default::default(),
+ }
+ }
+}
diff --git a/gen/src/nested.rs b/gen/src/nested.rs
new file mode 100644
index 0000000..22b0c9f
--- /dev/null
+++ b/gen/src/nested.rs
@@ -0,0 +1,136 @@
+use crate::syntax::Api;
+use proc_macro2::Ident;
+use std::collections::HashMap as Map;
+
+pub struct NamespaceEntries<'a> {
+ direct: Vec<&'a Api>,
+ nested: Vec<(&'a Ident, NamespaceEntries<'a>)>,
+}
+
+impl<'a> NamespaceEntries<'a> {
+ pub fn new(apis: Vec<&'a Api>) -> Self {
+ sort_by_inner_namespace(apis, 0)
+ }
+
+ pub fn direct_content(&self) -> &[&'a Api] {
+ &self.direct
+ }
+
+ pub fn nested_content(&self) -> impl Iterator<Item = (&'a Ident, &NamespaceEntries<'a>)> {
+ self.nested.iter().map(|(k, entries)| (*k, entries))
+ }
+}
+
+fn sort_by_inner_namespace(apis: Vec<&Api>, depth: usize) -> NamespaceEntries {
+ let mut direct = Vec::new();
+ let mut nested_namespaces = Vec::new();
+ let mut index_of_namespace = Map::new();
+
+ for api in &apis {
+ if let Some(first_ns_elem) = api.namespace().iter().nth(depth) {
+ match index_of_namespace.get(first_ns_elem) {
+ None => {
+ index_of_namespace.insert(first_ns_elem, nested_namespaces.len());
+ nested_namespaces.push((first_ns_elem, vec![*api]));
+ }
+ Some(&index) => nested_namespaces[index].1.push(*api),
+ }
+ continue;
+ }
+ direct.push(*api);
+ }
+
+ let nested = nested_namespaces
+ .into_iter()
+ .map(|(k, apis)| (k, sort_by_inner_namespace(apis, depth + 1)))
+ .collect();
+
+ NamespaceEntries { direct, nested }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::NamespaceEntries;
+ use crate::syntax::namespace::Namespace;
+ use crate::syntax::{Api, Doc, ExternType, Pair};
+ use proc_macro2::{Ident, Span};
+ use std::iter::FromIterator;
+ use syn::Token;
+
+ #[test]
+ fn test_ns_entries_sort() {
+ let apis = &[
+ make_api(None, "C"),
+ make_api(None, "A"),
+ make_api(Some("G"), "E"),
+ make_api(Some("D"), "F"),
+ make_api(Some("G"), "H"),
+ make_api(Some("D::K"), "L"),
+ make_api(Some("D::K"), "M"),
+ make_api(None, "B"),
+ make_api(Some("D"), "I"),
+ make_api(Some("D"), "J"),
+ ];
+
+ let root = NamespaceEntries::new(Vec::from_iter(apis));
+
+ // ::
+ let root_direct = root.direct_content();
+ assert_eq!(root_direct.len(), 3);
+ assert_ident(root_direct[0], "C");
+ assert_ident(root_direct[1], "A");
+ assert_ident(root_direct[2], "B");
+
+ let mut root_nested = root.nested_content();
+ let (id, g) = root_nested.next().unwrap();
+ assert_eq!(id, "G");
+ let (id, d) = root_nested.next().unwrap();
+ assert_eq!(id, "D");
+ assert!(root_nested.next().is_none());
+
+ // ::G
+ let g_direct = g.direct_content();
+ assert_eq!(g_direct.len(), 2);
+ assert_ident(g_direct[0], "E");
+ assert_ident(g_direct[1], "H");
+
+ let mut g_nested = g.nested_content();
+ assert!(g_nested.next().is_none());
+
+ // ::D
+ let d_direct = d.direct_content();
+ assert_eq!(d_direct.len(), 3);
+ assert_ident(d_direct[0], "F");
+ assert_ident(d_direct[1], "I");
+ assert_ident(d_direct[2], "J");
+
+ let mut d_nested = d.nested_content();
+ let (id, k) = d_nested.next().unwrap();
+ assert_eq!(id, "K");
+
+ // ::D::K
+ let k_direct = k.direct_content();
+ assert_eq!(k_direct.len(), 2);
+ assert_ident(k_direct[0], "L");
+ assert_ident(k_direct[1], "M");
+ }
+
+ fn assert_ident(api: &Api, expected: &str) {
+ if let Api::CxxType(cxx_type) = api {
+ assert_eq!(cxx_type.name.cxx, expected);
+ } else {
+ unreachable!()
+ }
+ }
+
+ fn make_api(ns: Option<&str>, ident: &str) -> Api {
+ let ns = ns.map_or(Namespace::ROOT, |ns| syn::parse_str(ns).unwrap());
+ Api::CxxType(ExternType {
+ doc: Doc::new(),
+ type_token: Token),
+ name: Pair::new(ns, Ident::new(ident, Span::call_site())),
+ semi_token: Token),
+ trusted: false,
+ })
+ }
+}
diff --git a/gen/src/out.rs b/gen/src/out.rs
index 08bf85f..bf880cc 100644
--- a/gen/src/out.rs
+++ b/gen/src/out.rs
@@ -1,59 +1,63 @@
+use crate::gen::block::Block;
+use crate::gen::builtin::Builtins;
use crate::gen::include::Includes;
+use crate::gen::Opt;
use crate::syntax::namespace::Namespace;
+use crate::syntax::Types;
use std::cell::RefCell;
use std::fmt::{self, Arguments, Write};
-pub(crate) struct OutFile {
- pub namespace: Namespace,
+pub(crate) struct OutFile<'a> {
pub header: bool,
- pub include: Includes,
- content: RefCell<Content>,
+ pub opt: &'a Opt,
+ pub types: &'a Types<'a>,
+ pub include: Includes<'a>,
+ pub builtin: Builtins<'a>,
+ content: RefCell<Content<'a>>,
}
-struct Content {
- bytes: Vec<u8>,
+#[derive(Default)]
+pub struct Content<'a> {
+ bytes: String,
+ namespace: &'a Namespace,
+ blocks: Vec<BlockBoundary<'a>>,
section_pending: bool,
- blocks_pending: Vec<&'static str>,
+ blocks_pending: usize,
}
-impl OutFile {
- pub fn new(namespace: Namespace, header: bool) -> Self {
+#[derive(Copy, Clone, PartialEq, Debug)]
+enum BlockBoundary<'a> {
+ Begin(Block<'a>),
+ End(Block<'a>),
+}
+
+impl<'a> OutFile<'a> {
+ pub fn new(header: bool, opt: &'a Opt, types: &'a Types) -> Self {
OutFile {
- namespace,
header,
+ opt,
+ types,
include: Includes::new(),
- content: RefCell::new(Content {
- bytes: Vec::new(),
- section_pending: false,
- blocks_pending: Vec::new(),
- }),
+ builtin: Builtins::new(),
+ content: RefCell::new(Content::new()),
}
}
// Write a blank line if the preceding section had any contents.
pub fn next_section(&mut self) {
- let content = self.content.get_mut();
- content.section_pending = true;
+ self.content.get_mut().next_section();
}
- pub fn begin_block(&mut self, block: &'static str) {
- let content = self.content.get_mut();
- content.blocks_pending.push(block);
+ pub fn begin_block(&mut self, block: Block<'a>) {
+ self.content.get_mut().begin_block(block);
}
- pub fn end_block(&mut self, block: &'static str) {
- let content = self.content.get_mut();
- if content.blocks_pending.pop().is_none() {
- content.bytes.extend_from_slice(b"} // ");
- content.bytes.extend_from_slice(block.as_bytes());
- content.bytes.push(b'\n');
- content.section_pending = true;
- }
+ pub fn end_block(&mut self, block: Block<'a>) {
+ self.content.get_mut().end_block(block);
}
- pub fn prepend(&mut self, section: String) {
- let content = self.content.get_mut();
- content.bytes.splice(..0, section.into_bytes());
+ pub fn set_namespace(&mut self, namespace: &'a Namespace) {
+ self.content.get_mut().set_namespace(namespace);
}
pub fn write_fmt(&self, args: Arguments) {
@@ -61,31 +65,146 @@
Write::write_fmt(content, args).unwrap();
}
- pub fn content(&self) -> Vec<u8> {
- self.content.borrow().bytes.clone()
+ pub fn content(&mut self) -> Vec<u8> {
+ self.flush();
+ let include = &self.include.content.bytes;
+ let builtin = &self.builtin.content.bytes;
+ let content = &self.content.get_mut().bytes;
+ let len = include.len() + builtin.len() + content.len() + 2;
+ let mut out = String::with_capacity(len);
+ out.push_str(include);
+ if !out.is_empty() && !builtin.is_empty() {
+ out.push('\n');
+ }
+ out.push_str(builtin);
+ if !out.is_empty() && !content.is_empty() {
+ out.push('\n');
+ }
+ out.push_str(content);
+ if out.is_empty() {
+ out.push_str("// empty\n");
+ }
+ out.into_bytes()
+ }
+
+ fn flush(&mut self) {
+ self.include.content.flush();
+ self.builtin.content.flush();
+ self.content.get_mut().flush();
}
}
-impl Write for Content {
+impl<'a> Write for Content<'a> {
fn write_str(&mut self, s: &str) -> fmt::Result {
- if !s.is_empty() {
- if !self.blocks_pending.is_empty() {
- if !self.bytes.is_empty() {
- self.bytes.push(b'\n');
- }
- for block in self.blocks_pending.drain(..) {
- self.bytes.extend_from_slice(block.as_bytes());
- self.bytes.extend_from_slice(b" {\n");
- }
- self.section_pending = false;
- } else if self.section_pending {
- if !self.bytes.is_empty() {
- self.bytes.push(b'\n');
- }
- self.section_pending = false;
- }
- self.bytes.extend_from_slice(s.as_bytes());
- }
+ self.write(s);
Ok(())
}
}
+
+impl<'a> PartialEq for Content<'a> {
+ fn eq(&self, _other: &Content) -> bool {
+ true
+ }
+}
+
+impl<'a> Content<'a> {
+ fn new() -> Self {
+ Content::default()
+ }
+
+ pub fn next_section(&mut self) {
+ self.section_pending = true;
+ }
+
+ pub fn begin_block(&mut self, block: Block<'a>) {
+ self.push_block_boundary(BlockBoundary::Begin(block));
+ }
+
+ pub fn end_block(&mut self, block: Block<'a>) {
+ self.push_block_boundary(BlockBoundary::End(block));
+ }
+
+ pub fn set_namespace(&mut self, namespace: &'a Namespace) {
+ for name in self.namespace.iter().rev() {
+ self.end_block(Block::UserDefinedNamespace(name));
+ }
+ for name in namespace {
+ self.begin_block(Block::UserDefinedNamespace(name));
+ }
+ self.namespace = namespace;
+ }
+
+ pub fn write_fmt(&mut self, args: Arguments) {
+ Write::write_fmt(self, args).unwrap();
+ }
+
+ fn write(&mut self, b: &str) {
+ if !b.is_empty() {
+ if self.blocks_pending > 0 {
+ self.flush_blocks();
+ }
+ if self.section_pending && !self.bytes.is_empty() {
+ self.bytes.push('\n');
+ }
+ self.bytes.push_str(b);
+ self.section_pending = false;
+ self.blocks_pending = 0;
+ }
+ }
+
+ fn push_block_boundary(&mut self, boundary: BlockBoundary<'a>) {
+ if self.blocks_pending > 0 && boundary == self.blocks.last().unwrap().rev() {
+ self.blocks.pop();
+ self.blocks_pending -= 1;
+ } else {
+ self.blocks.push(boundary);
+ self.blocks_pending += 1;
+ }
+ }
+
+ fn flush(&mut self) {
+ self.set_namespace(Default::default());
+ if self.blocks_pending > 0 {
+ self.flush_blocks();
+ }
+ }
+
+ fn flush_blocks(&mut self) {
+ self.section_pending = !self.bytes.is_empty();
+ let mut read = self.blocks.len() - self.blocks_pending;
+ let mut write = read;
+
+ while read < self.blocks.len() {
+ match self.blocks[read] {
+ BlockBoundary::Begin(begin_block) => {
+ if self.section_pending {
+ self.bytes.push('\n');
+ self.section_pending = false;
+ }
+ Block::write_begin(begin_block, &mut self.bytes);
+ self.blocks[write] = BlockBoundary::Begin(begin_block);
+ write += 1;
+ }
+ BlockBoundary::End(end_block) => {
+ write = write.checked_sub(1).unwrap();
+ let begin_block = self.blocks[write];
+ assert_eq!(begin_block, BlockBoundary::Begin(end_block));
+ Block::write_end(end_block, &mut self.bytes);
+ self.section_pending = true;
+ }
+ }
+ read += 1;
+ }
+
+ self.blocks.truncate(write);
+ }
+}
+
+impl<'a> BlockBoundary<'a> {
+ fn rev(self) -> BlockBoundary<'a> {
+ match self {
+ BlockBoundary::Begin(block) => BlockBoundary::End(block),
+ BlockBoundary::End(block) => BlockBoundary::Begin(block),
+ }
+ }
+}
diff --git a/gen/src/tests.rs b/gen/src/tests.rs
deleted file mode 100644
index 0e7a910..0000000
--- a/gen/src/tests.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use crate::gen::{generate, Opt};
-
-const CPP_EXAMPLE: &'static str = r#"
- #[cxx::bridge]
- mod ffi {
- extern "C" {
- pub fn do_cpp_thing(foo: &str);
- }
- }
- "#;
-
-#[test]
-fn test_cpp() {
- let opts = Opt {
- include: Vec::new(),
- cxx_impl_annotations: None,
- };
- let output = generate(CPP_EXAMPLE, opts, false).unwrap();
- let output = std::str::from_utf8(&output).unwrap();
- // To avoid continual breakage we won't test every byte.
- // Let's look for the major features.
- assert!(output.contains("void cxxbridge03$do_cpp_thing(::rust::Str::Repr foo)"));
-}
-
-#[test]
-fn test_annotation() {
- let opts = Opt {
- include: Vec::new(),
- cxx_impl_annotations: Some("ANNOTATION".to_string()),
- };
- let output = generate(CPP_EXAMPLE, opts, false).unwrap();
- let output = std::str::from_utf8(&output).unwrap();
- assert!(output.contains("ANNOTATION void cxxbridge03$do_cpp_thing(::rust::Str::Repr foo)"));
-}
diff --git a/gen/src/write.rs b/gen/src/write.rs
index 04d8e3e..5fe8ee3 100644
--- a/gen/src/write.rs
+++ b/gen/src/write.rs
@@ -1,79 +1,111 @@
+use crate::gen::block::Block;
+use crate::gen::nested::NamespaceEntries;
use crate::gen::out::OutFile;
-use crate::gen::{include, Opt};
+use crate::gen::{builtin, include, Opt};
use crate::syntax::atom::Atom::{self, *};
-use crate::syntax::namespace::Namespace;
use crate::syntax::symbol::Symbol;
-use crate::syntax::{mangle, Api, Enum, ExternFn, ExternType, Signature, Struct, Type, Types, Var};
+use crate::syntax::{
+ mangle, Api, Enum, ExternFn, ExternType, Pair, ResolvableName, Signature, Struct, Type, Types,
+ Var,
+};
use proc_macro2::Ident;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
-pub(super) fn gen(
- namespace: &Namespace,
- apis: &[Api],
- types: &Types,
- opt: Opt,
- header: bool,
-) -> OutFile {
- let mut out_file = OutFile::new(namespace.clone(), header);
+pub(super) fn gen(apis: &[Api], types: &Types, opt: &Opt, header: bool) -> Vec<u8> {
+ let mut out_file = OutFile::new(header, opt, types);
let out = &mut out_file;
- if header {
- writeln!(out, "#pragma once");
- }
+ pick_includes_and_builtins(out, apis);
+ out.include.extend(&opt.include);
- out.include.extend(opt.include);
- for api in apis {
- if let Api::Include(include) = api {
- out.include.insert(include);
+ write_forward_declarations(out, apis);
+ write_data_structures(out, apis);
+ write_functions(out, apis);
+ write_generic_instantiations(out);
+
+ builtin::write(out);
+ include::write(out);
+
+ out_file.content()
+}
+
+fn write_forward_declarations(out: &mut OutFile, apis: &[Api]) {
+ let needs_forward_declaration = |api: &&Api| match api {
+ Api::Struct(_) | Api::CxxType(_) | Api::RustType(_) => true,
+ Api::Enum(enm) => !out.types.cxx.contains(&enm.name.rust),
+ _ => false,
+ };
+
+ let apis_by_namespace =
+ NamespaceEntries::new(apis.iter().filter(needs_forward_declaration).collect());
+
+ write(out, &apis_by_namespace, 0);
+
+ fn write(out: &mut OutFile, ns_entries: &NamespaceEntries, indent: usize) {
+ let apis = ns_entries.direct_content();
+
+ for api in apis {
+ write!(out, "{:1$}", "", indent);
+ match api {
+ Api::Struct(strct) => write_struct_decl(out, &strct.name.cxx),
+ Api::Enum(enm) => write_enum_decl(out, enm),
+ Api::CxxType(ety) => write_struct_using(out, &ety.name),
+ Api::RustType(ety) => write_struct_decl(out, &ety.name.cxx),
+ _ => unreachable!(),
+ }
+ }
+
+ for (namespace, nested_ns_entries) in ns_entries.nested_content() {
+ writeln!(out, "{:2$}namespace {} {{", "", namespace, indent);
+ write(out, nested_ns_entries, indent + 2);
+ writeln!(out, "{:1$}}}", "", indent);
}
}
+}
- write_includes(out, types);
- write_include_cxxbridge(out, apis, types);
-
- out.next_section();
- for name in namespace {
- writeln!(out, "namespace {} {{", name);
- }
-
- out.next_section();
- for api in apis {
- match api {
- Api::Struct(strct) => write_struct_decl(out, &strct.ident),
- Api::CxxType(ety) => write_struct_using(out, &ety.ident),
- Api::RustType(ety) => write_struct_decl(out, &ety.ident),
- _ => {}
- }
- }
-
+fn write_data_structures<'a>(out: &mut OutFile<'a>, apis: &'a [Api]) {
let mut methods_for_type = HashMap::new();
for api in apis {
- if let Api::RustFunction(efn) = api {
+ if let Api::CxxFunction(efn) | Api::RustFunction(efn) = api {
if let Some(receiver) = &efn.sig.receiver {
methods_for_type
- .entry(&receiver.ty)
+ .entry(&receiver.ty.rust)
.or_insert_with(Vec::new)
.push(efn);
}
}
}
+ let mut structs_written = HashSet::new();
+ let mut toposorted_structs = out.types.toposorted_structs.iter();
for api in apis {
match api {
- Api::Struct(strct) => {
- out.next_section();
- write_struct(out, strct);
+ Api::Struct(strct) if !structs_written.contains(&strct.name.rust) => {
+ for next in &mut toposorted_structs {
+ if !out.types.cxx.contains(&strct.name.rust) {
+ out.next_section();
+ let methods = methods_for_type
+ .get(&strct.name.rust)
+ .map(Vec::as_slice)
+ .unwrap_or_default();
+ write_struct(out, next, methods);
+ }
+ structs_written.insert(&next.name.rust);
+ if next.name.rust == strct.name.rust {
+ break;
+ }
+ }
}
Api::Enum(enm) => {
out.next_section();
- if types.cxx.contains(&enm.ident) {
+ if out.types.cxx.contains(&enm.name.rust) {
check_enum(out, enm);
} else {
write_enum(out, enm);
}
}
Api::RustType(ety) => {
- if let Some(methods) = methods_for_type.get(&ety.ident) {
+ if let Some(methods) = methods_for_type.get(&ety.name.rust) {
out.next_section();
write_struct_with_methods(out, ety, methods);
}
@@ -82,290 +114,162 @@
}
}
- if !header {
- out.begin_block("extern \"C\"");
- write_exception_glue(out, apis);
- for api in apis {
- let (efn, write): (_, fn(_, _, _, _)) = match api {
- Api::CxxFunction(efn) => (efn, write_cxx_function_shim),
- Api::RustFunction(efn) => (efn, write_rust_function_decl),
- _ => continue,
- };
- out.next_section();
- write(out, efn, types, &opt.cxx_impl_annotations);
+ out.next_section();
+ for api in apis {
+ if let Api::TypeAlias(ety) = api {
+ if out.types.required_trivial.contains_key(&ety.name.rust) {
+ check_trivial_extern_type(out, &ety.name)
+ }
}
- out.end_block("extern \"C\"");
+ }
+}
+
+fn write_functions<'a>(out: &mut OutFile<'a>, apis: &'a [Api]) {
+ if !out.header {
+ for api in apis {
+ match api {
+ Api::CxxFunction(efn) => write_cxx_function_shim(out, efn),
+ Api::RustFunction(efn) => write_rust_function_decl(out, efn),
+ _ => {}
+ }
+ }
}
for api in apis {
if let Api::RustFunction(efn) = api {
out.next_section();
- write_rust_function_shim(out, efn, types);
+ write_rust_function_shim(out, efn);
+ }
+ }
+}
+
+fn pick_includes_and_builtins(out: &mut OutFile, apis: &[Api]) {
+ for api in apis {
+ if let Api::Include(include) = api {
+ out.include.insert(include);
}
}
- out.next_section();
- for name in namespace.iter().rev() {
- writeln!(out, "}} // namespace {}", name);
- }
-
- if !header {
- out.next_section();
- write_generic_instantiations(out, types);
- }
-
- out.prepend(out.include.to_string());
-
- out_file
-}
-
-fn write_includes(out: &mut OutFile, types: &Types) {
- for ty in types {
+ for ty in out.types {
match ty {
- Type::Ident(ident) => match Atom::from(ident) {
+ Type::Ident(ident) => match Atom::from(&ident.rust) {
Some(U8) | Some(U16) | Some(U32) | Some(U64) | Some(I8) | Some(I16) | Some(I32)
| Some(I64) => out.include.cstdint = true,
Some(Usize) => out.include.cstddef = true,
+ Some(Isize) => out.builtin.rust_isize = true,
Some(CxxString) => out.include.string = true,
- Some(Bool) | Some(Isize) | Some(F32) | Some(F64) | Some(RustString) | None => {}
+ Some(RustString) => out.builtin.rust_string = true,
+ Some(Bool) | Some(F32) | Some(F64) | None => {}
},
- Type::RustBox(_) => out.include.type_traits = true,
+ Type::RustBox(_) => out.builtin.rust_box = true,
+ Type::RustVec(_) => out.builtin.rust_vec = true,
Type::UniquePtr(_) => out.include.memory = true,
+ Type::Str(_) => out.builtin.rust_str = true,
Type::CxxVector(_) => out.include.vector = true,
- Type::SliceRefU8(_) => out.include.cstdint = true,
- _ => {}
+ Type::Fn(_) => out.builtin.rust_fn = true,
+ Type::Slice(_) => out.builtin.rust_slice = true,
+ Type::SliceRefU8(_) => {
+ out.include.cstdint = true;
+ out.builtin.rust_slice = true;
+ }
+ Type::Ref(_) | Type::Void(_) => {}
}
}
}
-fn write_include_cxxbridge(out: &mut OutFile, apis: &[Api], types: &Types) {
- let mut needs_rust_string = false;
- let mut needs_rust_str = false;
- let mut needs_rust_slice = false;
- let mut needs_rust_box = false;
- let mut needs_rust_vec = false;
- let mut needs_rust_fn = false;
- let mut needs_rust_isize = false;
- for ty in types {
- match ty {
- Type::RustBox(_) => {
- out.include.new = true;
- out.include.type_traits = true;
- needs_rust_box = true;
- }
- Type::RustVec(_) => {
- out.include.array = true;
- out.include.new = true;
- out.include.type_traits = true;
- needs_rust_vec = true;
- }
- Type::Str(_) => {
- out.include.cstdint = true;
- out.include.string = true;
- needs_rust_str = true;
- }
- Type::Fn(_) => {
- needs_rust_fn = true;
- }
- Type::Slice(_) | Type::SliceRefU8(_) => {
- needs_rust_slice = true;
- }
- ty if ty == Isize => {
- out.include.base_tsd = true;
- needs_rust_isize = true;
- }
- ty if ty == RustString => {
- out.include.array = true;
- out.include.cstdint = true;
- out.include.string = true;
- needs_rust_string = true;
- }
- _ => {}
- }
- }
-
- let mut needs_rust_error = false;
- let mut needs_unsafe_bitcopy = false;
- let mut needs_manually_drop = false;
- let mut needs_maybe_uninit = false;
- let mut needs_trycatch = false;
- for api in apis {
- match api {
- Api::CxxFunction(efn) if !out.header => {
- if efn.throws {
- needs_trycatch = true;
- }
- for arg in &efn.args {
- let bitcopy = match arg.ty {
- Type::RustVec(_) => true,
- _ => arg.ty == RustString,
- };
- if bitcopy {
- needs_unsafe_bitcopy = true;
- break;
- }
- }
- }
- Api::RustFunction(efn) if !out.header => {
- if efn.throws {
- out.include.exception = true;
- needs_rust_error = true;
- }
- for arg in &efn.args {
- if arg.ty != RustString && types.needs_indirect_abi(&arg.ty) {
- needs_manually_drop = true;
- break;
- }
- }
- if let Some(ret) = &efn.ret {
- if types.needs_indirect_abi(ret) {
- needs_maybe_uninit = true;
- }
- }
- }
- _ => {}
- }
- }
-
- out.begin_block("namespace rust");
- out.begin_block("inline namespace cxxbridge03");
-
- if needs_rust_string
- || needs_rust_str
- || needs_rust_slice
- || needs_rust_box
- || needs_rust_vec
- || needs_rust_fn
- || needs_rust_error
- || needs_rust_isize
- || needs_unsafe_bitcopy
- || needs_manually_drop
- || needs_maybe_uninit
- || needs_trycatch
- {
- writeln!(out, "// #include \"rust/cxx.h\"");
- }
-
- if needs_rust_string || needs_rust_vec {
- out.next_section();
- writeln!(out, "struct unsafe_bitcopy_t;");
- }
-
- include::write(out, needs_rust_string, "CXXBRIDGE03_RUST_STRING");
- include::write(out, needs_rust_str, "CXXBRIDGE03_RUST_STR");
- include::write(out, needs_rust_slice, "CXXBRIDGE03_RUST_SLICE");
- include::write(out, needs_rust_box, "CXXBRIDGE03_RUST_BOX");
- include::write(out, needs_rust_vec, "CXXBRIDGE03_RUST_VEC");
- include::write(out, needs_rust_fn, "CXXBRIDGE03_RUST_FN");
- include::write(out, needs_rust_error, "CXXBRIDGE03_RUST_ERROR");
- include::write(out, needs_rust_isize, "CXXBRIDGE03_RUST_ISIZE");
- include::write(out, needs_unsafe_bitcopy, "CXXBRIDGE03_RUST_BITCOPY");
-
- if needs_manually_drop {
- out.next_section();
- out.include.utility = true;
- writeln!(out, "template <typename T>");
- writeln!(out, "union ManuallyDrop {{");
- writeln!(out, " T value;");
- writeln!(
- out,
- " ManuallyDrop(T &&value) : value(::std::move(value)) {{}}",
- );
- writeln!(out, " ~ManuallyDrop() {{}}");
- writeln!(out, "}};");
- }
-
- if needs_maybe_uninit {
- out.next_section();
- writeln!(out, "template <typename T>");
- writeln!(out, "union MaybeUninit {{");
- writeln!(out, " T value;");
- writeln!(out, " MaybeUninit() {{}}");
- writeln!(out, " ~MaybeUninit() {{}}");
- writeln!(out, "}};");
- }
-
- out.end_block("namespace cxxbridge03");
-
- if needs_trycatch {
- out.begin_block("namespace behavior");
- out.include.exception = true;
- out.include.type_traits = true;
- out.include.utility = true;
- writeln!(out, "class missing {{}};");
- writeln!(out, "missing trycatch(...);");
- writeln!(out);
- writeln!(out, "template <typename Try, typename Fail>");
- writeln!(out, "static typename std::enable_if<");
- writeln!(
- out,
- " std::is_same<decltype(trycatch(std::declval<Try>(), std::declval<Fail>())),",
- );
- writeln!(out, " missing>::value>::type");
- writeln!(out, "trycatch(Try &&func, Fail &&fail) noexcept try {{");
- writeln!(out, " func();");
- writeln!(out, "}} catch (const ::std::exception &e) {{");
- writeln!(out, " fail(e.what());");
- writeln!(out, "}}");
- out.end_block("namespace behavior");
- }
-
- out.end_block("namespace rust");
-}
-
-fn write_struct(out: &mut OutFile, strct: &Struct) {
+fn write_struct<'a>(out: &mut OutFile<'a>, strct: &'a Struct, methods: &[&ExternFn]) {
+ out.set_namespace(&strct.name.namespace);
+ let guard = format!("CXXBRIDGE05_STRUCT_{}", strct.name.to_symbol());
+ writeln!(out, "#ifndef {}", guard);
+ writeln!(out, "#define {}", guard);
for line in strct.doc.to_string().lines() {
writeln!(out, "//{}", line);
}
- writeln!(out, "struct {} final {{", strct.ident);
+ writeln!(out, "struct {} final {{", strct.name.cxx);
for field in &strct.fields {
write!(out, " ");
write_type_space(out, &field.ty);
writeln!(out, "{};", field.ident);
}
+ if !methods.is_empty() {
+ writeln!(out);
+ }
+ for method in methods {
+ write!(out, " ");
+ let sig = &method.sig;
+ let local_name = method.name.cxx.to_string();
+ write_rust_function_shim_decl(out, &local_name, sig, false);
+ writeln!(out, ";");
+ }
writeln!(out, "}};");
+ writeln!(out, "#endif // {}", guard);
}
fn write_struct_decl(out: &mut OutFile, ident: &Ident) {
writeln!(out, "struct {};", ident);
}
-fn write_struct_using(out: &mut OutFile, ident: &Ident) {
- writeln!(out, "using {} = {};", ident, ident);
+fn write_enum_decl(out: &mut OutFile, enm: &Enum) {
+ write!(out, "enum class {} : ", enm.name.cxx);
+ write_atom(out, enm.repr);
+ writeln!(out, ";");
}
-fn write_struct_with_methods(out: &mut OutFile, ety: &ExternType, methods: &[&ExternFn]) {
+fn write_struct_using(out: &mut OutFile, ident: &Pair) {
+ writeln!(out, "using {} = {};", ident.cxx, ident.to_fully_qualified());
+}
+
+fn write_struct_with_methods<'a>(
+ out: &mut OutFile<'a>,
+ ety: &'a ExternType,
+ methods: &[&ExternFn],
+) {
+ out.set_namespace(&ety.name.namespace);
+ let guard = format!("CXXBRIDGE05_STRUCT_{}", ety.name.to_symbol());
+ writeln!(out, "#ifndef {}", guard);
+ writeln!(out, "#define {}", guard);
for line in ety.doc.to_string().lines() {
writeln!(out, "//{}", line);
}
- writeln!(out, "struct {} final {{", ety.ident);
- writeln!(out, " {}() = delete;", ety.ident);
- writeln!(out, " {}(const {} &) = delete;", ety.ident, ety.ident);
+ writeln!(out, "struct {} final {{", ety.name.cxx);
+ writeln!(out, " {}() = delete;", ety.name.cxx);
+ writeln!(
+ out,
+ " {}(const {} &) = delete;",
+ ety.name.cxx, ety.name.cxx,
+ );
for method in methods {
write!(out, " ");
let sig = &method.sig;
- let local_name = method.ident.to_string();
+ let local_name = method.name.cxx.to_string();
write_rust_function_shim_decl(out, &local_name, sig, false);
writeln!(out, ";");
}
writeln!(out, "}};");
+ writeln!(out, "#endif // {}", guard);
}
-fn write_enum(out: &mut OutFile, enm: &Enum) {
+fn write_enum<'a>(out: &mut OutFile<'a>, enm: &'a Enum) {
+ out.set_namespace(&enm.name.namespace);
+ let guard = format!("CXXBRIDGE05_ENUM_{}", enm.name.to_symbol());
+ writeln!(out, "#ifndef {}", guard);
+ writeln!(out, "#define {}", guard);
for line in enm.doc.to_string().lines() {
writeln!(out, "//{}", line);
}
- write!(out, "enum class {} : ", enm.ident);
+ write!(out, "enum class {} : ", enm.name.cxx);
write_atom(out, enm.repr);
writeln!(out, " {{");
for variant in &enm.variants {
writeln!(out, " {} = {},", variant.ident, variant.discriminant);
}
writeln!(out, "}};");
+ writeln!(out, "#endif // {}", guard);
}
-fn check_enum(out: &mut OutFile, enm: &Enum) {
- write!(out, "static_assert(sizeof({}) == sizeof(", enm.ident);
+fn check_enum<'a>(out: &mut OutFile<'a>, enm: &'a Enum) {
+ out.set_namespace(&enm.name.namespace);
+ write!(out, "static_assert(sizeof({}) == sizeof(", enm.name.cxx);
write_atom(out, enm.repr);
writeln!(out, "), \"incorrect size\");");
for variant in &enm.variants {
@@ -374,54 +278,80 @@
writeln!(
out,
">({}::{}) == {}, \"disagrees with the value in #[cxx::bridge]\");",
- enm.ident, variant.ident, variant.discriminant,
+ enm.name.cxx, variant.ident, variant.discriminant,
);
}
}
-fn write_exception_glue(out: &mut OutFile, apis: &[Api]) {
- let mut has_cxx_throws = false;
- for api in apis {
- if let Api::CxxFunction(efn) = api {
- if efn.throws {
- has_cxx_throws = true;
- break;
- }
- }
- }
+fn check_trivial_extern_type(out: &mut OutFile, id: &Pair) {
+ // NOTE: The following static assertion is just nice-to-have and not
+ // necessary for soundness. That's because triviality is always declared by
+ // the user in the form of an unsafe impl of cxx::ExternType:
+ //
+ // unsafe impl ExternType for MyType {
+ // type Id = cxx::type_id!("...");
+ // type Kind = cxx::kind::Trivial;
+ // }
+ //
+ // Since the user went on the record with their unsafe impl to unsafely
+ // claim they KNOW that the type is trivial, it's fine for that to be on
+ // them if that were wrong. However, in practice correctly reasoning about
+ // the relocatability of C++ types is challenging, particularly if the type
+ // definition were to change over time, so for now we add this check.
+ //
+ // There may be legitimate reasons to opt out of this assertion for support
+ // of types that the programmer knows are soundly Rust-movable despite not
+ // being recognized as such by the C++ type system due to a move constructor
+ // or destructor. To opt out of the relocatability check, they need to do
+ // one of the following things in any header used by `include!` in their
+ // bridge.
+ //
+ // --- if they define the type:
+ // struct MyType {
+ // ...
+ // + using IsRelocatable = std::true_type;
+ // };
+ //
+ // --- otherwise:
+ // + template <>
+ // + struct rust::IsRelocatable<MyType> : std::true_type {};
+ //
- if has_cxx_throws {
- out.next_section();
- writeln!(
- out,
- "const char *cxxbridge03$exception(const char *, size_t);",
- );
- }
+ let id = id.to_fully_qualified();
+ out.builtin.relocatable = true;
+ writeln!(out, "static_assert(");
+ writeln!(out, " ::rust::IsRelocatable<{}>::value,", id);
+ writeln!(
+ out,
+ " \"type {} marked as Trivial in Rust is not trivially move constructible and trivially destructible in C++\");",
+ id,
+ );
}
-fn write_cxx_function_shim(
- out: &mut OutFile,
- efn: &ExternFn,
- types: &Types,
- impl_annotations: &Option<String>,
-) {
- if !out.header {
- if let Some(annotation) = impl_annotations {
- write!(out, "{} ", annotation);
- }
+fn write_cxx_function_shim<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) {
+ out.next_section();
+ out.set_namespace(&efn.name.namespace);
+ out.begin_block(Block::ExternC);
+ if let Some(annotation) = &out.opt.cxx_impl_annotations {
+ write!(out, "{} ", annotation);
}
if efn.throws {
- write!(out, "::rust::Str::Repr ");
+ out.builtin.ptr_len = true;
+ write!(out, "::rust::repr::PtrLen ");
} else {
- write_extern_return_type_space(out, &efn.ret, types);
+ write_extern_return_type_space(out, &efn.ret);
}
- let mangled = mangle::extern_fn(&out.namespace, efn);
+ let mangled = mangle::extern_fn(efn, out.types);
write!(out, "{}(", mangled);
if let Some(receiver) = &efn.receiver {
if receiver.mutability.is_none() {
write!(out, "const ");
}
- write!(out, "{} &self", receiver.ty);
+ write!(
+ out,
+ "{} &self",
+ out.types.resolve(&receiver.ty).to_fully_qualified(),
+ );
}
for (i, arg) in efn.args.iter().enumerate() {
if i > 0 || efn.receiver.is_some() {
@@ -432,9 +362,9 @@
} else if let Type::RustVec(_) = arg.ty {
write!(out, "const ");
}
- write_extern_arg(out, arg, types);
+ write_extern_arg(out, arg);
}
- let indirect_return = indirect_return(efn, types);
+ let indirect_return = indirect_return(efn, out.types);
if indirect_return {
if !efn.args.is_empty() || efn.receiver.is_some() {
write!(out, ", ");
@@ -446,8 +376,13 @@
write!(out, " ");
write_return_type(out, &efn.ret);
match &efn.receiver {
- None => write!(out, "(*{}$)(", efn.ident),
- Some(receiver) => write!(out, "({}::*{}$)(", receiver.ty, efn.ident),
+ None => write!(out, "(*{}$)(", efn.name.rust),
+ Some(receiver) => write!(
+ out,
+ "({}::*{}$)(",
+ out.types.resolve(&receiver.ty).to_fully_qualified(),
+ efn.name.rust,
+ ),
}
for (i, arg) in efn.args.iter().enumerate() {
if i > 0 {
@@ -463,13 +398,20 @@
}
write!(out, " = ");
match &efn.receiver {
- None => write!(out, "{}", efn.ident),
- Some(receiver) => write!(out, "&{}::{}", receiver.ty, efn.ident),
+ None => write!(out, "{}", efn.name.to_fully_qualified()),
+ Some(receiver) => write!(
+ out,
+ "&{}::{}",
+ out.types.resolve(&receiver.ty).to_fully_qualified(),
+ efn.name.cxx,
+ ),
}
writeln!(out, ";");
write!(out, " ");
if efn.throws {
- writeln!(out, "::rust::Str::Repr throw$;");
+ out.builtin.ptr_len = true;
+ out.builtin.trycatch = true;
+ writeln!(out, "::rust::repr::PtrLen throw$;");
writeln!(out, " ::rust::behavior::trycatch(");
writeln!(out, " [&] {{");
write!(out, " ");
@@ -484,15 +426,19 @@
}
match &efn.ret {
Some(Type::Ref(_)) => write!(out, "&"),
- Some(Type::Str(_)) if !indirect_return => write!(out, "::rust::Str::Repr("),
+ Some(Type::Str(_)) if !indirect_return => {
+ out.builtin.rust_str_repr = true;
+ write!(out, "::rust::impl<::rust::Str>::repr(");
+ }
Some(Type::SliceRefU8(_)) if !indirect_return => {
- write!(out, "::rust::Slice<uint8_t>::Repr(")
+ out.builtin.rust_slice_repr = true;
+ write!(out, "::rust::impl<::rust::Slice<uint8_t>>::repr(")
}
_ => {}
}
match &efn.receiver {
- None => write!(out, "{}$(", efn.ident),
- Some(_) => write!(out, "(self.*{}$)(", efn.ident),
+ None => write!(out, "{}$(", efn.name.rust),
+ Some(_) => write!(out, "(self.*{}$)(", efn.name.rust),
}
for (i, arg) in efn.args.iter().enumerate() {
if i > 0 {
@@ -504,16 +450,31 @@
} else if let Type::UniquePtr(_) = &arg.ty {
write_type(out, &arg.ty);
write!(out, "({})", arg.ident);
+ } else if let Type::Str(_) = arg.ty {
+ out.builtin.rust_str_new_unchecked = true;
+ write!(
+ out,
+ "::rust::impl<::rust::Str>::new_unchecked({})",
+ arg.ident,
+ );
} else if arg.ty == RustString {
+ out.builtin.unsafe_bitcopy = true;
write!(
out,
"::rust::String(::rust::unsafe_bitcopy, *{})",
arg.ident,
);
} else if let Type::RustVec(_) = arg.ty {
+ out.builtin.unsafe_bitcopy = true;
write_type(out, &arg.ty);
write!(out, "(::rust::unsafe_bitcopy, *{})", arg.ident);
- } else if types.needs_indirect_abi(&arg.ty) {
+ } else if let Type::SliceRefU8(_) = arg.ty {
+ write!(
+ out,
+ "::rust::Slice<uint8_t>(static_cast<const uint8_t *>({0}.ptr), {0}.len)",
+ arg.ident,
+ );
+ } else if out.types.needs_indirect_abi(&arg.ty) {
out.include.utility = true;
write!(out, "::std::move(*{})", arg.ident);
} else {
@@ -533,13 +494,14 @@
writeln!(out, ";");
if efn.throws {
out.include.cstring = true;
+ out.builtin.exception = true;
writeln!(out, " throw$.ptr = nullptr;");
writeln!(out, " }},");
writeln!(out, " [&](const char *catch$) noexcept {{");
writeln!(out, " throw$.len = ::std::strlen(catch$);");
writeln!(
out,
- " throw$.ptr = cxxbridge03$exception(catch$, throw$.len);",
+ " throw$.ptr = ::cxxbridge05$exception(catch$, throw$.len);",
);
writeln!(out, " }});");
writeln!(out, " return throw$;");
@@ -548,9 +510,10 @@
for arg in &efn.args {
if let Type::Fn(f) = &arg.ty {
let var = &arg.ident;
- write_function_pointer_trampoline(out, efn, var, f, types);
+ write_function_pointer_trampoline(out, efn, var, f);
}
}
+ out.end_block(Block::ExternC);
}
fn write_function_pointer_trampoline(
@@ -558,35 +521,37 @@
efn: &ExternFn,
var: &Ident,
f: &Signature,
- types: &Types,
) {
- out.next_section();
- let r_trampoline = mangle::r_trampoline(&out.namespace, efn, var);
+ let r_trampoline = mangle::r_trampoline(efn, var, out.types);
let indirect_call = true;
- write_rust_function_decl_impl(out, &r_trampoline, f, types, indirect_call);
+ write_rust_function_decl_impl(out, &r_trampoline, f, indirect_call);
out.next_section();
- let c_trampoline = mangle::c_trampoline(&out.namespace, efn, var).to_string();
- write_rust_function_shim_impl(out, &c_trampoline, f, types, &r_trampoline, indirect_call);
+ let c_trampoline = mangle::c_trampoline(efn, var, out.types).to_string();
+ write_rust_function_shim_impl(out, &c_trampoline, f, &r_trampoline, indirect_call);
}
-fn write_rust_function_decl(out: &mut OutFile, efn: &ExternFn, types: &Types, _: &Option<String>) {
- let link_name = mangle::extern_fn(&out.namespace, efn);
+fn write_rust_function_decl<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) {
+ out.set_namespace(&efn.name.namespace);
+ out.begin_block(Block::ExternC);
+ let link_name = mangle::extern_fn(efn, out.types);
let indirect_call = false;
- write_rust_function_decl_impl(out, &link_name, efn, types, indirect_call);
+ write_rust_function_decl_impl(out, &link_name, efn, indirect_call);
+ out.end_block(Block::ExternC);
}
fn write_rust_function_decl_impl(
out: &mut OutFile,
link_name: &Symbol,
sig: &Signature,
- types: &Types,
indirect_call: bool,
) {
+ out.next_section();
if sig.throws {
- write!(out, "::rust::Str::Repr ");
+ out.builtin.ptr_len = true;
+ write!(out, "::rust::repr::PtrLen ");
} else {
- write_extern_return_type_space(out, &sig.ret, types);
+ write_extern_return_type_space(out, &sig.ret);
}
write!(out, "{}(", link_name);
let mut needs_comma = false;
@@ -594,17 +559,21 @@
if receiver.mutability.is_none() {
write!(out, "const ");
}
- write!(out, "{} &self", receiver.ty);
+ write!(
+ out,
+ "{} &self",
+ out.types.resolve(&receiver.ty).to_fully_qualified(),
+ );
needs_comma = true;
}
for arg in &sig.args {
if needs_comma {
write!(out, ", ");
}
- write_extern_arg(out, arg, types);
+ write_extern_arg(out, arg);
needs_comma = true;
}
- if indirect_return(sig, types) {
+ if indirect_return(sig, out.types) {
if needs_comma {
write!(out, ", ");
}
@@ -621,17 +590,18 @@
writeln!(out, ") noexcept;");
}
-fn write_rust_function_shim(out: &mut OutFile, efn: &ExternFn, types: &Types) {
+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.ident.to_string(),
- Some(receiver) => format!("{}::{}", receiver.ty, efn.ident),
+ None => efn.name.cxx.to_string(),
+ Some(receiver) => format!("{}::{}", out.types.resolve(&receiver.ty).cxx, efn.name.cxx),
};
- let invoke = mangle::extern_fn(&out.namespace, efn);
+ let invoke = mangle::extern_fn(efn, out.types);
let indirect_call = false;
- write_rust_function_shim_impl(out, &local_name, efn, types, &invoke, indirect_call);
+ write_rust_function_shim_impl(out, &local_name, efn, &invoke, indirect_call);
}
fn write_rust_function_shim_decl(
@@ -670,7 +640,6 @@
out: &mut OutFile,
local_name: &str,
sig: &Signature,
- types: &Types,
invoke: &Symbol,
indirect_call: bool,
) {
@@ -685,16 +654,18 @@
}
writeln!(out, " {{");
for arg in &sig.args {
- if arg.ty != RustString && types.needs_indirect_abi(&arg.ty) {
+ if arg.ty != RustString && out.types.needs_indirect_abi(&arg.ty) {
out.include.utility = true;
+ out.builtin.manually_drop = true;
write!(out, " ::rust::ManuallyDrop<");
write_type(out, &arg.ty);
writeln!(out, "> {}$(::std::move({0}));", arg.ident);
}
}
write!(out, " ");
- let indirect_return = indirect_return(sig, types);
+ let indirect_return = indirect_return(sig, out.types);
if indirect_return {
+ out.builtin.maybe_uninit = true;
write!(out, "::rust::MaybeUninit<");
write_type(out, sig.ret.as_ref().unwrap());
writeln!(out, "> return$;");
@@ -711,24 +682,41 @@
write!(out, "(");
}
Type::Ref(_) => write!(out, "*"),
+ Type::Str(_) => {
+ out.builtin.rust_str_new_unchecked = true;
+ write!(out, "::rust::impl<::rust::Str>::new_unchecked(");
+ }
+ Type::SliceRefU8(_) => {
+ out.builtin.rust_slice_new = true;
+ write!(out, "::rust::impl<::rust::Slice<uint8_t>>::slice(");
+ }
_ => {}
}
}
if sig.throws {
- write!(out, "::rust::Str::Repr error$ = ");
+ out.builtin.ptr_len = true;
+ write!(out, "::rust::repr::PtrLen error$ = ");
}
write!(out, "{}(", invoke);
+ let mut needs_comma = false;
if sig.receiver.is_some() {
write!(out, "*this");
+ needs_comma = true;
}
- for (i, arg) in sig.args.iter().enumerate() {
- if i > 0 || sig.receiver.is_some() {
+ for arg in &sig.args {
+ if needs_comma {
write!(out, ", ");
}
match &arg.ty {
- Type::Str(_) => write!(out, "::rust::Str::Repr("),
- Type::SliceRefU8(_) => write!(out, "::rust::Slice<uint8_t>::Repr("),
- ty if types.needs_indirect_abi(ty) => write!(out, "&"),
+ Type::Str(_) => {
+ out.builtin.rust_str_repr = true;
+ write!(out, "::rust::impl<::rust::Str>::repr(");
+ }
+ Type::SliceRefU8(_) => {
+ out.builtin.rust_slice_repr = true;
+ write!(out, "::rust::impl<::rust::Slice<uint8_t>>::repr(");
+ }
+ ty if out.types.needs_indirect_abi(ty) => write!(out, "&"),
_ => {}
}
write!(out, "{}", arg.ident);
@@ -736,32 +724,38 @@
Type::RustBox(_) => write!(out, ".into_raw()"),
Type::UniquePtr(_) => write!(out, ".release()"),
Type::Str(_) | Type::SliceRefU8(_) => write!(out, ")"),
- ty if ty != RustString && types.needs_indirect_abi(ty) => write!(out, "$.value"),
+ ty if ty != RustString && out.types.needs_indirect_abi(ty) => write!(out, "$.value"),
_ => {}
}
+ needs_comma = true;
}
if indirect_return {
- if !sig.args.is_empty() {
+ if needs_comma {
write!(out, ", ");
}
write!(out, "&return$.value");
+ needs_comma = true;
}
if indirect_call {
- if !sig.args.is_empty() || indirect_return {
+ if needs_comma {
write!(out, ", ");
}
write!(out, "extern$");
}
write!(out, ")");
- if let Some(ret) = &sig.ret {
- if let Type::RustBox(_) | Type::UniquePtr(_) = ret {
- write!(out, ")");
+ if !indirect_return {
+ if let Some(ret) = &sig.ret {
+ if let Type::RustBox(_) | Type::UniquePtr(_) | Type::Str(_) | Type::SliceRefU8(_) = ret
+ {
+ write!(out, ")");
+ }
}
}
writeln!(out, ";");
if sig.throws {
+ out.builtin.rust_error = true;
writeln!(out, " if (error$.ptr) {{");
- writeln!(out, " throw ::rust::Error(error$);");
+ writeln!(out, " throw ::rust::impl<::rust::Error>::error(error$);");
writeln!(out, " }}");
}
if indirect_return {
@@ -797,8 +791,6 @@
write_type(out, &ty.inner);
write!(out, " *");
}
- Type::Str(_) => write!(out, "::rust::Str::Repr"),
- Type::SliceRefU8(_) => write!(out, "::rust::Slice<uint8_t>::Repr"),
_ => write_type(out, ty),
}
}
@@ -812,7 +804,7 @@
}
}
-fn write_extern_return_type_space(out: &mut OutFile, ty: &Option<Type>, types: &Types) {
+fn write_extern_return_type_space(out: &mut OutFile, ty: &Option<Type>) {
match ty {
Some(Type::RustBox(ty)) | Some(Type::UniquePtr(ty)) => {
write_type_space(out, &ty.inner);
@@ -825,24 +817,28 @@
write_type(out, &ty.inner);
write!(out, " *");
}
- Some(Type::Str(_)) => write!(out, "::rust::Str::Repr "),
- Some(Type::SliceRefU8(_)) => write!(out, "::rust::Slice<uint8_t>::Repr "),
- Some(ty) if types.needs_indirect_abi(ty) => write!(out, "void "),
+ Some(Type::Str(_)) | Some(Type::SliceRefU8(_)) => {
+ out.builtin.ptr_len = true;
+ write!(out, "::rust::repr::PtrLen ");
+ }
+ Some(ty) if out.types.needs_indirect_abi(ty) => write!(out, "void "),
_ => write_return_type(out, ty),
}
}
-fn write_extern_arg(out: &mut OutFile, arg: &Var, types: &Types) {
+fn write_extern_arg(out: &mut OutFile, arg: &Var) {
match &arg.ty {
Type::RustBox(ty) | Type::UniquePtr(ty) | Type::CxxVector(ty) => {
write_type_space(out, &ty.inner);
write!(out, "*");
}
- Type::Str(_) => write!(out, "::rust::Str::Repr "),
- Type::SliceRefU8(_) => write!(out, "::rust::Slice<uint8_t>::Repr "),
+ Type::Str(_) | Type::SliceRefU8(_) => {
+ out.builtin.ptr_len = true;
+ write!(out, "::rust::repr::PtrLen ");
+ }
_ => write_type_space(out, &arg.ty),
}
- if types.needs_indirect_abi(&arg.ty) {
+ if out.types.needs_indirect_abi(&arg.ty) {
write!(out, "*");
}
write!(out, "{}", arg.ident);
@@ -850,9 +846,9 @@
fn write_type(out: &mut OutFile, ty: &Type) {
match ty {
- Type::Ident(ident) => match Atom::from(ident) {
+ Type::Ident(ident) => match Atom::from(&ident.rust) {
Some(atom) => write_atom(out, atom),
- None => write!(out, "{}", ident),
+ None => write!(out, "{}", out.types.resolve(ident).to_fully_qualified()),
},
Type::RustBox(ty) => {
write!(out, "::rust::Box<");
@@ -952,223 +948,256 @@
// Only called for legal referent types of unique_ptr and element types of
// std::vector and Vec.
-fn to_typename(namespace: &Namespace, ty: &Type) -> String {
+fn to_typename(ty: &Type, types: &Types) -> String {
match ty {
- Type::Ident(ident) => {
- let mut path = String::new();
- for name in namespace {
- path += &name.to_string();
- path += "::";
- }
- path += &ident.to_string();
- path
- }
- Type::CxxVector(ptr) => format!("::std::vector<{}>", to_typename(namespace, &ptr.inner)),
+ Type::Ident(ident) => types.resolve(&ident).to_fully_qualified(),
+ Type::CxxVector(ptr) => format!("::std::vector<{}>", to_typename(&ptr.inner, types)),
_ => unreachable!(),
}
}
// Only called for legal referent types of unique_ptr and element types of
// std::vector and Vec.
-fn to_mangled(namespace: &Namespace, ty: &Type) -> String {
+fn to_mangled(ty: &Type, types: &Types) -> Symbol {
match ty {
- Type::Ident(_) => to_typename(namespace, ty).replace("::", "$"),
- Type::CxxVector(ptr) => format!("std$vector${}", to_mangled(namespace, &ptr.inner)),
+ Type::Ident(ident) => ident.to_symbol(types),
+ Type::CxxVector(ptr) => to_mangled(&ptr.inner, types).prefix_with("std$vector$"),
_ => unreachable!(),
}
}
-fn write_generic_instantiations(out: &mut OutFile, types: &Types) {
- out.begin_block("extern \"C\"");
- for ty in types {
+fn write_generic_instantiations(out: &mut OutFile) {
+ if out.header {
+ return;
+ }
+
+ out.next_section();
+ out.set_namespace(Default::default());
+ out.begin_block(Block::ExternC);
+ for ty in out.types {
if let Type::RustBox(ty) = ty {
if let Type::Ident(inner) = &ty.inner {
out.next_section();
- write_rust_box_extern(out, inner);
+ write_rust_box_extern(out, &out.types.resolve(&inner));
}
} else if let Type::RustVec(ty) = ty {
if let Type::Ident(inner) = &ty.inner {
- if Atom::from(inner).is_none() {
+ if Atom::from(&inner.rust).is_none() {
out.next_section();
write_rust_vec_extern(out, inner);
}
}
} else if let Type::UniquePtr(ptr) = ty {
if let Type::Ident(inner) = &ptr.inner {
- if Atom::from(inner).is_none() && !types.aliases.contains_key(inner) {
+ if Atom::from(&inner.rust).is_none()
+ && (!out.types.aliases.contains_key(&inner.rust)
+ || out.types.explicit_impls.contains(ty))
+ {
out.next_section();
- write_unique_ptr(out, inner, types);
+ write_unique_ptr(out, inner);
}
}
} else if let Type::CxxVector(ptr) = ty {
if let Type::Ident(inner) = &ptr.inner {
- if Atom::from(inner).is_none() && !types.aliases.contains_key(inner) {
+ if Atom::from(&inner.rust).is_none()
+ && (!out.types.aliases.contains_key(&inner.rust)
+ || out.types.explicit_impls.contains(ty))
+ {
out.next_section();
- write_cxx_vector(out, ty, inner, types);
+ write_cxx_vector(out, ty, inner);
}
}
}
}
- out.end_block("extern \"C\"");
+ out.end_block(Block::ExternC);
- out.begin_block("namespace rust");
- out.begin_block("inline namespace cxxbridge03");
- for ty in types {
+ out.begin_block(Block::Namespace("rust"));
+ out.begin_block(Block::InlineNamespace("cxxbridge05"));
+ for ty in out.types {
if let Type::RustBox(ty) = ty {
if let Type::Ident(inner) = &ty.inner {
- write_rust_box_impl(out, inner);
+ write_rust_box_impl(out, &out.types.resolve(&inner));
}
} else if let Type::RustVec(ty) = ty {
if let Type::Ident(inner) = &ty.inner {
- if Atom::from(inner).is_none() {
+ if Atom::from(&inner.rust).is_none() {
write_rust_vec_impl(out, inner);
}
}
}
}
- out.end_block("namespace cxxbridge03");
- out.end_block("namespace rust");
+ out.end_block(Block::InlineNamespace("cxxbridge05"));
+ out.end_block(Block::Namespace("rust"));
}
-fn write_rust_box_extern(out: &mut OutFile, ident: &Ident) {
- let mut inner = String::new();
- for name in &out.namespace {
- inner += &name.to_string();
- inner += "::";
- }
- inner += &ident.to_string();
- let instance = inner.replace("::", "$");
+fn write_rust_box_extern(out: &mut OutFile, ident: &Pair) {
+ let inner = ident.to_fully_qualified();
+ let instance = ident.to_symbol();
- writeln!(out, "#ifndef CXXBRIDGE03_RUST_BOX_{}", instance);
- writeln!(out, "#define CXXBRIDGE03_RUST_BOX_{}", instance);
+ writeln!(out, "#ifndef CXXBRIDGE05_RUST_BOX_{}", instance);
+ writeln!(out, "#define CXXBRIDGE05_RUST_BOX_{}", instance);
writeln!(
out,
- "void cxxbridge03$box${}$uninit(::rust::Box<{}> *ptr) noexcept;",
+ "void cxxbridge05$box${}$uninit(::rust::Box<{}> *ptr) noexcept;",
instance, inner,
);
writeln!(
out,
- "void cxxbridge03$box${}$drop(::rust::Box<{}> *ptr) noexcept;",
+ "void cxxbridge05$box${}$drop(::rust::Box<{}> *ptr) noexcept;",
instance, inner,
);
- writeln!(out, "#endif // CXXBRIDGE03_RUST_BOX_{}", instance);
+ writeln!(out, "#endif // CXXBRIDGE05_RUST_BOX_{}", instance);
}
-fn write_rust_vec_extern(out: &mut OutFile, element: &Ident) {
+fn write_rust_vec_extern(out: &mut OutFile, element: &ResolvableName) {
let element = Type::Ident(element.clone());
- let inner = to_typename(&out.namespace, &element);
- let instance = to_mangled(&out.namespace, &element);
+ let inner = to_typename(&element, out.types);
+ let instance = to_mangled(&element, out.types);
- writeln!(out, "#ifndef CXXBRIDGE03_RUST_VEC_{}", instance);
- writeln!(out, "#define CXXBRIDGE03_RUST_VEC_{}", instance);
+ writeln!(out, "#ifndef CXXBRIDGE05_RUST_VEC_{}", instance);
+ writeln!(out, "#define CXXBRIDGE05_RUST_VEC_{}", instance);
writeln!(
out,
- "void cxxbridge03$rust_vec${}$new(const ::rust::Vec<{}> *ptr) noexcept;",
+ "void cxxbridge05$rust_vec${}$new(const ::rust::Vec<{}> *ptr) noexcept;",
instance, inner,
);
writeln!(
out,
- "void cxxbridge03$rust_vec${}$drop(::rust::Vec<{}> *ptr) noexcept;",
+ "void cxxbridge05$rust_vec${}$drop(::rust::Vec<{}> *ptr) noexcept;",
instance, inner,
);
writeln!(
out,
- "size_t cxxbridge03$rust_vec${}$len(const ::rust::Vec<{}> *ptr) noexcept;",
+ "size_t cxxbridge05$rust_vec${}$len(const ::rust::Vec<{}> *ptr) noexcept;",
instance, inner,
);
writeln!(
out,
- "const {} *cxxbridge03$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 cxxbridge03$rust_vec${}$stride() noexcept;",
+ "void cxxbridge05$rust_vec${}$reserve_total(::rust::Vec<{}> *ptr, size_t cap) noexcept;",
+ instance, inner,
+ );
+ writeln!(
+ out,
+ "void cxxbridge05$rust_vec${}$set_len(::rust::Vec<{}> *ptr, size_t len) noexcept;",
+ instance, inner,
+ );
+ writeln!(
+ out,
+ "size_t cxxbridge05$rust_vec${}$stride() noexcept;",
instance,
);
- writeln!(out, "#endif // CXXBRIDGE03_RUST_VEC_{}", instance);
+ writeln!(out, "#endif // CXXBRIDGE05_RUST_VEC_{}", instance);
}
-fn write_rust_box_impl(out: &mut OutFile, ident: &Ident) {
- let mut inner = String::new();
- for name in &out.namespace {
- inner += &name.to_string();
- inner += "::";
- }
- inner += &ident.to_string();
- let instance = inner.replace("::", "$");
+fn write_rust_box_impl(out: &mut OutFile, ident: &Pair) {
+ let inner = ident.to_fully_qualified();
+ let instance = ident.to_symbol();
writeln!(out, "template <>");
writeln!(out, "void Box<{}>::uninit() noexcept {{", inner);
- writeln!(out, " cxxbridge03$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, " cxxbridge03$box${}$drop(this);", instance);
+ writeln!(out, " cxxbridge05$box${}$drop(this);", instance);
writeln!(out, "}}");
}
-fn write_rust_vec_impl(out: &mut OutFile, element: &Ident) {
+fn write_rust_vec_impl(out: &mut OutFile, element: &ResolvableName) {
let element = Type::Ident(element.clone());
- let inner = to_typename(&out.namespace, &element);
- let instance = to_mangled(&out.namespace, &element);
+ let inner = to_typename(&element, out.types);
+ let instance = to_mangled(&element, out.types);
writeln!(out, "template <>");
writeln!(out, "Vec<{}>::Vec() noexcept {{", inner);
- writeln!(out, " cxxbridge03$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 cxxbridge03$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 cxxbridge03$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 cxxbridge03$rust_vec${}$data(this);",
+ " return cxxbridge05$rust_vec${}$data(this);",
+ instance,
+ );
+ writeln!(out, "}}");
+
+ writeln!(out, "template <>");
+ writeln!(
+ out,
+ "void Vec<{}>::reserve_total(size_t cap) noexcept {{",
+ inner,
+ );
+ writeln!(
+ out,
+ " return cxxbridge05$rust_vec${}$reserve_total(this, cap);",
+ instance,
+ );
+ writeln!(out, "}}");
+
+ writeln!(out, "template <>");
+ writeln!(out, "void Vec<{}>::set_len(size_t len) noexcept {{", inner);
+ writeln!(
+ out,
+ " return cxxbridge05$rust_vec${}$set_len(this, len);",
instance,
);
writeln!(out, "}}");
writeln!(out, "template <>");
writeln!(out, "size_t Vec<{}>::stride() noexcept {{", inner);
- writeln!(out, " return cxxbridge03$rust_vec${}$stride();", instance);
+ writeln!(out, " return cxxbridge05$rust_vec${}$stride();", instance);
writeln!(out, "}}");
}
-fn write_unique_ptr(out: &mut OutFile, ident: &Ident, types: &Types) {
+fn write_unique_ptr(out: &mut OutFile, ident: &ResolvableName) {
let ty = Type::Ident(ident.clone());
- let instance = to_mangled(&out.namespace, &ty);
+ let instance = to_mangled(&ty, out.types);
- writeln!(out, "#ifndef CXXBRIDGE03_UNIQUE_PTR_{}", instance);
- writeln!(out, "#define CXXBRIDGE03_UNIQUE_PTR_{}", instance);
+ writeln!(out, "#ifndef CXXBRIDGE05_UNIQUE_PTR_{}", instance);
+ writeln!(out, "#define CXXBRIDGE05_UNIQUE_PTR_{}", instance);
- write_unique_ptr_common(out, &ty, types);
+ write_unique_ptr_common(out, &ty);
- writeln!(out, "#endif // CXXBRIDGE03_UNIQUE_PTR_{}", instance);
+ writeln!(out, "#endif // CXXBRIDGE05_UNIQUE_PTR_{}", instance);
}
// Shared by UniquePtr<T> and UniquePtr<CxxVector<T>>.
-fn write_unique_ptr_common(out: &mut OutFile, ty: &Type, types: &Types) {
+fn write_unique_ptr_common(out: &mut OutFile, ty: &Type) {
out.include.new = true;
out.include.utility = true;
- let inner = to_typename(&out.namespace, ty);
- let instance = to_mangled(&out.namespace, ty);
+ let inner = to_typename(ty, out.types);
+ let instance = to_mangled(ty, out.types);
let can_construct_from_value = match ty {
- Type::Ident(ident) => types.structs.contains_key(ident),
+ // Some aliases are to opaque types; some are to trivial types. We can't
+ // 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.
+ Type::Ident(ident) => {
+ out.types.structs.contains_key(&ident.rust)
+ || out.types.aliases.contains_key(&ident.rust)
+ }
_ => false,
};
@@ -1184,7 +1213,7 @@
);
writeln!(
out,
- "void cxxbridge03$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);
@@ -1192,7 +1221,7 @@
if can_construct_from_value {
writeln!(
out,
- "void cxxbridge03$unique_ptr${}$new(::std::unique_ptr<{}> *ptr, {} *value) noexcept {{",
+ "void cxxbridge05$unique_ptr${}$new(::std::unique_ptr<{}> *ptr, {} *value) noexcept {{",
instance, inner, inner,
);
writeln!(
@@ -1204,57 +1233,57 @@
}
writeln!(
out,
- "void cxxbridge03$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 {} *cxxbridge03$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,
- "{} *cxxbridge03$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 cxxbridge03$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();");
writeln!(out, "}}");
}
-fn write_cxx_vector(out: &mut OutFile, vector_ty: &Type, element: &Ident, types: &Types) {
+fn write_cxx_vector(out: &mut OutFile, vector_ty: &Type, element: &ResolvableName) {
let element = Type::Ident(element.clone());
- let inner = to_typename(&out.namespace, &element);
- let instance = to_mangled(&out.namespace, &element);
+ let inner = to_typename(&element, out.types);
+ let instance = to_mangled(&element, out.types);
- writeln!(out, "#ifndef CXXBRIDGE03_VECTOR_{}", instance);
- writeln!(out, "#define CXXBRIDGE03_VECTOR_{}", instance);
+ writeln!(out, "#ifndef CXXBRIDGE05_VECTOR_{}", instance);
+ writeln!(out, "#define CXXBRIDGE05_VECTOR_{}", instance);
writeln!(
out,
- "size_t cxxbridge03$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 {} *cxxbridge03$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];");
writeln!(out, "}}");
- write_unique_ptr_common(out, vector_ty, types);
+ write_unique_ptr_common(out, vector_ty);
- writeln!(out, "#endif // CXXBRIDGE03_VECTOR_{}", instance);
+ writeln!(out, "#endif // CXXBRIDGE05_VECTOR_{}", instance);
}
diff --git a/include/cxx.h b/include/cxx.h
index c3231fd..7dfbbca 100644
--- a/include/cxx.h
+++ b/include/cxx.h
@@ -5,21 +5,27 @@
#include <exception>
#include <iosfwd>
#include <new>
+#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#if defined(_WIN32)
-#include <BaseTsd.h>
+#include <basetsd.h>
#endif
namespace rust {
-inline namespace cxxbridge03 {
+inline namespace cxxbridge05 {
struct unsafe_bitcopy_t;
-#ifndef CXXBRIDGE03_RUST_STRING
-#define CXXBRIDGE03_RUST_STRING
+namespace {
+template <typename T>
+class impl;
+}
+
+#ifndef CXXBRIDGE05_RUST_STRING
+#define CXXBRIDGE05_RUST_STRING
class String final {
public:
String() noexcept;
@@ -48,21 +54,18 @@
// Size and alignment statically verified by rust_string.rs.
std::array<uintptr_t, 3> repr;
};
-#endif // CXXBRIDGE03_RUST_STRING
+#endif // CXXBRIDGE05_RUST_STRING
-#ifndef CXXBRIDGE03_RUST_STR
-#define CXXBRIDGE03_RUST_STR
+#ifndef CXXBRIDGE05_RUST_STR
class Str final {
public:
Str() noexcept;
- Str(const Str &) noexcept;
-
Str(const std::string &);
Str(const char *);
Str(const char *, size_t);
Str(std::string &&) = delete;
- Str &operator=(Str) noexcept;
+ Str &operator=(const Str &) noexcept = default;
explicit operator std::string() const;
@@ -71,54 +74,46 @@
size_t size() const noexcept;
size_t length() const noexcept;
- // Repr is PRIVATE; must not be used other than by our generated code.
- //
- // Not necessarily ABI compatible with &str. Codegen will translate to
- // cxx::rust_str::RustStr which matches this layout.
- struct Repr {
- const char *ptr;
- size_t len;
- };
- Str(Repr) noexcept;
- explicit operator Repr() noexcept;
+ // Important in order for System V ABI to pass in registers.
+ Str(const Str &) noexcept = default;
+ ~Str() noexcept = default;
private:
- Repr repr;
+ friend impl<Str>;
+ // Not necessarily ABI compatible with &str. Codegen will translate to
+ // cxx::rust_str::RustStr which matches this layout.
+ const char *ptr;
+ size_t len;
};
-#endif // CXXBRIDGE03_RUST_STR
+#endif // CXXBRIDGE05_RUST_STR
-#ifndef CXXBRIDGE03_RUST_SLICE
+#ifndef CXXBRIDGE05_RUST_SLICE
template <typename T>
class Slice final {
public:
Slice() noexcept;
- Slice(const Slice<T> &) noexcept;
Slice(const T *, size_t count) noexcept;
- Slice &operator=(Slice<T>) noexcept;
+ Slice &operator=(const Slice<T> &) noexcept = default;
const T *data() const noexcept;
size_t size() const noexcept;
size_t length() const noexcept;
- // Repr is PRIVATE; must not be used other than by our generated code.
- //
- // At present this class is only used for &[u8] slices.
- // Not necessarily ABI compatible with &[u8]. Codegen will translate to
- // cxx::rust_sliceu8::RustSliceU8 which matches this layout.
- struct Repr {
- const T *ptr;
- size_t len;
- };
- Slice(Repr) noexcept;
- explicit operator Repr() noexcept;
+ // Important in order for System V ABI to pass in registers.
+ Slice(const Slice<T> &) noexcept = default;
+ ~Slice() noexcept = default;
private:
- Repr repr;
+ friend impl<Slice>;
+ // Not necessarily ABI compatible with &[T]. Codegen will translate to
+ // cxx::rust_sliceu8::RustSliceU8 which matches this layout.
+ const T *ptr;
+ size_t len;
};
-#endif // CXXBRIDGE03_RUST_SLICE
+#endif // CXXBRIDGE05_RUST_SLICE
-#ifndef CXXBRIDGE03_RUST_BOX
+#ifndef CXXBRIDGE05_RUST_BOX
template <typename T>
class Box final {
public:
@@ -157,9 +152,9 @@
void drop() noexcept;
T *ptr;
};
-#endif // CXXBRIDGE03_RUST_BOX
+#endif // CXXBRIDGE05_RUST_BOX
-#ifndef CXXBRIDGE03_RUST_VEC
+#ifndef CXXBRIDGE05_RUST_VEC
template <typename T>
class Vec final {
public:
@@ -174,8 +169,21 @@
size_t size() const noexcept;
bool empty() const noexcept;
const T *data() const noexcept;
+ T *data() noexcept;
- class const_iterator {
+ const T &operator[](size_t n) const noexcept;
+ const T &at(size_t n) const;
+
+ const T &front() const;
+ const T &back() const;
+
+ void reserve(size_t new_cap);
+ void push_back(const T &value);
+ void push_back(T &&value);
+ template <class... Args>
+ void emplace_back(Args &&... args);
+
+ class const_iterator final {
public:
using difference_type = ptrdiff_t;
using value_type = typename std::add_const<T>::type;
@@ -206,20 +214,21 @@
private:
static size_t stride() noexcept;
+ void reserve_total(size_t cap) noexcept;
+ void set_len(size_t len) noexcept;
void drop() noexcept;
// Size and alignment statically verified by rust_vec.rs.
std::array<uintptr_t, 3> repr;
};
-#endif // CXXBRIDGE03_RUST_VEC
+#endif // CXXBRIDGE05_RUST_VEC
-#ifndef CXXBRIDGE03_RUST_FN
-#define CXXBRIDGE03_RUST_FN
+#ifndef CXXBRIDGE05_RUST_FN
template <typename Signature, bool Throws = false>
class Fn;
template <typename Ret, typename... Args, bool Throws>
-class Fn<Ret(Args...), Throws> {
+class Fn<Ret(Args...), Throws> final {
public:
Ret operator()(Args... args) const noexcept(!Throws);
Fn operator*() const noexcept;
@@ -231,51 +240,92 @@
template <typename Signature>
using TryFn = Fn<Signature, true>;
-#endif // CXXBRIDGE03_RUST_FN
+#endif // CXXBRIDGE05_RUST_FN
-#ifndef CXXBRIDGE03_RUST_ERROR
-#define CXXBRIDGE03_RUST_ERROR
-class Error final : std::exception {
+#ifndef CXXBRIDGE05_RUST_ERROR
+#define CXXBRIDGE05_RUST_ERROR
+class Error final : public std::exception {
public:
Error(const Error &);
Error(Error &&) noexcept;
- Error(Str::Repr) noexcept;
~Error() noexcept;
+
+ Error &operator=(const Error &);
+ Error &operator=(Error &&) noexcept;
+
const char *what() const noexcept override;
private:
- Str::Repr msg;
+ Error() noexcept = default;
+ friend impl<Error>;
+ const char *msg;
+ size_t len;
};
-#endif // CXXBRIDGE03_RUST_ERROR
+#endif // CXXBRIDGE05_RUST_ERROR
-#ifndef CXXBRIDGE03_RUST_ISIZE
-#define CXXBRIDGE03_RUST_ISIZE
+#ifndef CXXBRIDGE05_RUST_ISIZE
+#define CXXBRIDGE05_RUST_ISIZE
#if defined(_WIN32)
using isize = SSIZE_T;
#else
using isize = ssize_t;
#endif
-#endif // CXXBRIDGE03_RUST_ISIZE
+#endif // CXXBRIDGE05_RUST_ISIZE
std::ostream &operator<<(std::ostream &, const String &);
std::ostream &operator<<(std::ostream &, const Str &);
+// IsRelocatable<T> is used in assertions that a C++ type passed by value
+// between Rust and C++ is soundly relocatable by Rust.
+//
+// There may be legitimate reasons to opt out of the check for support of types
+// that the programmer knows are soundly Rust-movable despite not being
+// recognized as such by the C++ type system due to a move constructor or
+// destructor. To opt out of the relocatability check, do either of the
+// following things in any header used by `include!` in the bridge.
+//
+// --- if you define the type:
+// struct MyType {
+// ...
+// + using IsRelocatable = std::true_type;
+// };
+//
+// --- otherwise:
+// + template <>
+// + struct rust::IsRelocatable<MyType> : std::true_type {};
+template <typename T>
+struct IsRelocatable;
+
// Snake case aliases for use in code that uses this style for type names.
using string = String;
using str = Str;
template <class T>
+using slice = Slice<T>;
+template <class T>
using box = Box<T>;
+template <class T>
+using vec = Vec<T>;
using error = Error;
template <typename Signature, bool Throws = false>
using fn = Fn<Signature, Throws>;
template <typename Signature>
using try_fn = TryFn<Signature>;
+template <typename T>
+using is_relocatable = IsRelocatable<T>;
////////////////////////////////////////////////////////////////////////////////
/// end public API, begin implementation details
+#ifndef CXXBRIDGE05_PANIC
+#define CXXBRIDGE05_PANIC
+template <typename Exception>
+void panic [[noreturn]] (const char *msg);
+#endif // CXXBRIDGE05_PANIC
+
+#ifndef CXXBRIDGE05_RUST_FN
+#define CXXBRIDGE05_RUST_FN
template <typename Ret, typename... Args, bool Throws>
Ret Fn<Ret(Args...), Throws>::operator()(Args... args) const noexcept(!Throws) {
return (*this->trampoline)(std::move(args)..., this->fn);
@@ -285,59 +335,52 @@
Fn<Ret(Args...), Throws> Fn<Ret(Args...), Throws>::operator*() const noexcept {
return *this;
}
+#endif // CXXBRIDGE05_RUST_FN
-#ifndef CXXBRIDGE03_RUST_BITCOPY
-#define CXXBRIDGE03_RUST_BITCOPY
-struct unsafe_bitcopy_t {
+#ifndef CXXBRIDGE05_RUST_BITCOPY
+#define CXXBRIDGE05_RUST_BITCOPY
+struct unsafe_bitcopy_t final {
explicit unsafe_bitcopy_t() = default;
};
constexpr unsafe_bitcopy_t unsafe_bitcopy{};
-#endif // CXXBRIDGE03_RUST_BITCOPY
+#endif // CXXBRIDGE05_RUST_BITCOPY
-#ifndef CXXBRIDGE03_RUST_SLICE
-#define CXXBRIDGE03_RUST_SLICE
+#ifndef CXXBRIDGE05_RUST_STR
+#define CXXBRIDGE05_RUST_STR
+inline const char *Str::data() const noexcept { return this->ptr; }
+
+inline size_t Str::size() const noexcept { return this->len; }
+
+inline size_t Str::length() const noexcept { return this->len; }
+#endif // CXXBRIDGE05_RUST_STR
+
+#ifndef CXXBRIDGE05_RUST_SLICE
+#define CXXBRIDGE05_RUST_SLICE
template <typename T>
-Slice<T>::Slice() noexcept : repr(Repr{reinterpret_cast<const T *>(this), 0}) {}
+Slice<T>::Slice() noexcept : ptr(reinterpret_cast<const T *>(this)), len(0) {}
template <typename T>
-Slice<T>::Slice(const Slice<T> &) noexcept = default;
-
-template <typename T>
-Slice<T>::Slice(const T *s, size_t count) noexcept : repr(Repr{s, count}) {}
-
-template <typename T>
-Slice<T> &Slice<T>::operator=(Slice<T> other) noexcept {
- this->repr = other.repr;
- return *this;
-}
+Slice<T>::Slice(const T *s, size_t count) noexcept : ptr(s), len(count) {}
template <typename T>
const T *Slice<T>::data() const noexcept {
- return this->repr.ptr;
+ return this->ptr;
}
template <typename T>
size_t Slice<T>::size() const noexcept {
- return this->repr.len;
+ return this->len;
}
template <typename T>
size_t Slice<T>::length() const noexcept {
- return this->repr.len;
+ return this->len;
}
+#endif // CXXBRIDGE05_RUST_SLICE
-template <typename T>
-Slice<T>::Slice(Repr repr_) noexcept : repr(repr_) {}
-
-template <typename T>
-Slice<T>::operator Repr() noexcept {
- return this->repr;
-}
-#endif // CXXBRIDGE03_RUST_SLICE
-
-#ifndef CXXBRIDGE03_RUST_BOX
-#define CXXBRIDGE03_RUST_BOX
+#ifndef CXXBRIDGE05_RUST_BOX
+#define CXXBRIDGE05_RUST_BOX
template <typename T>
Box<T>::Box(const Box &other) : Box(*other) {}
@@ -433,10 +476,10 @@
template <typename T>
Box<T>::Box() noexcept {}
-#endif // CXXBRIDGE03_RUST_BOX
+#endif // CXXBRIDGE05_RUST_BOX
-#ifndef CXXBRIDGE03_RUST_VEC
-#define CXXBRIDGE03_RUST_VEC
+#ifndef CXXBRIDGE05_RUST_VEC
+#define CXXBRIDGE05_RUST_VEC
template <typename T>
Vec<T>::Vec(Vec &&other) noexcept {
this->repr = other.repr;
@@ -464,6 +507,61 @@
}
template <typename T>
+T *Vec<T>::data() noexcept {
+ return const_cast<T *>(const_cast<const Vec<T> *>(this)->data());
+}
+
+template <typename T>
+const T &Vec<T>::operator[](size_t n) const noexcept {
+ auto data = reinterpret_cast<const char *>(this->data());
+ return *reinterpret_cast<const T *>(data + n * this->stride());
+}
+
+template <typename T>
+const T &Vec<T>::at(size_t n) const {
+ if (n >= this->size()) {
+ panic<std::out_of_range>("rust::Vec index out of range");
+ }
+ return (*this)[n];
+}
+
+template <typename T>
+const T &Vec<T>::front() const {
+ return (*this)[0];
+}
+
+template <typename T>
+const T &Vec<T>::back() const {
+ return (*this)[this->size() - 1];
+}
+
+template <typename T>
+void Vec<T>::reserve(size_t new_cap) {
+ this->reserve_total(new_cap);
+}
+
+template <typename T>
+void Vec<T>::push_back(const T &value) {
+ this->emplace_back(value);
+}
+
+template <typename T>
+void Vec<T>::push_back(T &&value) {
+ this->emplace_back(std::move(value));
+}
+
+template <typename T>
+template <typename... Args>
+void Vec<T>::emplace_back(Args &&... args) {
+ auto size = this->size();
+ this->reserve_total(size + 1);
+ ::new (reinterpret_cast<T *>(reinterpret_cast<char *>(this->data()) +
+ size * this->stride()))
+ T(std::forward<Args>(args)...);
+ this->set_len(size + 1);
+}
+
+template <typename T>
const T &Vec<T>::const_iterator::operator*() const noexcept {
return *static_cast<const T *>(this->pos);
}
@@ -488,14 +586,14 @@
}
template <typename T>
-bool Vec<T>::const_iterator::operator==(const const_iterator &other) const
- noexcept {
+bool Vec<T>::const_iterator::operator==(
+ const const_iterator &other) const noexcept {
return this->pos == other.pos;
}
template <typename T>
-bool Vec<T>::const_iterator::operator!=(const const_iterator &other) const
- noexcept {
+bool Vec<T>::const_iterator::operator!=(
+ const const_iterator &other) const noexcept {
return this->pos != other.pos;
}
@@ -517,7 +615,44 @@
// 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 // CXXBRIDGE03_RUST_VEC
+#endif // CXXBRIDGE05_RUST_VEC
-} // namespace cxxbridge03
+#ifndef CXXBRIDGE05_RELOCATABLE
+#define CXXBRIDGE05_RELOCATABLE
+namespace detail {
+template <typename... Ts>
+struct make_void {
+ using type = void;
+};
+
+template <typename... Ts>
+using void_t = typename make_void<Ts...>::type;
+
+template <typename Void, template <typename...> class, typename...>
+struct detect : std::false_type {};
+template <template <typename...> class T, typename... A>
+struct detect<void_t<T<A...>>, T, A...> : std::true_type {};
+
+template <template <typename...> class T, typename... A>
+using is_detected = detect<void, T, A...>;
+
+template <typename T>
+using detect_IsRelocatable = typename T::IsRelocatable;
+
+template <typename T>
+struct get_IsRelocatable
+ : std::is_same<typename T::IsRelocatable, std::true_type> {};
+} // namespace detail
+
+template <typename T>
+struct IsRelocatable
+ : std::conditional<
+ detail::is_detected<detail::detect_IsRelocatable, T>::value,
+ detail::get_IsRelocatable<T>,
+ std::integral_constant<
+ bool, std::is_trivially_move_constructible<T>::value &&
+ std::is_trivially_destructible<T>::value>>::type {};
+#endif // CXXBRIDGE05_RELOCATABLE
+
+} // namespace cxxbridge05
} // namespace rust
diff --git a/macro/Cargo.toml b/macro/Cargo.toml
index 21c4318..6b07a07 100644
--- a/macro/Cargo.toml
+++ b/macro/Cargo.toml
@@ -1,12 +1,12 @@
[package]
name = "cxxbridge-macro"
-version = "0.3.4"
+version = "0.5.9"
authors = ["David Tolnay <dtolnay@gmail.com>"]
edition = "2018"
license = "MIT OR Apache-2.0"
description = "Implementation detail of the `cxx` crate."
repository = "https://github.com/dtolnay/cxx"
-exclude = ["README.md"]
+exclude = ["build.rs", "README.md"]
keywords = ["ffi"]
categories = ["development-tools::ffi"]
@@ -19,7 +19,7 @@
syn = { version = "1.0.20", features = ["full"] }
[dev-dependencies]
-cxx = { version = "0.3", path = ".." }
+cxx = { version = "0.5", path = ".." }
[package.metadata.docs.rs]
targets = ["x86_64-unknown-linux-gnu"]
diff --git a/macro/build.rs b/macro/build.rs
new file mode 100644
index 0000000..927f72b
--- /dev/null
+++ b/macro/build.rs
@@ -0,0 +1 @@
+include!("../tools/cargo/build.rs");
diff --git a/macro/src/derive.rs b/macro/src/derive.rs
new file mode 100644
index 0000000..1abc5da
--- /dev/null
+++ b/macro/src/derive.rs
@@ -0,0 +1,14 @@
+use crate::syntax::Derive;
+use proc_macro2::TokenStream;
+use quote::{quote, ToTokens};
+
+pub struct DeriveAttribute<'a>(pub &'a [Derive]);
+
+impl<'a> ToTokens for DeriveAttribute<'a> {
+ fn to_tokens(&self, tokens: &mut TokenStream) {
+ if !self.0.is_empty() {
+ let derives = self.0;
+ tokens.extend(quote!(#[derive(#(#derives),*)]));
+ }
+ }
+}
diff --git a/macro/src/expand.rs b/macro/src/expand.rs
index f28d955..903585e 100644
--- a/macro/src/expand.rs
+++ b/macro/src/expand.rs
@@ -1,93 +1,95 @@
+use crate::derive::DeriveAttribute;
use crate::syntax::atom::Atom::{self, *};
-use crate::syntax::namespace::Namespace;
+use crate::syntax::file::Module;
use crate::syntax::report::Errors;
use crate::syntax::symbol::Symbol;
use crate::syntax::{
- self, check, mangle, Api, Enum, ExternFn, ExternType, Signature, Struct, Type, TypeAlias, Types,
+ self, check, mangle, Api, Enum, ExternFn, ExternType, Impl, Pair, ResolvableName, Signature,
+ Struct, Type, TypeAlias, Types,
};
use proc_macro2::{Ident, Span, TokenStream};
use quote::{format_ident, quote, quote_spanned, ToTokens};
-use syn::{parse_quote, Error, ItemMod, Result, Token};
+use std::mem;
+use syn::{parse_quote, Result, Token};
-pub fn bridge(namespace: &Namespace, mut ffi: ItemMod) -> Result<TokenStream> {
+pub fn bridge(mut ffi: Module) -> Result<TokenStream> {
let ref mut errors = Errors::new();
- let content = ffi.content.take().ok_or(Error::new(
- Span::call_site(),
- "#[cxx::bridge] module must have inline contents",
- ))?;
- let ref apis = syntax::parse_items(errors, content.1);
+ let content = mem::take(&mut ffi.content);
+ let trusted = ffi.unsafety.is_some();
+ let namespace = &ffi.namespace;
+ let ref apis = syntax::parse_items(errors, content, trusted, namespace);
let ref types = Types::collect(errors, apis);
errors.propagate()?;
- check::typecheck(errors, namespace, apis, types);
+ check::typecheck(errors, apis, types);
errors.propagate()?;
- Ok(expand(namespace, ffi, apis, types))
+ Ok(expand(ffi, apis, types))
}
-fn expand(namespace: &Namespace, ffi: ItemMod, apis: &[Api], types: &Types) -> TokenStream {
+fn expand(ffi: Module, apis: &[Api], types: &Types) -> TokenStream {
let mut expanded = TokenStream::new();
let mut hidden = TokenStream::new();
for api in apis {
if let Api::RustType(ety) = api {
expanded.extend(expand_rust_type(ety));
- let ident = &ety.ident;
- let span = ident.span();
- hidden.extend(quote_spanned! {span=>
- let _ = ::std::ptr::read::<#ident>;
- });
+ hidden.extend(expand_rust_type_assert_sized(ety));
}
}
for api in apis {
match api {
- Api::Include(_) | Api::RustType(_) => {}
+ Api::Include(_) | Api::RustType(_) | Api::Impl(_) => {}
Api::Struct(strct) => expanded.extend(expand_struct(strct)),
Api::Enum(enm) => expanded.extend(expand_enum(enm)),
Api::CxxType(ety) => {
- if !types.enums.contains_key(&ety.ident) {
- expanded.extend(expand_cxx_type(namespace, ety));
+ let ident = &ety.name.rust;
+ if !types.structs.contains_key(ident) && !types.enums.contains_key(ident) {
+ expanded.extend(expand_cxx_type(ety));
}
}
Api::CxxFunction(efn) => {
- expanded.extend(expand_cxx_function_shim(namespace, efn, types));
+ expanded.extend(expand_cxx_function_shim(efn, types));
}
- Api::RustFunction(efn) => {
- hidden.extend(expand_rust_function_shim(namespace, efn, types))
- }
+ Api::RustFunction(efn) => hidden.extend(expand_rust_function_shim(efn, types)),
Api::TypeAlias(alias) => {
expanded.extend(expand_type_alias(alias));
- hidden.extend(expand_type_alias_verify(namespace, alias));
+ hidden.extend(expand_type_alias_verify(alias, types));
}
}
}
for ty in types {
+ let explicit_impl = types.explicit_impls.get(ty);
if let Type::RustBox(ty) = ty {
if let Type::Ident(ident) = &ty.inner {
- if Atom::from(ident).is_none() {
- hidden.extend(expand_rust_box(namespace, ident));
+ if Atom::from(&ident.rust).is_none() {
+ hidden.extend(expand_rust_box(ident, types));
}
}
} else if let Type::RustVec(ty) = ty {
if let Type::Ident(ident) = &ty.inner {
- if Atom::from(ident).is_none() {
- hidden.extend(expand_rust_vec(namespace, ident));
+ if Atom::from(&ident.rust).is_none() {
+ hidden.extend(expand_rust_vec(ident, types));
}
}
} else if let Type::UniquePtr(ptr) = ty {
if let Type::Ident(ident) = &ptr.inner {
- if Atom::from(ident).is_none() && !types.aliases.contains_key(ident) {
- expanded.extend(expand_unique_ptr(namespace, ident, types));
+ if Atom::from(&ident.rust).is_none()
+ && (explicit_impl.is_some() || !types.aliases.contains_key(&ident.rust))
+ {
+ expanded.extend(expand_unique_ptr(ident, types, explicit_impl));
}
}
} else if let Type::CxxVector(ptr) = ty {
if let Type::Ident(ident) = &ptr.inner {
- if Atom::from(ident).is_none() && !types.aliases.contains_key(ident) {
+ if Atom::from(&ident.rust).is_none()
+ && (explicit_impl.is_some() || !types.aliases.contains_key(&ident.rust))
+ {
// Generate impl for CxxVector<T> if T is a struct or opaque
// C++ type. Impl for primitives is already provided by cxx
// crate.
- expanded.extend(expand_cxx_vector(namespace, ident));
+ expanded.extend(expand_cxx_vector(ident, explicit_impl, types));
}
}
}
@@ -121,29 +123,37 @@
}
fn expand_struct(strct: &Struct) -> TokenStream {
- let ident = &strct.ident;
+ let ident = &strct.name.rust;
let doc = &strct.doc;
- let derives = &strct.derives;
+ let derives = DeriveAttribute(&strct.derives);
+ let type_id = type_id(&strct.name);
let fields = strct.fields.iter().map(|field| {
// This span on the pub makes "private type in public interface" errors
// appear in the right place.
let vis = Token);
quote!(#vis #field)
});
+
quote! {
#doc
- #[derive(#(#derives),*)]
+ #derives
#[repr(C)]
pub struct #ident {
#(#fields,)*
}
+
+ unsafe impl ::cxx::ExternType for #ident {
+ type Id = #type_id;
+ type Kind = ::cxx::kind::Trivial;
+ }
}
}
fn expand_enum(enm: &Enum) -> TokenStream {
- let ident = &enm.ident;
+ let ident = &enm.name.rust;
let doc = &enm.doc;
let repr = enm.repr;
+ let type_id = type_id(&enm.name);
let variants = enm.variants.iter().map(|variant| {
let variant_ident = &variant.ident;
let discriminant = &variant.discriminant;
@@ -151,6 +161,7 @@
pub const #variant_ident: Self = #ident { repr: #discriminant };
})
});
+
quote! {
#doc
#[derive(Copy, Clone, PartialEq, Eq)]
@@ -163,13 +174,18 @@
impl #ident {
#(#variants)*
}
+
+ unsafe impl ::cxx::ExternType for #ident {
+ type Id = #type_id;
+ type Kind = ::cxx::kind::Trivial;
+ }
}
}
-fn expand_cxx_type(namespace: &Namespace, ety: &ExternType) -> TokenStream {
- let ident = &ety.ident;
+fn expand_cxx_type(ety: &ExternType) -> TokenStream {
+ let ident = &ety.name.rust;
let doc = &ety.doc;
- let type_id = type_id(namespace, ident);
+ let type_id = type_id(&ety.name);
quote! {
#doc
@@ -180,19 +196,19 @@
unsafe impl ::cxx::ExternType for #ident {
type Id = #type_id;
+ type Kind = ::cxx::kind::Opaque;
}
}
}
-fn expand_cxx_function_decl(namespace: &Namespace, efn: &ExternFn, types: &Types) -> TokenStream {
- let ident = &efn.ident;
+fn expand_cxx_function_decl(efn: &ExternFn, types: &Types) -> TokenStream {
let receiver = efn.receiver.iter().map(|receiver| {
let receiver_type = receiver.ty();
quote!(_: #receiver_type)
});
let args = efn.args.iter().map(|arg| {
let ident = &arg.ident;
- let ty = expand_extern_type(&arg.ty);
+ let ty = expand_extern_type(&arg.ty, types, true);
if arg.ty == RustString {
quote!(#ident: *const #ty)
} else if let Type::RustVec(_) = arg.ty {
@@ -209,25 +225,24 @@
let ret = if efn.throws {
quote!(-> ::cxx::private::Result)
} else {
- expand_extern_return_type(&efn.ret, types)
+ expand_extern_return_type(&efn.ret, types, true)
};
let mut outparam = None;
if indirect_return(efn, types) {
- let ret = expand_extern_type(efn.ret.as_ref().unwrap());
+ let ret = expand_extern_type(efn.ret.as_ref().unwrap(), types, true);
outparam = Some(quote!(__return: *mut #ret));
}
- let link_name = mangle::extern_fn(namespace, efn);
- let local_name = format_ident!("__{}", ident);
+ let link_name = mangle::extern_fn(efn, types);
+ let local_name = format_ident!("__{}", efn.name.rust);
quote! {
#[link_name = #link_name]
fn #local_name(#(#all_args,)* #outparam) #ret;
}
}
-fn expand_cxx_function_shim(namespace: &Namespace, efn: &ExternFn, types: &Types) -> TokenStream {
- let ident = &efn.ident;
+fn expand_cxx_function_shim(efn: &ExternFn, types: &Types) -> TokenStream {
let doc = &efn.doc;
- let decl = expand_cxx_function_decl(namespace, efn, types);
+ let decl = expand_cxx_function_decl(efn, types);
let receiver = efn.receiver.iter().map(|receiver| {
let ampersand = receiver.ampersand;
let mutability = receiver.mutability;
@@ -253,17 +268,29 @@
let arg_vars = efn.args.iter().map(|arg| {
let var = &arg.ident;
match &arg.ty {
- Type::Ident(ident) if ident == RustString => {
+ Type::Ident(ident) if ident.rust == RustString => {
quote!(#var.as_mut_ptr() as *const ::cxx::private::RustString)
}
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 == RustString => {
- quote!(::cxx::private::RustString::from_ref(#var))
- }
- Type::RustVec(_) => quote!(::cxx::private::RustVec::from_ref(#var)),
+ Type::Ident(ident) if ident.rust == RustString => match ty.mutability {
+ None => quote!(::cxx::private::RustString::from_ref(#var)),
+ Some(_) => quote!(::cxx::private::RustString::from_mut(#var)),
+ },
+ Type::RustVec(vec) if vec.inner == RustString => match ty.mutability {
+ None => quote!(::cxx::private::RustVec::from_ref_vec_string(#var)),
+ Some(_) => quote!(::cxx::private::RustVec::from_mut_vec_string(#var)),
+ },
+ Type::RustVec(_) => match ty.mutability {
+ None => quote!(::cxx::private::RustVec::from_ref(#var)),
+ Some(_) => quote!(::cxx::private::RustVec::from_mut(#var)),
+ },
+ inner if types.is_considered_improper_ctype(inner) => match ty.mutability {
+ None => quote!(#var as *const #inner as *const ::std::ffi::c_void),
+ Some(_) => quote!(#var as *mut #inner as *mut ::std::ffi::c_void),
+ },
_ => quote!(#var),
},
Type::Str(_) => quote!(::cxx::private::RustStr::from(#var)),
@@ -279,9 +306,7 @@
.filter_map(|arg| {
if let Type::Fn(f) = &arg.ty {
let var = &arg.ident;
- Some(expand_function_pointer_trampoline(
- namespace, efn, var, f, types,
- ))
+ Some(expand_function_pointer_trampoline(efn, var, f, types))
} else {
None
}
@@ -300,23 +325,22 @@
}
})
.collect::<TokenStream>();
- let local_name = format_ident!("__{}", ident);
+ let local_name = format_ident!("__{}", efn.name.rust);
let call = if indirect_return {
- let ret = expand_extern_type(efn.ret.as_ref().unwrap());
+ let ret = expand_extern_type(efn.ret.as_ref().unwrap(), types, true);
setup.extend(quote! {
let mut __return = ::std::mem::MaybeUninit::<#ret>::uninit();
});
- if efn.throws {
- setup.extend(quote! {
+ setup.extend(if efn.throws {
+ quote! {
#local_name(#(#vars,)* __return.as_mut_ptr()).exception()?;
- });
- quote!(::std::result::Result::Ok(__return.assume_init()))
+ }
} else {
- setup.extend(quote! {
+ quote! {
#local_name(#(#vars,)* __return.as_mut_ptr());
- });
- quote!(__return.assume_init())
- }
+ }
+ });
+ quote!(__return.assume_init())
} else if efn.throws {
quote! {
#local_name(#(#vars),*).exception()
@@ -326,53 +350,65 @@
#local_name(#(#vars),*)
}
};
- let expr = if efn.throws {
- efn.ret.as_ref().and_then(|ret| match ret {
- Type::Ident(ident) if ident == RustString => {
- Some(quote!(#call.map(|r| r.into_string())))
- }
- Type::RustBox(_) => Some(quote!(#call.map(|r| ::std::boxed::Box::from_raw(r)))),
- Type::RustVec(_) => Some(quote!(#call.map(|r| r.into_vec()))),
- Type::UniquePtr(_) => Some(quote!(#call.map(|r| ::cxx::UniquePtr::from_raw(r)))),
- Type::Ref(ty) => match &ty.inner {
- Type::Ident(ident) if ident == RustString => {
- Some(quote!(#call.map(|r| r.as_string())))
- }
- Type::RustVec(_) => Some(quote!(#call.map(|r| r.as_vec()))),
- _ => None,
- },
- Type::Str(_) => Some(quote!(#call.map(|r| r.as_str()))),
- Type::SliceRefU8(_) => Some(quote!(#call.map(|r| r.as_slice()))),
- _ => None,
- })
+ let mut expr;
+ if efn.throws && efn.sig.ret.is_none() {
+ expr = call;
} else {
- efn.ret.as_ref().and_then(|ret| match ret {
- Type::Ident(ident) if ident == RustString => Some(quote!(#call.into_string())),
- Type::RustBox(_) => Some(quote!(::std::boxed::Box::from_raw(#call))),
- Type::RustVec(_) => Some(quote!(#call.into_vec())),
- Type::UniquePtr(_) => Some(quote!(::cxx::UniquePtr::from_raw(#call))),
- Type::Ref(ty) => match &ty.inner {
- Type::Ident(ident) if ident == RustString => Some(quote!(#call.as_string())),
- Type::RustVec(_) => Some(quote!(#call.as_vec())),
- _ => None,
+ expr = match &efn.ret {
+ None => call,
+ Some(ret) => match ret {
+ 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!(#call.into_vec_string())
+ } else {
+ quote!(#call.into_vec())
+ }
+ }
+ Type::UniquePtr(_) => quote!(::cxx::UniquePtr::from_raw(#call)),
+ Type::Ref(ty) => match &ty.inner {
+ Type::Ident(ident) if ident.rust == RustString => match ty.mutability {
+ None => quote!(#call.as_string()),
+ Some(_) => quote!(#call.as_mut_string()),
+ },
+ Type::RustVec(vec) if vec.inner == RustString => match ty.mutability {
+ None => quote!(#call.as_vec_string()),
+ Some(_) => quote!(#call.as_mut_vec_string()),
+ },
+ Type::RustVec(_) => match ty.mutability {
+ None => quote!(#call.as_vec()),
+ Some(_) => quote!(#call.as_mut_vec()),
+ },
+ inner if types.is_considered_improper_ctype(inner) => {
+ let mutability = ty.mutability;
+ quote!(&#mutability *#call.cast())
+ }
+ _ => call,
+ },
+ Type::Str(_) => quote!(#call.as_str()),
+ Type::SliceRefU8(_) => quote!(#call.as_slice()),
+ _ => call,
},
- Type::Str(_) => Some(quote!(#call.as_str())),
- Type::SliceRefU8(_) => Some(quote!(#call.as_slice())),
- _ => None,
- })
+ };
+ if efn.throws {
+ expr = quote!(::std::result::Result::Ok(#expr));
+ }
+ };
+ let mut dispatch = quote!(#setup #expr);
+ let unsafety = &efn.sig.unsafety;
+ if unsafety.is_none() {
+ dispatch = quote!(unsafe { #dispatch });
}
- .unwrap_or(call);
+ let ident = &efn.name.rust;
let function_shim = quote! {
#doc
- pub fn #ident(#(#all_args,)*) #ret {
+ pub #unsafety fn #ident(#(#all_args,)*) #ret {
extern "C" {
#decl
}
#trampolines
- unsafe {
- #setup
- #expr
- }
+ #dispatch
}
};
match &efn.receiver {
@@ -385,16 +421,15 @@
}
fn expand_function_pointer_trampoline(
- namespace: &Namespace,
efn: &ExternFn,
var: &Ident,
sig: &Signature,
types: &Types,
) -> TokenStream {
- let c_trampoline = mangle::c_trampoline(namespace, efn, var);
- let r_trampoline = mangle::r_trampoline(namespace, efn, var);
+ let c_trampoline = mangle::c_trampoline(efn, var, types);
+ let r_trampoline = mangle::r_trampoline(efn, var, types);
let local_name = parse_quote!(__);
- let catch_unwind_label = format!("::{}::{}", efn.ident, var);
+ let catch_unwind_label = format!("::{}::{}", efn.name.rust, var);
let shim = expand_rust_function_shim_impl(
sig,
types,
@@ -420,18 +455,39 @@
}
fn expand_rust_type(ety: &ExternType) -> TokenStream {
- let ident = &ety.ident;
+ let ident = &ety.name.rust;
quote! {
use super::#ident;
}
}
-fn expand_rust_function_shim(namespace: &Namespace, efn: &ExternFn, types: &Types) -> TokenStream {
- let ident = &efn.ident;
- let link_name = mangle::extern_fn(namespace, efn);
- let local_name = format_ident!("__{}", ident);
- let catch_unwind_label = format!("::{}", ident);
- let invoke = Some(ident);
+fn expand_rust_type_assert_sized(ety: &ExternType) -> TokenStream {
+ // Rustc will render as follows if not sized:
+ //
+ // type TheirType;
+ // -----^^^^^^^^^-
+ // | |
+ // | doesn't have a size known at compile-time
+ // required by this bound in `ffi::_::__AssertSized`
+
+ let ident = &ety.name.rust;
+ let begin_span = Token;
+ let sized = quote_spanned! {ety.semi_token.span=>
+ #begin_span std::marker::Sized
+ };
+ quote_spanned! {ident.span()=>
+ let _ = {
+ fn __AssertSized<T: ?#sized + #sized>() {}
+ __AssertSized::<#ident>
+ };
+ }
+}
+
+fn expand_rust_function_shim(efn: &ExternFn, types: &Types) -> TokenStream {
+ let link_name = mangle::extern_fn(efn, types);
+ let local_name = format_ident!("__{}", efn.name.rust);
+ let catch_unwind_label = format!("::{}", efn.name.rust);
+ let invoke = Some(&efn.name.rust);
expand_rust_function_shim_impl(
efn,
types,
@@ -460,7 +516,7 @@
});
let args = sig.args.iter().map(|arg| {
let ident = &arg.ident;
- let ty = expand_extern_type(&arg.ty);
+ let ty = expand_extern_type(&arg.ty, types, false);
if types.needs_indirect_abi(&arg.ty) {
quote!(#ident: *mut #ty)
} else {
@@ -472,15 +528,31 @@
let arg_vars = sig.args.iter().map(|arg| {
let ident = &arg.ident;
match &arg.ty {
- Type::Ident(i) if i == RustString => {
+ Type::Ident(i) if i.rust == RustString => {
quote!(::std::mem::take((*#ident).as_mut_string()))
}
Type::RustBox(_) => quote!(::std::boxed::Box::from_raw(#ident)),
- Type::RustVec(_) => quote!(::std::mem::take((*#ident).as_mut_vec())),
+ Type::RustVec(vec) => {
+ if vec.inner == RustString {
+ quote!(::std::mem::take((*#ident).as_mut_vec_string()))
+ } else {
+ quote!(::std::mem::take((*#ident).as_mut_vec()))
+ }
+ }
Type::UniquePtr(_) => quote!(::cxx::UniquePtr::from_raw(#ident)),
Type::Ref(ty) => match &ty.inner {
- Type::Ident(i) if i == RustString => quote!(#ident.as_string()),
- Type::RustVec(_) => quote!(#ident.as_vec()),
+ Type::Ident(i) if i.rust == RustString => match ty.mutability {
+ None => quote!(#ident.as_string()),
+ Some(_) => quote!(#ident.as_mut_string()),
+ },
+ Type::RustVec(vec) if vec.inner == RustString => match ty.mutability {
+ None => quote!(#ident.as_vec_string()),
+ Some(_) => quote!(#ident.as_mut_vec_string()),
+ },
+ Type::RustVec(_) => match ty.mutability {
+ None => quote!(#ident.as_vec()),
+ Some(_) => quote!(#ident.as_mut_vec()),
+ },
_ => quote!(#ident),
},
Type::Str(_) => quote!(#ident.as_str()),
@@ -491,45 +563,57 @@
});
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 call = match invoke {
- Some(ident) => match &sig.receiver {
- None => quote!(super::#ident),
- Some(receiver) => {
- let receiver_type = &receiver.ty;
- quote!(#receiver_type::#ident)
- }
- },
- None => quote!(__extern),
+ Some(_) => quote!(#local_name),
+ None => quote!(::std::mem::transmute::<*const (), #sig>(__extern)),
};
call.extend(quote! { (#(#vars),*) });
- let mut expr = sig
- .ret
- .as_ref()
- .and_then(|ret| match ret {
- Type::Ident(ident) if ident == RustString => {
- Some(quote!(::cxx::private::RustString::from(#call)))
+ let conversion = sig.ret.as_ref().and_then(|ret| match ret {
+ Type::Ident(ident) if ident.rust == RustString => {
+ Some(quote!(::cxx::private::RustString::from))
+ }
+ Type::RustBox(_) => Some(quote!(::std::boxed::Box::into_raw)),
+ Type::RustVec(vec) => {
+ if vec.inner == RustString {
+ Some(quote!(::cxx::private::RustVec::from_vec_string))
+ } else {
+ Some(quote!(::cxx::private::RustVec::from))
}
- Type::RustBox(_) => Some(quote!(::std::boxed::Box::into_raw(#call))),
- Type::RustVec(_) => Some(quote!(::cxx::private::RustVec::from(#call))),
- Type::UniquePtr(_) => Some(quote!(::cxx::UniquePtr::into_raw(#call))),
- Type::Ref(ty) => match &ty.inner {
- Type::Ident(ident) if ident == RustString => {
- Some(quote!(::cxx::private::RustString::from_ref(#call)))
- }
- Type::RustVec(_) => Some(quote!(::cxx::private::RustVec::from_ref(#call))),
- _ => None,
+ }
+ Type::UniquePtr(_) => Some(quote!(::cxx::UniquePtr::into_raw)),
+ Type::Ref(ty) => match &ty.inner {
+ Type::Ident(ident) if ident.rust == RustString => match ty.mutability {
+ None => Some(quote!(::cxx::private::RustString::from_ref)),
+ Some(_) => Some(quote!(::cxx::private::RustString::from_mut)),
},
- Type::Str(_) => Some(quote!(::cxx::private::RustStr::from(#call))),
- Type::SliceRefU8(_) => Some(quote!(::cxx::private::RustSliceU8::from(#call))),
+ Type::RustVec(vec) if vec.inner == RustString => match ty.mutability {
+ None => Some(quote!(::cxx::private::RustVec::from_ref_vec_string)),
+ Some(_) => Some(quote!(::cxx::private::RustVec::from_mut_vec_string)),
+ },
+ Type::RustVec(_) => match ty.mutability {
+ None => Some(quote!(::cxx::private::RustVec::from_ref)),
+ Some(_) => Some(quote!(::cxx::private::RustVec::from_mut)),
+ },
_ => None,
- })
- .unwrap_or(call);
+ },
+ Type::Str(_) => Some(quote!(::cxx::private::RustStr::from)),
+ Type::SliceRefU8(_) => Some(quote!(::cxx::private::RustSliceU8::from)),
+ _ => None,
+ });
+
+ let mut expr = match conversion {
+ None => call,
+ 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());
+ let ret = expand_extern_type(sig.ret.as_ref().unwrap(), types, false);
outparam = Some(quote!(__return: *mut #ret,));
}
if sig.throws {
@@ -547,11 +631,11 @@
let ret = if sig.throws {
quote!(-> ::cxx::private::Result)
} else {
- expand_extern_return_type(&sig.ret, types)
+ expand_extern_return_type(&sig.ret, types, false)
};
let pointer = match invoke {
- None => Some(quote!(__extern: #sig)),
+ None => Some(quote!(__extern: *const ())),
Some(_) => None,
};
@@ -560,51 +644,108 @@
#[export_name = #link_name]
unsafe extern "C" fn #local_name(#(#all_args,)* #outparam #pointer) #ret {
let __fn = concat!(module_path!(), #catch_unwind_label);
+ #wrap_super
#expr
}
}
}
+// A wrapper like `fn f(x: Arg) { super::f(x) }` just to ensure we have the
+// accurate unsafety declaration and no problematic elided lifetimes.
+fn expand_rust_function_shim_super(
+ sig: &Signature,
+ local_name: &Ident,
+ invoke: &Ident,
+) -> TokenStream {
+ let unsafety = sig.unsafety;
+
+ let receiver_var = sig
+ .receiver
+ .as_ref()
+ .map(|receiver| Ident::new("__self", receiver.var.span));
+ let receiver = sig.receiver.iter().map(|receiver| {
+ let receiver_type = receiver.ty();
+ quote!(#receiver_var: #receiver_type)
+ });
+ let args = sig.args.iter().map(|arg| quote!(#arg));
+ let all_args = receiver.chain(args);
+
+ let ret = if let Some((result, _langle, rangle)) = sig.throws_tokens {
+ let ok = match &sig.ret {
+ Some(ret) => quote!(#ret),
+ None => quote!(()),
+ };
+ 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)
+ };
+
+ let arg_vars = sig.args.iter().map(|arg| &arg.ident);
+ let vars = receiver_var.iter().chain(arg_vars);
+
+ let span = invoke.span();
+ let call = match &sig.receiver {
+ None => quote_spanned!(span=> super::#invoke),
+ Some(receiver) => {
+ let receiver_type = &receiver.ty;
+ quote_spanned!(span=> #receiver_type::#invoke)
+ }
+ };
+
+ quote_spanned! {span=>
+ #unsafety fn #local_name(#(#all_args,)*) #ret {
+ #call(#(#vars,)*)
+ }
+ }
+}
+
fn expand_type_alias(alias: &TypeAlias) -> TokenStream {
- let ident = &alias.ident;
+ let doc = &alias.doc;
+ let ident = &alias.name.rust;
let ty = &alias.ty;
quote! {
+ #doc
pub type #ident = #ty;
}
}
-fn expand_type_alias_verify(namespace: &Namespace, alias: &TypeAlias) -> TokenStream {
- let ident = &alias.ident;
- let type_id = type_id(namespace, ident);
+fn expand_type_alias_verify(alias: &TypeAlias, types: &Types) -> TokenStream {
+ let ident = &alias.name.rust;
+ let type_id = type_id(&alias.name);
let begin_span = alias.type_token.span;
let end_span = alias.semi_token.span;
let begin = quote_spanned!(begin_span=> ::cxx::private::verify_extern_type::<);
let end = quote_spanned!(end_span=> >);
- quote! {
+ let mut verify = quote! {
const _: fn() = #begin #ident, #type_id #end;
+ };
+
+ if types.required_trivial.contains_key(&alias.name.rust) {
+ let begin = quote_spanned!(begin_span=> ::cxx::private::verify_extern_kind::<);
+ verify.extend(quote! {
+ const _: fn() = #begin #ident, ::cxx::kind::Trivial #end;
+ });
}
+
+ verify
}
-fn type_id(namespace: &Namespace, ident: &Ident) -> TokenStream {
- let mut path = String::new();
- for name in namespace {
- path += &name.to_string();
- path += "::";
- }
- path += &ident.to_string();
-
+fn type_id(name: &Pair) -> TokenStream {
+ let path = name.to_fully_qualified();
quote! {
::cxx::type_id!(#path)
}
}
-fn expand_rust_box(namespace: &Namespace, ident: &Ident) -> TokenStream {
- let link_prefix = format!("cxxbridge03$box${}{}$", namespace, ident);
+fn expand_rust_box(ident: &ResolvableName, types: &Types) -> TokenStream {
+ let link_prefix = format!("cxxbridge05$box${}$", types.resolve(ident).to_symbol());
let link_uninit = format!("{}uninit", link_prefix);
let link_drop = format!("{}drop", link_prefix);
- let local_prefix = format_ident!("{}__box_", ident);
+ let local_prefix = format_ident!("{}__box_", &ident.rust);
let local_uninit = format_ident!("{}uninit", local_prefix);
let local_drop = format_ident!("{}drop", local_prefix);
@@ -628,19 +769,23 @@
}
}
-fn expand_rust_vec(namespace: &Namespace, elem: &Ident) -> TokenStream {
- let link_prefix = format!("cxxbridge03$rust_vec${}{}$", namespace, elem);
+fn expand_rust_vec(elem: &ResolvableName, types: &Types) -> TokenStream {
+ let link_prefix = format!("cxxbridge05$rust_vec${}$", elem.to_symbol(types));
let link_new = format!("{}new", link_prefix);
let link_drop = format!("{}drop", link_prefix);
let link_len = format!("{}len", link_prefix);
let link_data = format!("{}data", link_prefix);
+ let link_reserve_total = format!("{}reserve_total", link_prefix);
+ let link_set_len = format!("{}set_len", link_prefix);
let link_stride = format!("{}stride", link_prefix);
- let local_prefix = format_ident!("{}__vec_", elem);
+ let local_prefix = format_ident!("{}__vec_", elem.rust);
let local_new = format_ident!("{}new", local_prefix);
let local_drop = format_ident!("{}drop", local_prefix);
let local_len = format_ident!("{}len", local_prefix);
let local_data = format_ident!("{}data", local_prefix);
+ let local_reserve_total = format_ident!("{}reserve_total", local_prefix);
+ let local_set_len = format_ident!("{}set_len", local_prefix);
let local_stride = format_ident!("{}stride", local_prefix);
let span = elem.span();
@@ -666,6 +811,16 @@
(*this).as_ptr()
}
#[doc(hidden)]
+ #[export_name = #link_reserve_total]
+ unsafe extern "C" fn #local_reserve_total(this: *mut ::cxx::private::RustVec<#elem>, cap: usize) {
+ (*this).reserve_total(cap);
+ }
+ #[doc(hidden)]
+ #[export_name = #link_set_len]
+ unsafe extern "C" fn #local_set_len(this: *mut ::cxx::private::RustVec<#elem>, len: usize) {
+ (*this).set_len(len);
+ }
+ #[doc(hidden)]
#[export_name = #link_stride]
unsafe extern "C" fn #local_stride() -> usize {
::std::mem::size_of::<#elem>()
@@ -673,9 +828,13 @@
}
}
-fn expand_unique_ptr(namespace: &Namespace, ident: &Ident, types: &Types) -> TokenStream {
- let name = ident.to_string();
- let prefix = format!("cxxbridge03$unique_ptr${}{}$", namespace, ident);
+fn expand_unique_ptr(
+ ident: &ResolvableName,
+ types: &Types,
+ explicit_impl: Option<&Impl>,
+) -> TokenStream {
+ let name = ident.rust.to_string();
+ let prefix = format!("cxxbridge05$unique_ptr${}$", ident.to_symbol(types));
let link_null = format!("{}null", prefix);
let link_new = format!("{}new", prefix);
let link_raw = format!("{}raw", prefix);
@@ -683,24 +842,30 @@
let link_release = format!("{}release", prefix);
let link_drop = format!("{}drop", prefix);
- let new_method = if types.structs.contains_key(ident) {
- Some(quote! {
- fn __new(mut value: Self) -> *mut ::std::ffi::c_void {
- extern "C" {
- #[link_name = #link_new]
- fn __new(this: *mut *mut ::std::ffi::c_void, value: *mut #ident);
+ let new_method =
+ if types.structs.contains_key(&ident.rust) || types.aliases.contains_key(&ident.rust) {
+ Some(quote! {
+ fn __new(mut value: Self) -> *mut ::std::ffi::c_void {
+ extern "C" {
+ #[link_name = #link_new]
+ fn __new(this: *mut *mut ::std::ffi::c_void, value: *mut #ident);
+ }
+ let mut repr = ::std::ptr::null_mut::<::std::ffi::c_void>();
+ unsafe { __new(&mut repr, &mut value) }
+ repr
}
- let mut repr = ::std::ptr::null_mut::<::std::ffi::c_void>();
- unsafe { __new(&mut repr, &mut value) }
- repr
- }
- })
- } else {
- None
- };
+ })
+ } else {
+ None
+ };
- quote! {
- unsafe impl ::cxx::private::UniquePtrTarget for #ident {
+ let begin_span =
+ explicit_impl.map_or_else(Span::call_site, |explicit| explicit.impl_token.span);
+ let end_span = explicit_impl.map_or_else(Span::call_site, |explicit| explicit.brace_token.span);
+ let unsafe_token = format_ident!("unsafe", span = begin_span);
+
+ quote_spanned! {end_span=>
+ #unsafe_token impl ::cxx::private::UniquePtrTarget for #ident {
const __NAME: &'static dyn ::std::fmt::Display = &#name;
fn __null() -> *mut ::std::ffi::c_void {
extern "C" {
@@ -746,20 +911,33 @@
}
}
-fn expand_cxx_vector(namespace: &Namespace, elem: &Ident) -> TokenStream {
- let name = elem.to_string();
- let prefix = format!("cxxbridge03$std$vector${}{}$", namespace, elem);
+fn expand_cxx_vector(
+ elem: &ResolvableName,
+ explicit_impl: Option<&Impl>,
+ types: &Types,
+) -> TokenStream {
+ let _ = explicit_impl;
+ let name = elem.rust.to_string();
+ let prefix = format!("cxxbridge05$std$vector${}$", elem.to_symbol(types));
let link_size = format!("{}size", prefix);
let link_get_unchecked = format!("{}get_unchecked", prefix);
- let unique_ptr_prefix = format!("cxxbridge03$unique_ptr$std$vector${}{}$", namespace, elem);
+ let unique_ptr_prefix = format!(
+ "cxxbridge05$unique_ptr$std$vector${}$",
+ elem.to_symbol(types)
+ );
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);
let link_unique_ptr_release = format!("{}release", unique_ptr_prefix);
let link_unique_ptr_drop = format!("{}drop", unique_ptr_prefix);
- quote! {
- unsafe impl ::cxx::private::VectorElement for #elem {
+ let begin_span =
+ explicit_impl.map_or_else(Span::call_site, |explicit| explicit.impl_token.span);
+ let end_span = explicit_impl.map_or_else(Span::call_site, |explicit| explicit.brace_token.span);
+ let unsafe_token = format_ident!("unsafe", span = begin_span);
+
+ quote_spanned! {end_span=>
+ #unsafe_token impl ::cxx::private::VectorElement for #elem {
const __NAME: &'static dyn ::std::fmt::Display = &#name;
fn __vector_size(v: &::cxx::CxxVector<Self>) -> usize {
extern "C" {
@@ -768,12 +946,12 @@
}
unsafe { __vector_size(v) }
}
- unsafe fn __get_unchecked(v: &::cxx::CxxVector<Self>, pos: usize) -> &Self {
+ unsafe fn __get_unchecked(v: &::cxx::CxxVector<Self>, pos: usize) -> *const Self {
extern "C" {
#[link_name = #link_get_unchecked]
fn __get_unchecked(_: &::cxx::CxxVector<#elem>, _: usize) -> *const #elem;
}
- &*__get_unchecked(v, pos)
+ __get_unchecked(v, pos)
}
fn __unique_ptr_null() -> *mut ::std::ffi::c_void {
extern "C" {
@@ -831,36 +1009,45 @@
.map_or(false, |ret| sig.throws || types.needs_indirect_abi(ret))
}
-fn expand_extern_type(ty: &Type) -> TokenStream {
+fn expand_extern_type(ty: &Type, types: &Types, proper: bool) -> TokenStream {
match ty {
- Type::Ident(ident) if ident == RustString => quote!(::cxx::private::RustString),
+ Type::Ident(ident) if ident.rust == RustString => quote!(::cxx::private::RustString),
Type::RustBox(ty) | Type::UniquePtr(ty) => {
- let inner = expand_extern_type(&ty.inner);
+ let inner = expand_extern_type(&ty.inner, types, proper);
quote!(*mut #inner)
}
Type::RustVec(ty) => {
- let elem = expand_extern_type(&ty.inner);
+ let elem = expand_extern_type(&ty.inner, types, proper);
quote!(::cxx::private::RustVec<#elem>)
}
- Type::Ref(ty) => match &ty.inner {
- Type::Ident(ident) if ident == RustString => quote!(&::cxx::private::RustString),
- Type::RustVec(ty) => {
- let inner = expand_extern_type(&ty.inner);
- quote!(&::cxx::private::RustVec<#inner>)
+ Type::Ref(ty) => {
+ let mutability = ty.mutability;
+ match &ty.inner {
+ Type::Ident(ident) if ident.rust == RustString => {
+ quote!(&#mutability ::cxx::private::RustString)
+ }
+ Type::RustVec(ty) => {
+ let inner = expand_extern_type(&ty.inner, types, proper);
+ quote!(&#mutability ::cxx::private::RustVec<#inner>)
+ }
+ inner if proper && types.is_considered_improper_ctype(inner) => match mutability {
+ None => quote!(*const ::std::ffi::c_void),
+ Some(_) => quote!(*#mutability ::std::ffi::c_void),
+ },
+ _ => quote!(#ty),
}
- _ => quote!(#ty),
- },
+ }
Type::Str(_) => quote!(::cxx::private::RustStr),
Type::SliceRefU8(_) => quote!(::cxx::private::RustSliceU8),
_ => quote!(#ty),
}
}
-fn expand_extern_return_type(ret: &Option<Type>, types: &Types) -> TokenStream {
+fn expand_extern_return_type(ret: &Option<Type>, types: &Types, proper: bool) -> TokenStream {
let ret = match ret {
Some(ret) if !types.needs_indirect_abi(ret) => ret,
_ => return TokenStream::new(),
};
- let ty = expand_extern_type(ret);
+ let ty = expand_extern_type(ret, types, proper);
quote!(-> #ty)
}
diff --git a/macro/src/lib.rs b/macro/src/lib.rs
index bc8d19b..e55a08a 100644
--- a/macro/src/lib.rs
+++ b/macro/src/lib.rs
@@ -9,13 +9,17 @@
extern crate proc_macro;
+mod derive;
mod expand;
mod syntax;
mod type_id;
+use crate::syntax::file::Module;
use crate::syntax::namespace::Namespace;
+use crate::syntax::qualified::QualifiedName;
use proc_macro::TokenStream;
-use syn::{parse_macro_input, ItemMod, LitStr};
+use syn::parse::{Parse, ParseStream, Parser, Result};
+use syn::parse_macro_input;
/// `#[cxx::bridge] mod ffi { ... }`
///
@@ -28,7 +32,7 @@
/// attribute macro.
///
/// ```
-/// #[cxx::bridge(namespace = mycompany::rust)]
+/// #[cxx::bridge(namespace = "mycompany::rust")]
/// # mod ffi {}
/// ```
///
@@ -38,16 +42,28 @@
pub fn bridge(args: TokenStream, input: TokenStream) -> TokenStream {
let _ = syntax::error::ERRORS;
- let namespace = parse_macro_input!(args as Namespace);
- let ffi = parse_macro_input!(input as ItemMod);
+ let namespace = match Namespace::parse_bridge_attr_namespace.parse(args) {
+ Ok(namespace) => namespace,
+ Err(err) => return err.to_compile_error().into(),
+ };
+ let mut ffi = parse_macro_input!(input as Module);
+ ffi.namespace = namespace;
- expand::bridge(&namespace, ffi)
+ expand::bridge(ffi)
.unwrap_or_else(|err| err.to_compile_error())
.into()
}
#[proc_macro]
pub fn type_id(input: TokenStream) -> TokenStream {
- let arg = parse_macro_input!(input as LitStr);
- type_id::expand(arg).into()
+ struct TypeId(QualifiedName);
+
+ impl Parse for TypeId {
+ fn parse(input: ParseStream) -> Result<Self> {
+ QualifiedName::parse_quoted_or_unquoted(input).map(TypeId)
+ }
+ }
+
+ let arg = parse_macro_input!(input as TypeId);
+ type_id::expand(arg.0).into()
}
diff --git a/macro/src/type_id.rs b/macro/src/type_id.rs
index 445da2b..5c5d9cc 100644
--- a/macro/src/type_id.rs
+++ b/macro/src/type_id.rs
@@ -1,16 +1,16 @@
+use crate::syntax::qualified::QualifiedName;
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
-use syn::LitStr;
// "folly::File" => `(f, o, l, l, y, (), F, i, l, e)`
-pub fn expand(arg: LitStr) -> TokenStream {
+pub fn expand(arg: QualifiedName) -> TokenStream {
let mut ids = Vec::new();
- for word in arg.value().split("::") {
+ for word in arg.segments {
if !ids.is_empty() {
ids.push(quote!(()));
}
- for ch in word.chars() {
+ for ch in word.to_string().chars() {
ids.push(match ch {
'A'..='Z' | 'a'..='z' => {
let t = format_ident!("{}", ch);
diff --git a/src/cxx.cc b/src/cxx.cc
index da05ee2..cbaecbf 100644
--- a/src/cxx.cc
+++ b/src/cxx.cc
@@ -1,13 +1,41 @@
#include "../include/cxx.h"
+#include <cassert>
#include <cstring>
#include <exception>
#include <iostream>
#include <memory>
#include <stdexcept>
+#include <type_traits>
#include <vector>
+extern "C" {
+const char *cxxbridge05$cxx_string$data(const std::string &s) noexcept {
+ return s.data();
+}
+
+size_t cxxbridge05$cxx_string$length(const std::string &s) noexcept {
+ return s.length();
+}
+
+// rust::String
+void cxxbridge05$string$new(rust::String *self) noexcept;
+void cxxbridge05$string$clone(rust::String *self,
+ const rust::String &other) noexcept;
+bool cxxbridge05$string$from(rust::String *self, const char *ptr,
+ size_t len) 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 cxxbridge05$str$valid(const char *ptr, size_t len) noexcept;
+} // extern "C"
+
+namespace rust {
+inline namespace cxxbridge05 {
+
template <typename Exception>
-static void panic [[noreturn]] (const char *msg) {
+void panic [[noreturn]] (const char *msg) {
#if defined(RUST_CXX_NO_EXCEPTIONS)
std::cerr << "Error: " << msg << ". Aborting." << std::endl;
std::terminate();
@@ -16,68 +44,54 @@
#endif
}
-extern "C" {
-const char *cxxbridge03$cxx_string$data(const std::string &s) noexcept {
- return s.data();
-}
+template void panic<std::out_of_range>[[noreturn]] (const char *msg);
-size_t cxxbridge03$cxx_string$length(const std::string &s) noexcept {
- return s.length();
-}
-
-// rust::String
-void cxxbridge03$string$new(rust::String *self) noexcept;
-void cxxbridge03$string$clone(rust::String *self,
- const rust::String &other) noexcept;
-bool cxxbridge03$string$from(rust::String *self, const char *ptr,
- size_t len) noexcept;
-void cxxbridge03$string$drop(rust::String *self) noexcept;
-const char *cxxbridge03$string$ptr(const rust::String *self) noexcept;
-size_t cxxbridge03$string$len(const rust::String *self) noexcept;
-
-// rust::Str
-bool cxxbridge03$str$valid(const char *ptr, size_t len) noexcept;
-} // extern "C"
-
-namespace rust {
-inline namespace cxxbridge03 {
-
-String::String() noexcept { cxxbridge03$string$new(this); }
+String::String() noexcept { cxxbridge05$string$new(this); }
String::String(const String &other) noexcept {
- cxxbridge03$string$clone(this, other);
+ cxxbridge05$string$clone(this, other);
}
String::String(String &&other) noexcept {
this->repr = other.repr;
- cxxbridge03$string$new(&other);
+ cxxbridge05$string$new(&other);
}
-String::~String() noexcept { cxxbridge03$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 (!cxxbridge03$string$from(this, s, len)) {
+static void initString(String *self, const char *s, size_t len) {
+ if (!cxxbridge05$string$from(self, s, len)) {
panic<std::invalid_argument>("data for rust::String is not utf-8");
}
}
+String::String(const std::string &s) { initString(this, s.data(), s.length()); }
+
+String::String(const char *s) {
+ assert(s != nullptr);
+ initString(this, s, std::strlen(s));
+}
+
+String::String(const char *s, size_t len) {
+ assert(s != nullptr || len == 0);
+ initString(this,
+ s == nullptr && len == 0 ? reinterpret_cast<const char *>(1) : s,
+ len);
+}
+
String &String::operator=(const String &other) noexcept {
if (this != &other) {
- cxxbridge03$string$drop(this);
- cxxbridge03$string$clone(this, other);
+ cxxbridge05$string$drop(this);
+ cxxbridge05$string$clone(this, other);
}
return *this;
}
String &String::operator=(String &&other) noexcept {
if (this != &other) {
- cxxbridge03$string$drop(this);
+ cxxbridge05$string$drop(this);
this->repr = other.repr;
- cxxbridge03$string$new(&other);
+ cxxbridge05$string$new(&other);
}
return *this;
}
@@ -87,12 +101,12 @@
}
const char *String::data() const noexcept {
- return cxxbridge03$string$ptr(this);
+ return cxxbridge05$string$ptr(this);
}
-size_t String::size() const noexcept { return cxxbridge03$string$len(this); }
+size_t String::size() const noexcept { return cxxbridge05$string$len(this); }
-size_t String::length() const noexcept { return cxxbridge03$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) {}
@@ -102,160 +116,191 @@
return os;
}
-Str::Str() noexcept : repr(Repr{reinterpret_cast<const char *>(this), 0}) {}
+Str::Str() noexcept : ptr(reinterpret_cast<const char *>(1)), len(0) {}
-Str::Str(const Str &) noexcept = default;
-
-Str::Str(const std::string &s) : Str(s.data(), s.length()) {}
-
-Str::Str(const char *s) : Str(s, std::strlen(s)) {}
-
-Str::Str(const char *s, size_t len) : repr(Repr{s, len}) {
- if (!cxxbridge03$str$valid(this->repr.ptr, this->repr.len)) {
+static void initStr(const char *ptr, size_t len) {
+ if (!cxxbridge05$str$valid(ptr, len)) {
panic<std::invalid_argument>("data for rust::Str is not utf-8");
}
}
-Str &Str::operator=(Str other) noexcept {
- this->repr = other.repr;
- return *this;
+Str::Str(const std::string &s) : ptr(s.data()), len(s.length()) {
+ initStr(this->ptr, this->len);
+}
+
+Str::Str(const char *s) : ptr(s), len(std::strlen(s)) {
+ assert(s != nullptr);
+ initStr(this->ptr, this->len);
+}
+
+Str::Str(const char *s, size_t len)
+ : ptr(s == nullptr && len == 0 ? reinterpret_cast<const char *>(1) : s),
+ len(len) {
+ assert(s != nullptr || len == 0);
+ initStr(this->ptr, this->len);
}
Str::operator std::string() const {
return std::string(this->data(), this->size());
}
-const char *Str::data() const noexcept { return this->repr.ptr; }
-
-size_t Str::size() const noexcept { return this->repr.len; }
-
-size_t Str::length() const noexcept { return this->repr.len; }
-
-Str::Str(Repr repr_) noexcept : repr(repr_) {}
-
-Str::operator Repr() noexcept { return this->repr; }
-
std::ostream &operator<<(std::ostream &os, const Str &s) {
os.write(s.data(), s.size());
return os;
}
+static_assert(std::is_trivially_copy_constructible<Str>::value,
+ "trivial Str(const Str &)");
+static_assert(std::is_trivially_copy_assignable<Str>::value,
+ "trivial operator=(const Str &)");
+static_assert(std::is_trivially_destructible<Str>::value, "trivial ~Str()");
+
extern "C" {
-const char *cxxbridge03$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);
+ std::strncpy(copy, ptr, len);
return copy;
}
} // extern "C"
-Error::Error(Str::Repr msg) noexcept : msg(msg) {}
+Error::Error(const Error &other)
+ : std::exception(other), msg(cxxbridge05$error(other.msg, other.len)),
+ len(other.len) {}
-Error::Error(const Error &other) {
- this->msg.ptr = cxxbridge03$error(other.msg.ptr, other.msg.len);
- this->msg.len = other.msg.len;
+Error::Error(Error &&other) noexcept
+ : std::exception(std::move(other)), msg(other.msg), len(other.len) {
+ other.msg = nullptr;
+ other.len = 0;
}
-Error::Error(Error &&other) noexcept {
- delete[] this->msg.ptr;
- this->msg = other.msg;
- other.msg.ptr = nullptr;
- other.msg.len = 0;
+Error::~Error() noexcept { delete[] this->msg; }
+
+Error &Error::operator=(const Error &other) {
+ if (this != &other) {
+ std::exception::operator=(other);
+ delete[] this->msg;
+ this->msg = nullptr;
+ this->msg = cxxbridge05$error(other.msg, other.len);
+ this->len = other.len;
+ }
+ return *this;
}
-Error::~Error() noexcept { delete[] this->msg.ptr; }
+Error &Error::operator=(Error &&other) noexcept {
+ if (this != &other) {
+ std::exception::operator=(std::move(other));
+ this->msg = other.msg;
+ this->len = other.len;
+ other.msg = nullptr;
+ other.len = 0;
+ }
+ return *this;
+}
-const char *Error::what() const noexcept { return this->msg.ptr; }
+const char *Error::what() const noexcept { return this->msg; }
-} // namespace cxxbridge03
+} // namespace cxxbridge05
} // namespace rust
extern "C" {
-void cxxbridge03$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 cxxbridge03$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 *cxxbridge03$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 *cxxbridge03$unique_ptr$std$string$release(
+std::string *cxxbridge05$unique_ptr$std$string$release(
std::unique_ptr<std::string> &ptr) noexcept {
return ptr.release();
}
-void cxxbridge03$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 cxxbridge03$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 *cxxbridge03$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 cxxbridge03$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 cxxbridge03$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> \
- *cxxbridge03$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> \
- *cxxbridge03$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 cxxbridge03$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 cxxbridge03$rust_vec$##RUST_TYPE##$new( \
+ void cxxbridge05$rust_vec$##RUST_TYPE##$new( \
rust::Vec<CXX_TYPE> *ptr) noexcept; \
- void cxxbridge03$rust_vec$##RUST_TYPE##$drop( \
+ void cxxbridge05$rust_vec$##RUST_TYPE##$drop( \
rust::Vec<CXX_TYPE> *ptr) noexcept; \
- size_t cxxbridge03$rust_vec$##RUST_TYPE##$len( \
+ size_t cxxbridge05$rust_vec$##RUST_TYPE##$len( \
const rust::Vec<CXX_TYPE> *ptr) noexcept; \
- const CXX_TYPE *cxxbridge03$rust_vec$##RUST_TYPE##$data( \
+ const CXX_TYPE *cxxbridge05$rust_vec$##RUST_TYPE##$data( \
const rust::Vec<CXX_TYPE> *ptr) noexcept; \
- size_t cxxbridge03$rust_vec$##RUST_TYPE##$stride() noexcept;
+ void cxxbridge05$rust_vec$##RUST_TYPE##$reserve_total( \
+ rust::Vec<CXX_TYPE> *ptr, size_t cap) noexcept; \
+ void cxxbridge05$rust_vec$##RUST_TYPE##$set_len(rust::Vec<CXX_TYPE> *ptr, \
+ size_t len) noexcept; \
+ size_t cxxbridge05$rust_vec$##RUST_TYPE##$stride() noexcept;
#define RUST_VEC_OPS(RUST_TYPE, CXX_TYPE) \
template <> \
Vec<CXX_TYPE>::Vec() noexcept { \
- cxxbridge03$rust_vec$##RUST_TYPE##$new(this); \
+ cxxbridge05$rust_vec$##RUST_TYPE##$new(this); \
} \
template <> \
void Vec<CXX_TYPE>::drop() noexcept { \
- return cxxbridge03$rust_vec$##RUST_TYPE##$drop(this); \
+ return cxxbridge05$rust_vec$##RUST_TYPE##$drop(this); \
} \
template <> \
size_t Vec<CXX_TYPE>::size() const noexcept { \
- return cxxbridge03$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 cxxbridge03$rust_vec$##RUST_TYPE##$data(this); \
+ return cxxbridge05$rust_vec$##RUST_TYPE##$data(this); \
+ } \
+ template <> \
+ void Vec<CXX_TYPE>::reserve_total(size_t cap) noexcept { \
+ cxxbridge05$rust_vec$##RUST_TYPE##$reserve_total(this, cap); \
+ } \
+ template <> \
+ void Vec<CXX_TYPE>::set_len(size_t len) noexcept { \
+ cxxbridge05$rust_vec$##RUST_TYPE##$set_len(this, len); \
} \
template <> \
size_t Vec<CXX_TYPE>::stride() noexcept { \
- return cxxbridge03$rust_vec$##RUST_TYPE##$stride(); \
+ return cxxbridge05$rust_vec$##RUST_TYPE##$stride(); \
}
// Usize and isize are the same type as one of the below.
@@ -274,11 +319,13 @@
#define FOR_EACH_STD_VECTOR(MACRO) \
FOR_EACH_NUMERIC(MACRO) \
MACRO(usize, size_t) \
- MACRO(isize, rust::isize)
+ MACRO(isize, rust::isize) \
+ MACRO(string, std::string)
#define FOR_EACH_RUST_VEC(MACRO) \
FOR_EACH_NUMERIC(MACRO) \
- MACRO(bool, bool)
+ MACRO(bool, bool) \
+ MACRO(string, rust::String)
extern "C" {
FOR_EACH_STD_VECTOR(STD_VECTOR_OPS)
@@ -286,7 +333,7 @@
} // extern "C"
namespace rust {
-inline namespace cxxbridge03 {
+inline namespace cxxbridge05 {
FOR_EACH_RUST_VEC(RUST_VEC_OPS)
-} // namespace cxxbridge03
+} // namespace cxxbridge05
} // namespace rust
diff --git a/src/cxx_string.rs b/src/cxx_string.rs
index ffd0c5c..7b47feb 100644
--- a/src/cxx_string.rs
+++ b/src/cxx_string.rs
@@ -1,12 +1,13 @@
-use std::borrow::Cow;
-use std::fmt::{self, Debug, Display};
-use std::slice;
-use std::str::{self, Utf8Error};
+use alloc::borrow::Cow;
+use alloc::string::String;
+use core::fmt::{self, Debug, Display};
+use core::slice;
+use core::str::{self, Utf8Error};
extern "C" {
- #[link_name = "cxxbridge03$cxx_string$data"]
+ #[link_name = "cxxbridge05$cxx_string$data"]
fn string_data(_: &CxxString) -> *const u8;
- #[link_name = "cxxbridge03$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 bfb4a4e..5fb0807 100644
--- a/src/cxx_vector.rs
+++ b/src/cxx_vector.rs
@@ -1,8 +1,10 @@
-use std::ffi::c_void;
-use std::fmt::{self, Display};
-use std::marker::PhantomData;
-use std::mem;
-use std::ptr;
+use crate::cxx_string::CxxString;
+use core::ffi::c_void;
+use core::fmt::{self, Display};
+use core::marker::PhantomData;
+use core::mem;
+use core::ptr;
+use core::slice;
/// Binding to C++ `std::vector<T, std::allocator<T>>`.
///
@@ -43,7 +45,7 @@
/// out of bounds.
pub fn get(&self, pos: usize) -> Option<&T> {
if pos < self.len() {
- Some(unsafe { T::__get_unchecked(self, pos) })
+ Some(unsafe { self.get_unchecked(pos) })
} else {
None
}
@@ -60,7 +62,24 @@
///
/// [operator_at]: https://en.cppreference.com/w/cpp/container/vector/operator_at
pub unsafe fn get_unchecked(&self, pos: usize) -> &T {
- T::__get_unchecked(self, pos)
+ &*T::__get_unchecked(self, pos)
+ }
+
+ /// Returns a slice to the underlying contiguous array of elements.
+ pub fn as_slice(&self) -> &[T] {
+ let len = self.len();
+ if len == 0 {
+ // The slice::from_raw_parts in the other branch requires a nonnull
+ // and properly aligned data ptr. C++ standard does not guarantee
+ // that data() on a vector with size 0 would return a nonnull
+ // pointer or sufficiently aligned pointer, so using it would be
+ // undefined behavior. Create our own empty slice in Rust instead
+ // which upholds the invariants.
+ &[]
+ } else {
+ let ptr = unsafe { T::__get_unchecked(self, 0) };
+ unsafe { slice::from_raw_parts(ptr, len) }
+ }
}
}
@@ -121,7 +140,7 @@
pub unsafe trait VectorElement: Sized {
const __NAME: &'static dyn Display;
fn __vector_size(v: &CxxVector<Self>) -> usize;
- unsafe fn __get_unchecked(v: &CxxVector<Self>, pos: usize) -> &Self;
+ unsafe fn __get_unchecked(v: &CxxVector<Self>, pos: usize) -> *const Self;
fn __unique_ptr_null() -> *mut c_void;
unsafe fn __unique_ptr_raw(raw: *mut CxxVector<Self>) -> *mut c_void;
unsafe fn __unique_ptr_get(repr: *mut c_void) -> *const CxxVector<Self>;
@@ -129,34 +148,34 @@
unsafe fn __unique_ptr_drop(repr: *mut c_void);
}
-macro_rules! impl_vector_element_for_primitive {
- ($ty:ident) => {
+macro_rules! impl_vector_element {
+ ($segment:expr, $name:expr, $ty:ty) => {
const_assert_eq!(1, mem::align_of::<CxxVector<$ty>>());
unsafe impl VectorElement for $ty {
- const __NAME: &'static dyn Display = &stringify!($ty);
+ const __NAME: &'static dyn Display = &$name;
fn __vector_size(v: &CxxVector<$ty>) -> usize {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge03$std$vector$", stringify!($ty), "$size")]
+ #[link_name = concat!("cxxbridge05$std$vector$", $segment, "$size")]
fn __vector_size(_: &CxxVector<$ty>) -> usize;
}
}
unsafe { __vector_size(v) }
}
- unsafe fn __get_unchecked(v: &CxxVector<$ty>, pos: usize) -> &$ty {
+ unsafe fn __get_unchecked(v: &CxxVector<$ty>, pos: usize) -> *const $ty {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge03$std$vector$", stringify!($ty), "$get_unchecked")]
+ #[link_name = concat!("cxxbridge05$std$vector$", $segment, "$get_unchecked")]
fn __get_unchecked(_: &CxxVector<$ty>, _: usize) -> *const $ty;
}
}
- &*__get_unchecked(v, pos)
+ __get_unchecked(v, pos)
}
fn __unique_ptr_null() -> *mut c_void {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge03$unique_ptr$std$vector$", stringify!($ty), "$null")]
+ #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$null")]
fn __unique_ptr_null(this: *mut *mut c_void);
}
}
@@ -167,7 +186,7 @@
unsafe fn __unique_ptr_raw(raw: *mut CxxVector<Self>) -> *mut c_void {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge03$unique_ptr$std$vector$", stringify!($ty), "$raw")]
+ #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$raw")]
fn __unique_ptr_raw(this: *mut *mut c_void, raw: *mut CxxVector<$ty>);
}
}
@@ -178,7 +197,7 @@
unsafe fn __unique_ptr_get(repr: *mut c_void) -> *const CxxVector<Self> {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge03$unique_ptr$std$vector$", stringify!($ty), "$get")]
+ #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$get")]
fn __unique_ptr_get(this: *const *mut c_void) -> *const CxxVector<$ty>;
}
}
@@ -187,7 +206,7 @@
unsafe fn __unique_ptr_release(mut repr: *mut c_void) -> *mut CxxVector<Self> {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge03$unique_ptr$std$vector$", stringify!($ty), "$release")]
+ #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$release")]
fn __unique_ptr_release(this: *mut *mut c_void) -> *mut CxxVector<$ty>;
}
}
@@ -196,7 +215,7 @@
unsafe fn __unique_ptr_drop(mut repr: *mut c_void) {
extern "C" {
attr! {
- #[link_name = concat!("cxxbridge03$unique_ptr$std$vector$", stringify!($ty), "$drop")]
+ #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$drop")]
fn __unique_ptr_drop(this: *mut *mut c_void);
}
}
@@ -206,6 +225,12 @@
};
}
+macro_rules! impl_vector_element_for_primitive {
+ ($ty:ident) => {
+ impl_vector_element!(stringify!($ty), stringify!($ty), $ty);
+ };
+}
+
impl_vector_element_for_primitive!(u8);
impl_vector_element_for_primitive!(u16);
impl_vector_element_for_primitive!(u32);
@@ -218,3 +243,5 @@
impl_vector_element_for_primitive!(isize);
impl_vector_element_for_primitive!(f32);
impl_vector_element_for_primitive!(f64);
+
+impl_vector_element!("string", "CxxString", CxxString);
diff --git a/src/exception.rs b/src/exception.rs
index 125e484..0ffca66 100644
--- a/src/exception.rs
+++ b/src/exception.rs
@@ -1,4 +1,5 @@
-use std::fmt::{self, Debug, Display};
+use alloc::boxed::Box;
+use core::fmt::{self, Debug, Display};
/// Exception thrown from an `extern "C"` function.
#[derive(Debug)]
diff --git a/src/extern_type.rs b/src/extern_type.rs
index 6701ef5..f92ff40 100644
--- a/src/extern_type.rs
+++ b/src/extern_type.rs
@@ -1,3 +1,5 @@
+use self::kind::{Kind, Opaque, Trivial};
+
/// A type for which the layout is determined by its C++ definition.
///
/// This trait serves the following two related purposes.
@@ -26,7 +28,7 @@
/// ```no_run
/// // file1.rs
/// # mod file1 {
-/// #[cxx::bridge(namespace = example)]
+/// #[cxx::bridge(namespace = "example")]
/// pub mod ffi {
/// extern "C" {
/// type Demo;
@@ -37,7 +39,7 @@
/// # }
///
/// // file2.rs
-/// #[cxx::bridge(namespace = example)]
+/// #[cxx::bridge(namespace = "example")]
/// pub mod ffi {
/// extern "C" {
/// type Demo = crate::file1::ffi::Demo;
@@ -54,7 +56,7 @@
/// ## Integrating with bindgen-generated types
///
/// Handwritten `ExternType` impls make it possible to plug in a data structure
-/// emitted by bindgen as the definition of an opaque C++ type emitted by CXX.
+/// emitted by bindgen as the definition of a C++ type emitted by CXX.
///
/// By writing the unsafe `ExternType` impl, the programmer asserts that the C++
/// namespace and type name given in the type id refers to a C++ type that is
@@ -73,9 +75,10 @@
///
/// unsafe impl ExternType for folly_sys::StringPiece {
/// type Id = type_id!("folly::StringPiece");
+/// type Kind = cxx::kind::Opaque;
/// }
///
-/// #[cxx::bridge(namespace = folly)]
+/// #[cxx::bridge(namespace = "folly")]
/// pub mod ffi {
/// extern "C" {
/// include!("rust_cxx_bindings.h");
@@ -101,10 +104,80 @@
/// # struct TypeName;
/// # unsafe impl cxx::ExternType for TypeName {
/// type Id = cxx::type_id!("name::space::of::TypeName");
+ /// # type Kind = cxx::kind::Opaque;
/// # }
/// ```
type Id;
+
+ /// Either [`cxx::kind::Opaque`] or [`cxx::kind::Trivial`].
+ ///
+ /// [`cxx::kind::Opaque`]: kind::Opaque
+ /// [`cxx::kind::Trivial`]: kind::Trivial
+ ///
+ /// A C++ type is only okay to hold and pass around by value in Rust if its
+ /// [move constructor is trivial] and it has no destructor. In CXX, these
+ /// are called Trivial extern C++ types, while types with nontrivial move
+ /// behavior or a destructor must be considered Opaque and handled by Rust
+ /// only behind an indirection, such as a reference or UniquePtr.
+ ///
+ /// [move constructor is trivial]: https://en.cppreference.com/w/cpp/types/is_move_constructible
+ ///
+ /// If you believe your C++ type reflected by this ExternType impl is indeed
+ /// fine to hold by value and move in Rust, you can specify:
+ ///
+ /// ```
+ /// # struct TypeName;
+ /// # unsafe impl cxx::ExternType for TypeName {
+ /// # type Id = cxx::type_id!("name::space::of::TypeName");
+ /// type Kind = cxx::kind::Trivial;
+ /// # }
+ /// ```
+ ///
+ /// which will enable you to pass it into C++ functions by value, return it
+ /// by value, and include it in `struct`s that you have declared to
+ /// `cxx::bridge`. Your claim about the triviality of the C++ type will be
+ /// checked by a `static_assert` in the generated C++ side of the binding.
+ type Kind: Kind;
+}
+
+/// Marker types identifying Rust's knowledge about an extern C++ type.
+///
+/// These markers are used in the [`Kind`][ExternType::Kind] associated type in
+/// impls of the `ExternType` trait. Refer to the documentation of `Kind` for an
+/// overview of their purpose.
+pub mod kind {
+ use super::private;
+
+ /// An opaque type which cannot be passed or held by value within Rust.
+ ///
+ /// Rust's move semantics are such that every move is equivalent to a
+ /// memcpy. This is incompatible in general with C++'s constructor-based
+ /// move semantics, so a C++ type which has a destructor or nontrivial move
+ /// constructor must never exist by value in Rust. In CXX, such types are
+ /// called opaque C++ types.
+ ///
+ /// When passed across an FFI boundary, an opaque C++ type must be behind an
+ /// indirection such as a reference or UniquePtr.
+ pub enum Opaque {}
+
+ /// A type with trivial move constructor and no destructor, which can
+ /// therefore be owned and moved around in Rust code without requiring
+ /// indirection.
+ pub enum Trivial {}
+
+ pub trait Kind: private::Sealed {}
+ impl Kind for Opaque {}
+ impl Kind for Trivial {}
+}
+
+mod private {
+ pub trait Sealed {}
+ impl Sealed for super::Opaque {}
+ impl Sealed for super::Trivial {}
}
#[doc(hidden)]
pub fn verify_extern_type<T: ExternType<Id = Id>, Id>() {}
+
+#[doc(hidden)]
+pub fn verify_extern_kind<T: ExternType<Kind = Kind>, Kind: self::Kind>() {}
diff --git a/src/lib.rs b/src/lib.rs
index 30dd41f..17d7548 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -18,7 +18,7 @@
//!
//! <br>
//!
-//! *Compiler support: requires rustc 1.42+ and c++11 or newer*<br>
+//! *Compiler support: requires rustc 1.43+ and c++11 or newer*<br>
//! *[Release notes](https://github.com/dtolnay/cxx/releases)*
//!
//! <br>
@@ -57,66 +57,72 @@
//!
//! # Example
//!
-//! A runnable version of this example is provided under the *demo-rs* directory
-//! of [https://github.com/dtolnay/cxx] (with the C++ side of the implementation
-//! in the *demo-cxx* directory). To try it out, jump into demo-rs and run
-//! `cargo run`.
+//! In this example we are writing a Rust application that wishes to take
+//! advantage of an existing C++ client for a large-file blobstore service. The
+//! blobstore supports a `put` operation for a discontiguous buffer upload. For
+//! example we might be uploading snapshots of a circular buffer which would
+//! tend to consist of 2 chunks, or fragments of a file spread across memory for
+//! some other reason.
+//!
+//! A runnable version of this example is provided under the *demo* directory of
+//! <https://github.com/dtolnay/cxx>. To try it out, run `cargo run` from that
+//! directory.
//!
//! ```no_run
//! #[cxx::bridge]
//! mod ffi {
//! // Any shared structs, whose fields will be visible to both languages.
-//! struct SharedThing {
-//! z: i32,
-//! y: Box<ThingR>,
-//! x: UniquePtr<ThingC>,
-//! }
-//!
-//! extern "C" {
-//! // One or more headers with the matching C++ declarations. Our code
-//! // generators don't read it but it gets #include'd and used in static
-//! // assertions to ensure our picture of the FFI boundary is accurate.
-//! include!("demo-cxx/demo.h");
-//!
-//! // Zero or more opaque types which both languages can pass around but
-//! // only C++ can see the fields.
-//! type ThingC;
-//!
-//! // Functions implemented in C++.
-//! fn make_demo(appname: &str) -> UniquePtr<ThingC>;
-//! fn get_name(thing: &ThingC) -> &CxxString;
-//! fn do_thing(state: SharedThing);
+//! struct BlobMetadata {
+//! size: usize,
+//! tags: Vec<String>,
//! }
//!
//! extern "Rust" {
//! // Zero or more opaque types which both languages can pass around but
//! // only Rust can see the fields.
-//! type ThingR;
+//! type MultiBuf;
//!
//! // Functions implemented in Rust.
-//! fn print_r(r: &ThingR);
+//! fn next_chunk(buf: &mut MultiBuf) -> &[u8];
+//! }
+//!
+//! extern "C++" {
+//! // One or more headers with the matching C++ declarations. Our code
+//! // generators don't read it but it gets #include'd and used in static
+//! // assertions to ensure our picture of the FFI boundary is accurate.
+//! include!("demo/include/blobstore.h");
+//!
+//! // Zero or more opaque types which both languages can pass around but
+//! // only C++ can see the fields.
+//! type BlobstoreClient;
+//!
+//! // Functions implemented in C++.
+//! fn new_blobstore_client() -> UniquePtr<BlobstoreClient>;
+//! fn put(&self, parts: &mut MultiBuf) -> u64;
+//! fn tag(&self, blobid: u64, tag: &str);
+//! fn metadata(&self, blobid: u64) -> BlobMetadata;
//! }
//! }
//! #
-//! # pub struct ThingR(usize);
+//! # pub struct MultiBuf;
//! #
-//! # fn print_r(r: &ThingR) {
-//! # println!("called back with r={}", r.0);
+//! # fn next_chunk(_buf: &mut MultiBuf) -> &[u8] {
+//! # unimplemented!()
//! # }
//! #
//! # fn main() {}
//! ```
//!
-//! Now we simply provide C++ definitions of all the things in the `extern "C"`
-//! block and Rust definitions of all the things in the `extern "Rust"` block,
-//! and get to call back and forth safely.
+//! Now we simply provide Rust definitions of all the things in the `extern
+//! "Rust"` block and C++ definitions of all the things in the `extern "C++"`
+//! block, and get to call back and forth safely.
//!
//! Here are links to the complete set of source files involved in the demo:
//!
-//! - [demo-rs/src/main.rs](https://github.com/dtolnay/cxx/blob/master/demo-rs/src/main.rs)
-//! - [demo-rs/build.rs](https://github.com/dtolnay/cxx/blob/master/demo-rs/build.rs)
-//! - [demo-cxx/demo.h](https://github.com/dtolnay/cxx/blob/master/demo-cxx/demo.h)
-//! - [demo-cxx/demo.cc](https://github.com/dtolnay/cxx/blob/master/demo-cxx/demo.cc)
+//! - [demo/src/main.rs](https://github.com/dtolnay/cxx/blob/master/demo/src/main.rs)
+//! - [demo/build.rs](https://github.com/dtolnay/cxx/blob/master/demo/build.rs)
+//! - [demo/include/blobstore.h](https://github.com/dtolnay/cxx/blob/master/demo/include/blobstore.h)
+//! - [demo/src/blobstore.cc](https://github.com/dtolnay/cxx/blob/master/demo/src/blobstore.cc)
//!
//! To look at the code generated in both languages for the example by the CXX
//! code generators:
@@ -124,10 +130,10 @@
//! ```console
//! # run Rust code generator and print to stdout
//! # (requires https://github.com/dtolnay/cargo-expand)
-//! $ cargo expand --manifest-path demo-rs/Cargo.toml
+//! $ cargo expand --manifest-path demo/Cargo.toml
//!
//! # run C++ code generator and print to stdout
-//! $ cargo run --manifest-path gen/cmd/Cargo.toml -- demo-rs/src/main.rs
+//! $ cargo run --manifest-path gen/cmd/Cargo.toml -- demo/src/main.rs
//! ```
//!
//! <br>
@@ -229,7 +235,7 @@
//! # Cargo.toml
//!
//! [build-dependencies]
-//! cxx-build = "0.3"
+//! cxx-build = "0.5"
//! ```
//!
//! ```no_run
@@ -237,13 +243,13 @@
//!
//! fn main() {
//! cxx_build::bridge("src/main.rs") // returns a cc::Build
-//! .file("../demo-cxx/demo.cc")
+//! .file("src/demo.cc")
//! .flag_if_supported("-std=c++11")
//! .compile("cxxbridge-demo");
//!
//! println!("cargo:rerun-if-changed=src/main.rs");
-//! println!("cargo:rerun-if-changed=../demo-cxx/demo.h");
-//! println!("cargo:rerun-if-changed=../demo-cxx/demo.cc");
+//! println!("cargo:rerun-if-changed=src/demo.cc");
+//! println!("cargo:rerun-if-changed=include/demo.h");
//! }
//! ```
//!
@@ -254,7 +260,7 @@
//! For use in non-Cargo builds like Bazel or Buck, CXX provides an alternate
//! way of invoking the C++ code generator as a standalone command line tool.
//! The tool is packaged as the `cxxbridge-cmd` crate on crates.io or can be
-//! built from the *cmd* directory of [https://github.com/dtolnay/cxx].
+//! built from the *gen/cmd* directory of <https://github.com/dtolnay/cxx>.
//!
//! ```bash
//! $ cargo install cxxbridge-cmd
@@ -329,7 +335,7 @@
//! </table>
//!
//! The C++ API of the `rust` namespace is defined by the *include/cxx.h* file
-//! in [https://github.com/dtolnay/cxx]. You will need to include this header in
+//! in <https://github.com/dtolnay/cxx>. You will need to include this header in
//! your C++ code when working with those types.
//!
//! The following types are intended to be supported "soon" but are just not
@@ -341,14 +347,14 @@
//! <tr><td>BTreeMap<K, V></td><td><sup><i>tbd</i></sup></td></tr>
//! <tr><td>HashMap<K, V></td><td><sup><i>tbd</i></sup></td></tr>
//! <tr><td>Arc<T></td><td><sup><i>tbd</i></sup></td></tr>
+//! <tr><td>Option<T></td><td><sup><i>tbd</i></sup></td></tr>
//! <tr><td><sup><i>tbd</i></sup></td><td>std::map<K, V></td></tr>
//! <tr><td><sup><i>tbd</i></sup></td><td>std::unordered_map<K, V></td></tr>
//! <tr><td><sup><i>tbd</i></sup></td><td>std::shared_ptr<T></td></tr>
//! </table>
-//!
-//! [https://github.com/dtolnay/cxx]: https://github.com/dtolnay/cxx
-#![doc(html_root_url = "https://docs.rs/cxx/0.3.4")]
+#![no_std]
+#![doc(html_root_url = "https://docs.rs/cxx/0.5.9")]
#![deny(improper_ctypes)]
#![allow(non_camel_case_types)]
#![allow(
@@ -367,6 +373,12 @@
clippy::useless_let_if_seq
)]
+#[cfg(built_with_cargo)]
+extern crate link_cplusplus;
+
+extern crate alloc;
+extern crate std;
+
#[macro_use]
mod macros;
@@ -381,27 +393,41 @@
mod rust_str;
mod rust_string;
mod rust_vec;
+mod symbols;
mod unique_ptr;
mod unwind;
-#[cfg(not(no_export_symbols))]
-mod symbols;
-
pub use crate::cxx_string::CxxString;
pub use crate::cxx_vector::CxxVector;
pub use crate::exception::Exception;
-pub use crate::extern_type::ExternType;
+pub use crate::extern_type::{kind, ExternType};
pub use crate::unique_ptr::UniquePtr;
pub use cxxbridge_macro::bridge;
/// For use in impls of the `ExternType` trait. See [`ExternType`].
+///
+/// [`ExternType`]: trait.ExternType.html
pub use cxxbridge_macro::type_id;
+/// Synonym for `CxxString`.
+///
+/// To avoid confusion with Rust's standard library string you probably
+/// shouldn't import this type with `use`. Instead, write `cxx::String`, or
+/// import and use `CxxString`.
+pub type String = CxxString;
+
+/// Synonym for `CxxVector`.
+///
+/// To avoid confusion with Rust's standard library vector you probably
+/// shouldn't import this type with `use`. Instead, write `cxx::Vector<T>`, or
+/// import and use `CxxVector`.
+pub type Vector<T> = CxxVector<T>;
+
// Not public API.
#[doc(hidden)]
pub mod private {
pub use crate::cxx_vector::VectorElement;
- pub use crate::extern_type::verify_extern_type;
+ pub use crate::extern_type::{verify_extern_kind, verify_extern_type};
pub use crate::function::FatFunction;
pub use crate::opaque::Opaque;
pub use crate::result::{r#try, Result};
diff --git a/src/macros/assert.rs b/src/macros/assert.rs
index 738e5bb..5d5ea9e 100644
--- a/src/macros/assert.rs
+++ b/src/macros/assert.rs
@@ -1,3 +1,5 @@
+#[macro_export]
+#[doc(hidden)]
macro_rules! const_assert_eq {
($left:expr, $right:expr $(,)?) => {
const _: [(); $left] = [(); $right];
diff --git a/src/macros/concat.rs b/src/macros/concat.rs
index e67e50d..5ee77c5 100644
--- a/src/macros/concat.rs
+++ b/src/macros/concat.rs
@@ -1,3 +1,5 @@
+#[macro_export]
+#[doc(hidden)]
macro_rules! attr {
(#[$name:ident = $value:expr] $($rest:tt)*) => {
#[$name = $value]
diff --git a/src/opaque.rs b/src/opaque.rs
index 0ff6bb9..bad57e7 100644
--- a/src/opaque.rs
+++ b/src/opaque.rs
@@ -1,4 +1,4 @@
-use std::mem;
+use core::mem;
// . size = 0
// . align = 1
diff --git a/src/result.rs b/src/result.rs
index 0373bd8..fcced76 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -1,10 +1,12 @@
use crate::exception::Exception;
use crate::rust_str::RustStr;
-use std::fmt::Display;
-use std::ptr;
-use std::result::Result as StdResult;
-use std::slice;
-use std::str;
+use alloc::boxed::Box;
+use alloc::string::{String, ToString};
+use core::fmt::Display;
+use core::ptr;
+use core::result::Result as StdResult;
+use core::slice;
+use core::str;
#[repr(C)]
pub union Result {
@@ -32,7 +34,7 @@
let len = msg.len();
extern "C" {
- #[link_name = "cxxbridge03$error"]
+ #[link_name = "cxxbridge05$error"]
fn error(ptr: *const u8, len: usize) -> *const u8;
}
diff --git a/src/rust_sliceu8.rs b/src/rust_sliceu8.rs
index f509c7f..32f8798 100644
--- a/src/rust_sliceu8.rs
+++ b/src/rust_sliceu8.rs
@@ -1,6 +1,6 @@
-use std::mem;
-use std::ptr::NonNull;
-use std::slice;
+use core::mem;
+use core::ptr::NonNull;
+use core::slice;
// Not necessarily ABI compatible with &[u8]. Codegen performs the translation.
#[repr(C)]
diff --git a/src/rust_str.rs b/src/rust_str.rs
index b944ede..38e5cab 100644
--- a/src/rust_str.rs
+++ b/src/rust_str.rs
@@ -1,7 +1,7 @@
-use std::mem;
-use std::ptr::NonNull;
-use std::slice;
-use std::str;
+use core::mem;
+use core::ptr::NonNull;
+use core::slice;
+use core::str;
// Not necessarily ABI compatible with &str. Codegen performs the translation.
#[repr(C)]
diff --git a/src/rust_string.rs b/src/rust_string.rs
index a923ced..a5fa3f4 100644
--- a/src/rust_string.rs
+++ b/src/rust_string.rs
@@ -1,4 +1,5 @@
-use std::mem;
+use alloc::string::String;
+use core::mem;
#[repr(C)]
pub struct RustString {
@@ -14,6 +15,10 @@
unsafe { &*(s as *const String as *const RustString) }
}
+ pub fn from_mut(s: &mut String) -> &mut Self {
+ unsafe { &mut *(s as *mut String as *mut RustString) }
+ }
+
pub fn into_string(self) -> String {
self.repr
}
diff --git a/src/rust_vec.rs b/src/rust_vec.rs
index 4c5035d..8ddc4a7 100644
--- a/src/rust_vec.rs
+++ b/src/rust_vec.rs
@@ -1,6 +1,11 @@
+use crate::rust_string::RustString;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::mem::ManuallyDrop;
+
#[repr(C)]
pub struct RustVec<T> {
- repr: Vec<T>,
+ pub(crate) repr: Vec<T>,
}
impl<T> RustVec<T> {
@@ -16,6 +21,10 @@
unsafe { &*(v as *const Vec<T> as *const RustVec<T>) }
}
+ pub fn from_mut(v: &mut Vec<T>) -> &mut Self {
+ unsafe { &mut *(v as *mut Vec<T> as *mut RustVec<T>) }
+ }
+
pub fn into_vec(self) -> Vec<T> {
self.repr
}
@@ -35,4 +44,49 @@
pub fn as_ptr(&self) -> *const T {
self.repr.as_ptr()
}
+
+ 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) {
+ self.repr.set_len(len);
+ }
+}
+
+impl RustVec<RustString> {
+ pub fn from_vec_string(v: Vec<String>) -> Self {
+ let mut v = ManuallyDrop::new(v);
+ let ptr = v.as_mut_ptr().cast::<RustString>();
+ let len = v.len();
+ let cap = v.capacity();
+ Self::from(unsafe { Vec::from_raw_parts(ptr, len, cap) })
+ }
+
+ pub fn from_ref_vec_string(v: &Vec<String>) -> &Self {
+ Self::from_ref(unsafe { &*(v as *const Vec<String> as *const Vec<RustString>) })
+ }
+
+ pub fn from_mut_vec_string(v: &mut Vec<String>) -> &mut Self {
+ Self::from_mut(unsafe { &mut *(v as *mut Vec<String> as *mut Vec<RustString>) })
+ }
+
+ pub fn into_vec_string(self) -> Vec<String> {
+ let mut v = ManuallyDrop::new(self.repr);
+ let ptr = v.as_mut_ptr().cast::<String>();
+ let len = v.len();
+ let cap = v.capacity();
+ unsafe { Vec::from_raw_parts(ptr, len, cap) }
+ }
+
+ pub fn as_vec_string(&self) -> &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 *(&mut self.repr as *mut Vec<RustString> as *mut Vec<String>) }
+ }
}
diff --git a/src/symbols/exception.rs b/src/symbols/exception.rs
index 849db3b..b408f25 100644
--- a/src/symbols/exception.rs
+++ b/src/symbols/exception.rs
@@ -1,6 +1,8 @@
-use std::slice;
+use alloc::boxed::Box;
+use alloc::string::String;
+use core::slice;
-#[export_name = "cxxbridge03$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 6dc04ac..b655381 100644
--- a/src/symbols/rust_str.rs
+++ b/src/symbols/rust_str.rs
@@ -1,7 +1,7 @@
-use std::slice;
-use std::str;
+use core::slice;
+use core::str;
-#[export_name = "cxxbridge03$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 63d4ba7..e5ab9ea 100644
--- a/src/symbols/rust_string.rs
+++ b/src/symbols/rust_string.rs
@@ -1,19 +1,21 @@
-use std::mem::{ManuallyDrop, MaybeUninit};
-use std::ptr;
-use std::slice;
-use std::str;
+use alloc::borrow::ToOwned;
+use alloc::string::String;
+use core::mem::{ManuallyDrop, MaybeUninit};
+use core::ptr;
+use core::slice;
+use core::str;
-#[export_name = "cxxbridge03$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 = "cxxbridge03$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 = "cxxbridge03$string$from"]
+#[export_name = "cxxbridge05$string$from"]
unsafe extern "C" fn string_from(
this: &mut MaybeUninit<String>,
ptr: *const u8,
@@ -29,17 +31,17 @@
}
}
-#[export_name = "cxxbridge03$string$drop"]
+#[export_name = "cxxbridge05$string$drop"]
unsafe extern "C" fn string_drop(this: &mut ManuallyDrop<String>) {
ManuallyDrop::drop(this);
}
-#[export_name = "cxxbridge03$string$ptr"]
+#[export_name = "cxxbridge05$string$ptr"]
unsafe extern "C" fn string_ptr(this: &String) -> *const u8 {
this.as_ptr()
}
-#[export_name = "cxxbridge03$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 9ce87ab..90fbc54 100644
--- a/src/symbols/rust_vec.rs
+++ b/src/symbols/rust_vec.rs
@@ -1,50 +1,53 @@
-use std::mem;
-use std::ptr;
+use crate::rust_string::RustString;
+use crate::rust_vec::RustVec;
+use alloc::vec::Vec;
+use core::mem;
+use core::ptr;
-#[repr(C)]
-pub struct RustVec<T> {
- repr: Vec<T>,
-}
-
-macro_rules! attr {
- (#[$name:ident = $value:expr] $($rest:tt)*) => {
- #[$name = $value]
- $($rest)*
- };
-}
-
-macro_rules! rust_vec_shims_for_primitive {
- ($ty:ident) => {
+macro_rules! rust_vec_shims {
+ ($segment:expr, $ty: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!("cxxbridge03$rust_vec$", stringify!($ty), "$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!("cxxbridge03$rust_vec$", stringify!($ty), "$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!("cxxbridge03$rust_vec$", stringify!($ty), "$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!("cxxbridge03$rust_vec$", stringify!($ty), "$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!("cxxbridge03$rust_vec$", stringify!($ty), "$stride")]
+ #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$reserve_total")]
+ unsafe extern "C" fn __reserve_total(this: *mut RustVec<$ty>, cap: usize) {
+ (*this).reserve_total(cap);
+ }
+ }
+ attr! {
+ #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$set_len")]
+ unsafe extern "C" fn __set_len(this: *mut RustVec<$ty>, len: usize) {
+ (*this).repr.set_len(len);
+ }
+ }
+ attr! {
+ #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$stride")]
unsafe extern "C" fn __stride() -> usize {
mem::size_of::<$ty>()
}
@@ -53,6 +56,12 @@
};
}
+macro_rules! rust_vec_shims_for_primitive {
+ ($ty:ident) => {
+ rust_vec_shims!(stringify!($ty), $ty);
+ };
+}
+
rust_vec_shims_for_primitive!(bool);
rust_vec_shims_for_primitive!(u8);
rust_vec_shims_for_primitive!(u16);
@@ -64,3 +73,5 @@
rust_vec_shims_for_primitive!(i64);
rust_vec_shims_for_primitive!(f32);
rust_vec_shims_for_primitive!(f64);
+
+rust_vec_shims!("string", RustString);
diff --git a/src/symbols/symbols.rs b/src/symbols/symbols.rs
deleted file mode 100644
index 2c052ec..0000000
--- a/src/symbols/symbols.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#[path = "../macros/mod.rs"]
-#[macro_use]
-mod macros;
-
-include!("mod.rs");
diff --git a/src/unique_ptr.rs b/src/unique_ptr.rs
index 34a1f0e..3a5fc66 100644
--- a/src/unique_ptr.rs
+++ b/src/unique_ptr.rs
@@ -1,11 +1,13 @@
use crate::cxx_string::CxxString;
use crate::cxx_vector::{self, CxxVector, VectorElement};
-use std::ffi::c_void;
-use std::fmt::{self, Debug, Display};
-use std::marker::PhantomData;
-use std::mem;
-use std::ops::{Deref, DerefMut};
-use std::ptr;
+use crate::kind::Trivial;
+use crate::ExternType;
+use core::ffi::c_void;
+use core::fmt::{self, Debug, Display};
+use core::marker::PhantomData;
+use core::mem;
+use core::ops::{Deref, DerefMut};
+use core::ptr;
/// Binding to C++ `std::unique_ptr<T, std::default_delete<T>>`.
#[repr(C)]
@@ -32,7 +34,10 @@
}
/// Allocates memory on the heap and makes a UniquePtr pointing to it.
- pub fn new(value: T) -> Self {
+ pub fn new(value: T) -> Self
+ where
+ T: ExternType<Kind = Trivial>,
+ {
UniquePtr {
repr: T::__new(value),
ty: PhantomData,
@@ -174,15 +179,15 @@
}
extern "C" {
- #[link_name = "cxxbridge03$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 = "cxxbridge03$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 = "cxxbridge03$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 = "cxxbridge03$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 = "cxxbridge03$unique_ptr$std$string$drop"]
+ #[link_name = "cxxbridge05$unique_ptr$std$string$drop"]
fn unique_ptr_std_string_drop(this: *mut *mut c_void);
}
@@ -190,7 +195,9 @@
const __NAME: &'static dyn Display = &"CxxString";
fn __null() -> *mut c_void {
let mut repr = ptr::null_mut::<c_void>();
- unsafe { unique_ptr_std_string_null(&mut repr) }
+ unsafe {
+ unique_ptr_std_string_null(&mut repr);
+ }
repr
}
unsafe fn __raw(raw: *mut Self) -> *mut c_void {
diff --git a/syntax/atom.rs b/syntax/atom.rs
index 6e5fa88..7d0ef6b 100644
--- a/syntax/atom.rs
+++ b/syntax/atom.rs
@@ -81,7 +81,7 @@
impl PartialEq<Atom> for Type {
fn eq(&self, atom: &Atom) -> bool {
match self {
- Type::Ident(ident) => ident == atom,
+ Type::Ident(ident) => ident.rust == atom,
_ => false,
}
}
diff --git a/syntax/attrs.rs b/syntax/attrs.rs
index 4c76641..af73b7a 100644
--- a/syntax/attrs.rs
+++ b/syntax/attrs.rs
@@ -1,3 +1,4 @@
+use crate::syntax::namespace::Namespace;
use crate::syntax::report::Errors;
use crate::syntax::Atom::{self, *};
use crate::syntax::{Derive, Doc};
@@ -10,19 +11,9 @@
pub doc: Option<&'a mut Doc>,
pub derives: Option<&'a mut Vec<Derive>>,
pub repr: Option<&'a mut Option<Atom>>,
-}
-
-pub(super) fn parse_doc(cx: &mut Errors, attrs: &[Attribute]) -> Doc {
- let mut doc = Doc::new();
- parse(
- cx,
- attrs,
- Parser {
- doc: Some(&mut doc),
- ..Parser::default()
- },
- );
- doc
+ pub cxx_name: Option<&'a mut Option<Ident>>,
+ pub rust_name: Option<&'a mut Option<Ident>>,
+ pub namespace: Option<&'a mut Namespace>,
}
pub(super) fn parse(cx: &mut Errors, attrs: &[Attribute], mut parser: Parser) {
@@ -57,6 +48,36 @@
}
Err(err) => return cx.push(err),
}
+ } else if attr.path.is_ident("cxx_name") {
+ match parse_function_alias_attribute.parse2(attr.tokens.clone()) {
+ Ok(attr) => {
+ if let Some(cxx_name) = &mut parser.cxx_name {
+ **cxx_name = Some(attr);
+ continue;
+ }
+ }
+ Err(err) => return cx.push(err),
+ }
+ } else if attr.path.is_ident("rust_name") {
+ match parse_function_alias_attribute.parse2(attr.tokens.clone()) {
+ Ok(attr) => {
+ if let Some(rust_name) = &mut parser.rust_name {
+ **rust_name = Some(attr);
+ continue;
+ }
+ }
+ Err(err) => return cx.push(err),
+ }
+ } else if attr.path.is_ident("namespace") {
+ match parse_namespace_attribute.parse2(attr.tokens.clone()) {
+ Ok(attr) => {
+ if let Some(namespace) = &mut parser.namespace {
+ **namespace = attr;
+ continue;
+ }
+ }
+ Err(err) => return cx.push(err),
+ }
}
return cx.error(attr, "unsupported attribute");
}
@@ -99,3 +120,19 @@
"unrecognized repr",
))
}
+
+fn parse_function_alias_attribute(input: ParseStream) -> Result<Ident> {
+ input.parse::<Token![=]>()?;
+ if input.peek(LitStr) {
+ let lit: LitStr = input.parse()?;
+ lit.parse()
+ } else {
+ input.parse()
+ }
+}
+
+fn parse_namespace_attribute(input: ParseStream) -> Result<Namespace> {
+ input.parse::<Token![=]>()?;
+ let namespace = input.parse::<Namespace>()?;
+ Ok(namespace)
+}
diff --git a/syntax/check.rs b/syntax/check.rs
index c54430c..e8a6448 100644
--- a/syntax/check.rs
+++ b/syntax/check.rs
@@ -1,24 +1,22 @@
use crate::syntax::atom::Atom::{self, *};
-use crate::syntax::namespace::Namespace;
use crate::syntax::report::Errors;
+use crate::syntax::types::TrivialReason;
use crate::syntax::{
- error, ident, Api, Enum, ExternFn, ExternType, Lang, Receiver, Ref, Slice, Struct, Ty1, Type,
- Types,
+ error, ident, Api, Enum, ExternFn, ExternType, Impl, Lang, Receiver, Ref, Slice, Struct, Ty1,
+ Type, Types,
};
use proc_macro2::{Delimiter, Group, Ident, TokenStream};
use quote::{quote, ToTokens};
use std::fmt::Display;
pub(crate) struct Check<'a> {
- namespace: &'a Namespace,
apis: &'a [Api],
types: &'a Types<'a>,
errors: &'a mut Errors,
}
-pub(crate) fn typecheck(cx: &mut Errors, namespace: &Namespace, apis: &[Api], types: &Types) {
+pub(crate) fn typecheck(cx: &mut Errors, apis: &[Api], types: &Types) {
do_typecheck(&mut Check {
- namespace,
apis,
types,
errors: cx,
@@ -26,11 +24,11 @@
}
fn do_typecheck(cx: &mut Check) {
- ident::check_all(cx, cx.namespace, cx.apis);
+ ident::check_all(cx, cx.apis);
for ty in cx.types {
match ty {
- Type::Ident(ident) => check_type_ident(cx, ident),
+ Type::Ident(ident) => check_type_ident(cx, &ident.rust),
Type::RustBox(ptr) => check_type_box(cx, ptr),
Type::RustVec(ty) => check_type_rust_vec(cx, ty),
Type::UniquePtr(ptr) => check_type_unique_ptr(cx, ptr),
@@ -45,8 +43,9 @@
match api {
Api::Struct(strct) => check_api_struct(cx, strct),
Api::Enum(enm) => check_api_enum(cx, enm),
- Api::CxxType(ty) | Api::RustType(ty) => check_api_type(cx, ty),
+ Api::CxxType(ety) | Api::RustType(ety) => check_api_type(cx, ety),
Api::CxxFunction(efn) | Api::RustFunction(efn) => check_api_fn(cx, efn),
+ Api::Impl(imp) => check_api_impl(cx, imp),
_ => {}
}
}
@@ -65,17 +64,21 @@
&& !cx.types.cxx.contains(ident)
&& !cx.types.rust.contains(ident)
{
- cx.error(ident, "unsupported type");
+ let msg = format!("unsupported type: {}", ident);
+ cx.error(ident, &msg);
}
}
fn check_type_box(cx: &mut Check, ptr: &Ty1) {
if let Type::Ident(ident) = &ptr.inner {
- if cx.types.cxx.contains(ident) {
+ if cx.types.cxx.contains(&ident.rust)
+ && !cx.types.structs.contains_key(&ident.rust)
+ && !cx.types.enums.contains_key(&ident.rust)
+ {
cx.error(ptr, error::BOX_CXX_TYPE.msg);
}
- if Atom::from(ident).is_none() {
+ if Atom::from(&ident.rust).is_none() {
return;
}
}
@@ -85,15 +88,19 @@
fn check_type_rust_vec(cx: &mut Check, ty: &Ty1) {
if let Type::Ident(ident) = &ty.inner {
- if cx.types.cxx.contains(ident) {
+ if cx.types.cxx.contains(&ident.rust)
+ && !cx.types.structs.contains_key(&ident.rust)
+ && !cx.types.enums.contains_key(&ident.rust)
+ {
cx.error(ty, "Rust Vec containing C++ type is not supported yet");
return;
}
- match Atom::from(ident) {
+ match Atom::from(&ident.rust) {
None | Some(U8) | Some(U16) | Some(U32) | Some(U64) | Some(Usize) | Some(I8)
- | Some(I16) | Some(I32) | Some(I64) | Some(Isize) | Some(F32) | Some(F64) => return,
- Some(Bool) | Some(RustString) => { /* todo */ }
+ | Some(I16) | Some(I32) | Some(I64) | Some(Isize) | Some(F32) | Some(F64)
+ | Some(RustString) => return,
+ Some(Bool) => { /* todo */ }
Some(CxxString) => {}
}
}
@@ -103,11 +110,11 @@
fn check_type_unique_ptr(cx: &mut Check, ptr: &Ty1) {
if let Type::Ident(ident) = &ptr.inner {
- if cx.types.rust.contains(ident) {
+ if cx.types.rust.contains(&ident.rust) {
cx.error(ptr, "unique_ptr of a Rust type is not supported yet");
}
- match Atom::from(ident) {
+ match Atom::from(&ident.rust) {
None | Some(CxxString) => return,
_ => {}
}
@@ -120,17 +127,17 @@
fn check_type_cxx_vector(cx: &mut Check, ptr: &Ty1) {
if let Type::Ident(ident) = &ptr.inner {
- if cx.types.rust.contains(ident) {
+ if cx.types.rust.contains(&ident.rust) {
cx.error(
ptr,
"C++ vector containing a Rust type is not supported yet",
);
}
- match Atom::from(ident) {
+ match Atom::from(&ident.rust) {
None | Some(U8) | Some(U16) | Some(U32) | Some(U64) | Some(Usize) | Some(I8)
- | Some(I16) | Some(I32) | Some(I64) | Some(Isize) | Some(F32) | Some(F64) => return,
- Some(CxxString) => { /* todo */ }
+ | Some(I16) | Some(I32) | Some(I64) | Some(Isize) | Some(F32) | Some(F64)
+ | Some(CxxString) => return,
Some(Bool) | Some(RustString) => {}
}
}
@@ -160,13 +167,21 @@
}
fn check_api_struct(cx: &mut Check, strct: &Struct) {
- check_reserved_name(cx, &strct.ident);
+ let name = &strct.name;
+ check_reserved_name(cx, &name.rust);
if strct.fields.is_empty() {
let span = span_for_struct_error(strct);
cx.error(span, "structs without any fields are not supported");
}
+ if cx.types.cxx.contains(&name.rust) {
+ if let Some(ety) = cx.types.untrusted.get(&name.rust) {
+ let msg = "extern shared struct must be declared in an `unsafe extern` block";
+ cx.error(ety, msg);
+ }
+ }
+
for field in &strct.fields {
if is_unsized(cx, &field.ty) {
let desc = describe(cx, &field.ty);
@@ -183,7 +198,7 @@
}
fn check_api_enum(cx: &mut Check, enm: &Enum) {
- check_reserved_name(cx, &enm.ident);
+ check_reserved_name(cx, &enm.name.rust);
if enm.variants.is_empty() {
let span = span_for_enum_error(enm);
@@ -191,15 +206,28 @@
}
}
-fn check_api_type(cx: &mut Check, ty: &ExternType) {
- check_reserved_name(cx, &ty.ident);
+fn check_api_type(cx: &mut Check, ety: &ExternType) {
+ check_reserved_name(cx, &ety.name.rust);
+
+ if let Some(reason) = cx.types.required_trivial.get(&ety.name.rust) {
+ let what = match reason {
+ TrivialReason::StructField(strct) => format!("a field of `{}`", strct.name.rust),
+ TrivialReason::FunctionArgument(efn) => format!("an argument of `{}`", efn.name.rust),
+ TrivialReason::FunctionReturn(efn) => format!("a return value of `{}`", efn.name.rust),
+ };
+ let msg = format!(
+ "needs a cxx::ExternType impl in order to be used as {}",
+ what,
+ );
+ cx.error(ety, msg);
+ }
}
fn check_api_fn(cx: &mut Check, efn: &ExternFn) {
if let Some(receiver) = &efn.receiver {
let ref span = span_for_receiver_error(receiver);
- if receiver.ty == "Self" {
+ if receiver.ty.is_self() {
let mutability = match receiver.mutability {
Some(_) => "mut ",
None => "",
@@ -211,9 +239,9 @@
mutability = mutability,
);
cx.error(span, msg);
- } else if !cx.types.structs.contains_key(&receiver.ty)
- && !cx.types.cxx.contains(&receiver.ty)
- && !cx.types.rust.contains(&receiver.ty)
+ } else if !cx.types.structs.contains_key(&receiver.ty.rust)
+ && !cx.types.cxx.contains(&receiver.ty.rust)
+ && !cx.types.rust.contains(&receiver.ty.rust)
{
cx.error(span, "unrecognized receiver type");
}
@@ -257,6 +285,18 @@
check_multiple_arg_lifetimes(cx, efn);
}
+fn check_api_impl(cx: &mut Check, imp: &Impl) {
+ if let Type::UniquePtr(ty) | Type::CxxVector(ty) = &imp.ty {
+ if let Type::Ident(inner) = &ty.inner {
+ if Atom::from(&inner.rust).is_none() {
+ return;
+ }
+ }
+ }
+
+ cx.error(imp, "unsupported Self type of explicit impl");
+}
+
fn check_mut_return_restriction(cx: &mut Check, efn: &ExternFn) {
match &efn.ret {
Some(Type::Ref(ty)) if ty.mutability.is_some() => {}
@@ -315,11 +355,17 @@
fn is_unsized(cx: &mut Check, ty: &Type) -> bool {
let ident = match ty {
- Type::Ident(ident) => ident,
+ Type::Ident(ident) => &ident.rust,
Type::CxxVector(_) | Type::Slice(_) | Type::Void(_) => return true,
_ => return false,
};
- ident == CxxString || cx.types.cxx.contains(ident) || cx.types.rust.contains(ident)
+ ident == CxxString
+ || cx.types.cxx.contains(ident)
+ && !cx.types.structs.contains_key(ident)
+ && !cx.types.enums.contains_key(ident)
+ && !(cx.types.aliases.contains_key(ident)
+ && cx.types.required_trivial.contains_key(ident))
+ || cx.types.rust.contains(ident)
}
fn span_for_struct_error(strct: &Struct) -> TokenStream {
@@ -352,16 +398,20 @@
fn describe(cx: &mut Check, ty: &Type) -> String {
match ty {
Type::Ident(ident) => {
- if cx.types.structs.contains_key(ident) {
+ if cx.types.structs.contains_key(&ident.rust) {
"struct".to_owned()
- } else if cx.types.cxx.contains(ident) {
+ } else if cx.types.enums.contains_key(&ident.rust) {
+ "enum".to_owned()
+ } else if cx.types.aliases.contains_key(&ident.rust) {
"C++ type".to_owned()
- } else if cx.types.rust.contains(ident) {
+ } else if cx.types.cxx.contains(&ident.rust) {
+ "opaque C++ type".to_owned()
+ } else if cx.types.rust.contains(&ident.rust) {
"opaque Rust type".to_owned()
- } else if Atom::from(ident) == Some(CxxString) {
+ } else if Atom::from(&ident.rust) == Some(CxxString) {
"C++ string".to_owned()
} else {
- ident.to_string()
+ ident.rust.to_string()
}
}
Type::RustBox(_) => "Box".to_owned(),
diff --git a/syntax/error.rs b/syntax/error.rs
index a60b7da..d0ae021 100644
--- a/syntax/error.rs
+++ b/syntax/error.rs
@@ -19,8 +19,10 @@
CXX_STRING_BY_VALUE,
CXX_TYPE_BY_VALUE,
DISCRIMINANT_OVERFLOW,
+ DOT_INCLUDE,
DOUBLE_UNDERSCORE,
RUST_TYPE_BY_VALUE,
+ UNSUPPORTED_TYPE,
USE_NOT_ALLOWED,
];
@@ -54,6 +56,12 @@
note: Some("note: explicitly set `= 0` if that is desired outcome"),
};
+pub static DOT_INCLUDE: Error = Error {
+ msg: "#include relative to `.` or `..` is not supported in Cargo builds",
+ label: Some("#include relative to `.` or `..` is not supported in Cargo builds"),
+ note: Some("note: use a path starting with the crate name"),
+};
+
pub static DOUBLE_UNDERSCORE: Error = Error {
msg: "identifiers containing double underscore are reserved in C++",
label: Some("reserved identifier"),
@@ -66,6 +74,12 @@
note: Some("hint: wrap it in a Box<>"),
};
+pub static UNSUPPORTED_TYPE: Error = Error {
+ msg: "unsupported type: ",
+ label: Some("unsupported type"),
+ note: None,
+};
+
pub static USE_NOT_ALLOWED: Error = Error {
msg: "`use` items are not allowed within cxx bridge",
label: Some("not allowed"),
diff --git a/syntax/file.rs b/syntax/file.rs
new file mode 100644
index 0000000..fd6dd98
--- /dev/null
+++ b/syntax/file.rs
@@ -0,0 +1,108 @@
+use crate::syntax::namespace::Namespace;
+use quote::quote;
+use syn::parse::{Error, Parse, ParseStream, Result};
+use syn::{
+ braced, token, Abi, Attribute, ForeignItem, Ident, Item as RustItem, ItemEnum, ItemImpl,
+ ItemStruct, ItemUse, LitStr, Token, Visibility,
+};
+
+pub struct Module {
+ pub namespace: Namespace,
+ pub attrs: Vec<Attribute>,
+ pub vis: Visibility,
+ pub unsafety: Option<Token![unsafe]>,
+ pub mod_token: Token![mod],
+ pub ident: Ident,
+ pub brace_token: token::Brace,
+ pub content: Vec<Item>,
+}
+
+pub enum Item {
+ Struct(ItemStruct),
+ Enum(ItemEnum),
+ ForeignMod(ItemForeignMod),
+ Use(ItemUse),
+ Impl(ItemImpl),
+ Other(RustItem),
+}
+
+pub struct ItemForeignMod {
+ pub attrs: Vec<Attribute>,
+ pub unsafety: Option<Token![unsafe]>,
+ pub abi: Abi,
+ pub brace_token: token::Brace,
+ pub items: Vec<ForeignItem>,
+}
+
+impl Parse for Module {
+ fn parse(input: ParseStream) -> Result<Self> {
+ let namespace = Namespace::ROOT;
+ let mut attrs = input.call(Attribute::parse_outer)?;
+ let vis: Visibility = input.parse()?;
+ let unsafety: Option<Token![unsafe]> = input.parse()?;
+ let mod_token: Token![mod] = input.parse()?;
+ let ident: Ident = input.parse()?;
+
+ let semi: Option<Token![;]> = input.parse()?;
+ if let Some(semi) = semi {
+ let span = quote!(#vis #mod_token #semi);
+ return Err(Error::new_spanned(
+ span,
+ "#[cxx::bridge] module must have inline contents",
+ ));
+ }
+
+ let content;
+ let brace_token = braced!(content in input);
+ attrs.extend(content.call(Attribute::parse_inner)?);
+
+ let mut items = Vec::new();
+ while !content.is_empty() {
+ items.push(content.parse()?);
+ }
+
+ Ok(Module {
+ namespace,
+ attrs,
+ vis,
+ unsafety,
+ mod_token,
+ ident,
+ brace_token,
+ content: items,
+ })
+ }
+}
+
+impl Parse for Item {
+ fn parse(input: ParseStream) -> Result<Self> {
+ let attrs = input.call(Attribute::parse_outer)?;
+
+ let ahead = input.fork();
+ let unsafety = if ahead.parse::<Option<Token![unsafe]>>()?.is_some()
+ && ahead.parse::<Option<Token![extern]>>()?.is_some()
+ && ahead.parse::<Option<LitStr>>().is_ok()
+ && ahead.peek(token::Brace)
+ {
+ Some(input.parse()?)
+ } else {
+ None
+ };
+
+ let item = input.parse()?;
+ match 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/ident.rs b/syntax/ident.rs
index 7545e92..aaf7832 100644
--- a/syntax/ident.rs
+++ b/syntax/ident.rs
@@ -1,6 +1,5 @@
use crate::syntax::check::Check;
-use crate::syntax::namespace::Namespace;
-use crate::syntax::{error, Api};
+use crate::syntax::{error, Api, Pair};
use proc_macro2::Ident;
fn check(cx: &mut Check, ident: &Ident) {
@@ -13,37 +12,40 @@
}
}
-pub(crate) fn check_all(cx: &mut Check, namespace: &Namespace, apis: &[Api]) {
- for segment in namespace {
+fn check_ident(cx: &mut Check, name: &Pair) {
+ for segment in &name.namespace {
check(cx, segment);
}
+ check(cx, &name.cxx);
+}
+pub(crate) fn check_all(cx: &mut Check, apis: &[Api]) {
for api in apis {
match api {
- Api::Include(_) => {}
+ Api::Include(_) | Api::Impl(_) => {}
Api::Struct(strct) => {
- check(cx, &strct.ident);
+ check_ident(cx, &strct.name);
for field in &strct.fields {
check(cx, &field.ident);
}
}
Api::Enum(enm) => {
- check(cx, &enm.ident);
+ check_ident(cx, &enm.name);
for variant in &enm.variants {
check(cx, &variant.ident);
}
}
Api::CxxType(ety) | Api::RustType(ety) => {
- check(cx, &ety.ident);
+ check_ident(cx, &ety.name);
}
Api::CxxFunction(efn) | Api::RustFunction(efn) => {
- check(cx, &efn.ident);
+ check(cx, &efn.name.rust);
for arg in &efn.args {
check(cx, &arg.ident);
}
}
Api::TypeAlias(alias) => {
- check(cx, &alias.ident);
+ check_ident(cx, &alias.name);
}
}
}
diff --git a/syntax/impls.rs b/syntax/impls.rs
index c34e3e5..a4b393a 100644
--- a/syntax/impls.rs
+++ b/syntax/impls.rs
@@ -1,8 +1,27 @@
-use crate::syntax::{ExternFn, Receiver, Ref, Signature, Slice, Ty1, Type};
+use crate::syntax::{ExternFn, Impl, Include, Receiver, Ref, Signature, Slice, Ty1, Type};
+use std::borrow::Borrow;
use std::hash::{Hash, Hasher};
use std::mem;
use std::ops::{Deref, DerefMut};
+impl PartialEq for Include {
+ fn eq(&self, other: &Include) -> bool {
+ let Include {
+ path,
+ kind,
+ begin_span: _,
+ end_span: _,
+ } = self;
+ let Include {
+ path: path2,
+ kind: kind2,
+ begin_span: _,
+ end_span: _,
+ } = other;
+ path == path2 && kind == kind2
+ }
+}
+
impl Deref for ExternFn {
type Target = Signature;
@@ -149,6 +168,7 @@
impl PartialEq for Signature {
fn eq(&self, other: &Signature) -> bool {
let Signature {
+ unsafety,
fn_token: _,
receiver,
args,
@@ -158,6 +178,7 @@
throws_tokens: _,
} = self;
let Signature {
+ unsafety: unsafety2,
fn_token: _,
receiver: receiver2,
args: args2,
@@ -166,7 +187,8 @@
paren_token: _,
throws_tokens: _,
} = other;
- receiver == receiver2
+ unsafety.is_some() == unsafety2.is_some()
+ && receiver == receiver2
&& ret == ret2
&& throws == throws2
&& args.len() == args2.len()
@@ -177,6 +199,7 @@
impl Hash for Signature {
fn hash<H: Hasher>(&self, state: &mut H) {
let Signature {
+ unsafety,
fn_token: _,
receiver,
args,
@@ -185,6 +208,7 @@
paren_token: _,
throws_tokens: _,
} = self;
+ unsafety.is_some().hash(state);
receiver.hash(state);
for arg in args {
arg.hash(state);
@@ -233,3 +257,38 @@
ty.hash(state);
}
}
+
+impl Hash for Impl {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ let Impl {
+ impl_token: _,
+ ty,
+ brace_token: _,
+ } = self;
+ ty.hash(state);
+ }
+}
+
+impl Eq for Impl {}
+
+impl PartialEq for Impl {
+ fn eq(&self, other: &Impl) -> bool {
+ let Impl {
+ impl_token: _,
+ ty,
+ brace_token: _,
+ } = self;
+ let Impl {
+ impl_token: _,
+ ty: ty2,
+ brace_token: _,
+ } = other;
+ ty == ty2
+ }
+}
+
+impl Borrow<Type> for &Impl {
+ fn borrow(&self) -> &Type {
+ &self.ty
+ }
+}
diff --git a/syntax/improper.rs b/syntax/improper.rs
new file mode 100644
index 0000000..6fd3162
--- /dev/null
+++ b/syntax/improper.rs
@@ -0,0 +1,36 @@
+use self::ImproperCtype::*;
+use crate::syntax::atom::Atom::{self, *};
+use crate::syntax::{Type, Types};
+use proc_macro2::Ident;
+
+pub enum ImproperCtype<'a> {
+ Definite(bool),
+ Depends(&'a Ident),
+}
+
+impl<'a> Types<'a> {
+ // yes, no, maybe
+ pub fn determine_improper_ctype(&self, ty: &Type) -> ImproperCtype<'a> {
+ match ty {
+ Type::Ident(ident) => {
+ let ident = &ident.rust;
+ if let Some(atom) = Atom::from(ident) {
+ Definite(atom == RustString)
+ } else if let Some(strct) = self.structs.get(ident) {
+ Depends(&strct.name.rust) // iterate to fixed-point
+ } else {
+ Definite(self.rust.contains(ident))
+ }
+ }
+ Type::RustBox(_)
+ | Type::RustVec(_)
+ | Type::Str(_)
+ | Type::Fn(_)
+ | Type::Void(_)
+ | Type::Slice(_)
+ | Type::SliceRefU8(_) => Definite(true),
+ Type::UniquePtr(_) | Type::CxxVector(_) => Definite(false),
+ Type::Ref(ty) => self.determine_improper_ctype(&ty.inner),
+ }
+ }
+}
diff --git a/syntax/mangle.rs b/syntax/mangle.rs
index c9392db..cc5115a 100644
--- a/syntax/mangle.rs
+++ b/syntax/mangle.rs
@@ -1,9 +1,8 @@
-use crate::syntax::namespace::Namespace;
use crate::syntax::symbol::{self, Symbol};
-use crate::syntax::ExternFn;
+use crate::syntax::{ExternFn, Types};
use proc_macro2::Ident;
-const CXXBRIDGE: &str = "cxxbridge03";
+const CXXBRIDGE: &str = "cxxbridge05";
macro_rules! join {
($($segment:expr),*) => {
@@ -11,19 +10,27 @@
};
}
-pub fn extern_fn(namespace: &Namespace, efn: &ExternFn) -> Symbol {
+pub fn extern_fn(efn: &ExternFn, types: &Types) -> Symbol {
match &efn.receiver {
- Some(receiver) => join!(namespace, CXXBRIDGE, receiver.ty, efn.ident),
- None => join!(namespace, CXXBRIDGE, efn.ident),
+ Some(receiver) => {
+ let receiver_ident = types.resolve(&receiver.ty);
+ join!(
+ efn.name.namespace,
+ CXXBRIDGE,
+ receiver_ident.cxx,
+ efn.name.rust
+ )
+ }
+ None => join!(efn.name.namespace, CXXBRIDGE, efn.name.rust),
}
}
// The C half of a function pointer trampoline.
-pub fn c_trampoline(namespace: &Namespace, efn: &ExternFn, var: &Ident) -> Symbol {
- join!(extern_fn(namespace, efn), var, 0)
+pub fn c_trampoline(efn: &ExternFn, var: &Ident, types: &Types) -> Symbol {
+ join!(extern_fn(efn, types), var, 0)
}
// The Rust half of a function pointer trampoline.
-pub fn r_trampoline(namespace: &Namespace, efn: &ExternFn, var: &Ident) -> Symbol {
- join!(extern_fn(namespace, efn), var, 1)
+pub fn r_trampoline(efn: &ExternFn, var: &Ident, types: &Types) -> Symbol {
+ join!(extern_fn(efn, types), var, 1)
}
diff --git a/syntax/mod.rs b/syntax/mod.rs
index 88c96e8..33ed31c 100644
--- a/syntax/mod.rs
+++ b/syntax/mod.rs
@@ -7,19 +7,26 @@
mod discriminant;
mod doc;
pub mod error;
+pub mod file;
pub mod ident;
mod impls;
+mod improper;
pub mod mangle;
+mod names;
pub mod namespace;
mod parse;
+pub mod qualified;
pub mod report;
pub mod set;
pub mod symbol;
mod tokens;
+mod toposort;
pub mod types;
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};
@@ -32,7 +39,7 @@
pub use self::types::Types;
pub enum Api {
- Include(String),
+ Include(Include),
Struct(Struct),
Enum(Enum),
CxxType(ExternType),
@@ -40,19 +47,38 @@
RustType(ExternType),
RustFunction(ExternFn),
TypeAlias(TypeAlias),
+ Impl(Impl),
+}
+
+pub struct Include {
+ pub path: String,
+ pub kind: IncludeKind,
+ pub begin_span: Span,
+ pub end_span: Span,
+}
+
+/// Whether to emit `#include "path"` or `#include <path>`.
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum IncludeKind {
+ /// `#include "quoted/path/to"`
+ Quoted,
+ /// `#include <bracketed/path/to>`
+ Bracketed,
}
pub struct ExternType {
pub doc: Doc,
pub type_token: Token![type],
- pub ident: Ident,
+ pub name: Pair,
+ pub semi_token: Token![;],
+ pub trusted: bool,
}
pub struct Struct {
pub doc: Doc,
pub derives: Vec<Derive>,
pub struct_token: Token![struct],
- pub ident: Ident,
+ pub name: Pair,
pub brace_token: Brace,
pub fields: Vec<Var>,
}
@@ -60,7 +86,7 @@
pub struct Enum {
pub doc: Doc,
pub enum_token: Token![enum],
- pub ident: Ident,
+ pub name: Pair,
pub brace_token: Brace,
pub variants: Vec<Variant>,
pub repr: Atom,
@@ -69,20 +95,28 @@
pub struct ExternFn {
pub lang: Lang,
pub doc: Doc,
- pub ident: Ident,
+ pub name: Pair,
pub sig: Signature,
pub semi_token: Token![;],
}
pub struct TypeAlias {
+ pub doc: Doc,
pub type_token: Token![type],
- pub ident: Ident,
+ pub name: Pair,
pub eq_token: Token![=],
pub ty: RustType,
pub semi_token: Token![;],
}
+pub struct Impl {
+ pub impl_token: Token![impl],
+ pub ty: Type,
+ pub brace_token: Brace,
+}
+
pub struct Signature {
+ pub unsafety: Option<Token![unsafe]>,
pub fn_token: Token![fn],
pub receiver: Option<Receiver>,
pub args: Punctuated<Var, Token![,]>,
@@ -103,7 +137,7 @@
pub lifetime: Option<Lifetime>,
pub mutability: Option<Token![mut]>,
pub var: Token![self],
- pub ty: Ident,
+ pub ty: ResolvableName,
pub shorthand: bool,
}
@@ -114,7 +148,7 @@
}
pub enum Type {
- Ident(Ident),
+ Ident(ResolvableName),
RustBox(Box<Ty1>),
RustVec(Box<Ty1>),
UniquePtr(Box<Ty1>),
@@ -151,3 +185,19 @@
Cxx,
Rust,
}
+
+// An association of a defined Rust name with a fully resolved, namespace
+// qualified C++ name.
+#[derive(Clone)]
+pub struct Pair {
+ pub namespace: Namespace,
+ pub cxx: Ident,
+ pub rust: Ident,
+}
+
+// Wrapper for a type which needs to be resolved before it can be printed in
+// C++.
+#[derive(Clone, PartialEq, Hash)]
+pub struct ResolvableName {
+ pub rust: Ident,
+}
diff --git a/syntax/names.rs b/syntax/names.rs
new file mode 100644
index 0000000..25ae9f4
--- /dev/null
+++ b/syntax/names.rs
@@ -0,0 +1,73 @@
+use crate::syntax::{Namespace, Pair, ResolvableName, Symbol, Types};
+use proc_macro2::{Ident, Span};
+use std::iter;
+use syn::Token;
+
+impl Pair {
+ // Use this constructor when the item can't have a different name in Rust
+ // and C++.
+ pub fn new(namespace: Namespace, ident: Ident) -> Self {
+ Self {
+ namespace,
+ cxx: ident.clone(),
+ rust: ident,
+ }
+ }
+
+ // Use this constructor when attributes such as #[rust_name] can be used to
+ // potentially give a different name in Rust vs C++.
+ pub fn new_from_differing_names(
+ namespace: Namespace,
+ cxx_ident: Ident,
+ rust_ident: Ident,
+ ) -> Self {
+ Self {
+ namespace,
+ cxx: cxx_ident,
+ rust: rust_ident,
+ }
+ }
+
+ pub fn to_symbol(&self) -> Symbol {
+ Symbol::from_idents(self.iter_all_segments())
+ }
+
+ pub fn to_fully_qualified(&self) -> String {
+ format!("::{}", self.join("::"))
+ }
+
+ fn iter_all_segments(&self) -> impl Iterator<Item = &Ident> {
+ self.namespace.iter().chain(iter::once(&self.cxx))
+ }
+
+ fn join(&self, sep: &str) -> String {
+ self.iter_all_segments()
+ .map(|s| s.to_string())
+ .collect::<Vec<_>>()
+ .join(sep)
+ }
+}
+
+impl ResolvableName {
+ pub fn new(ident: Ident) -> Self {
+ Self { rust: ident }
+ }
+
+ pub fn make_self(span: Span) -> Self {
+ Self {
+ rust: Token.into(),
+ }
+ }
+
+ pub fn is_self(&self) -> bool {
+ self.rust == "Self"
+ }
+
+ pub fn span(&self) -> Span {
+ self.rust.span()
+ }
+
+ pub fn to_symbol(&self, types: &Types) -> Symbol {
+ types.resolve(self).to_symbol()
+ }
+}
diff --git a/syntax/namespace.rs b/syntax/namespace.rs
index e2dce18..07185e1 100644
--- a/syntax/namespace.rs
+++ b/syntax/namespace.rs
@@ -1,42 +1,52 @@
+use crate::syntax::qualified::QualifiedName;
use quote::IdentFragment;
use std::fmt::{self, Display};
+use std::iter::FromIterator;
use std::slice::Iter;
use syn::parse::{Parse, ParseStream, Result};
-use syn::{Ident, Path, Token};
+use syn::{Ident, Token};
mod kw {
syn::custom_keyword!(namespace);
}
-#[derive(Clone)]
+#[derive(Clone, Default)]
pub struct Namespace {
segments: Vec<Ident>,
}
impl Namespace {
- pub fn none() -> Self {
- Namespace {
- segments: Vec::new(),
- }
- }
+ pub const ROOT: Self = Namespace {
+ segments: Vec::new(),
+ };
pub fn iter(&self) -> Iter<Ident> {
self.segments.iter()
}
+
+ pub fn parse_bridge_attr_namespace(input: ParseStream) -> Result<Namespace> {
+ if input.is_empty() {
+ return Ok(Namespace::ROOT);
+ }
+
+ input.parse::<kw::namespace>()?;
+ input.parse::<Token![=]>()?;
+ let namespace = input.parse::<Namespace>()?;
+ input.parse::<Option<Token![,]>>()?;
+ Ok(namespace)
+ }
+}
+
+impl Default for &Namespace {
+ fn default() -> Self {
+ const ROOT: &Namespace = &Namespace::ROOT;
+ ROOT
+ }
}
impl Parse for Namespace {
fn parse(input: ParseStream) -> Result<Self> {
- let mut segments = Vec::new();
- if !input.is_empty() {
- input.parse::<kw::namespace>()?;
- input.parse::<Token![=]>()?;
- let path = input.call(Path::parse_mod_style)?;
- for segment in path.segments {
- segments.push(segment.ident);
- }
- input.parse::<Option<Token![,]>>()?;
- }
+ let segments = QualifiedName::parse_quoted_or_unquoted(input)?.segments;
Ok(Namespace { segments })
}
}
@@ -63,3 +73,13 @@
self.iter()
}
}
+
+impl<'a> FromIterator<&'a Ident> for Namespace {
+ fn from_iter<I>(idents: I) -> Self
+ where
+ I: IntoIterator<Item = &'a Ident>,
+ {
+ let segments = idents.into_iter().cloned().collect();
+ Namespace { segments }
+ }
+}
diff --git a/syntax/parse.rs b/syntax/parse.rs
index a1d31cf..a5f8bd1 100644
--- a/syntax/parse.rs
+++ b/syntax/parse.rs
@@ -1,45 +1,58 @@
use crate::syntax::discriminant::DiscriminantSet;
+use crate::syntax::file::{Item, ItemForeignMod};
use crate::syntax::report::Errors;
use crate::syntax::Atom::*;
use crate::syntax::{
- attrs, error, Api, Doc, Enum, ExternFn, ExternType, Lang, Receiver, Ref, Signature, Slice,
- Struct, Ty1, Type, TypeAlias, Var, Variant,
+ attrs, error, Api, Doc, Enum, ExternFn, ExternType, Impl, Include, IncludeKind, Lang,
+ Namespace, Pair, Receiver, Ref, ResolvableName, Signature, Slice, Struct, Ty1, Type, TypeAlias,
+ Var, Variant,
};
-use proc_macro2::{TokenStream, TokenTree};
+use proc_macro2::{Delimiter, Group, TokenStream, TokenTree};
use quote::{format_ident, quote, quote_spanned};
use syn::parse::{ParseStream, Parser};
use syn::punctuated::Punctuated;
use syn::{
Abi, Attribute, Error, Fields, FnArg, ForeignItem, ForeignItemFn, ForeignItemType,
- GenericArgument, Ident, Item, ItemEnum, ItemForeignMod, ItemStruct, LitStr, Pat, PathArguments,
- Result, ReturnType, Token, Type as RustType, TypeBareFn, TypePath, TypeReference, TypeSlice,
+ GenericArgument, Ident, ItemEnum, ItemImpl, ItemStruct, LitStr, Pat, PathArguments, Result,
+ ReturnType, Token, Type as RustType, TypeBareFn, TypePath, TypeReference, TypeSlice,
};
pub mod kw {
syn::custom_keyword!(Result);
}
-pub fn parse_items(cx: &mut Errors, items: Vec<Item>) -> Vec<Api> {
+pub fn parse_items(
+ cx: &mut Errors,
+ items: Vec<Item>,
+ trusted: bool,
+ namespace: &Namespace,
+) -> Vec<Api> {
let mut apis = Vec::new();
for item in items {
match item {
- Item::Struct(item) => match parse_struct(cx, item) {
+ Item::Struct(item) => match parse_struct(cx, item, namespace) {
Ok(strct) => apis.push(strct),
Err(err) => cx.push(err),
},
- Item::Enum(item) => match parse_enum(cx, item) {
+ Item::Enum(item) => match parse_enum(cx, item, namespace) {
Ok(enm) => apis.push(enm),
Err(err) => cx.push(err),
},
- Item::ForeignMod(foreign_mod) => parse_foreign_mod(cx, foreign_mod, &mut apis),
+ Item::ForeignMod(foreign_mod) => {
+ parse_foreign_mod(cx, foreign_mod, &mut apis, trusted, namespace)
+ }
+ Item::Impl(item) => match parse_impl(item, namespace) {
+ Ok(imp) => apis.push(imp),
+ Err(err) => cx.push(err),
+ },
Item::Use(item) => cx.error(item, error::USE_NOT_ALLOWED),
- _ => cx.error(item, "unsupported item"),
+ Item::Other(item) => cx.error(item, "unsupported item"),
}
}
apis
}
-fn parse_struct(cx: &mut Errors, item: ItemStruct) -> Result<Api> {
+fn parse_struct(cx: &mut Errors, item: ItemStruct, namespace: &Namespace) -> Result<Api> {
let generics = &item.generics;
if !generics.params.is_empty() || generics.where_clause.is_some() {
let struct_token = item.struct_token;
@@ -54,44 +67,48 @@
let mut doc = Doc::new();
let mut derives = Vec::new();
+ let mut namespace = namespace.clone();
attrs::parse(
cx,
&item.attrs,
attrs::Parser {
doc: Some(&mut doc),
derives: Some(&mut derives),
+ namespace: Some(&mut namespace),
..Default::default()
},
);
- let fields = match item.fields {
+ let named_fields = match item.fields {
Fields::Named(fields) => fields,
Fields::Unit => return Err(Error::new_spanned(item, "unit structs are not supported")),
Fields::Unnamed(_) => {
- return Err(Error::new_spanned(item, "tuple structs are not supported"))
+ return Err(Error::new_spanned(item, "tuple structs are not supported"));
}
};
+ let fields = named_fields
+ .named
+ .into_iter()
+ .map(|field| {
+ Ok(Var {
+ ident: field.ident.unwrap(),
+ ty: parse_type(&field.ty, &namespace)?,
+ })
+ })
+ .collect::<Result<_>>()?;
+
Ok(Api::Struct(Struct {
doc,
derives,
struct_token: item.struct_token,
- ident: item.ident,
- brace_token: fields.brace_token,
- fields: fields
- .named
- .into_iter()
- .map(|field| {
- Ok(Var {
- ident: field.ident.unwrap(),
- ty: parse_type(&field.ty)?,
- })
- })
- .collect::<Result<_>>()?,
+ name: Pair::new(namespace, item.ident),
+ brace_token: named_fields.brace_token,
+ fields,
}))
}
-fn parse_enum(cx: &mut Errors, item: ItemEnum) -> Result<Api> {
+fn parse_enum(cx: &mut Errors, item: ItemEnum, namespace: &Namespace) -> Result<Api> {
let generics = &item.generics;
if !generics.params.is_empty() || generics.where_clause.is_some() {
let enum_token = item.enum_token;
@@ -106,12 +123,14 @@
let mut doc = Doc::new();
let mut repr = None;
+ let mut namespace = namespace.clone();
attrs::parse(
cx,
&item.attrs,
attrs::Parser {
doc: Some(&mut doc),
repr: Some(&mut repr),
+ namespace: Some(&mut namespace),
..Default::default()
},
);
@@ -162,27 +181,59 @@
Ok(Api::Enum(Enum {
doc,
enum_token,
- ident: item.ident,
+ name: Pair::new(namespace, item.ident),
brace_token,
variants,
repr,
}))
}
-fn parse_foreign_mod(cx: &mut Errors, foreign_mod: ItemForeignMod, out: &mut Vec<Api>) {
- let lang = match parse_lang(foreign_mod.abi) {
+fn parse_foreign_mod(
+ cx: &mut Errors,
+ foreign_mod: ItemForeignMod,
+ out: &mut Vec<Api>,
+ trusted: bool,
+ namespace: &Namespace,
+) {
+ let lang = match parse_lang(&foreign_mod.abi) {
Ok(lang) => lang,
Err(err) => return cx.push(err),
};
+ match lang {
+ Lang::Rust => {
+ if foreign_mod.unsafety.is_some() {
+ let unsafety = foreign_mod.unsafety;
+ let abi = foreign_mod.abi;
+ let span = quote!(#unsafety #abi);
+ cx.error(span, "extern \"Rust\" block does not need to be unsafe");
+ }
+ }
+ Lang::Cxx => {}
+ }
+
+ let trusted = trusted || foreign_mod.unsafety.is_some();
+
+ let mut namespace = namespace.clone();
+ attrs::parse(
+ cx,
+ &foreign_mod.attrs,
+ attrs::Parser {
+ namespace: Some(&mut namespace),
+ ..Default::default()
+ },
+ );
+
let mut items = Vec::new();
for foreign in &foreign_mod.items {
match foreign {
- ForeignItem::Type(foreign) => match parse_extern_type(cx, foreign, lang) {
- Ok(ety) => items.push(ety),
- Err(err) => cx.push(err),
- },
- ForeignItem::Fn(foreign) => match parse_extern_fn(cx, foreign, lang) {
+ ForeignItem::Type(foreign) => {
+ match parse_extern_type(cx, foreign, lang, trusted, &namespace) {
+ Ok(ety) => items.push(ety),
+ Err(err) => cx.push(err),
+ }
+ }
+ ForeignItem::Fn(foreign) => match parse_extern_fn(cx, foreign, lang, &namespace) {
Ok(efn) => items.push(efn),
Err(err) => cx.push(err),
},
@@ -192,17 +243,19 @@
Err(err) => cx.push(err),
}
}
- ForeignItem::Verbatim(tokens) => match parse_extern_verbatim(cx, tokens, lang) {
- Ok(api) => items.push(api),
- Err(err) => cx.push(err),
- },
+ ForeignItem::Verbatim(tokens) => {
+ match parse_extern_verbatim(cx, tokens, lang, &namespace) {
+ Ok(api) => items.push(api),
+ Err(err) => cx.push(err),
+ }
+ }
_ => cx.error(foreign, "unsupported foreign item"),
}
}
let mut types = items.iter().filter_map(|item| match item {
- Api::CxxType(ty) | Api::RustType(ty) => Some(&ty.ident),
- Api::TypeAlias(alias) => Some(&alias.ident),
+ Api::CxxType(ety) | Api::RustType(ety) => Some(&ety.name),
+ Api::TypeAlias(alias) => Some(&alias.name),
_ => None,
});
if let (Some(single_type), None) = (types.next(), types.next()) {
@@ -210,8 +263,8 @@
for item in &mut items {
if let Api::CxxFunction(efn) | Api::RustFunction(efn) = item {
if let Some(receiver) = &mut efn.receiver {
- if receiver.ty == "Self" {
- receiver.ty = single_type.clone();
+ if receiver.ty.is_self() {
+ receiver.ty = ResolvableName::new(single_type.rust.clone());
}
}
}
@@ -221,7 +274,7 @@
out.extend(items);
}
-fn parse_lang(abi: Abi) -> Result<Lang> {
+fn parse_lang(abi: &Abi) -> Result<Lang> {
let name = match &abi.name {
Some(name) => name,
None => {
@@ -238,10 +291,27 @@
}
}
-fn parse_extern_type(cx: &mut Errors, foreign_type: &ForeignItemType, lang: Lang) -> Result<Api> {
- let doc = attrs::parse_doc(cx, &foreign_type.attrs);
+fn parse_extern_type(
+ cx: &mut Errors,
+ foreign_type: &ForeignItemType,
+ lang: Lang,
+ trusted: bool,
+ namespace: &Namespace,
+) -> Result<Api> {
+ let mut doc = Doc::new();
+ let mut namespace = namespace.clone();
+ attrs::parse(
+ cx,
+ &foreign_type.attrs,
+ attrs::Parser {
+ doc: Some(&mut doc),
+ namespace: Some(&mut namespace),
+ ..Default::default()
+ },
+ );
let type_token = foreign_type.type_token;
let ident = foreign_type.ident.clone();
+ let semi_token = foreign_type.semi_token;
let api_type = match lang {
Lang::Cxx => Api::CxxType,
Lang::Rust => Api::RustType,
@@ -249,11 +319,18 @@
Ok(api_type(ExternType {
doc,
type_token,
- ident,
+ name: Pair::new(namespace, ident),
+ semi_token,
+ trusted,
}))
}
-fn parse_extern_fn(cx: &mut Errors, foreign_fn: &ForeignItemFn, lang: Lang) -> Result<Api> {
+fn parse_extern_fn(
+ cx: &mut Errors,
+ foreign_fn: &ForeignItemFn,
+ lang: Lang,
+ namespace: &Namespace,
+) -> Result<Api> {
let generics = &foreign_fn.sig.generics;
if !generics.params.is_empty() || generics.where_clause.is_some() {
return Err(Error::new_spanned(
@@ -268,6 +345,22 @@
));
}
+ let mut doc = Doc::new();
+ let mut cxx_name = None;
+ let mut rust_name = None;
+ let mut namespace = namespace.clone();
+ attrs::parse(
+ cx,
+ &foreign_fn.attrs,
+ attrs::Parser {
+ doc: Some(&mut doc),
+ cxx_name: Some(&mut cxx_name),
+ rust_name: Some(&mut rust_name),
+ namespace: Some(&mut namespace),
+ ..Default::default()
+ },
+ );
+
let mut receiver = None;
let mut args = Punctuated::new();
for arg in foreign_fn.sig.inputs.pairs() {
@@ -280,7 +373,7 @@
lifetime: lifetime.clone(),
mutability: arg.mutability,
var: arg.self_token,
- ty: Token.into(),
+ ty: ResolvableName::make_self(arg.self_token.span),
shorthand: true,
});
continue;
@@ -295,7 +388,7 @@
}
_ => return Err(Error::new_spanned(arg, "unsupported signature")),
};
- let ty = parse_type(&arg.ty)?;
+ let ty = parse_type(&arg.ty, &namespace)?;
if ident != "self" {
args.push_value(Var { ident, ty });
if let Some(comma) = comma {
@@ -309,7 +402,7 @@
ampersand: reference.ampersand,
lifetime: reference.lifetime,
mutability: reference.mutability,
- var: Token),
+ var: Token),
ty: ident,
shorthand: false,
});
@@ -322,11 +415,15 @@
}
let mut throws_tokens = None;
- let ret = parse_return_type(&foreign_fn.sig.output, &mut throws_tokens)?;
+ let ret = parse_return_type(&foreign_fn.sig.output, &mut throws_tokens, &namespace)?;
let throws = throws_tokens.is_some();
- let doc = attrs::parse_doc(cx, &foreign_fn.attrs);
+ let unsafety = foreign_fn.sig.unsafety;
let fn_token = foreign_fn.sig.fn_token;
- let ident = foreign_fn.sig.ident.clone();
+ let name = Pair::new_from_differing_names(
+ namespace,
+ cxx_name.unwrap_or(foreign_fn.sig.ident.clone()),
+ rust_name.unwrap_or(foreign_fn.sig.ident.clone()),
+ );
let paren_token = foreign_fn.sig.paren_token;
let semi_token = foreign_fn.semi_token;
let api_function = match lang {
@@ -337,8 +434,9 @@
Ok(api_function(ExternFn {
lang,
doc,
- ident,
+ name,
sig: Signature {
+ unsafety,
fn_token,
receiver,
args,
@@ -351,7 +449,12 @@
}))
}
-fn parse_extern_verbatim(cx: &mut Errors, tokens: &TokenStream, lang: Lang) -> Result<Api> {
+fn parse_extern_verbatim(
+ cx: &mut Errors,
+ tokens: &TokenStream,
+ lang: Lang,
+ namespace: &Namespace,
+) -> Result<Api> {
// type Alias = crate::path::to::Type;
let parse = |input: ParseStream| -> Result<TypeAlias> {
let attrs = input.call(Attribute::parse_outer)?;
@@ -366,11 +469,22 @@
let eq_token: Token![=] = input.parse()?;
let ty: RustType = input.parse()?;
let semi_token: Token![;] = input.parse()?;
- attrs::parse_doc(cx, &attrs);
+ let mut doc = Doc::new();
+ let mut namespace = namespace.clone();
+ attrs::parse(
+ cx,
+ &attrs,
+ attrs::Parser {
+ doc: Some(&mut doc),
+ namespace: Some(&mut namespace),
+ ..Default::default()
+ },
+ );
Ok(TypeAlias {
+ doc,
type_token,
- ident,
+ name: Pair::new(namespace, ident),
eq_token,
ty,
semi_token,
@@ -389,15 +503,53 @@
}
}
-fn parse_include(input: ParseStream) -> Result<String> {
+fn parse_impl(imp: ItemImpl, namespace: &Namespace) -> Result<Api> {
+ if !imp.items.is_empty() {
+ let mut span = Group::new(Delimiter::Brace, TokenStream::new());
+ span.set_span(imp.brace_token.span);
+ return Err(Error::new_spanned(span, "expected an empty impl block"));
+ }
+
+ let self_ty = &imp.self_ty;
+ if let Some((bang, path, for_token)) = &imp.trait_ {
+ let span = quote!(#bang #path #for_token #self_ty);
+ return Err(Error::new_spanned(
+ span,
+ "unexpected impl, expected something like `impl UniquePtr<T> {}`",
+ ));
+ }
+
+ let generics = &imp.generics;
+ if !generics.params.is_empty() || generics.where_clause.is_some() {
+ return Err(Error::new_spanned(
+ imp,
+ "generic parameters on an impl is not supported",
+ ));
+ }
+
+ Ok(Api::Impl(Impl {
+ impl_token: imp.impl_token,
+ ty: parse_type(&self_ty, namespace)?,
+ brace_token: imp.brace_token,
+ }))
+}
+
+fn parse_include(input: ParseStream) -> Result<Include> {
if input.peek(LitStr) {
- return Ok(input.parse::<LitStr>()?.value());
+ let lit: LitStr = input.parse()?;
+ let span = lit.span();
+ return Ok(Include {
+ path: lit.value(),
+ kind: IncludeKind::Quoted,
+ begin_span: span,
+ end_span: span,
+ });
}
if input.peek(Token![<]) {
let mut path = String::new();
- input.parse::<Token![<]>()?;
- path.push('<');
+
+ let langle: Token![<] = input.parse()?;
while !input.is_empty() && !input.peek(Token![>]) {
let token: TokenTree = input.parse()?;
match token {
@@ -413,29 +565,34 @@
_ => return Err(Error::new(token.span(), "unexpected token in include path")),
}
}
- input.parse::<Token![>]>()?;
- path.push('>');
- return Ok(path);
+ let rangle: Token![>] = input.parse()?;
+
+ return Ok(Include {
+ path,
+ kind: IncludeKind::Bracketed,
+ begin_span: langle.span,
+ end_span: rangle.span,
+ });
}
Err(input.error("expected \"quoted/path/to\" or <bracketed/path/to>"))
}
-fn parse_type(ty: &RustType) -> Result<Type> {
+fn parse_type(ty: &RustType, namespace: &Namespace) -> Result<Type> {
match ty {
- RustType::Reference(ty) => parse_type_reference(ty),
- RustType::Path(ty) => parse_type_path(ty),
- RustType::Slice(ty) => parse_type_slice(ty),
- RustType::BareFn(ty) => parse_type_fn(ty),
+ RustType::Reference(ty) => parse_type_reference(ty, namespace),
+ RustType::Path(ty) => parse_type_path(ty, namespace),
+ RustType::Slice(ty) => parse_type_slice(ty, namespace),
+ RustType::BareFn(ty) => parse_type_fn(ty, namespace),
RustType::Tuple(ty) if ty.elems.is_empty() => Ok(Type::Void(ty.paren_token.span)),
_ => Err(Error::new_spanned(ty, "unsupported type")),
}
}
-fn parse_type_reference(ty: &TypeReference) -> Result<Type> {
- let inner = parse_type(&ty.elem)?;
+fn parse_type_reference(ty: &TypeReference, namespace: &Namespace) -> Result<Type> {
+ let inner = parse_type(&ty.elem, namespace)?;
let which = match &inner {
- Type::Ident(ident) if ident == "str" => {
+ Type::Ident(ident) if ident.rust == "str" => {
if ty.mutability.is_some() {
return Err(Error::new_spanned(ty, "unsupported type"));
} else {
@@ -443,7 +600,7 @@
}
}
Type::Slice(slice) => match &slice.inner {
- Type::Ident(ident) if ident == U8 && ty.mutability.is_none() => Type::SliceRefU8,
+ Type::Ident(ident) if ident.rust == U8 && ty.mutability.is_none() => Type::SliceRefU8,
_ => Type::Ref,
},
_ => Type::Ref,
@@ -456,17 +613,17 @@
})))
}
-fn parse_type_path(ty: &TypePath) -> Result<Type> {
+fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
let path = &ty.path;
if ty.qself.is_none() && path.leading_colon.is_none() && path.segments.len() == 1 {
let segment = &path.segments[0];
let ident = segment.ident.clone();
match &segment.arguments {
- PathArguments::None => return Ok(Type::Ident(ident)),
+ PathArguments::None => return Ok(Type::Ident(ResolvableName::new(ident))),
PathArguments::AngleBracketed(generic) => {
if ident == "UniquePtr" && generic.args.len() == 1 {
if let GenericArgument::Type(arg) = &generic.args[0] {
- let inner = parse_type(arg)?;
+ let inner = parse_type(arg, namespace)?;
return Ok(Type::UniquePtr(Box::new(Ty1 {
name: ident,
langle: generic.lt_token,
@@ -476,7 +633,7 @@
}
} else if ident == "CxxVector" && generic.args.len() == 1 {
if let GenericArgument::Type(arg) = &generic.args[0] {
- let inner = parse_type(arg)?;
+ let inner = parse_type(arg, namespace)?;
return Ok(Type::CxxVector(Box::new(Ty1 {
name: ident,
langle: generic.lt_token,
@@ -486,7 +643,7 @@
}
} else if ident == "Box" && generic.args.len() == 1 {
if let GenericArgument::Type(arg) = &generic.args[0] {
- let inner = parse_type(arg)?;
+ let inner = parse_type(arg, namespace)?;
return Ok(Type::RustBox(Box::new(Ty1 {
name: ident,
langle: generic.lt_token,
@@ -496,7 +653,7 @@
}
} else if ident == "Vec" && generic.args.len() == 1 {
if let GenericArgument::Type(arg) = &generic.args[0] {
- let inner = parse_type(arg)?;
+ let inner = parse_type(arg, namespace)?;
return Ok(Type::RustVec(Box::new(Ty1 {
name: ident,
langle: generic.lt_token,
@@ -512,15 +669,15 @@
Err(Error::new_spanned(ty, "unsupported type"))
}
-fn parse_type_slice(ty: &TypeSlice) -> Result<Type> {
- let inner = parse_type(&ty.elem)?;
+fn parse_type_slice(ty: &TypeSlice, namespace: &Namespace) -> Result<Type> {
+ let inner = parse_type(&ty.elem, namespace)?;
Ok(Type::Slice(Box::new(Slice {
bracket: ty.bracket_token,
inner,
})))
}
-fn parse_type_fn(ty: &TypeBareFn) -> Result<Type> {
+fn parse_type_fn(ty: &TypeBareFn, namespace: &Namespace) -> Result<Type> {
if ty.lifetimes.is_some() {
return Err(Error::new_spanned(
ty,
@@ -538,7 +695,7 @@
.iter()
.enumerate()
.map(|(i, arg)| {
- let ty = parse_type(&arg.ty)?;
+ let ty = parse_type(&arg.ty, namespace)?;
let ident = match &arg.name {
Some(ident) => ident.0.clone(),
None => format_ident!("_{}", i),
@@ -547,9 +704,10 @@
})
.collect::<Result<_>>()?;
let mut throws_tokens = None;
- let ret = parse_return_type(&ty.output, &mut throws_tokens)?;
+ let ret = parse_return_type(&ty.output, &mut throws_tokens, namespace)?;
let throws = throws_tokens.is_some();
Ok(Type::Fn(Box::new(Signature {
+ unsafety: ty.unsafety,
fn_token: ty.fn_token,
receiver: None,
args,
@@ -563,6 +721,7 @@
fn parse_return_type(
ty: &ReturnType,
throws_tokens: &mut Option<(kw::Result, Token![<], Token![>])>,
+ namespace: &Namespace,
) -> Result<Option<Type>> {
let mut ret = match ty {
ReturnType::Default => return Ok(None),
@@ -584,7 +743,7 @@
}
}
}
- match parse_type(ret)? {
+ match parse_type(ret, namespace)? {
Type::Void(_) => Ok(None),
ty => Ok(Some(ty)),
}
diff --git a/syntax/qualified.rs b/syntax/qualified.rs
new file mode 100644
index 0000000..5eefb8d
--- /dev/null
+++ b/syntax/qualified.rs
@@ -0,0 +1,36 @@
+use syn::ext::IdentExt;
+use syn::parse::{ParseStream, Result};
+use syn::{Ident, LitStr, Token};
+
+pub struct QualifiedName {
+ pub segments: Vec<Ident>,
+}
+
+impl QualifiedName {
+ pub fn parse_unquoted(input: ParseStream) -> Result<Self> {
+ let mut segments = Vec::new();
+ let mut trailing_punct = true;
+ input.parse::<Option<Token![::]>>()?;
+ while trailing_punct && input.peek(Ident::peek_any) {
+ let ident = Ident::parse_any(input)?;
+ segments.push(ident);
+ let colons: Option<Token![::]> = input.parse()?;
+ trailing_punct = colons.is_some();
+ }
+ if segments.is_empty() {
+ return Err(input.error("expected path"));
+ } else if trailing_punct {
+ return Err(input.error("expected path segment"));
+ }
+ Ok(QualifiedName { segments })
+ }
+
+ pub fn parse_quoted_or_unquoted(input: ParseStream) -> Result<Self> {
+ if input.peek(LitStr) {
+ let lit: LitStr = input.parse()?;
+ lit.parse_with(Self::parse_unquoted)
+ } else {
+ Self::parse_unquoted(input)
+ }
+ }
+}
diff --git a/syntax/set.rs b/syntax/set.rs
index 688d1c0..6508f55 100644
--- a/syntax/set.rs
+++ b/syntax/set.rs
@@ -1,41 +1,100 @@
-use std::collections::HashSet;
-use std::hash::Hash;
+use std::fmt::{self, Debug};
use std::slice;
-pub struct OrderedSet<'a, T> {
- set: HashSet<&'a T>,
- vec: Vec<&'a T>,
-}
+pub use self::ordered::OrderedSet;
+pub use self::unordered::UnorderedSet;
-impl<'a, T> OrderedSet<'a, T>
-where
- T: Hash + Eq,
-{
- pub fn new() -> Self {
- OrderedSet {
- set: HashSet::new(),
- vec: Vec::new(),
+mod ordered {
+ use super::{Iter, UnorderedSet};
+ use std::borrow::Borrow;
+ use std::hash::Hash;
+
+ pub struct OrderedSet<T> {
+ set: UnorderedSet<T>,
+ vec: Vec<T>,
+ }
+
+ impl<'a, T> OrderedSet<&'a T>
+ where
+ T: Hash + Eq,
+ {
+ pub fn new() -> Self {
+ OrderedSet {
+ set: UnorderedSet::new(),
+ vec: Vec::new(),
+ }
+ }
+
+ pub fn insert(&mut self, value: &'a T) -> bool {
+ let new = self.set.insert(value);
+ if new {
+ self.vec.push(value);
+ }
+ new
+ }
+
+ pub fn contains<Q>(&self, value: &Q) -> bool
+ where
+ &'a T: Borrow<Q>,
+ Q: ?Sized + Hash + Eq,
+ {
+ self.set.contains(value)
+ }
+
+ pub fn get<Q>(&self, value: &Q) -> Option<&'a T>
+ where
+ &'a T: Borrow<Q>,
+ Q: ?Sized + Hash + Eq,
+ {
+ self.set.get(value).copied()
}
}
- pub fn insert(&mut self, value: &'a T) -> bool {
- let new = self.set.insert(value);
- if new {
- self.vec.push(value);
+ impl<'s, 'a, T> IntoIterator for &'s OrderedSet<&'a T> {
+ type Item = &'a T;
+ type IntoIter = Iter<'s, 'a, T>;
+ fn into_iter(self) -> Self::IntoIter {
+ Iter(self.vec.iter())
}
- new
- }
-
- pub fn contains(&self, value: &T) -> bool {
- self.set.contains(value)
}
}
-impl<'s, 'a, T> IntoIterator for &'s OrderedSet<'a, T> {
- type Item = &'a T;
- type IntoIter = Iter<'s, 'a, T>;
- fn into_iter(self) -> Self::IntoIter {
- Iter(self.vec.iter())
+mod unordered {
+ use std::borrow::Borrow;
+ use std::collections::HashSet;
+ use std::hash::Hash;
+
+ // Wrapper prohibits accidentally introducing iteration over the set, which
+ // could lead to nondeterministic generated code.
+ pub struct UnorderedSet<T>(HashSet<T>);
+
+ impl<T> UnorderedSet<T>
+ where
+ T: Hash + Eq,
+ {
+ pub fn new() -> Self {
+ UnorderedSet(HashSet::new())
+ }
+
+ pub fn insert(&mut self, value: T) -> bool {
+ self.0.insert(value)
+ }
+
+ pub fn contains<Q>(&self, value: &Q) -> bool
+ where
+ T: Borrow<Q>,
+ Q: ?Sized + Hash + Eq,
+ {
+ self.0.contains(value)
+ }
+
+ pub fn get<Q>(&self, value: &Q) -> Option<&T>
+ where
+ T: Borrow<Q>,
+ Q: ?Sized + Hash + Eq,
+ {
+ self.0.get(value)
+ }
}
}
@@ -47,3 +106,12 @@
self.0.next().copied()
}
}
+
+impl<'a, T> Debug for OrderedSet<&'a T>
+where
+ T: Debug,
+{
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.debug_set().entries(self).finish()
+ }
+}
diff --git a/syntax/symbol.rs b/syntax/symbol.rs
index 066d238..253f57d 100644
--- a/syntax/symbol.rs
+++ b/syntax/symbol.rs
@@ -1,10 +1,11 @@
use crate::syntax::namespace::Namespace;
+use crate::syntax::Pair;
use proc_macro2::{Ident, TokenStream};
use quote::ToTokens;
use std::fmt::{self, Display, Write};
// A mangled symbol consisting of segments separated by '$'.
-// For example: cxxbridge03$string$new
+// For example: cxxbridge05$string$new
pub struct Symbol(String);
impl Display for Symbol {
@@ -19,12 +20,6 @@
}
}
-impl From<&Ident> for Symbol {
- fn from(ident: &Ident) -> Self {
- Symbol(ident.to_string())
- }
-}
-
impl Symbol {
fn push(&mut self, segment: &dyn Display) {
let len_before = self.0.len();
@@ -34,18 +29,47 @@
self.0.write_fmt(format_args!("{}", segment)).unwrap();
assert!(self.0.len() > len_before);
}
+
+ pub fn from_idents<'a, T: Iterator<Item = &'a Ident>>(it: T) -> Self {
+ let mut symbol = Symbol(String::new());
+ for segment in it {
+ segment.write(&mut symbol);
+ }
+ assert!(!symbol.0.is_empty());
+ symbol
+ }
+
+ /// For example, for taking a symbol and then making a new symbol
+ /// for a vec of that symbol.
+ pub fn prefix_with(&self, prefix: &str) -> Symbol {
+ Symbol(format!("{}{}", prefix, self.to_string()))
+ }
}
-pub trait Segment: Display {
+pub trait Segment {
+ fn write(&self, symbol: &mut Symbol);
+}
+
+impl Segment for str {
fn write(&self, symbol: &mut Symbol) {
symbol.push(&self);
}
}
-
-impl Segment for str {}
-impl Segment for usize {}
-impl Segment for Ident {}
-impl Segment for Symbol {}
+impl Segment for usize {
+ fn write(&self, symbol: &mut Symbol) {
+ symbol.push(&self);
+ }
+}
+impl Segment for Ident {
+ fn write(&self, symbol: &mut Symbol) {
+ symbol.push(&self);
+ }
+}
+impl Segment for Symbol {
+ fn write(&self, symbol: &mut Symbol) {
+ symbol.push(&self);
+ }
+}
impl Segment for Namespace {
fn write(&self, symbol: &mut Symbol) {
@@ -55,9 +79,16 @@
}
}
+impl Segment for Pair {
+ fn write(&self, symbol: &mut Symbol) {
+ self.namespace.write(symbol);
+ self.cxx.write(symbol);
+ }
+}
+
impl<T> Segment for &'_ T
where
- T: ?Sized + Segment,
+ T: ?Sized + Segment + Display,
{
fn write(&self, symbol: &mut Symbol) {
(**self).write(symbol);
diff --git a/syntax/tokens.rs b/syntax/tokens.rs
index 4ed264a..500ea0b 100644
--- a/syntax/tokens.rs
+++ b/syntax/tokens.rs
@@ -1,7 +1,7 @@
use crate::syntax::atom::Atom::*;
use crate::syntax::{
- Atom, Derive, Enum, ExternFn, ExternType, Receiver, Ref, Signature, Slice, Struct, Ty1, Type,
- TypeAlias, Var,
+ Atom, Derive, Enum, ExternFn, ExternType, Impl, Receiver, Ref, ResolvableName, Signature,
+ Slice, Struct, Ty1, Type, TypeAlias, Var,
};
use proc_macro2::{Ident, Span, TokenStream};
use quote::{quote_spanned, ToTokens};
@@ -11,11 +11,11 @@
fn to_tokens(&self, tokens: &mut TokenStream) {
match self {
Type::Ident(ident) => {
- if ident == CxxString {
- let span = ident.span();
+ if ident.rust == CxxString {
+ let span = ident.rust.span();
tokens.extend(quote_spanned!(span=> ::cxx::));
}
- ident.to_tokens(tokens);
+ ident.rust.to_tokens(tokens);
}
Type::RustBox(ty) | Type::UniquePtr(ty) | Type::CxxVector(ty) | Type::RustVec(ty) => {
ty.to_tokens(tokens)
@@ -85,7 +85,7 @@
fn to_tokens(&self, tokens: &mut TokenStream) {
// Notional token range for error reporting purposes.
self.type_token.to_tokens(tokens);
- self.ident.to_tokens(tokens);
+ self.name.rust.to_tokens(tokens);
}
}
@@ -93,7 +93,7 @@
fn to_tokens(&self, tokens: &mut TokenStream) {
// Notional token range for error reporting purposes.
self.type_token.to_tokens(tokens);
- self.ident.to_tokens(tokens);
+ self.name.rust.to_tokens(tokens);
}
}
@@ -101,7 +101,7 @@
fn to_tokens(&self, tokens: &mut TokenStream) {
// Notional token range for error reporting purposes.
self.struct_token.to_tokens(tokens);
- self.ident.to_tokens(tokens);
+ self.name.rust.to_tokens(tokens);
}
}
@@ -109,7 +109,7 @@
fn to_tokens(&self, tokens: &mut TokenStream) {
// Notional token range for error reporting purposes.
self.enum_token.to_tokens(tokens);
- self.ident.to_tokens(tokens);
+ self.name.rust.to_tokens(tokens);
}
}
@@ -121,6 +121,14 @@
}
}
+impl ToTokens for Impl {
+ fn to_tokens(&self, tokens: &mut TokenStream) {
+ self.impl_token.to_tokens(tokens);
+ self.ty.to_tokens(tokens);
+ self.brace_token.surround(tokens, |_tokens| {});
+ }
+}
+
impl ToTokens for Signature {
fn to_tokens(&self, tokens: &mut TokenStream) {
self.fn_token.to_tokens(tokens);
@@ -141,6 +149,12 @@
}
}
+impl ToTokens for ResolvableName {
+ fn to_tokens(&self, tokens: &mut TokenStream) {
+ self.rust.to_tokens(tokens);
+ }
+}
+
pub struct ReceiverType<'a>(&'a Receiver);
impl Receiver {
diff --git a/syntax/toposort.rs b/syntax/toposort.rs
new file mode 100644
index 0000000..876f9ad
--- /dev/null
+++ b/syntax/toposort.rs
@@ -0,0 +1,51 @@
+use crate::syntax::report::Errors;
+use crate::syntax::{Api, Struct, Type, Types};
+use std::collections::btree_map::{BTreeMap as Map, Entry};
+
+enum Mark {
+ Visiting,
+ Visited,
+}
+
+pub fn sort<'a>(cx: &mut Errors, apis: &'a [Api], types: &Types<'a>) -> Vec<&'a Struct> {
+ let mut sorted = Vec::new();
+ let ref mut marks = Map::new();
+ for api in apis {
+ if let Api::Struct(strct) = api {
+ let _ = visit(cx, strct, &mut sorted, marks, types);
+ }
+ }
+ sorted
+}
+
+fn visit<'a>(
+ cx: &mut Errors,
+ strct: &'a Struct,
+ sorted: &mut Vec<&'a Struct>,
+ marks: &mut Map<*const Struct, Mark>,
+ types: &Types<'a>,
+) -> Result<(), ()> {
+ match marks.entry(strct) {
+ Entry::Occupied(entry) => match entry.get() {
+ Mark::Visiting => return Err(()), // not a DAG
+ Mark::Visited => return Ok(()),
+ },
+ Entry::Vacant(entry) => {
+ entry.insert(Mark::Visiting);
+ }
+ }
+ let mut result = Ok(());
+ for field in &strct.fields {
+ if let Type::Ident(ident) = &field.ty {
+ if let Some(inner) = types.structs.get(&ident.rust) {
+ if visit(cx, inner, sorted, marks, types).is_err() {
+ cx.error(field, "unsupported cyclic data structure");
+ result = Err(());
+ }
+ }
+ }
+ }
+ marks.insert(strct, Mark::Visited);
+ sorted.push(strct);
+ result
+}
diff --git a/syntax/types.rs b/syntax/types.rs
index ba9bc78..90a8221 100644
--- a/syntax/types.rs
+++ b/syntax/types.rs
@@ -1,18 +1,28 @@
use crate::syntax::atom::Atom::{self, *};
+use crate::syntax::improper::ImproperCtype;
use crate::syntax::report::Errors;
-use crate::syntax::set::OrderedSet as Set;
-use crate::syntax::{Api, Derive, Enum, Struct, Type, TypeAlias};
+use crate::syntax::set::{OrderedSet as Set, UnorderedSet};
+use crate::syntax::{
+ toposort, Api, Derive, Enum, ExternFn, ExternType, Impl, Pair, ResolvableName, Struct, Type,
+ TypeAlias,
+};
use proc_macro2::Ident;
use quote::ToTokens;
-use std::collections::{BTreeMap as Map, HashSet as UnorderedSet};
+use std::collections::BTreeMap as Map;
pub struct Types<'a> {
- pub all: Set<'a, Type>,
- pub structs: Map<Ident, &'a Struct>,
- pub enums: Map<Ident, &'a Enum>,
- pub cxx: Set<'a, Ident>,
- pub rust: Set<'a, Ident>,
- pub aliases: Map<Ident, &'a TypeAlias>,
+ pub all: Set<&'a Type>,
+ pub structs: Map<&'a Ident, &'a Struct>,
+ pub enums: Map<&'a Ident, &'a Enum>,
+ pub cxx: Set<&'a Ident>,
+ pub rust: Set<&'a Ident>,
+ pub aliases: Map<&'a Ident, &'a TypeAlias>,
+ pub untrusted: Map<&'a Ident, &'a ExternType>,
+ pub required_trivial: Map<&'a Ident, TrivialReason<'a>>,
+ pub explicit_impls: Set<&'a Impl>,
+ pub resolutions: Map<&'a Ident, &'a Pair>,
+ pub struct_improper_ctypes: UnorderedSet<&'a Ident>,
+ pub toposorted_structs: Vec<&'a Struct>,
}
impl<'a> Types<'a> {
@@ -23,8 +33,13 @@
let mut cxx = Set::new();
let mut rust = Set::new();
let mut aliases = Map::new();
+ let mut untrusted = Map::new();
+ let mut explicit_impls = Set::new();
+ let mut resolutions = Map::new();
+ let struct_improper_ctypes = UnorderedSet::new();
+ let toposorted_structs = Vec::new();
- fn visit<'a>(all: &mut Set<'a, Type>, ty: &'a Type) {
+ fn visit<'a>(all: &mut Set<&'a Type>, ty: &'a Type) {
all.insert(ty);
match ty {
Type::Ident(_) | Type::Str(_) | Type::Void(_) | Type::SliceRefU8(_) => {}
@@ -45,51 +60,84 @@
}
}
+ let mut add_resolution = |pair: &'a Pair| {
+ resolutions.insert(&pair.rust, pair);
+ };
+
let mut type_names = UnorderedSet::new();
let mut function_names = UnorderedSet::new();
for api in apis {
+ // The same identifier is permitted to be declared as both a shared
+ // enum and extern C++ type, or shared struct and extern C++ type.
+ // That indicates to not emit the C++ enum/struct definition because
+ // it's defined by the included headers already.
+ //
+ // All other cases of duplicate identifiers are reported as an error.
match api {
Api::Include(_) => {}
Api::Struct(strct) => {
- let ident = &strct.ident;
- if type_names.insert(ident) {
- structs.insert(ident.clone(), strct);
- } else {
+ let ident = &strct.name.rust;
+ if !type_names.insert(ident)
+ && (!cxx.contains(ident)
+ || structs.contains_key(ident)
+ || enums.contains_key(ident))
+ {
+ // If already declared as a struct or enum, or if
+ // colliding with something other than an extern C++
+ // type, then error.
duplicate_name(cx, strct, ident);
}
+ structs.insert(&strct.name.rust, strct);
for field in &strct.fields {
visit(&mut all, &field.ty);
}
+ add_resolution(&strct.name);
}
Api::Enum(enm) => {
- let ident = &enm.ident;
- // We allow declaring the same type as a shared enum and as a Cxxtype, as this
- // means not to emit the C++ enum definition.
- if !type_names.insert(ident) && !cxx.contains(ident) {
+ let ident = &enm.name.rust;
+ if !type_names.insert(ident)
+ && (!cxx.contains(ident)
+ || structs.contains_key(ident)
+ || enums.contains_key(ident))
+ {
+ // If already declared as a struct or enum, or if
+ // colliding with something other than an extern C++
+ // type, then error.
duplicate_name(cx, enm, ident);
}
- enums.insert(ident.clone(), enm);
+ enums.insert(ident, enm);
+ add_resolution(&enm.name);
}
Api::CxxType(ety) => {
- let ident = &ety.ident;
- // We allow declaring the same type as a shared enum and as a Cxxtype, as this
- // means not to emit the C++ enum definition.
- if !type_names.insert(ident) && !enums.contains_key(ident) {
+ let ident = &ety.name.rust;
+ if !type_names.insert(ident)
+ && (cxx.contains(ident)
+ || !structs.contains_key(ident) && !enums.contains_key(ident))
+ {
+ // If already declared as an extern C++ type, or if
+ // colliding with something which is neither struct nor
+ // enum, then error.
duplicate_name(cx, ety, ident);
}
cxx.insert(ident);
+ if !ety.trusted {
+ untrusted.insert(ident, ety);
+ }
+ add_resolution(&ety.name);
}
Api::RustType(ety) => {
- let ident = &ety.ident;
+ let ident = &ety.name.rust;
if !type_names.insert(ident) {
duplicate_name(cx, ety, ident);
}
rust.insert(ident);
+ add_resolution(&ety.name);
}
Api::CxxFunction(efn) | Api::RustFunction(efn) => {
- let ident = &efn.ident;
- if !function_names.insert((&efn.receiver, ident)) {
- duplicate_name(cx, efn, ident);
+ // Note: duplication of the C++ name is fine because C++ has
+ // function overloading.
+ if !function_names.insert((&efn.receiver, &efn.name.rust)) {
+ duplicate_name(cx, efn, &efn.name.rust);
}
for arg in &efn.args {
visit(&mut all, &arg.ty);
@@ -99,33 +147,106 @@
}
}
Api::TypeAlias(alias) => {
- let ident = &alias.ident;
+ let ident = &alias.name.rust;
if !type_names.insert(ident) {
duplicate_name(cx, alias, ident);
}
cxx.insert(ident);
- aliases.insert(ident.clone(), alias);
+ aliases.insert(ident, alias);
+ add_resolution(&alias.name);
+ }
+ Api::Impl(imp) => {
+ visit(&mut all, &imp.ty);
+ explicit_impls.insert(imp);
}
}
}
- Types {
+ // All these APIs may contain types passed by value. We need to ensure
+ // we check that this is permissible. We do this _after_ scanning all
+ // the APIs above, in case some function or struct references a type
+ // which is declared subsequently.
+ let mut required_trivial = Map::new();
+ let mut insist_alias_types_are_trivial = |ty: &'a Type, reason| {
+ if let Type::Ident(ident) = ty {
+ if cxx.contains(&ident.rust) {
+ required_trivial.entry(&ident.rust).or_insert(reason);
+ }
+ }
+ };
+ for api in apis {
+ match api {
+ Api::Struct(strct) => {
+ let reason = TrivialReason::StructField(strct);
+ for field in &strct.fields {
+ insist_alias_types_are_trivial(&field.ty, reason);
+ }
+ }
+ Api::CxxFunction(efn) | Api::RustFunction(efn) => {
+ let reason = TrivialReason::FunctionArgument(efn);
+ for arg in &efn.args {
+ insist_alias_types_are_trivial(&arg.ty, reason);
+ }
+ if let Some(ret) = &efn.ret {
+ let reason = TrivialReason::FunctionReturn(efn);
+ insist_alias_types_are_trivial(&ret, reason);
+ }
+ }
+ _ => {}
+ }
+ }
+
+ let mut types = Types {
all,
structs,
enums,
cxx,
rust,
aliases,
+ untrusted,
+ required_trivial,
+ explicit_impls,
+ resolutions,
+ struct_improper_ctypes,
+ toposorted_structs,
+ };
+
+ types.toposorted_structs = toposort::sort(cx, apis, &types);
+
+ let mut unresolved_structs: Vec<&Ident> = types.structs.keys().copied().collect();
+ let mut new_information = true;
+ while new_information {
+ new_information = false;
+ unresolved_structs.retain(|ident| {
+ let mut retain = false;
+ for var in &types.structs[ident].fields {
+ if match types.determine_improper_ctype(&var.ty) {
+ ImproperCtype::Depends(inner) => {
+ retain = true;
+ types.struct_improper_ctypes.contains(inner)
+ }
+ ImproperCtype::Definite(improper) => improper,
+ } {
+ types.struct_improper_ctypes.insert(ident);
+ new_information = true;
+ return false;
+ }
+ }
+ // If all fields definite false, remove from unresolved_structs.
+ retain
+ });
}
+
+ types
}
pub fn needs_indirect_abi(&self, ty: &Type) -> bool {
match ty {
Type::Ident(ident) => {
- if let Some(strct) = self.structs.get(ident) {
+ if let Some(strct) = self.structs.get(&ident.rust) {
!self.is_pod(strct)
} else {
- Atom::from(ident) == Some(RustString)
+ Atom::from(&ident.rust) == Some(RustString)
}
}
Type::RustVec(_) => true,
@@ -141,6 +262,25 @@
}
false
}
+
+ // Types that trigger rustc's default #[warn(improper_ctypes)] lint, even if
+ // they may be otherwise unproblematic to mention in an extern signature.
+ // For example in a signature like `extern "C" fn(*const String)`, rustc
+ // refuses to believe that C could know how to supply us with a pointer to a
+ // Rust String, even though C could easily have obtained that pointer
+ // legitimately from a Rust call.
+ pub fn is_considered_improper_ctype(&self, ty: &Type) -> bool {
+ match self.determine_improper_ctype(ty) {
+ ImproperCtype::Definite(improper) => improper,
+ ImproperCtype::Depends(ident) => self.struct_improper_ctypes.contains(ident),
+ }
+ }
+
+ pub fn resolve(&self, ident: &ResolvableName) -> &Pair {
+ self.resolutions
+ .get(&ident.rust)
+ .expect("Unable to resolve type")
+ }
}
impl<'t, 'a> IntoIterator for &'t Types<'a> {
@@ -151,6 +291,13 @@
}
}
+#[derive(Copy, Clone)]
+pub enum TrivialReason<'a> {
+ StructField(&'a Struct),
+ FunctionArgument(&'a ExternFn),
+ FunctionReturn(&'a ExternFn),
+}
+
fn duplicate_name(cx: &mut Errors, sp: impl ToTokens, ident: &Ident) {
let msg = format!("the name `{}` is defined multiple times", ident);
cx.error(sp, msg);
diff --git a/tests/BUCK b/tests/BUCK
index 41781c8..5bbe500 100644
--- a/tests/BUCK
+++ b/tests/BUCK
@@ -1,12 +1,18 @@
+load("//tools/buck:rust_cxx_bridge.bzl", "rust_cxx_bridge")
+
rust_test(
name = "test",
srcs = ["test.rs"],
- deps = [":ffi"],
+ deps = [
+ ":ffi",
+ "//:cxx",
+ ],
)
rust_library(
name = "ffi",
srcs = [
+ "ffi/extra.rs",
"ffi/lib.rs",
"ffi/module.rs",
],
@@ -21,33 +27,28 @@
name = "impl",
srcs = [
"ffi/tests.cc",
- ":gen-lib-source",
- ":gen-module-source",
+ ":bridge/source",
+ ":extra/source",
+ ":module/source",
],
headers = {
- "ffi/lib.rs.h": ":gen-lib-header",
+ "ffi/lib.rs.h": ":bridge/header",
"ffi/tests.h": "ffi/tests.h",
},
deps = ["//:core"],
)
-genrule(
- name = "gen-lib-header",
- srcs = ["ffi/lib.rs"],
- cmd = "$(exe //:codegen) --header ${SRCS} > ${OUT}",
- out = "lib.rs.h",
+rust_cxx_bridge(
+ name = "bridge",
+ src = "ffi/lib.rs",
)
-genrule(
- name = "gen-lib-source",
- srcs = ["ffi/lib.rs"],
- cmd = "$(exe //:codegen) ${SRCS} > ${OUT}",
- out = "lib.rs.cc",
+rust_cxx_bridge(
+ name = "extra",
+ src = "ffi/extra.rs",
)
-genrule(
- name = "gen-module-source",
- srcs = ["ffi/module.rs"],
- cmd = "$(exe //:codegen) ${SRCS} > ${OUT}",
- out = "module.rs.cc",
+rust_cxx_bridge(
+ name = "module",
+ src = "ffi/module.rs",
)
diff --git a/tests/BUILD b/tests/BUILD
index e1f1637..57ffab9 100644
--- a/tests/BUILD
+++ b/tests/BUILD
@@ -1,14 +1,21 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
load("//tools/bazel:rust.bzl", "rust_library", "rust_test")
+load("//tools/bazel:rust_cxx_bridge.bzl", "rust_cxx_bridge")
rust_test(
name = "test",
+ size = "small",
srcs = ["test.rs"],
- deps = [":cxx_test_suite"],
+ deps = [
+ ":cxx_test_suite",
+ "//:cxx",
+ ],
)
rust_library(
name = "cxx_test_suite",
srcs = [
+ "ffi/extra.rs",
"ffi/lib.rs",
"ffi/module.rs",
],
@@ -22,42 +29,31 @@
name = "impl",
srcs = [
"ffi/tests.cc",
- ":gen-lib-source",
- ":gen-module-source",
+ ":bridge/source",
+ ":extra/source",
+ ":module/source",
],
hdrs = ["ffi/tests.h"],
deps = [
- ":lib-include",
+ ":bridge/include",
"//:core",
],
)
-genrule(
- name = "gen-lib-header",
- srcs = ["ffi/lib.rs"],
- outs = ["lib.rs.h"],
- cmd = "$(location //:codegen) --header $< > $@",
- tools = ["//:codegen"],
+rust_cxx_bridge(
+ name = "bridge",
+ src = "ffi/lib.rs",
+ deps = [":impl"],
)
-genrule(
- name = "gen-lib-source",
- srcs = ["ffi/lib.rs"],
- outs = ["lib.rs.cc"],
- cmd = "$(location //:codegen) $< > $@",
- tools = ["//:codegen"],
+rust_cxx_bridge(
+ name = "extra",
+ src = "ffi/extra.rs",
+ deps = [":impl"],
)
-cc_library(
- name = "lib-include",
- hdrs = [":gen-lib-header"],
- include_prefix = "tests/ffi",
-)
-
-genrule(
- name = "gen-module-source",
- srcs = ["ffi/module.rs"],
- outs = ["module.rs.cc"],
- cmd = "$(location //:codegen) $< > $@",
- tools = ["//:codegen"],
+rust_cxx_bridge(
+ name = "module",
+ src = "ffi/module.rs",
+ deps = [":impl"],
)
diff --git a/tests/compiletest.rs b/tests/compiletest.rs
index f9aea23..d2b516f 100644
--- a/tests/compiletest.rs
+++ b/tests/compiletest.rs
@@ -1,4 +1,5 @@
#[rustversion::attr(not(nightly), ignore)]
+#[cfg_attr(skip_ui_tests, ignore)]
#[test]
fn ui() {
let t = trybuild::TestCases::new();
diff --git a/tests/cxx_gen.rs b/tests/cxx_gen.rs
new file mode 100644
index 0000000..06d7bc7
--- /dev/null
+++ b/tests/cxx_gen.rs
@@ -0,0 +1,34 @@
+#![allow(clippy::field_reassign_with_default)]
+
+use cxx_gen::{generate_header_and_cc, Opt};
+use std::str;
+
+const BRIDGE0: &str = r#"
+ #[cxx::bridge]
+ mod ffi {
+ extern "C" {
+ pub fn do_cpp_thing(foo: &str);
+ }
+ }
+"#;
+
+#[test]
+fn test_extern_c_function() {
+ let opt = Opt::default();
+ let source = BRIDGE0.parse().unwrap();
+ let generated = generate_header_and_cc(source, &opt).unwrap();
+ 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 cxxbridge05$do_cpp_thing(::rust::repr::PtrLen foo)"));
+}
+
+#[test]
+fn test_impl_annotation() {
+ let mut opt = Opt::default();
+ opt.cxx_impl_annotations = Some("ANNOTATION".to_owned());
+ 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 cxxbridge05$do_cpp_thing(::rust::repr::PtrLen foo)"));
+}
diff --git a/tests/ffi/Cargo.toml b/tests/ffi/Cargo.toml
index c2d8227..e62d090 100644
--- a/tests/ffi/Cargo.toml
+++ b/tests/ffi/Cargo.toml
@@ -12,3 +12,4 @@
[build-dependencies]
cxx-build = { path = "../../gen/build" }
+cxxbridge-flags = { path = "../../flags" }
diff --git a/tests/ffi/build.rs b/tests/ffi/build.rs
index f6fa59e..4b2cbdf 100644
--- a/tests/ffi/build.rs
+++ b/tests/ffi/build.rs
@@ -1,11 +1,14 @@
+use cxx_build::CFG;
+
fn main() {
if cfg!(trybuild) {
return;
}
- let sources = vec!["lib.rs", "module.rs"];
+ CFG.include_prefix = "tests/ffi";
+ let sources = vec!["lib.rs", "extra.rs", "module.rs"];
cxx_build::bridges(sources)
.file("tests.cc")
- .flag_if_supported("-std=c++11")
+ .flag_if_supported(cxxbridge_flags::STD)
.compile("cxx-test-suite");
}
diff --git a/tests/ffi/extra.rs b/tests/ffi/extra.rs
new file mode 100644
index 0000000..cd76a7d
--- /dev/null
+++ b/tests/ffi/extra.rs
@@ -0,0 +1,63 @@
+// Separate mod so that &self in the lib.rs mod has an unambiguous receiver. At
+// the moment, the cxx C++ codegen can't convert more than one cxx::bridge mod
+// per file, so that's why we need to put this outside of lib.rs. All of this
+// could go into module.rs instead, but for now its purpose is narrowly scoped
+// for testing aliasing between cxx::bridge mods, so we'll keep it that way and
+// start a new mod here.
+
+// Rustfmt mangles the extern type alias.
+// https://github.com/rust-lang/rustfmt/issues/4159
+#[rustfmt::skip]
+#[cxx::bridge(namespace = "tests")]
+pub mod ffi2 {
+ impl UniquePtr<D> {}
+ impl UniquePtr<E> {}
+ impl UniquePtr<F> {}
+ impl UniquePtr<G> {}
+
+ extern "C" {
+ include!("tests/ffi/tests.h");
+
+ type D = crate::other::D;
+ type E = crate::other::E;
+ #[namespace = "F"]
+ type F = crate::other::f::F;
+ #[namespace = "G"]
+ type G = crate::other::G;
+
+ #[namespace = "H"]
+ type H;
+
+ fn c_take_trivial_ptr(d: UniquePtr<D>);
+ fn c_take_trivial_ref(d: &D);
+ fn c_take_trivial(d: D);
+ fn c_take_trivial_ns_ptr(g: UniquePtr<G>);
+ fn c_take_trivial_ns_ref(g: &G);
+ fn c_take_trivial_ns(g: G);
+ fn c_take_opaque_ptr(e: UniquePtr<E>);
+ fn c_take_opaque_ref(e: &E);
+ fn c_take_opaque_ns_ptr(e: UniquePtr<F>);
+ fn c_take_opaque_ns_ref(e: &F);
+ fn c_return_trivial_ptr() -> UniquePtr<D>;
+ fn c_return_trivial() -> D;
+ fn c_return_trivial_ns_ptr() -> UniquePtr<G>;
+ fn c_return_trivial_ns() -> G;
+ fn c_return_opaque_ptr() -> UniquePtr<E>;
+ fn c_return_ns_opaque_ptr() -> UniquePtr<F>;
+ fn c_return_ns_unique_ptr() -> UniquePtr<H>;
+ fn c_take_ref_ns_c(h: &H);
+
+ #[namespace = "other"]
+ fn ns_c_take_trivial(d: D);
+ #[namespace = "other"]
+ fn ns_c_return_trivial() -> D;
+
+ #[namespace = "I"]
+ type I;
+
+ fn get(self: &I) -> u32;
+
+ #[namespace = "I"]
+ fn ns_c_return_unique_ptr_ns() -> UniquePtr<I>;
+ }
+}
diff --git a/tests/ffi/lib.rs b/tests/ffi/lib.rs
index 84a746b..4c7cbe4 100644
--- a/tests/ffi/lib.rs
+++ b/tests/ffi/lib.rs
@@ -1,26 +1,121 @@
#![allow(
clippy::boxed_local,
+ clippy::just_underscores_and_digits,
clippy::ptr_arg,
clippy::trivially_copy_pass_by_ref
)]
+pub mod extra;
pub mod module;
-use cxx::{CxxString, UniquePtr};
+use cxx::{CxxString, CxxVector, UniquePtr};
use std::fmt::{self, Display};
-#[cxx::bridge(namespace = tests)]
+mod other {
+ use cxx::kind::{Opaque, Trivial};
+ use cxx::{type_id, CxxString, ExternType};
+
+ #[repr(C)]
+ pub struct D {
+ pub d: u64,
+ }
+
+ #[repr(C)]
+ pub struct E {
+ e: u64,
+ e_str: CxxString,
+ }
+
+ pub mod f {
+ use cxx::kind::Opaque;
+ use cxx::{type_id, CxxString, ExternType};
+
+ #[repr(C)]
+ pub struct F {
+ e: u64,
+ e_str: CxxString,
+ }
+
+ unsafe impl ExternType for F {
+ type Id = type_id!("F::F");
+ type Kind = Opaque;
+ }
+ }
+
+ #[repr(C)]
+ pub struct G {
+ pub g: u64,
+ }
+
+ unsafe impl ExternType for G {
+ type Id = type_id!("G::G");
+ type Kind = Trivial;
+ }
+
+ unsafe impl ExternType for D {
+ type Id = type_id!("tests::D");
+ type Kind = Trivial;
+ }
+
+ unsafe impl ExternType for E {
+ type Id = type_id!("tests::E");
+ type Kind = Opaque;
+ }
+}
+
+#[cxx::bridge(namespace = "tests")]
pub mod ffi {
+ #[derive(Clone)]
struct Shared {
z: usize,
}
+ struct SharedString {
+ msg: String,
+ }
+
enum Enum {
AVal,
BVal = 2020,
CVal,
}
+ #[namespace = "A"]
+ #[derive(Clone)]
+ struct AShared {
+ z: usize,
+ }
+
+ #[namespace = "A"]
+ enum AEnum {
+ AAVal,
+ ABVal = 2020,
+ ACVal,
+ }
+
+ #[namespace = "A::B"]
+ enum ABEnum {
+ ABAVal,
+ ABBVal = 2020,
+ ABCVal,
+ }
+
+ #[namespace = "A::B"]
+ #[derive(Clone)]
+ struct ABShared {
+ z: usize,
+ }
+
+ #[namespace = "first"]
+ struct First {
+ second: Box<Second>,
+ }
+
+ #[namespace = "second"]
+ struct Second {
+ i: i32,
+ }
+
extern "C" {
include!("tests/ffi/tests.h");
@@ -31,20 +126,29 @@
fn c_return_box() -> Box<R>;
fn c_return_unique_ptr() -> UniquePtr<C>;
fn c_return_ref(shared: &Shared) -> &usize;
+ fn c_return_mut(shared: &mut Shared) -> &mut usize;
fn c_return_str(shared: &Shared) -> &str;
fn c_return_sliceu8(shared: &Shared) -> &[u8];
fn c_return_rust_string() -> String;
fn c_return_unique_ptr_string() -> UniquePtr<CxxString>;
fn c_return_unique_ptr_vector_u8() -> UniquePtr<CxxVector<u8>>;
fn c_return_unique_ptr_vector_f64() -> UniquePtr<CxxVector<f64>>;
+ fn c_return_unique_ptr_vector_string() -> UniquePtr<CxxVector<CxxString>>;
fn c_return_unique_ptr_vector_shared() -> UniquePtr<CxxVector<Shared>>;
fn c_return_unique_ptr_vector_opaque() -> UniquePtr<CxxVector<C>>;
fn c_return_ref_vector(c: &C) -> &CxxVector<u8>;
+ fn c_return_mut_vector(c: &mut C) -> &mut CxxVector<u8>;
fn c_return_rust_vec() -> Vec<u8>;
fn c_return_ref_rust_vec(c: &C) -> &Vec<u8>;
+ fn c_return_mut_rust_vec(c: &mut C) -> &mut Vec<u8>;
+ fn c_return_rust_vec_string() -> Vec<String>;
fn c_return_identity(_: usize) -> usize;
fn c_return_sum(_: usize, _: usize) -> usize;
fn c_return_enum(n: u16) -> Enum;
+ fn c_return_ns_ref(shared: &AShared) -> &usize;
+ fn c_return_nested_ns_ref(shared: &ABShared) -> &usize;
+ fn c_return_ns_enum(n: u16) -> AEnum;
+ fn c_return_nested_ns_enum(n: u16) -> ABEnum;
fn c_take_primitive(n: usize);
fn c_take_shared(shared: Shared);
@@ -57,18 +161,29 @@
fn c_take_unique_ptr_string(s: UniquePtr<CxxString>);
fn c_take_unique_ptr_vector_u8(v: UniquePtr<CxxVector<u8>>);
fn c_take_unique_ptr_vector_f64(v: UniquePtr<CxxVector<f64>>);
+ fn c_take_unique_ptr_vector_string(v: UniquePtr<CxxVector<CxxString>>);
fn c_take_unique_ptr_vector_shared(v: UniquePtr<CxxVector<Shared>>);
fn c_take_ref_vector(v: &CxxVector<u8>);
fn c_take_rust_vec(v: Vec<u8>);
fn c_take_rust_vec_shared(v: Vec<Shared>);
+ fn c_take_rust_vec_string(v: Vec<String>);
+ fn c_take_rust_vec_index(v: Vec<u8>);
+ fn c_take_rust_vec_shared_index(v: Vec<Shared>);
+ fn c_take_rust_vec_shared_push(v: Vec<Shared>);
fn c_take_rust_vec_shared_forward_iterator(v: Vec<Shared>);
fn c_take_ref_rust_vec(v: &Vec<u8>);
+ fn c_take_ref_rust_vec_string(v: &Vec<String>);
+ fn c_take_ref_rust_vec_index(v: &Vec<u8>);
fn c_take_ref_rust_vec_copy(v: &Vec<u8>);
- /*
- // https://github.com/dtolnay/cxx/issues/232
+ fn c_take_ref_shared_string(s: &SharedString) -> &SharedString;
fn c_take_callback(callback: fn(String) -> usize);
- */
fn c_take_enum(e: Enum);
+ fn c_take_ns_enum(e: AEnum);
+ fn c_take_nested_ns_enum(e: ABEnum);
+ fn c_take_ns_shared(shared: AShared);
+ fn c_take_nested_ns_shared(shared: ABShared);
+ fn c_take_rust_vec_ns_shared(v: Vec<AShared>);
+ fn c_take_rust_vec_nested_ns_shared(v: Vec<ABShared>);
fn c_try_return_void() -> Result<()>;
fn c_try_return_primitive() -> Result<usize>;
@@ -80,6 +195,7 @@
fn c_try_return_rust_string() -> Result<String>;
fn c_try_return_unique_ptr_string() -> Result<UniquePtr<CxxString>>;
fn c_try_return_rust_vec() -> Result<Vec<u8>>;
+ fn c_try_return_rust_vec_string() -> Result<Vec<String>>;
fn c_try_return_ref_rust_vec(c: &C) -> Result<&Vec<u8>>;
fn get(self: &C) -> usize;
@@ -88,6 +204,19 @@
fn set2(&mut self, n: usize) -> usize;
fn set_succeed(&mut self, n: usize) -> Result<usize>;
fn get_fail(&mut self) -> Result<usize>;
+ fn c_method_on_shared(self: &Shared) -> usize;
+
+ #[rust_name = "i32_overloaded_method"]
+ fn cOverloadedMethod(&self, x: i32) -> String;
+ #[rust_name = "str_overloaded_method"]
+ fn cOverloadedMethod(&self, x: &str) -> String;
+ #[rust_name = "i32_overloaded_function"]
+ fn cOverloadedFunction(x: i32) -> String;
+ #[rust_name = "str_overloaded_function"]
+ fn cOverloadedFunction(x: &str) -> String;
+
+ #[namespace = "other"]
+ fn ns_c_take_ns_shared(shared: AShared);
}
extern "C" {
@@ -109,11 +238,14 @@
fn r_return_box() -> Box<R>;
fn r_return_unique_ptr() -> UniquePtr<C>;
fn r_return_ref(shared: &Shared) -> &usize;
+ fn r_return_mut(shared: &mut Shared) -> &mut usize;
fn r_return_str(shared: &Shared) -> &str;
fn r_return_rust_string() -> String;
fn r_return_unique_ptr_string() -> UniquePtr<CxxString>;
fn r_return_rust_vec() -> Vec<u8>;
+ fn r_return_rust_vec_string() -> Vec<String>;
fn r_return_ref_rust_vec(shared: &Shared) -> &Vec<u8>;
+ fn r_return_mut_rust_vec(shared: &mut Shared) -> &mut Vec<u8>;
fn r_return_identity(_: usize) -> usize;
fn r_return_sum(_: usize, _: usize) -> usize;
fn r_return_enum(n: u32) -> Enum;
@@ -128,17 +260,47 @@
fn r_take_sliceu8(s: &[u8]);
fn r_take_rust_string(s: String);
fn r_take_unique_ptr_string(s: UniquePtr<CxxString>);
+ fn r_take_ref_vector(v: &CxxVector<u8>);
+ fn r_take_ref_empty_vector(v: &CxxVector<u64>);
fn r_take_rust_vec(v: Vec<u8>);
+ fn r_take_rust_vec_string(v: Vec<String>);
fn r_take_ref_rust_vec(v: &Vec<u8>);
+ fn r_take_ref_rust_vec_string(v: &Vec<String>);
fn r_take_enum(e: Enum);
fn r_try_return_void() -> Result<()>;
fn r_try_return_primitive() -> Result<usize>;
+ fn r_try_return_box() -> Result<Box<R>>;
fn r_fail_return_primitive() -> Result<usize>;
fn r_return_r2(n: usize) -> Box<R2>;
fn get(self: &R2) -> usize;
fn set(self: &mut R2, n: usize) -> usize;
+ fn r_method_on_shared(self: &Shared) -> String;
+
+ #[cxx_name = "rAliasedFunction"]
+ fn r_aliased_function(x: i32) -> String;
+ }
+
+ struct Dag0 {
+ i: i32,
+ }
+
+ struct Dag1 {
+ dag2: Dag2,
+ vec: Vec<Dag3>,
+ }
+
+ struct Dag2 {
+ dag4: Dag4,
+ }
+
+ struct Dag3 {
+ dag1: Dag1,
+ }
+
+ struct Dag4 {
+ dag0: Dag0,
}
}
@@ -157,6 +319,12 @@
}
}
+impl ffi::Shared {
+ fn r_method_on_shared(&self) -> String {
+ "2020".to_owned()
+ }
+}
+
#[derive(Debug)]
struct Error;
@@ -191,6 +359,10 @@
&shared.z
}
+fn r_return_mut(shared: &mut ffi::Shared) -> &mut usize {
+ &mut shared.z
+}
+
fn r_return_str(shared: &ffi::Shared) -> &str {
let _ = shared;
"2020"
@@ -211,11 +383,20 @@
Vec::new()
}
+fn r_return_rust_vec_string() -> Vec<String> {
+ Vec::new()
+}
+
fn r_return_ref_rust_vec(shared: &ffi::Shared) -> &Vec<u8> {
let _ = shared;
unimplemented!()
}
+fn r_return_mut_rust_vec(shared: &mut ffi::Shared) -> &mut Vec<u8> {
+ let _ = shared;
+ unimplemented!()
+}
+
fn r_return_identity(n: usize) -> usize {
n
}
@@ -275,14 +456,32 @@
assert_eq!(s.as_ref().unwrap().to_str().unwrap(), "2020");
}
+fn r_take_ref_vector(v: &CxxVector<u8>) {
+ let slice = v.as_slice();
+ assert_eq!(slice, [20, 2, 0]);
+}
+
+fn r_take_ref_empty_vector(v: &CxxVector<u64>) {
+ assert!(v.as_slice().is_empty());
+ assert!(v.is_empty());
+}
+
fn r_take_rust_vec(v: Vec<u8>) {
let _ = v;
}
+fn r_take_rust_vec_string(v: Vec<String>) {
+ let _ = v;
+}
+
fn r_take_ref_rust_vec(v: &Vec<u8>) {
let _ = v;
}
+fn r_take_ref_rust_vec_string(v: &Vec<String>) {
+ let _ = v;
+}
+
fn r_take_enum(e: ffi::Enum) {
let _ = e;
}
@@ -295,6 +494,10 @@
Ok(2020)
}
+fn r_try_return_box() -> Result<Box<R>, Error> {
+ Ok(Box::new(2020))
+}
+
fn r_fail_return_primitive() -> Result<usize, Error> {
Err(Error)
}
@@ -302,3 +505,7 @@
fn r_return_r2(n: usize) -> Box<R2> {
Box::new(R2(n))
}
+
+fn r_aliased_function(x: i32) -> String {
+ x.to_string()
+}
diff --git a/tests/ffi/module.rs b/tests/ffi/module.rs
index 77bae06..899d45b 100644
--- a/tests/ffi/module.rs
+++ b/tests/ffi/module.rs
@@ -1,7 +1,7 @@
// Rustfmt mangles the extern type alias.
// https://github.com/rust-lang/rustfmt/issues/4159
#[rustfmt::skip]
-#[cxx::bridge(namespace = tests)]
+#[cxx::bridge(namespace = "tests")]
pub mod ffi {
extern "C" {
include!("tests/ffi/tests.h");
diff --git a/tests/ffi/tests.cc b/tests/ffi/tests.cc
index d70d5a0..2305766 100644
--- a/tests/ffi/tests.cc
+++ b/tests/ffi/tests.cc
@@ -1,8 +1,11 @@
#include "tests/ffi/tests.h"
#include "tests/ffi/lib.rs.h"
#include <cstring>
+#include <iterator>
+#include <memory>
#include <numeric>
#include <stdexcept>
+#include <string>
extern "C" void cxx_test_suite_set_correct() noexcept;
extern "C" tests::R *cxx_test_suite_get_box() noexcept;
@@ -32,12 +35,20 @@
size_t C::get_fail() { throw std::runtime_error("unimplemented"); }
+size_t Shared::c_method_on_shared() const noexcept { return 2021; }
+
const std::vector<uint8_t> &C::get_v() const { return this->v; }
+std::vector<uint8_t> &C::get_v() { return this->v; }
+
size_t c_return_primitive() { return 2020; }
Shared c_return_shared() { return Shared{2020}; }
+::A::AShared c_return_ns_shared() { return ::A::AShared{2020}; }
+
+::A::B::ABShared c_return_nested_ns_shared() { return ::A::B::ABShared{2020}; }
+
rust::Box<R> c_return_box() {
return rust::Box<R>::from_raw(cxx_test_suite_get_box());
}
@@ -46,8 +57,20 @@
return std::unique_ptr<C>(new C{2020});
}
+std::unique_ptr<::H::H> c_return_ns_unique_ptr() {
+ return std::unique_ptr<::H::H>(new ::H::H{"hello"});
+}
+
const size_t &c_return_ref(const Shared &shared) { return shared.z; }
+const size_t &c_return_ns_ref(const ::A::AShared &shared) { return shared.z; }
+
+const size_t &c_return_nested_ns_ref(const ::A::B::ABShared &shared) {
+ return shared.z;
+}
+
+size_t &c_return_mut(Shared &shared) { return shared.z; }
+
rust::Str c_return_str(const Shared &shared) {
(void)shared;
return "2020";
@@ -83,6 +106,11 @@
return vec;
}
+std::unique_ptr<std::vector<std::string>> c_return_unique_ptr_vector_string() {
+ return std::unique_ptr<std::vector<std::string>>(
+ new std::vector<std::string>());
+}
+
std::unique_ptr<std::vector<Shared>> c_return_unique_ptr_vector_shared() {
auto vec = std::unique_ptr<std::vector<Shared>>(new std::vector<Shared>());
vec->push_back(Shared{1010});
@@ -98,6 +126,8 @@
return c.get_v();
}
+std::vector<uint8_t> &c_return_mut_vector(C &c) { return c.get_v(); }
+
rust::Vec<uint8_t> c_return_rust_vec() {
throw std::runtime_error("unimplemented");
}
@@ -107,6 +137,15 @@
throw std::runtime_error("unimplemented");
}
+rust::Vec<uint8_t> &c_return_mut_rust_vec(C &c) {
+ (void)c;
+ throw std::runtime_error("unimplemented");
+}
+
+rust::Vec<rust::String> c_return_rust_vec_string() {
+ throw std::runtime_error("unimplemented");
+}
+
size_t c_return_identity(size_t n) { return n; }
size_t c_return_sum(size_t n1, size_t n2) { return n1 + n2; }
@@ -121,6 +160,26 @@
}
}
+::A::AEnum c_return_ns_enum(uint16_t n) {
+ if (n <= static_cast<uint16_t>(::A::AEnum::AAVal)) {
+ return ::A::AEnum::AAVal;
+ } else if (n <= static_cast<uint16_t>(::A::AEnum::ABVal)) {
+ return ::A::AEnum::ABVal;
+ } else {
+ return ::A::AEnum::ACVal;
+ }
+}
+
+::A::B::ABEnum c_return_nested_ns_enum(uint16_t n) {
+ if (n <= static_cast<uint16_t>(::A::B::ABEnum::ABAVal)) {
+ return ::A::B::ABEnum::ABAVal;
+ } else if (n <= static_cast<uint16_t>(::A::B::ABEnum::ABBVal)) {
+ return ::A::B::ABEnum::ABBVal;
+ } else {
+ return ::A::B::ABEnum::ABCVal;
+ }
+}
+
void c_take_primitive(size_t n) {
if (n == 2020) {
cxx_test_suite_set_correct();
@@ -133,6 +192,18 @@
}
}
+void c_take_ns_shared(::A::AShared shared) {
+ if (shared.z == 2020) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_nested_ns_shared(::A::B::ABShared shared) {
+ if (shared.z == 2020) {
+ cxx_test_suite_set_correct();
+ }
+}
+
void c_take_box(rust::Box<R> r) {
if (cxx_test_suite_r_is_correct(&*r)) {
cxx_test_suite_set_correct();
@@ -157,6 +228,12 @@
}
}
+void c_take_ref_ns_c(const ::H::H &h) {
+ if (h.h == "hello") {
+ cxx_test_suite_set_correct();
+ }
+}
+
void c_take_str(rust::Str s) {
if (std::string(s) == "2020") {
cxx_test_suite_set_correct();
@@ -194,6 +271,12 @@
}
}
+void c_take_unique_ptr_vector_string(
+ std::unique_ptr<std::vector<std::string>> v) {
+ (void)v;
+ cxx_test_suite_set_correct();
+}
+
void c_take_unique_ptr_vector_shared(std::unique_ptr<std::vector<Shared>> v) {
if (v->size() == 2) {
cxx_test_suite_set_correct();
@@ -208,6 +291,17 @@
void c_take_rust_vec(rust::Vec<uint8_t> v) { c_take_ref_rust_vec(v); }
+void c_take_rust_vec_index(rust::Vec<uint8_t> v) {
+ try {
+ v.at(100);
+ } catch (const std::out_of_range &ex) {
+ std::string expected = "rust::Vec index out of range";
+ if (ex.what() == expected) {
+ cxx_test_suite_set_correct();
+ }
+ }
+}
+
void c_take_rust_vec_shared(rust::Vec<Shared> v) {
uint32_t sum = 0;
for (auto i : v) {
@@ -218,6 +312,31 @@
}
}
+void c_take_rust_vec_ns_shared(rust::Vec<::A::AShared> v) {
+ uint32_t sum = 0;
+ for (auto i : v) {
+ sum += i.z;
+ }
+ if (sum == 2021) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_rust_vec_nested_ns_shared(rust::Vec<::A::B::ABShared> v) {
+ uint32_t sum = 0;
+ for (auto i : v) {
+ sum += i.z;
+ }
+ if (sum == 2021) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_rust_vec_string(rust::Vec<rust::String> v) {
+ (void)v;
+ cxx_test_suite_set_correct();
+}
+
void c_take_rust_vec_shared_forward_iterator(rust::Vec<Shared> v) {
// Exercise requirements of ForwardIterator
// https://en.cppreference.com/w/cpp/named_req/ForwardIterator
@@ -230,6 +349,21 @@
}
}
+void c_take_rust_vec_shared_index(rust::Vec<Shared> v) {
+ if (v[0].z == 1010 && v.at(0).z == 1010 && v.front().z == 1010 &&
+ v[1].z == 1011 && v.at(1).z == 1011 && v.back().z == 1011) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_rust_vec_shared_push(rust::Vec<Shared> v) {
+ v.push_back(Shared{3});
+ v.emplace_back(Shared{2});
+ if (v[v.size() - 2].z == 3 && v.back().z == 2) {
+ cxx_test_suite_set_correct();
+ }
+}
+
void c_take_ref_rust_vec(const rust::Vec<uint8_t> &v) {
uint8_t sum = std::accumulate(v.begin(), v.end(), 0);
if (sum == 200) {
@@ -237,6 +371,18 @@
}
}
+void c_take_ref_rust_vec_string(const rust::Vec<rust::String> &v) {
+ (void)v;
+ cxx_test_suite_set_correct();
+}
+
+void c_take_ref_rust_vec_index(const rust::Vec<uint8_t> &v) {
+ if (v[0] == 86 && v.at(0) == 86 && v.front() == 86 && v[1] == 75 &&
+ v.at(1) == 75 && v[3] == 9 && v.at(3) == 9 && v.back() == 9) {
+ cxx_test_suite_set_correct();
+ }
+}
+
void c_take_ref_rust_vec_copy(const rust::Vec<uint8_t> &v) {
// The std::copy() will make sure rust::Vec<>::const_iterator satisfies the
// requirements for std::iterator_traits.
@@ -249,12 +395,16 @@
}
}
-/*
-// https://github.com/dtolnay/cxx/issues/232
+const SharedString &c_take_ref_shared_string(const SharedString &s) {
+ if (std::string(s.msg) == "2020") {
+ cxx_test_suite_set_correct();
+ }
+ return s;
+}
+
void c_take_callback(rust::Fn<size_t(rust::String)> callback) {
callback("2020");
}
-*/
void c_take_enum(Enum e) {
if (e == Enum::AVal) {
@@ -262,6 +412,18 @@
}
}
+void c_take_ns_enum(::A::AEnum e) {
+ if (e == ::A::AEnum::AAVal) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_nested_ns_enum(::A::B::ABEnum e) {
+ if (e == ::A::B::ABEnum::ABAVal) {
+ cxx_test_suite_set_correct();
+ }
+}
+
void c_try_return_void() {}
size_t c_try_return_primitive() { return 2020; }
@@ -286,6 +448,10 @@
throw std::runtime_error("unimplemented");
}
+rust::Vec<rust::String> c_try_return_rust_vec_string() {
+ throw std::runtime_error("unimplemented");
+}
+
const rust::Vec<uint8_t> &c_try_return_ref_rust_vec(const C &c) {
(void)c;
throw std::runtime_error("unimplemented");
@@ -299,6 +465,120 @@
return std::unique_ptr<std::string>(new std::string("2020")).release();
}
+rust::String C::cOverloadedMethod(int32_t x) const {
+ return rust::String(std::to_string(x));
+}
+
+rust::String C::cOverloadedMethod(rust::Str x) const {
+ return rust::String(std::string(x));
+}
+
+rust::String cOverloadedFunction(int x) {
+ return rust::String(std::to_string(x));
+}
+
+rust::String cOverloadedFunction(rust::Str x) {
+ return rust::String(std::string(x));
+}
+
+void c_take_trivial_ptr(std::unique_ptr<D> d) {
+ if (d->d == 30) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_trivial_ref(const D &d) {
+ if (d.d == 30) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_trivial(D d) {
+ if (d.d == 30) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_trivial_ns_ptr(std::unique_ptr<::G::G> g) {
+ if (g->g == 30) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_trivial_ns_ref(const ::G::G &g) {
+ if (g.g == 30) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_trivial_ns(::G::G g) {
+ if (g.g == 30) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_opaque_ptr(std::unique_ptr<E> e) {
+ if (e->e == 40) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_opaque_ns_ptr(std::unique_ptr<::F::F> f) {
+ if (f->f == 40) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_opaque_ref(const E &e) {
+ if (e.e == 40 && e.e_str == "hello") {
+ cxx_test_suite_set_correct();
+ }
+}
+
+void c_take_opaque_ns_ref(const ::F::F &f) {
+ if (f.f == 40 && f.f_str == "hello") {
+ cxx_test_suite_set_correct();
+ }
+}
+
+std::unique_ptr<D> c_return_trivial_ptr() {
+ auto d = std::unique_ptr<D>(new D());
+ d->d = 30;
+ return d;
+}
+
+D c_return_trivial() {
+ D d;
+ d.d = 30;
+ return d;
+}
+
+std::unique_ptr<::G::G> c_return_trivial_ns_ptr() {
+ auto g = std::unique_ptr<::G::G>(new ::G::G());
+ g->g = 30;
+ return g;
+}
+
+::G::G c_return_trivial_ns() {
+ ::G::G g;
+ g.g = 30;
+ return g;
+}
+
+std::unique_ptr<E> c_return_opaque_ptr() {
+ auto e = std::unique_ptr<E>(new E());
+ e->e = 40;
+ e->e_str = std::string("hello");
+ return e;
+}
+
+std::unique_ptr<::F::F> c_return_ns_opaque_ptr() {
+ auto f = std::unique_ptr<::F::F>(new ::F::F());
+ f->f = 40;
+ f->f_str = std::string("hello");
+ return f;
+}
+
extern "C" const char *cxx_run_test() noexcept {
#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)
@@ -333,6 +613,11 @@
r_take_rust_string(rust::String("2020"));
r_take_unique_ptr_string(
std::unique_ptr<std::string>(new std::string("2020")));
+ r_take_ref_vector(std::vector<uint8_t>{20, 2, 0});
+ std::vector<uint64_t> empty_vector;
+ r_take_ref_empty_vector(empty_vector);
+ empty_vector.reserve(10);
+ r_take_ref_empty_vector(empty_vector);
r_take_enum(Enum::AVal);
ASSERT(r_try_return_primitive() == 2020);
@@ -349,9 +634,40 @@
ASSERT(r2->get() == 2021);
ASSERT(r2->set(2020) == 2020);
ASSERT(r2->get() == 2020);
+ ASSERT(std::string(Shared{0}.r_method_on_shared()) == "2020");
+
+ ASSERT(std::string(rAliasedFunction(2020)) == "2020");
cxx_test_suite_set_correct();
return nullptr;
}
} // namespace tests
+
+namespace other {
+void ns_c_take_trivial(::tests::D d) {
+ if (d.d == 30) {
+ cxx_test_suite_set_correct();
+ }
+}
+
+::tests::D ns_c_return_trivial() {
+ ::tests::D d;
+ d.d = 30;
+ return d;
+}
+
+void ns_c_take_ns_shared(::A::AShared shared) {
+ if (shared.z == 2020) {
+ cxx_test_suite_set_correct();
+ }
+}
+} // namespace other
+
+namespace I {
+uint32_t I::get() const { return a; }
+
+std::unique_ptr<I> ns_c_return_unique_ptr_ns() {
+ return std::unique_ptr<I>(new I());
+}
+} // namespace I
diff --git a/tests/ffi/tests.h b/tests/ffi/tests.h
index 7121cb2..2217c36 100644
--- a/tests/ffi/tests.h
+++ b/tests/ffi/tests.h
@@ -3,10 +3,40 @@
#include <memory>
#include <string>
+namespace A {
+struct AShared;
+enum class AEnum : uint16_t;
+namespace B {
+struct ABShared;
+enum class ABEnum : uint16_t;
+} // namespace B
+} // namespace A
+
+namespace F {
+struct F {
+ uint64_t f;
+ std::string f_str;
+};
+} // namespace F
+
+namespace G {
+struct G {
+ uint64_t g;
+};
+} // namespace G
+
+namespace H {
+class H {
+public:
+ std::string h;
+};
+} // namespace H
+
namespace tests {
struct R;
struct Shared;
+struct SharedString;
enum class Enum : uint16_t;
class C {
@@ -19,12 +49,24 @@
size_t set_succeed(size_t n);
size_t get_fail();
const std::vector<uint8_t> &get_v() const;
+ std::vector<uint8_t> &get_v();
+ rust::String cOverloadedMethod(int32_t x) const;
+ rust::String cOverloadedMethod(rust::Str x) const;
private:
size_t n;
std::vector<uint8_t> v;
};
+struct D {
+ uint64_t d;
+};
+
+struct E {
+ uint64_t e;
+ std::string e_str;
+};
+
enum COwnedEnum {
CVal1,
CVal2,
@@ -32,48 +74,73 @@
size_t c_return_primitive();
Shared c_return_shared();
+::A::AShared c_return_ns_shared();
+::A::B::ABShared c_return_nested_ns_shared();
rust::Box<R> c_return_box();
std::unique_ptr<C> c_return_unique_ptr();
+std::unique_ptr<::H::H> c_return_ns_unique_ptr();
const size_t &c_return_ref(const Shared &shared);
+const size_t &c_return_ns_ref(const ::A::AShared &shared);
+const size_t &c_return_nested_ns_ref(const ::A::B::ABShared &shared);
+size_t &c_return_mut(Shared &shared);
rust::Str c_return_str(const Shared &shared);
rust::Slice<uint8_t> c_return_sliceu8(const Shared &shared);
rust::String c_return_rust_string();
std::unique_ptr<std::string> c_return_unique_ptr_string();
std::unique_ptr<std::vector<uint8_t>> c_return_unique_ptr_vector_u8();
std::unique_ptr<std::vector<double>> c_return_unique_ptr_vector_f64();
+std::unique_ptr<std::vector<std::string>> c_return_unique_ptr_vector_string();
std::unique_ptr<std::vector<Shared>> c_return_unique_ptr_vector_shared();
std::unique_ptr<std::vector<C>> c_return_unique_ptr_vector_opaque();
const std::vector<uint8_t> &c_return_ref_vector(const C &c);
+std::vector<uint8_t> &c_return_mut_vector(C &c);
rust::Vec<uint8_t> c_return_rust_vec();
const rust::Vec<uint8_t> &c_return_ref_rust_vec(const C &c);
+rust::Vec<uint8_t> &c_return_mut_rust_vec(C &c);
+rust::Vec<rust::String> c_return_rust_vec_string();
size_t c_return_identity(size_t n);
size_t c_return_sum(size_t n1, size_t n2);
Enum c_return_enum(uint16_t n);
+::A::AEnum c_return_ns_enum(uint16_t n);
+::A::B::ABEnum c_return_nested_ns_enum(uint16_t n);
void c_take_primitive(size_t n);
void c_take_shared(Shared shared);
+void c_take_ns_shared(::A::AShared shared);
+void c_take_nested_ns_shared(::A::B::ABShared shared);
void c_take_box(rust::Box<R> r);
void c_take_unique_ptr(std::unique_ptr<C> c);
void c_take_ref_r(const R &r);
void c_take_ref_c(const C &c);
+void c_take_ref_ns_c(const ::H::H &h);
void c_take_str(rust::Str s);
void c_take_sliceu8(rust::Slice<uint8_t> s);
void c_take_rust_string(rust::String s);
void c_take_unique_ptr_string(std::unique_ptr<std::string> s);
void c_take_unique_ptr_vector_u8(std::unique_ptr<std::vector<uint8_t>> v);
void c_take_unique_ptr_vector_f64(std::unique_ptr<std::vector<double>> v);
+void c_take_unique_ptr_vector_string(
+ std::unique_ptr<std::vector<std::string>> v);
void c_take_unique_ptr_vector_shared(std::unique_ptr<std::vector<Shared>> v);
void c_take_ref_vector(const std::vector<uint8_t> &v);
void c_take_rust_vec(rust::Vec<uint8_t> v);
+void c_take_rust_vec_index(rust::Vec<uint8_t> v);
void c_take_rust_vec_shared(rust::Vec<Shared> v);
+void c_take_rust_vec_ns_shared(rust::Vec<::A::AShared> v);
+void c_take_rust_vec_nested_ns_shared(rust::Vec<::A::B::ABShared> v);
+void c_take_rust_vec_string(rust::Vec<rust::String> v);
+void c_take_rust_vec_shared_index(rust::Vec<Shared> v);
+void c_take_rust_vec_shared_push(rust::Vec<Shared> v);
void c_take_rust_vec_shared_forward_iterator(rust::Vec<Shared> v);
void c_take_ref_rust_vec(const rust::Vec<uint8_t> &v);
+void c_take_ref_rust_vec_string(const rust::Vec<rust::String> &v);
+void c_take_ref_rust_vec_index(const rust::Vec<uint8_t> &v);
void c_take_ref_rust_vec_copy(const rust::Vec<uint8_t> &v);
-/*
-// https://github.com/dtolnay/cxx/issues/232
+const SharedString &c_take_ref_shared_string(const SharedString &s);
void c_take_callback(rust::Fn<size_t(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);
void c_try_return_void();
size_t c_try_return_primitive();
@@ -85,6 +152,47 @@
rust::String c_try_return_rust_string();
std::unique_ptr<std::string> c_try_return_unique_ptr_string();
rust::Vec<uint8_t> c_try_return_rust_vec();
+rust::Vec<rust::String> c_try_return_rust_vec_string();
const rust::Vec<uint8_t> &c_try_return_ref_rust_vec(const C &c);
+void c_take_trivial_ptr(std::unique_ptr<D> d);
+void c_take_trivial_ref(const D &d);
+void c_take_trivial(D d);
+
+void c_take_trivial_ns_ptr(std::unique_ptr<::G::G> g);
+void c_take_trivial_ns_ref(const ::G::G &g);
+void c_take_trivial_ns(::G::G g);
+void c_take_opaque_ptr(std::unique_ptr<E> e);
+void c_take_opaque_ns_ptr(std::unique_ptr<::F::F> f);
+void c_take_opaque_ref(const E &e);
+void c_take_opaque_ns_ref(const ::F::F &f);
+std::unique_ptr<D> c_return_trivial_ptr();
+D c_return_trivial();
+std::unique_ptr<::G::G> c_return_trivial_ns_ptr();
+::G::G c_return_trivial_ns();
+std::unique_ptr<E> c_return_opaque_ptr();
+std::unique_ptr<::F::F> c_return_ns_opaque_ptr();
+
+rust::String cOverloadedFunction(int32_t x);
+rust::String cOverloadedFunction(rust::Str x);
+
} // namespace tests
+
+namespace other {
+void ns_c_take_trivial(::tests::D d);
+::tests::D ns_c_return_trivial();
+void ns_c_take_ns_shared(::A::AShared shared);
+} // namespace other
+
+namespace I {
+class I {
+private:
+ uint32_t a;
+
+public:
+ I() : a(1000) {}
+ uint32_t get() const;
+};
+
+std::unique_ptr<I> ns_c_return_unique_ptr_ns();
+} // namespace I
diff --git a/tests/test.rs b/tests/test.rs
index f2f670c..2bae4d8 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -1,3 +1,6 @@
+#![allow(clippy::assertions_on_constants, clippy::float_cmp, clippy::unit_cmp)]
+
+use cxx_test_suite::extra::ffi2;
use cxx_test_suite::ffi;
use std::cell::Cell;
use std::ffi::CStr;
@@ -22,12 +25,17 @@
#[test]
fn test_c_return() {
let shared = ffi::Shared { z: 2020 };
+ let ns_shared = ffi::AShared { z: 2020 };
+ let nested_ns_shared = ffi::ABShared { z: 2020 };
assert_eq!(2020, ffi::c_return_primitive());
assert_eq!(2020, ffi::c_return_shared().z);
assert_eq!(2020, *ffi::c_return_box());
ffi::c_return_unique_ptr();
+ ffi2::c_return_ns_unique_ptr();
assert_eq!(2020, *ffi::c_return_ref(&shared));
+ assert_eq!(2020, *ffi::c_return_ns_ref(&ns_shared));
+ assert_eq!(2020, *ffi::c_return_nested_ns_ref(&nested_ns_shared));
assert_eq!("2020", ffi::c_return_str(&shared));
assert_eq!(b"2020\0", ffi::c_return_sliceu8(&shared));
assert_eq!("2020", ffi::c_return_rust_string());
@@ -63,6 +71,14 @@
enm @ ffi::Enum::CVal => assert_eq!(2021, enm.repr),
_ => assert!(false),
}
+ match ffi::c_return_ns_enum(0) {
+ enm @ ffi::AEnum::AAVal => assert_eq!(0, enm.repr),
+ _ => assert!(false),
+ }
+ match ffi::c_return_nested_ns_enum(0) {
+ enm @ ffi::ABEnum::ABAVal => assert_eq!(0, enm.repr),
+ _ => assert!(false),
+ }
}
#[test]
@@ -84,11 +100,16 @@
#[test]
fn test_c_take() {
let unique_ptr = ffi::c_return_unique_ptr();
+ let unique_ptr_ns = ffi2::c_return_ns_unique_ptr();
check!(ffi::c_take_primitive(2020));
check!(ffi::c_take_shared(ffi::Shared { z: 2020 }));
+ check!(ffi::c_take_ns_shared(ffi::AShared { z: 2020 }));
+ check!(ffi::ns_c_take_ns_shared(ffi::AShared { z: 2020 }));
+ check!(ffi::c_take_nested_ns_shared(ffi::ABShared { z: 2020 }));
check!(ffi::c_take_box(Box::new(2020)));
check!(ffi::c_take_ref_c(&unique_ptr));
+ check!(ffi2::c_take_ref_ns_c(&unique_ptr_ns));
check!(cxx_test_suite::module::ffi::c_take_unique_ptr(unique_ptr));
check!(ffi::c_take_str("2020"));
check!(ffi::c_take_sliceu8(b"2020"));
@@ -108,21 +129,32 @@
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()));
- check!(ffi::c_take_rust_vec_shared(vec![
- ffi::Shared { z: 1010 },
- ffi::Shared { z: 1011 }
- ]));
- check!(ffi::c_take_rust_vec_shared_forward_iterator(vec![
- ffi::Shared { z: 1010 },
- ffi::Shared { z: 1011 }
- ]));
+ check!(ffi::c_take_rust_vec_index(test_vec.clone()));
+ let shared_test_vec = vec![ffi::Shared { z: 1010 }, ffi::Shared { z: 1011 }];
+ check!(ffi::c_take_rust_vec_shared(shared_test_vec.clone()));
+ check!(ffi::c_take_rust_vec_shared_index(shared_test_vec.clone()));
+ check!(ffi::c_take_rust_vec_shared_push(shared_test_vec.clone()));
+ check!(ffi::c_take_rust_vec_shared_forward_iterator(
+ shared_test_vec,
+ ));
check!(ffi::c_take_ref_rust_vec(&test_vec));
+ check!(ffi::c_take_ref_rust_vec_index(&test_vec));
check!(ffi::c_take_ref_rust_vec_copy(&test_vec));
+ check!(ffi::c_take_ref_shared_string(&ffi::SharedString {
+ msg: "2020".to_owned()
+ }));
+ let ns_shared_test_vec = vec![ffi::AShared { z: 1010 }, ffi::AShared { z: 1011 }];
+ check!(ffi::c_take_rust_vec_ns_shared(ns_shared_test_vec));
+ let nested_ns_shared_test_vec = vec![ffi::ABShared { z: 1010 }, ffi::ABShared { z: 1011 }];
+ check!(ffi::c_take_rust_vec_nested_ns_shared(
+ nested_ns_shared_test_vec
+ ));
+
check!(ffi::c_take_enum(ffi::Enum::AVal));
+ check!(ffi::c_take_ns_enum(ffi::AEnum::AAVal));
+ check!(ffi::c_take_nested_ns_enum(ffi::ABEnum::ABAVal));
}
-/*
-// https://github.com/dtolnay/cxx/issues/232
#[test]
fn test_c_callback() {
fn callback(s: String) -> usize {
@@ -134,7 +166,6 @@
check!(ffi::c_take_callback(callback));
}
-*/
#[test]
fn test_c_call_r() {
@@ -163,6 +194,15 @@
assert_eq!(old_value, unique_ptr.get2());
assert_eq!(2022, unique_ptr.set_succeed(2022).unwrap());
assert!(unique_ptr.get_fail().is_err());
+ assert_eq!(2021, ffi::Shared { z: 0 }.c_method_on_shared());
+}
+
+#[test]
+fn test_c_ns_method_calls() {
+ let unique_ptr = ffi2::ns_c_return_unique_ptr_ns();
+
+ let old_value = unique_ptr.get();
+ assert_eq!(1000, old_value);
}
#[test]
@@ -181,3 +221,42 @@
unsafe extern "C" fn cxx_test_suite_r_is_correct(r: *const cxx_test_suite::R) -> bool {
*r == 2020
}
+
+#[test]
+fn test_rust_name_attribute() {
+ assert_eq!("2020", ffi::i32_overloaded_function(2020));
+ assert_eq!("2020", ffi::str_overloaded_function("2020"));
+ let unique_ptr = ffi::c_return_unique_ptr();
+ assert_eq!("2020", unique_ptr.i32_overloaded_method(2020));
+ assert_eq!("2020", unique_ptr.str_overloaded_method("2020"));
+}
+
+#[test]
+fn test_extern_trivial() {
+ let d = ffi2::c_return_trivial();
+ check!(ffi2::c_take_trivial_ref(&d));
+ check!(ffi2::c_take_trivial(d));
+ let d = ffi2::c_return_trivial_ptr();
+ check!(ffi2::c_take_trivial_ptr(d));
+ cxx::UniquePtr::new(ffi2::D { d: 42 });
+ let d = ffi2::ns_c_return_trivial();
+ check!(ffi2::ns_c_take_trivial(d));
+
+ let g = ffi2::c_return_trivial_ns();
+ check!(ffi2::c_take_trivial_ns_ref(&g));
+ check!(ffi2::c_take_trivial_ns(g));
+ let g = ffi2::c_return_trivial_ns_ptr();
+ check!(ffi2::c_take_trivial_ns_ptr(g));
+ cxx::UniquePtr::new(ffi2::G { g: 42 });
+}
+
+#[test]
+fn test_extern_opaque() {
+ let e = ffi2::c_return_opaque_ptr();
+ check!(ffi2::c_take_opaque_ref(e.as_ref().unwrap()));
+ check!(ffi2::c_take_opaque_ptr(e));
+
+ let f = ffi2::c_return_ns_opaque_ptr();
+ check!(ffi2::c_take_opaque_ns_ref(f.as_ref().unwrap()));
+ check!(ffi2::c_take_opaque_ns_ptr(f));
+}
diff --git a/tests/ui/bad_explicit_impl.rs b/tests/ui/bad_explicit_impl.rs
new file mode 100644
index 0000000..2106446
--- /dev/null
+++ b/tests/ui/bad_explicit_impl.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+ struct S {
+ x: u8,
+ }
+
+ impl fn() -> &S {}
+}
+
+fn main() {}
diff --git a/tests/ui/bad_explicit_impl.stderr b/tests/ui/bad_explicit_impl.stderr
new file mode 100644
index 0000000..cd0a317
--- /dev/null
+++ b/tests/ui/bad_explicit_impl.stderr
@@ -0,0 +1,5 @@
+error: unsupported Self type of explicit impl
+ --> $DIR/bad_explicit_impl.rs:7:5
+ |
+7 | impl fn() -> &S {}
+ | ^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/by_value_not_supported.stderr b/tests/ui/by_value_not_supported.stderr
index 1ff8dbf..0a56dd4 100644
--- a/tests/ui/by_value_not_supported.stderr
+++ b/tests/ui/by_value_not_supported.stderr
@@ -1,4 +1,4 @@
-error: using C++ type by value is not supported
+error: using opaque C++ type by value is not supported
--> $DIR/by_value_not_supported.rs:4:9
|
4 | c: C,
@@ -16,13 +16,19 @@
6 | s: CxxString,
| ^^^^^^^^^^^^
-error: passing C++ type by value is not supported
+error: needs a cxx::ExternType impl in order to be used as a field of `S`
+ --> $DIR/by_value_not_supported.rs:10:9
+ |
+10 | type C;
+ | ^^^^^^
+
+error: passing opaque C++ type by value is not supported
--> $DIR/by_value_not_supported.rs:16:14
|
16 | fn f(c: C) -> C;
| ^^^^
-error: returning C++ type by value is not supported
+error: returning opaque C++ type by value is not supported
--> $DIR/by_value_not_supported.rs:16:23
|
16 | fn f(c: C) -> C;
diff --git a/tests/ui/empty_enum.rs b/tests/ui/empty_enum.rs
index a9ad533..987004b 100644
--- a/tests/ui/empty_enum.rs
+++ b/tests/ui/empty_enum.rs
@@ -1,8 +1,6 @@
#[cxx::bridge]
mod ffi {
- enum A {
-
- }
+ enum A {}
}
fn main() {}
diff --git a/tests/ui/empty_enum.stderr b/tests/ui/empty_enum.stderr
index c73578a..7f35019 100644
--- a/tests/ui/empty_enum.stderr
+++ b/tests/ui/empty_enum.stderr
@@ -1,7 +1,5 @@
error: enums without any variants are not supported
--> $DIR/empty_enum.rs:3:5
|
-3 | / enum A {
-4 | |
-5 | | }
- | |_____^
+3 | enum A {}
+ | ^^^^^^^^^
diff --git a/tests/ui/impl_trait_for_type.rs b/tests/ui/impl_trait_for_type.rs
new file mode 100644
index 0000000..9284f73
--- /dev/null
+++ b/tests/ui/impl_trait_for_type.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+ struct S {
+ x: u8,
+ }
+
+ impl UniquePtrTarget for S {}
+}
+
+fn main() {}
diff --git a/tests/ui/impl_trait_for_type.stderr b/tests/ui/impl_trait_for_type.stderr
new file mode 100644
index 0000000..e05a461
--- /dev/null
+++ b/tests/ui/impl_trait_for_type.stderr
@@ -0,0 +1,5 @@
+error: unexpected impl, expected something like `impl UniquePtr<T> {}`
+ --> $DIR/impl_trait_for_type.rs:7:10
+ |
+7 | impl UniquePtrTarget for S {}
+ | ^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/missing_unsafe.rs b/tests/ui/missing_unsafe.rs
new file mode 100644
index 0000000..d8c0a23
--- /dev/null
+++ b/tests/ui/missing_unsafe.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+ extern "Rust" {
+ fn f(x: i32);
+ }
+}
+
+unsafe fn f(_x: i32) {}
+
+fn main() {}
diff --git a/tests/ui/missing_unsafe.stderr b/tests/ui/missing_unsafe.stderr
new file mode 100644
index 0000000..df1bce2
--- /dev/null
+++ b/tests/ui/missing_unsafe.stderr
@@ -0,0 +1,7 @@
+error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
+ --> $DIR/missing_unsafe.rs:4:12
+ |
+4 | fn f(x: i32);
+ | ^ call to unsafe function
+ |
+ = note: consult the function's documentation for information on how to avoid undefined behavior
diff --git a/tests/ui/multiple_parse_error.rs b/tests/ui/multiple_parse_error.rs
index 061eab6..138d6d6 100644
--- a/tests/ui/multiple_parse_error.rs
+++ b/tests/ui/multiple_parse_error.rs
@@ -2,8 +2,7 @@
mod ffi {
struct Monad<T>;
- extern "Haskell" {
- }
+ extern "Haskell" {}
}
fn main() {}
diff --git a/tests/ui/multiple_parse_error.stderr b/tests/ui/multiple_parse_error.stderr
index 854aa90..4189507 100644
--- a/tests/ui/multiple_parse_error.stderr
+++ b/tests/ui/multiple_parse_error.stderr
@@ -7,5 +7,5 @@
error: unrecognized ABI
--> $DIR/multiple_parse_error.rs:5:5
|
-5 | extern "Haskell" {
+5 | extern "Haskell" {}
| ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/nonempty_impl_block.rs b/tests/ui/nonempty_impl_block.rs
new file mode 100644
index 0000000..239d1ec
--- /dev/null
+++ b/tests/ui/nonempty_impl_block.rs
@@ -0,0 +1,12 @@
+#[cxx::bridge]
+mod ffi {
+ struct S {
+ x: u8,
+ }
+
+ impl UniquePtr<S> {
+ fn new() -> Self;
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/nonempty_impl_block.stderr b/tests/ui/nonempty_impl_block.stderr
new file mode 100644
index 0000000..e7881bb
--- /dev/null
+++ b/tests/ui/nonempty_impl_block.stderr
@@ -0,0 +1,8 @@
+error: expected an empty impl block
+ --> $DIR/nonempty_impl_block.rs:7:23
+ |
+7 | impl UniquePtr<S> {
+ | _______________________^
+8 | | fn new() -> Self;
+9 | | }
+ | |_____^
diff --git a/tests/ui/opaque_not_sized.stderr b/tests/ui/opaque_not_sized.stderr
index efd1144..9818e44 100644
--- a/tests/ui/opaque_not_sized.stderr
+++ b/tests/ui/opaque_not_sized.stderr
@@ -1,8 +1,11 @@
error[E0277]: the size for values of type `str` cannot be known at compilation time
- --> $DIR/opaque_not_sized.rs:4:14
- |
-4 | type TypeR;
- | ^^^^^ doesn't have a size known at compile-time
- |
- = help: within `TypeR`, the trait `std::marker::Sized` is not implemented for `str`
- = note: required because it appears within the type `TypeR`
+ --> $DIR/opaque_not_sized.rs:4:14
+ |
+4 | type TypeR;
+ | -----^^^^^-
+ | | |
+ | | 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`
diff --git a/tests/ui/result_no_display.rs b/tests/ui/result_no_display.rs
new file mode 100644
index 0000000..b535677
--- /dev/null
+++ b/tests/ui/result_no_display.rs
@@ -0,0 +1,14 @@
+#[cxx::bridge]
+mod ffi {
+ extern "Rust" {
+ fn f() -> Result<()>;
+ }
+}
+
+pub struct NonError;
+
+fn f() -> Result<(), NonError> {
+ Ok(())
+}
+
+fn main() {}
diff --git a/tests/ui/result_no_display.stderr b/tests/ui/result_no_display.stderr
new file mode 100644
index 0000000..d0502f9
--- /dev/null
+++ b/tests/ui/result_no_display.stderr
@@ -0,0 +1,8 @@
+error[E0277]: `NonError` doesn't implement `std::fmt::Display`
+ --> $DIR/result_no_display.rs:4:19
+ |
+4 | fn f() -> Result<()>;
+ | ^^^^^^^^^^ `NonError` cannot be formatted with the default formatter
+ |
+ = help: the trait `std::fmt::Display` is not implemented for `NonError`
+ = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
diff --git a/tests/ui/struct_cycle.rs b/tests/ui/struct_cycle.rs
new file mode 100644
index 0000000..e74c2b1
--- /dev/null
+++ b/tests/ui/struct_cycle.rs
@@ -0,0 +1,34 @@
+#[cxx::bridge]
+mod ffi {
+ struct Node0 {
+ i: i32,
+ }
+
+ struct Node1 {
+ node2: Node2,
+ vec: Vec<Node3>,
+ }
+
+ struct Node2 {
+ node4: Node4,
+ }
+
+ struct Node3 {
+ node1: Node1,
+ }
+
+ struct Node4 {
+ node0: Node0,
+ node5: Node5,
+ }
+
+ struct Node5 {
+ node2: Node2,
+ }
+
+ struct Node6 {
+ node2: Node2,
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/struct_cycle.stderr b/tests/ui/struct_cycle.stderr
new file mode 100644
index 0000000..49bcb5f
--- /dev/null
+++ b/tests/ui/struct_cycle.stderr
@@ -0,0 +1,23 @@
+error: unsupported cyclic data structure
+ --> $DIR/struct_cycle.rs:26:9
+ |
+26 | node2: Node2,
+ | ^^^^^^^^^^^^
+
+error: unsupported cyclic data structure
+ --> $DIR/struct_cycle.rs:22:9
+ |
+22 | node5: Node5,
+ | ^^^^^^^^^^^^
+
+error: unsupported cyclic data structure
+ --> $DIR/struct_cycle.rs:13:9
+ |
+13 | node4: Node4,
+ | ^^^^^^^^^^^^
+
+error: unsupported cyclic data structure
+ --> $DIR/struct_cycle.rs:8:9
+ |
+8 | node2: Node2,
+ | ^^^^^^^^^^^^
diff --git a/tests/ui/unique_ptr_to_opaque.rs b/tests/ui/unique_ptr_to_opaque.rs
new file mode 100644
index 0000000..720ca69
--- /dev/null
+++ b/tests/ui/unique_ptr_to_opaque.rs
@@ -0,0 +1,23 @@
+mod outside {
+ #[repr(C)]
+ pub struct C {
+ pub a: u8,
+ }
+ unsafe impl cxx::ExternType for C {
+ type Id = cxx::type_id!("C");
+ type Kind = cxx::kind::Opaque;
+ }
+}
+
+#[cxx::bridge]
+mod ffi {
+ extern "C" {
+ type C = crate::outside::C;
+ }
+
+ impl UniquePtr<C> {}
+}
+
+fn main() {
+ cxx::UniquePtr::new(outside::C { a: 4 });
+}
diff --git a/tests/ui/unique_ptr_to_opaque.stderr b/tests/ui/unique_ptr_to_opaque.stderr
new file mode 100644
index 0000000..19d76a3
--- /dev/null
+++ b/tests/ui/unique_ptr_to_opaque.stderr
@@ -0,0 +1,7 @@
+error[E0271]: type mismatch resolving `<outside::C as ExternType>::Kind == Trivial`
+ --> $DIR/unique_ptr_to_opaque.rs:22:5
+ |
+22 | cxx::UniquePtr::new(outside::C { a: 4 });
+ | ^^^^^^^^^^^^^^^^^^^ expected enum `Trivial`, found enum `cxx::kind::Opaque`
+ |
+ = note: required by `UniquePtr::<T>::new`
diff --git a/tests/ui/unique_ptr_twice.rs b/tests/ui/unique_ptr_twice.rs
new file mode 100644
index 0000000..b6cb4d4
--- /dev/null
+++ b/tests/ui/unique_ptr_twice.rs
@@ -0,0 +1,19 @@
+#[cxx::bridge]
+mod here {
+ extern "C" {
+ type C;
+ }
+
+ impl UniquePtr<C> {}
+}
+
+#[cxx::bridge]
+mod there {
+ extern "C" {
+ type C = crate::here::C;
+ }
+
+ impl UniquePtr<C> {}
+}
+
+fn main() {}
diff --git a/tests/ui/unique_ptr_twice.stderr b/tests/ui/unique_ptr_twice.stderr
new file mode 100644
index 0000000..5686cf1
--- /dev/null
+++ b/tests/ui/unique_ptr_twice.stderr
@@ -0,0 +1,8 @@
+error[E0119]: conflicting implementations of trait `cxx::private::UniquePtrTarget` for type `here::C`:
+ --> $DIR/unique_ptr_twice.rs:16:5
+ |
+7 | impl UniquePtr<C> {}
+ | ----------------- first implementation here
+...
+16 | impl UniquePtr<C> {}
+ | ^^^^^^^^^^^^^^^^^ conflicting implementation for `here::C`
diff --git a/tests/ui/unsupported_elided.rs b/tests/ui/unsupported_elided.rs
new file mode 100644
index 0000000..4033319
--- /dev/null
+++ b/tests/ui/unsupported_elided.rs
@@ -0,0 +1,20 @@
+use std::marker::PhantomData;
+
+#[cxx::bridge]
+mod ffi {
+ extern "Rust" {
+ type T;
+
+ fn f(t: &T) -> &str;
+ }
+}
+
+pub struct T<'a> {
+ _lifetime: PhantomData<&'a ()>,
+}
+
+fn f<'a>(_t: &T<'a>) -> &'a str {
+ ""
+}
+
+fn main() {}
diff --git a/tests/ui/unsupported_elided.stderr b/tests/ui/unsupported_elided.stderr
new file mode 100644
index 0000000..5136390
--- /dev/null
+++ b/tests/ui/unsupported_elided.stderr
@@ -0,0 +1,11 @@
+error[E0106]: missing lifetime specifier
+ --> $DIR/unsupported_elided.rs:8:24
+ |
+8 | fn f(t: &T) -> &str;
+ | -- ^ expected named lifetime parameter
+ |
+ = help: this function's return type contains a borrowed value, but the signature does not say which one of `t`'s 2 lifetimes it is borrowed from
+help: consider introducing a named lifetime parameter
+ |
+8 | fn f<'a>(t: &'a T) -> &'a str;
+ | ^^^^ ^^^^^ ^^^
diff --git a/tests/ui/wrong_type_id.rs b/tests/ui/wrong_type_id.rs
index 81a9b3f..e3d1380 100644
--- a/tests/ui/wrong_type_id.rs
+++ b/tests/ui/wrong_type_id.rs
@@ -1,11 +1,11 @@
-#[cxx::bridge(namespace = folly)]
+#[cxx::bridge(namespace = "folly")]
mod here {
extern "C" {
type StringPiece;
}
}
-#[cxx::bridge(namespace = folly)]
+#[cxx::bridge(namespace = "folly")]
mod there {
extern "C" {
type ByteRange = crate::here::StringPiece;
diff --git a/tests/ui/wrong_type_id.stderr b/tests/ui/wrong_type_id.stderr
index cb3ae15..2d8e50a 100644
--- a/tests/ui/wrong_type_id.stderr
+++ b/tests/ui/wrong_type_id.stderr
@@ -1,13 +1,13 @@
-error[E0271]: type mismatch resolving `<here::StringPiece as cxx::ExternType>::Id == (cxx::f, cxx::o, cxx::l, cxx::l, cxx::y, (), cxx::B, cxx::y, cxx::t, cxx::e, cxx::R, cxx::a, cxx::n, cxx::g, cxx::e)`
+error[E0271]: type mismatch resolving `<StringPiece as ExternType>::Id == (f, o, l, l, y, (), B, y, t, e, R, a, n, g, e)`
--> $DIR/wrong_type_id.rs:11:9
|
11 | type ByteRange = crate::here::StringPiece;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected a tuple with 15 elements, found one with 17 elements
|
- ::: $WORKSPACE/src/extern_type.rs:110:41
+ ::: $WORKSPACE/src/extern_type.rs
|
-110 | pub fn verify_extern_type<T: ExternType<Id = Id>, Id>() {}
- | ------- required by this bound in `cxx::private::verify_extern_type`
+ | pub fn verify_extern_type<T: ExternType<Id = Id>, Id>() {}
+ | ------- required by this bound in `verify_extern_type`
|
- = note: expected tuple `(cxx::f, cxx::o, cxx::l, cxx::l, cxx::y, (), cxx::B, cxx::y, cxx::t, cxx::e, cxx::R, cxx::a, cxx::n, cxx::g, cxx::e)`
- found tuple `(cxx::f, cxx::o, cxx::l, cxx::l, cxx::y, (), cxx::S, cxx::t, cxx::r, cxx::i, cxx::n, cxx::g, cxx::P, cxx::i, cxx::e, cxx::c, cxx::e)`
+ = 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)`
diff --git a/third-party/BUCK b/third-party/BUCK
index 9890a71..a9a3913 100644
--- a/third-party/BUCK
+++ b/third-party/BUCK
@@ -1,27 +1,21 @@
# To be generated by Facebook's `reindeer` tool once that is open source.
rust_library(
- name = "anyhow",
- srcs = glob(["vendor/anyhow-1.0.32/src/**"]),
- visibility = ["PUBLIC"],
- features = ["std"],
-)
-
-rust_library(
name = "bitflags",
srcs = glob(["vendor/bitflags-1.2.1/src/**"]),
)
rust_library(
name = "cc",
- srcs = glob(["vendor/cc-1.0.58/src/**"]),
+ srcs = glob(["vendor/cc-1.0.62/src/**"]),
visibility = ["PUBLIC"],
)
rust_library(
name = "clap",
- srcs = glob(["vendor/clap-2.33.1/src/**"]),
+ srcs = glob(["vendor/clap-2.33.3/src/**"]),
edition = "2015",
+ visibility = ["PUBLIC"],
deps = [
":bitflags",
":textwrap",
@@ -40,50 +34,14 @@
)
rust_library(
- name = "heck",
- srcs = glob(["vendor/heck-0.3.1/src/**"]),
- edition = "2015",
- deps = [":unicode-segmentation"],
-)
-
-rust_library(
name = "lazy_static",
srcs = glob(["vendor/lazy_static-1.4.0/src/**"]),
-)
-
-rust_library(
- name = "link-cplusplus",
- srcs = glob(["vendor/link-cplusplus-1.0.2/src/**"]),
visibility = ["PUBLIC"],
)
rust_library(
- name = "proc-macro-error",
- srcs = glob(["vendor/proc-macro-error-1.0.3/src/**"]),
- rustc_flags = ["--cfg=use_fallback"],
- deps = [
- ":proc-macro-error-attr",
- ":proc-macro2",
- ":quote",
- ":syn",
- ],
-)
-
-rust_library(
- name = "proc-macro-error-attr",
- srcs = glob(["vendor/proc-macro-error-attr-1.0.3/src/**"]),
- proc_macro = True,
- deps = [
- ":proc-macro2",
- ":quote",
- ":syn",
- ":syn-mid",
- ],
-)
-
-rust_library(
name = "proc-macro2",
- srcs = glob(["vendor/proc-macro2-1.0.19/src/**"]),
+ srcs = glob(["vendor/proc-macro2-1.0.24/src/**"]),
visibility = ["PUBLIC"],
features = [
"proc-macro",
@@ -106,32 +64,15 @@
)
rust_library(
- name = "structopt",
- srcs = glob(["vendor/structopt-0.3.15/src/**"]),
+ name = "scratch",
+ srcs = glob(["vendor/scratch-1.0.0/src/**"]),
+ env = {"OUT_DIR": ""},
visibility = ["PUBLIC"],
- deps = [
- ":clap",
- ":lazy_static",
- ":structopt-derive",
- ],
-)
-
-rust_library(
- name = "structopt-derive",
- srcs = glob(["vendor/structopt-derive-0.4.8/src/**"]),
- proc_macro = True,
- deps = [
- ":heck",
- ":proc-macro-error",
- ":proc-macro2",
- ":quote",
- ":syn",
- ],
)
rust_library(
name = "syn",
- srcs = glob(["vendor/syn-1.0.36/src/**"]),
+ srcs = glob(["vendor/syn-1.0.48/src/**"]),
visibility = ["PUBLIC"],
features = [
"clone-impls",
@@ -149,16 +90,6 @@
)
rust_library(
- name = "syn-mid",
- srcs = glob(["vendor/syn-mid-0.5.0/src/**"]),
- deps = [
- ":proc-macro2",
- ":quote",
- ":syn",
- ],
-)
-
-rust_library(
name = "termcolor",
srcs = glob(["vendor/termcolor-1.1.0/src/**"]),
)
@@ -170,12 +101,6 @@
)
rust_library(
- name = "unicode-segmentation",
- srcs = glob(["vendor/unicode-segmentation-1.6.0/src/**"]),
- edition = "2015",
-)
-
-rust_library(
name = "unicode-width",
srcs = glob(["vendor/unicode-width-0.1.8/src/**"]),
)
diff --git a/third-party/BUILD b/third-party/BUILD
index a01d4b7..d72b083 100644
--- a/third-party/BUILD
+++ b/third-party/BUILD
@@ -1,32 +1,27 @@
load(
"//tools/bazel:rust.bzl",
+ glob = "third_party_glob",
rust_binary = "third_party_rust_binary",
rust_library = "third_party_rust_library",
)
load("@bazel_tools//tools/build_defs/pkg:pkg.bzl", "pkg_tar")
rust_library(
- name = "anyhow",
- srcs = glob(["vendor/anyhow-1.0.32/src/**"]),
- crate_features = ["std"],
- visibility = ["//visibility:public"],
-)
-
-rust_library(
name = "bitflags",
srcs = glob(["vendor/bitflags-1.2.1/src/**"]),
)
rust_library(
name = "cc",
- srcs = glob(["vendor/cc-1.0.58/src/**"]),
+ srcs = glob(["vendor/cc-1.0.62/src/**"]),
visibility = ["//visibility:public"],
)
rust_library(
name = "clap",
- srcs = glob(["vendor/clap-2.33.1/src/**"]),
+ srcs = glob(["vendor/clap-2.33.3/src/**"]),
edition = "2015",
+ visibility = ["//visibility:public"],
deps = [
":bitflags",
":textwrap",
@@ -45,52 +40,14 @@
)
rust_library(
- name = "heck",
- srcs = glob(["vendor/heck-0.3.1/src/**"]),
- edition = "2015",
- deps = [":unicode-segmentation"],
-)
-
-rust_library(
name = "lazy_static",
srcs = glob(["vendor/lazy_static-1.4.0/src/**"]),
-)
-
-rust_library(
- name = "link-cplusplus",
- srcs = glob(["vendor/link-cplusplus-1.0.2/src/**"]),
visibility = ["//visibility:public"],
)
rust_library(
- name = "proc-macro-error",
- srcs = glob(["vendor/proc-macro-error-1.0.3/src/**"]),
- proc_macro_deps = [
- ":proc-macro-error-attr",
- ],
- rustc_flags = ["--cfg=use_fallback"],
- deps = [
- ":proc-macro2",
- ":quote",
- ":syn",
- ],
-)
-
-rust_library(
- name = "proc-macro-error-attr",
- srcs = glob(["vendor/proc-macro-error-attr-1.0.3/src/**"]),
- crate_type = "proc-macro",
- deps = [
- ":proc-macro2",
- ":quote",
- ":syn",
- ":syn-mid",
- ],
-)
-
-rust_library(
name = "proc-macro2",
- srcs = glob(["vendor/proc-macro2-1.0.19/src/**"]),
+ srcs = glob(["vendor/proc-macro2-1.0.24/src/**"]),
crate_features = [
"proc-macro",
"span-locations",
@@ -113,34 +70,15 @@
)
rust_library(
- name = "structopt",
- srcs = glob(["vendor/structopt-0.3.15/src/**"]),
- proc_macro_deps = [
- ":structopt-derive",
- ],
+ name = "scratch",
+ srcs = glob(["vendor/scratch-1.0.0/src/**"]),
+ rustc_env = {"OUT_DIR": ""},
visibility = ["//visibility:public"],
- deps = [
- ":clap",
- ":lazy_static",
- ],
-)
-
-rust_library(
- name = "structopt-derive",
- srcs = glob(["vendor/structopt-derive-0.4.8/src/**"]),
- crate_type = "proc-macro",
- deps = [
- ":heck",
- ":proc-macro-error",
- ":proc-macro2",
- ":quote",
- ":syn",
- ],
)
rust_library(
name = "syn",
- srcs = glob(["vendor/syn-1.0.36/src/**"]),
+ srcs = glob(["vendor/syn-1.0.48/src/**"]),
crate_features = [
"clone-impls",
"derive",
@@ -158,16 +96,6 @@
)
rust_library(
- name = "syn-mid",
- srcs = glob(["vendor/syn-mid-0.5.0/src/**"]),
- deps = [
- ":proc-macro2",
- ":quote",
- ":syn",
- ],
-)
-
-rust_library(
name = "termcolor",
srcs = glob(["vendor/termcolor-1.1.0/src/**"]),
)
@@ -179,12 +107,6 @@
)
rust_library(
- name = "unicode-segmentation",
- srcs = glob(["vendor/unicode-segmentation-1.6.0/src/**"]),
- edition = "2015",
-)
-
-rust_library(
name = "unicode-width",
srcs = glob(["vendor/unicode-width-0.1.8/src/**"]),
)
diff --git a/third-party/Cargo.lock b/third-party/Cargo.lock
index 8f40664..76b95f0 100644
--- a/third-party/Cargo.lock
+++ b/third-party/Cargo.lock
@@ -10,12 +10,6 @@
]
[[package]]
-name = "anyhow"
-version = "1.0.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b602bfe940d21c130f3895acd65221e8a61270debe89d628b9cb4e3ccb8569b"
-
-[[package]]
name = "atty"
version = "0.2.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -34,15 +28,15 @@
[[package]]
name = "cc"
-version = "1.0.58"
+version = "1.0.62"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9a06fb2e53271d7c279ec1efea6ab691c35a2ae67ec0d91d7acec0caf13b518"
+checksum = "f1770ced377336a88a67c473594ccc14eca6f4559217c34f64aac8f83d641b40"
[[package]]
name = "clap"
-version = "2.33.1"
+version = "2.33.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdfa80d47f954d53a35a64987ca1422f495b8d6483c0fe9f7117b36c2a792129"
+checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
dependencies = [
"ansi_term",
"atty",
@@ -65,11 +59,13 @@
[[package]]
name = "cxx"
-version = "0.3.4"
+version = "0.5.9"
dependencies = [
"cc",
"cxx-build",
+ "cxx-gen",
"cxx-test-suite",
+ "cxxbridge-flags",
"cxxbridge-macro",
"link-cplusplus",
"rustversion",
@@ -78,9 +74,23 @@
[[package]]
name = "cxx-build"
-version = "0.3.4"
+version = "0.5.9"
dependencies = [
- "anyhow",
+ "cc",
+ "codespan-reporting",
+ "cxx-gen",
+ "lazy_static",
+ "pkg-config",
+ "proc-macro2",
+ "quote",
+ "scratch",
+ "syn",
+]
+
+[[package]]
+name = "cxx-gen"
+version = "0.6.6"
+dependencies = [
"cc",
"codespan-reporting",
"proc-macro2",
@@ -94,22 +104,36 @@
dependencies = [
"cxx",
"cxx-build",
+ "cxxbridge-flags",
]
[[package]]
name = "cxxbridge-cmd"
-version = "0.3.4"
+version = "0.5.9"
dependencies = [
- "anyhow",
+ "clap",
"codespan-reporting",
"proc-macro2",
"quote",
- "structopt",
"syn",
]
[[package]]
-name = "cxxbridge-demo"
+name = "cxxbridge-flags"
+version = "0.5.9"
+
+[[package]]
+name = "cxxbridge-macro"
+version = "0.5.9"
+dependencies = [
+ "cxx",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "demo"
version = "0.0.0"
dependencies = [
"cxx",
@@ -117,16 +141,6 @@
]
[[package]]
-name = "cxxbridge-macro"
-version = "0.3.4"
-dependencies = [
- "cxx",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
name = "dissimilar"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -139,19 +153,10 @@
checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
[[package]]
-name = "heck"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20564e78d53d2bb135c343b3f47714a56af2061f1c928fdb541dc7b9fdd94205"
-dependencies = [
- "unicode-segmentation",
-]
-
-[[package]]
name = "hermit-abi"
-version = "0.1.15"
+version = "0.1.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3deed196b6e7f9e44a2ae8d94225d80302d81208b1bb673fd21fe634645c85a9"
+checksum = "5aca5565f760fb5b220e499d72710ed156fdb74e631659e99377d9ebfbd13ae8"
dependencies = [
"libc",
]
@@ -170,50 +175,30 @@
[[package]]
name = "libc"
-version = "0.2.74"
+version = "0.2.80"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2f02823cf78b754822df5f7f268fb59822e7296276d3e069d8e8cb26a14bd10"
+checksum = "4d58d1b70b004888f764dfbf6a26a3b0342a1632d33968e4a179d8011c760614"
[[package]]
name = "link-cplusplus"
-version = "1.0.2"
+version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f563b3814ea63e830e3e321206e4e2b5177854586ebe3f595795ed7053b217f5"
+checksum = "f96aa785c87218ec773df6c510af203872b34e2df2cf47d6e908e5f36231e354"
dependencies = [
"cc",
]
[[package]]
-name = "proc-macro-error"
-version = "1.0.3"
+name = "pkg-config"
+version = "0.3.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc175e9777c3116627248584e8f8b3e2987405cabe1c0adf7d1dd28f09dc7880"
-dependencies = [
- "proc-macro-error-attr",
- "proc-macro2",
- "quote",
- "syn",
- "version_check",
-]
-
-[[package]]
-name = "proc-macro-error-attr"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cc9795ca17eb581285ec44936da7fc2335a3f34f2ddd13118b6f4d515435c50"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "syn-mid",
- "version_check",
-]
+checksum = "3831453b3449ceb48b6d9c7ad7c96d5ea673e9b470a1dc578c2ce6521230884c"
[[package]]
name = "proc-macro2"
-version = "1.0.19"
+version = "1.0.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04f5f085b5d71e2188cb8271e5da0161ad52c3f227a661a3c135fdf28e258b12"
+checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71"
dependencies = [
"unicode-xid",
]
@@ -229,14 +214,9 @@
[[package]]
name = "rustversion"
-version = "1.0.3"
+version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9bdc5e856e51e685846fb6c13a1f5e5432946c2c90501bdc76a1319f19e29da"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
+checksum = "cb5d2a036dc6d2d8fd16fde3498b04306e29bd193bf306a57427019b823d5acd"
[[package]]
name = "ryu"
@@ -245,19 +225,25 @@
checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
[[package]]
-name = "serde"
-version = "1.0.114"
+name = "scratch"
+version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5317f7588f0a5078ee60ef675ef96735a1442132dc645eb1d12c018620ed8cd3"
+checksum = "7e114536316b51a5aa7a0e59fc49661fd263c5507dd08bd28de052e57626ce69"
+
+[[package]]
+name = "serde"
+version = "1.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b88fa983de7720629c9387e9f517353ed404164b1e482c970a90c1a4aaf7dc1a"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
-version = "1.0.114"
+version = "1.0.117"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a0be94b04690fbaed37cddffc5c134bf537c8e3329d53e982fe04c374978f8e"
+checksum = "cbd1ae72adb44aab48f325a02444a5fc079349a8d804c1fc922aed3f7454c74e"
dependencies = [
"proc-macro2",
"quote",
@@ -266,9 +252,9 @@
[[package]]
name = "serde_json"
-version = "1.0.57"
+version = "1.0.59"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "164eacbdb13512ec2745fb09d51fd5b22b0d65ed294a1dcf7285a360c80a675c"
+checksum = "dcac07dbffa1c65e7f816ab9eba78eb142c6d44410f4eeba1e26e4f5dfa56b95"
dependencies = [
"itoa",
"ryu",
@@ -282,34 +268,10 @@
checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
[[package]]
-name = "structopt"
-version = "0.3.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de2f5e239ee807089b62adce73e48c625e0ed80df02c7ab3f068f5db5281065c"
-dependencies = [
- "clap",
- "lazy_static",
- "structopt-derive",
-]
-
-[[package]]
-name = "structopt-derive"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "510413f9de616762a4fbeab62509bf15c729603b72d7cd71280fbca431b1c118"
-dependencies = [
- "heck",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
name = "syn"
-version = "1.0.36"
+version = "1.0.48"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cdb98bcb1f9d81d07b536179c269ea15999b5d14ea958196413869445bb5250"
+checksum = "cc371affeffc477f42a221a1e4297aedcea33d47d19b61455588bd9d8f6b19ac"
dependencies = [
"proc-macro2",
"quote",
@@ -317,17 +279,6 @@
]
[[package]]
-name = "syn-mid"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7be3539f6c128a931cf19dcee741c1af532c7fd387baa739c03dd2e96479338a"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
name = "termcolor"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -347,18 +298,18 @@
[[package]]
name = "toml"
-version = "0.5.6"
+version = "0.5.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffc92d160b1eef40665be3a05630d003936a3bc7da7421277846c2613e92c71a"
+checksum = "75cf45bb0bef80604d001caaec0d09da99611b3c0fd39d3080468875cdb65645"
dependencies = [
"serde",
]
[[package]]
name = "trybuild"
-version = "1.0.31"
+version = "1.0.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a4d94e6adf00b96b1ab94fcfcd8c3cf916733b39adf90c8f72693629887b9b8"
+checksum = "b7d30fe369fd650072b352b1a9cb9587669de6b89be3b8225544012c1c45292d"
dependencies = [
"dissimilar",
"glob",
@@ -370,12 +321,6 @@
]
[[package]]
-name = "unicode-segmentation"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0"
-
-[[package]]
name = "unicode-width"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -394,12 +339,6 @@
checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
[[package]]
-name = "version_check"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5a972e5669d67ba988ce3dc826706fb0a8b01471c088cb0b6110b805cc36aed"
-
-[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/tools/bazel/rust.bzl b/tools/bazel/rust.bzl
index 3ef4d91..b7b23e5 100644
--- a/tools/bazel/rust.bzl
+++ b/tools/bazel/rust.bzl
@@ -4,6 +4,10 @@
_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)
diff --git a/tools/bazel/rust_cxx_bridge.bzl b/tools/bazel/rust_cxx_bridge.bzl
new file mode 100644
index 0000000..534f6b5
--- /dev/null
+++ b/tools/bazel/rust_cxx_bridge.bzl
@@ -0,0 +1,41 @@
+load("@bazel_skylib//rules:run_binary.bzl", "run_binary")
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+def rust_cxx_bridge(name, src, deps = []):
+ native.alias(
+ name = "%s/header" % name,
+ actual = src + ".h",
+ )
+
+ native.alias(
+ name = "%s/source" % name,
+ actual = src + ".cc",
+ )
+
+ run_binary(
+ name = "%s/generated" % name,
+ srcs = [src],
+ outs = [
+ src + ".h",
+ src + ".cc",
+ ],
+ args = [
+ "$(location %s)" % src,
+ "-o",
+ "$(location %s.h)" % src,
+ "-o",
+ "$(location %s.cc)" % src,
+ ],
+ tool = "//:codegen",
+ )
+
+ cc_library(
+ name = name,
+ srcs = [src + ".cc"],
+ deps = deps + [":%s/include" % name],
+ )
+
+ cc_library(
+ name = "%s/include" % name,
+ hdrs = [src + ".h"],
+ )
diff --git a/tools/bazel/vendor.bzl b/tools/bazel/vendor.bzl
new file mode 100644
index 0000000..e9f10ac
--- /dev/null
+++ b/tools/bazel/vendor.bzl
@@ -0,0 +1,54 @@
+def _impl(repository_ctx):
+ # Link cxx repository into @third-party.
+ lockfile = repository_ctx.path(repository_ctx.attr.lockfile)
+ workspace = lockfile.dirname.dirname
+ repository_ctx.symlink(workspace, "workspace")
+
+ # Copy third-party/Cargo.lock since those are the crate versions that the
+ # BUILD file is written against.
+ vendor_lockfile = repository_ctx.path("workspace/third-party/Cargo.lock")
+ root_lockfile = repository_ctx.path("workspace/Cargo.lock")
+ _copy_file(repository_ctx, src = vendor_lockfile, dst = root_lockfile)
+
+ # Execute cargo vendor.
+ cmd = ["cargo", "vendor", "--versioned-dirs", "third-party/vendor"]
+ result = repository_ctx.execute(
+ cmd,
+ quiet = True,
+ working_directory = "workspace",
+ )
+ _log_cargo_vendor(repository_ctx, result)
+ if result.return_code != 0:
+ fail("failed to execute `{}`".format(" ".join(cmd)))
+
+ # Copy lockfile back to third-party/Cargo.lock to reflect any modification
+ # performed by Cargo.
+ _copy_file(repository_ctx, src = root_lockfile, dst = vendor_lockfile)
+
+ # Produce a token for third_party_glob to depend on so that the necessary
+ # sequencing is visible to Bazel.
+ repository_ctx.file("BUILD", executable = False)
+ repository_ctx.file("vendor.bzl", "vendored = True", executable = False)
+
+def _copy_file(repository_ctx, *, src, dst):
+ content = repository_ctx.read(src)
+ if not dst.exists or content != repository_ctx.read(dst):
+ repository_ctx.file(dst, content = content, executable = False)
+
+def _log_cargo_vendor(repository_ctx, result):
+ relevant = ""
+ for line in result.stderr.splitlines(True):
+ if line.strip() and not line.startswith("To use vendored sources,"):
+ relevant += line
+ if relevant:
+ # Render it as command output.
+ # If we just use print(), Bazel will cache and repeat the output even
+ # when not rerunning the command.
+ print = ["echo", relevant]
+ repository_ctx.execute(print, quiet = False)
+
+vendor = repository_rule(
+ attrs = {"lockfile": attr.label()},
+ local = True,
+ implementation = _impl,
+)
diff --git a/tools/buck/genrule.bzl b/tools/buck/genrule.bzl
new file mode 100644
index 0000000..b5364b7
--- /dev/null
+++ b/tools/buck/genrule.bzl
@@ -0,0 +1,8 @@
+def genrule(cmd, **kwargs):
+ # Resolve a distracting inconsistency between Buck and Bazel.
+ # Bazel creates the directory for your output file, while Buck expects the
+ # cmd to create it.
+ #
+ # TODO: send this as a PR to Buck, because Bazel's behavior here is better.
+ cmd = "mkdir -p `dirname ${OUT}`; " + cmd
+ native.genrule(cmd = cmd, **kwargs)
diff --git a/tools/buck/rust_cxx_bridge.bzl b/tools/buck/rust_cxx_bridge.bzl
new file mode 100644
index 0000000..4acc7c6
--- /dev/null
+++ b/tools/buck/rust_cxx_bridge.bzl
@@ -0,0 +1,34 @@
+load("//tools/buck:genrule.bzl", "genrule")
+
+def rust_cxx_bridge(name, src, deps = []):
+ genrule(
+ name = "%s/header" % name,
+ out = src + ".h",
+ cmd = "cp $(location :%s/generated)/generated.h ${OUT}" % name,
+ )
+
+ genrule(
+ name = "%s/source" % name,
+ out = src + ".cc",
+ cmd = "cp $(location :%s/generated)/generated.cc ${OUT}" % name,
+ )
+
+ genrule(
+ name = "%s/generated" % name,
+ srcs = [src],
+ out = ".",
+ cmd = "$(exe //:codegen) ${SRCS} -o ${OUT}/generated.h -o ${OUT}/generated.cc",
+ type = "cxxbridge",
+ )
+
+ cxx_library(
+ name = name,
+ srcs = [":%s/source" % name],
+ preferred_linkage = "static",
+ deps = deps + [":%s/include" % name],
+ )
+
+ cxx_library(
+ name = "%s/include" % name,
+ exported_headers = [":%s/header" % name],
+ )
diff --git a/tools/cargo/build.rs b/tools/cargo/build.rs
new file mode 100644
index 0000000..6c9d22d
--- /dev/null
+++ b/tools/cargo/build.rs
@@ -0,0 +1,73 @@
+use std::io::{self, Write};
+#[cfg(windows)]
+use std::os::windows::fs as windows;
+use std::path::Path;
+use std::process;
+#[cfg(windows)]
+use std::{env, fs};
+
+const MISSING: &str = "
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+When building `cxx` from a git clone, git's symlink support needs
+to be enabled on platforms that have it off by default (Windows).
+Either use:
+
+ $ git config --global core.symlinks true
+
+prior to cloning, or else use:
+
+ $ git clone -c core.symlinks=true https://github.com/dtolnay/cxx
+
+for the clone.
+
+Symlinks are only required when compiling locally from a clone of
+the git repository---they are NOT required when building `cxx` as
+a Cargo-managed (possibly transitive) build dependency downloaded
+through crates.io.
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+";
+
+#[cfg(windows)]
+const DENIED: &str = "
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+When building `cxx` from a git clone on Windows we need Developer
+Mode enabled for symlink support.
+
+To enable Developer Mode: go under Settings to Update & Security,
+then 'For developers', and turn on the toggle for Developer Mode.
+
+For more explanation of symlinks in Windows, see these resources:
+> https://blogs.windows.com/windowsdeveloper/2016/12/02/symlinks-windows-10/
+> https://docs.microsoft.com/windows/uwp/get-started/enable-your-device-for-development
+
+Symlinks are only required when compiling locally from a clone of
+the git repository---they are NOT required when building `cxx` as
+a Cargo-managed (possibly transitive) build dependency downloaded
+through crates.io.
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+";
+
+fn main() {
+ if Path::new("src/syntax/mod.rs").exists() {
+ return;
+ }
+
+ #[allow(unused_mut)]
+ let mut message = MISSING;
+
+ #[cfg(windows)]
+ if let Some(out_dir) = env::var_os("OUT_DIR") {
+ let parent_dir = Path::new(&out_dir).join("symlink");
+ let from_dir = parent_dir.join("from");
+ let to_dir = parent_dir.join("to");
+ if fs::create_dir_all(&from_dir).is_ok()
+ && fs::remove_dir(&to_dir).is_ok()
+ && windows::symlink_dir(&from_dir, &to_dir).is_err()
+ {
+ message = DENIED;
+ }
+ }
+
+ let _ = io::stderr().write_all(message.as_bytes());
+ process::exit(1);
+}
