Better integration between derives and operator overloads · dtolnay/cxx

(5 commentaires) (0 réaction) (0 personne assignée)Rust (253 forks)batch import

help wanted

Métriques du dépôt

Stars: (4 472 étoiles)
Métriques de merge PR: (Merge moyen 8m) (3 PRs mergées en 30 j)

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 ==`
    }
}
```

Guide contributeur

Direction de recherche: Implémentez des macros de dérivation qui génèrent des surcharges d'opérateurs C++ pour les structures dérivant PartialEq/Ord, et génèrent des implémentations de trait pour les types opaques liés aux opérateurs C++.
Stack technique: rust
Domaine: api
Type d'issue: Fonctionnalité
Difficulté: 3
Temps estimé: 1-2 jours
Statut d'activité: Active
Clarté: Claire
Prérequis: RustC++
Accessibilité débutant: 30