dtolnay/cxx

Support UniquePtr as self type of extern C++ member function

Open

#690 opened on Jan 27, 2021

View on GitHub
 (0 comments) (5 reactions) (0 assignees)Rust (4,472 stars) (253 forks)batch import
help wanted

Description

I'd like to be able to write:

#[cxx::bridge]
mod ffi {
    unsafe extern "C++" {
        type Thing;

        fn method(self: &UniquePtr<Thing>, arg: i32);
    }
}

and have this translate a Rust uptr_thing.method(arg) (where the type of uptr_thing is UniquePtr<Thing>) to uptr_thing->method(arg) in C++, by way of std::unique_ptr's operator->.

This pattern turns out to be quite common for exposing threadsafe non-const member functions to Rust. A threadsafe non-const member function requires a this of type non-const Thing*, which cannot be obtained from simply a &Thing in Rust, but at the same time it does not require this to be exclusively held when called, so a &mut Thing argument in Rust is also not appropriate. Aside from #537 the easy and correct way to expose such threadsafe non-const member functions to Rust is by passing &UniquePtr<Thing> as seen above.

Contributor guide

Tech stack
rustcpp
Domain
developer experienceapi
Issue type
feature
DifficultyEstimated implementation difficulty for a new contributor, from 1 for very small changes to 5 for expert-level work.
3
Estimated timeA rough time range for an experienced contributor to investigate, implement, test, and prepare a pull request.
1-3 hours
Activity statusHow available the issue appears right now: fresh, active, stale, blocked, or waiting on maintainer input.
stale
ClarityHow clearly the issue explains the expected change, acceptance criteria, and next step.
clear
Prerequisites
Rust FFI conceptscxx crate usageC++ smart pointers
Newbie friendlinessA 1-100 score estimating how approachable this issue is for first-time contributors.
40
Research direction
First, examine the cxx crate's source code, particularly the macro expansion for extern C++ functions (likely in the `cxxbridge macro` crate) to understand how `self` types are currently handled. Focus on the handling of `&self` and `&mut self` and identify where to add support for `&UniquePtr<Thing>`. Then, review the linked issue #537 for context on threadsafe non const methods. Finally, implement the change to generate ` >` operator call for `UniquePtr` and add corresponding tests. Consult maintainers if acceptance criteria are unclear.