Better integration between derives and operator overloads · dtolnay/cxx

(5 comentários) (0 reação) (0 responsável)Rust (253 forks)batch import

help wanted

Métricas do repositório

Stars: (4.472 estrelas)
Métricas de merge de PR: (Métricas PR pendentes)

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

Guia do colaborador

Direção de pesquisa: Implemente macros de derivação que geram sobrecargas de operadores C++ para structs que derivam PartialEq/Ord e geram implementações de trait para tipos opacos que vinculam a operadores C++.
Pilha de tecnologia: rust
Domain: api
Tipo Issue: Funcionalidade
Difficulty: 3
Tempo estimado: 1-2 dias
Status da atividade: Ativo
Clarity: Claro
Prerequisites: RustC++
Simpatia para novatos: 30