Better integration between derives and operator overloads

[dtolnay]

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

[dtolnay]

Update: cxx 1.0.6 covers the first of the 3 bullets above. We support derive(PartialEq) \<-> operator== operator!=; derive(PartialOrd) \<-> operator< operator<= operator> operator>=; and derive(Hash) \<-> template <> struct std::hash<T>.

[yan-zaretskiy]

I check for a new cxx release every morning, every new feature is so helpful! Do you plan to add devive support to shared enums? It looks like PartialEq works, but PartialOrd does not.

[dtolnay]

derive(PartialOrd, Ord) for shared enums is fixed in 1.0.9.

[benruijl]

What is the current recommended way of overloading operators in C++ for a Rust opaque type (for example the + operator)? For example, I have:

#[cxx::bridge]
mod ffi {
    extern "Rust" {
        type Atom;
        fn add_atom(at1: &Atom, at2: &Atom) -> Box<Atom>;
    }
}

and I want to add something like

rust::cxxbridge1::Box<Atom> operator+(const Atom &other)
{
    return add_atom(this, other);
}

to the auto-generated code for struct Atom final : public ::rust::Opaque.