cxx-dlang — Rust ↔ D bindings + LDC2 build glue for cxx.rs

Reusable D-side bindings for the cxx.rs rust::* types plus a LDC2 build pipeline that downstream crates can adopt without rewriting the toolchain glue every time.

This crate is build-only: it does not define an FFI surface of its own. Consumers ship their own #[cxx::bridge], import the D module cxx_d, and link against the static archive produced here.

[dependencies]
cxx = "1.0"
cxx-dlang = "0.2"

[build-dependencies]
cxx-build = "1.0"

Requires LDC2 ≥ 1.40, Rust edition 2024 (rustc 1.85+). CI matrix: Linux / macOS / Windows MSVC.

Set $DC (D-toolchain convention, e.g. DC=ldc2) or $LDC2_PATH if ldc2 is not on $PATH.

What you get

D-side type bindings (d/cxx_d.d, imported as import cxx_d;):

Per-runtime adaptations (driven by D's predefined version (CppRuntime_*)):

• CppRuntime_GNU (Linux libstdc++) → pragma(lib, "stdc++"); smart-pointer methods omitted; use inline-C++ trampolines in the consumer's bridge header.
• CppRuntime_LLVM (macOS / libc++) → pragma(lib, "c++"); smart-pointer methods direct.
• CppRuntime_Microsoft (Windows MSVC) → linked automatically; smart-pointer methods direct.

(Validated empirically via zig c++ -c -target {x86_64-linux-gnu, aarch64-macos-none, x86_64-windows-msvc} + llvm-nm — see CLAUDE.md for the methodology.)

Build pipeline (build.rs):

• Locates ldc2 via $DC → $LDC2_PATH → walks $PATH → ~/.dlang/ldc2-*/bin/ldc2.
• Compiles every .d file under d/ with the curated safety-preview list.
• Probes the LDC2 lib dir across Linux (lib/), macOS universal (lib-arm64/, lib-x86_64/) and Windows MSVC (lib64/).
• Bundles the D objects into libcxx_d_dlib.a (named after the crate's links = key) and links druntime + phobos2 statically.

LDC2 --preview= safety flags applied to every compilation unit: safer, dip1000, nosharedaccess, fixImmutableConv, systemVariables.

Sketching a consumer

// src/ffi.rs in the consumer crate
#[cxx::bridge(namespace = "my_app")]
mod bridge {
    extern "Rust" { /* ... */ }

    unsafe extern "C++" {
        include!("my_app/include/my_app.h");
        // declare D-implemented functions here
    }
}

// d/my_app.d
module my_app;
import cxx_d; // Str, String, Slice(T), Vec(T), Fn(R,A...), unique_ptr,
              // shared_ptr, weak_ptr, vector, CxxString, CxxArray, …

extern(C++, "my_app") nothrow {
    @assumeUsed pragma(inline, false)
    size_t my_app_str_len(Str s) @nogc { return s.len; }
}

The consumer's build.rs runs cxx_build::bridge("src/ffi.rs"), adds its own d/my_app.d as an extra object (compiled with LDC2 the same way cxx-dlang's own build does), and links everything together. cxx-dlang contributes the rust::* D bindings and the druntime/phobos linkage.

Testing

cargo test --tests
# test result: ok. 99 passed; 0 failed

tests/integration.rs writes one tiny fixture .d file per #[test] and compiles it under the safety previews:

• every binding × {const, mut} × all D integer/float widths (Slice, Vec)
• ABI invariants via D static assert (Str.sizeof == 16, String.sizeof == 24, Slice!T.sizeof == 16, Vec(T) methods present, Fn(R,A).sizeof == 16, …)
• structural traits: field types, tuple lengths, disabled ctors / postblits
• version (CppRuntime_*) conditional smart-ptr method probes
• a "full surface" fixture that uses every binding in a single extern(C++) block

End-to-end validation against a real consumer lives in examples/demo/ — a self-contained sub-package with its own Cargo.toml, build.rs, #[cxx::bridge], and d/demo.d that exercises every C++ stdlib type category we ship (UniquePtr, SharedPtr refcount, CxxVector, CxxString, std::array, Result<T> throw, callbacks, shared structs/enums). CI runs it on every push:

cd examples/demo && cargo run --bin demo
# === cxx-dlang full-parity demo ===
#   demo_str_len + demo_sum_u8       ok
#   demo_fill + demo_double_i32      ok
#   shared enum + shared struct      ok
#   String roundtrip + Vec<i32> sum  ok
#   UniquePtr<DPayload>              ok
#   rust::Fn callback                ok
#   Result<T> via C++ throw          ok
#   SharedPtr<T> refcount            ok
#   CxxVector<i32> sum               ok
#   CxxString len                    ok
#   std::array<int,4> sum            ok
#   RustCounter (extern Rust)        ok
# ✔ every binding category exercised end-to-end.

Safety contract

• D fns called from Rust through cxx must be nothrow — exceptions must not cross the C++ ABI boundary (UB).
• Rust fns called from D must be wrapped in cxx::private::prevent_unwind so panics turn into aborts at the boundary.
• Allocator discipline: D handles returned through UniquePtr<T> must be allocated with __cpp_new_nothrow from core.stdcpp.new_, not D's GC new — std::unique_ptr's default deleter calls operator delete.
• GC safety: never store a Rust Box<T> / Arc<T> in a D class field; druntime will trace and corrupt the Rust heap. Use a Rust-side registry keyed by an integer instead.

Known limitations

• LDC2 only — DMD and GDC are not supported.
• rust::Fn<R(A)> needs pragma(mangle) on consumer functions because D TMP encodes the template arg as a pack (J..E) while cxx uses a function type (F..E). Itanium and MSVC use distinct symbol shapes, so a version(Windows) branch is required when targeting both.
• On Linux libstdc++, std::shared_ptr<T>::use_count / std::weak_ptr<T>::expired delegate to the private base classes __shared_ptr / __weak_ptr, so the user-facing class emits no direct method symbols. The D bindings ship the methods only under version(CppRuntime_LLVM) / version(CppRuntime_Microsoft); libstdc++ consumers should wrap them with an inline-C++ helper in their bridge header (see cxx-dlang-demo for the pattern).
• Out of scope: async futures, D class polymorphism, variant enums (Rust enums with payload). Canonical alternatives: cxx-async, cxx-enumext.

References

• D Interface to C++
• Calling C++ from D
• cxx.rs
• dlang/stdcpp

License

MIT OR Apache-2.0