Better integration between derives and operator overloads · dtolnay/cxx#109

2020-04-11T23:55:44.000Z

Many integration opportunities here. - If a shared struct has a #\[derive(`PartialEq` or `Ord`)\] then emit a compatible `operator ==`, `operator !=`, `operator `, `operator >=` on the type for C++. ```rust mod ffi { #[derive(PartialEq)] struct Key { n: usize, } } ``` - If an opaque Rust type is written with trait bounds then wire up the corresponding operator for C++ in a way that delegates to Rust's implementation of the operator. ```rust mod ffi { extern "Rust" { type R: PartialEq; } } struct R {...} impl PartialEq for R {...} ``` - If an opaque C++ type is written with trait bounds then produce a trait impl in Rust that delegates to the corresponding overloaded operator(s) in C++. ```rust mod ffi { extern "C++" { type C: PartialEq; // produce a PartialEq that calls `operator ==` } } ```

(5 comments) (0 reactions) (0 assignees)Rust (4,472 stars) (253 forks)batch import

help wanted

Description

Many integration opportunities here.

If a shared struct has a #[derive(PartialEq or Ord)] then emit a compatible operator ==, operator !=, operator <, operator <=, operator >, operator >= on the type for C++.
```
mod ffi {
    #[derive(PartialEq)]
    struct Key {
        n: usize,
    }
}
```
If an opaque Rust type is written with trait bounds then wire up the corresponding operator for C++ in a way that delegates to Rust's implementation of the operator.
```
mod ffi {
    extern "Rust" {
        type R: PartialEq;
    }
}

struct R {...}
impl PartialEq for R {...}
```
If an opaque C++ type is written with trait bounds then produce a trait impl in Rust that delegates to the corresponding overloaded operator(s) in C++.
```
mod ffi {
    extern "C++" {
        type C: PartialEq;  // produce a PartialEq that calls `operator ==`
    }
}
```

Contributor guide

Tech stack: rustcpp
Domain: tooling
Issue type: feature
Difficulty: 4
Estimated time: 3-5 days
Activity status: stale
Clarity: clear
Prerequisites: Rust derive macrosC++ operator overloadingcxx code generation fundamentals
Newbie friendliness: 20
Research direction: Review the cxx code generation pipeline in the `src/` directory to understand how `#[derive]` attributes are currently handled for structs. Examine the existing emission of C++ operator overloads in the codegen module. Investigate how trait bounds on opaque types are parsed and stored in the `syntax/` module. Look for any existing tests or comments related to operator integration.