Better integration between derives and operator overloads · dtolnay/cxx

(5 Kommentare) (0 Reaktionen) (0 zugewiesene Personen)Rust (253 Forks)batch import

help wanted

Repository-Metriken

Stars: (4.472 Sterne)
PR-Merge-Metriken: (Durchschn. Merge 8m) (3 gemergte PRs in 30 T)

Beschreibung

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

Research-Richtung: Implementieren Sie Ableitungsmakros, die C++ Operatorüberladungen für Strukturen generieren, die PartialEq/Ord ableiten, und generieren Sie Trait Implementierungen für undurchsichtige Typen, die an C++ Operatoren gebunden sind.
Tech Stack: rust
Domain: api
Issue Type: Funktion
Schwierigkeit: 3
Geschätzte Zeit: 1-2 Tage
Aktivitätsstatus: Aktiv
Klarheit: Klar
Voraussetzungen: RustC++
Einsteigerfreundlichkeit: 30