WIP Show edge case with operator overloading, reversal, and mixing

docs/advanced/classes.rst

@@ -748,7 +748,7 @@ throwing a type error.
 
     The file :file:`tests/test_operator_overloading.cpp` contains a
     complete example that demonstrates how to work with overloaded operators in
-    more detail.
+    more detail, as well of some of the nuances you may encounter.
 
 .. _pickling:
 

tests/test_operator_overloading.cpp

@@ -62,6 +62,8 @@ int operator+(const C2 &, const C2 &) { return 22; }
 int operator+(const C2 &, const C1 &) { return 21; }
 int operator+(const C1 &, const C2 &) { return 12; }
 
+
+
 // Note: Specializing explicit within `namespace std { ... }` is done due to a
 // bug in GCC<7. If you are supporting compilers later than this, consider
 // specializing `using template<> struct std::hash<...>` in the global
@@ -80,6 +82,17 @@ std::string abs(const Vector2&) {
     return "abs(Vector2)";
 }
 
+// ReverseA and ReverseB simulate two classes defined in separate files, both
+// with oeprator overloads on +, and ReverseB wishes to overload __radd__ with
+// ReversedA. This won't work, as will be shown in the Python test.
+struct ReverseA {
+    friend int operator+(int, ReverseA) { return 1; };
+};
+struct ReverseB {
+    friend int operator+(ReverseB, ReverseA) { return 2; };
+    friend int operator+(ReverseA, ReverseB) { return 3; };
+};
+
 // MSVC warns about unknown pragmas, and warnings are errors.
 #ifndef _MSC_VER
   #pragma GCC diagnostic push
@@ -219,6 +232,14 @@ TEST_SUBMODULE(operators, m) {
         .def("__hash__", &Hashable::hash)
         .def(py::init<int>())
         .def(py::self == py::self);
+
+    py::class_<ReverseA>(m, "ReverseA")
+        .def(py::init())
+        .def(int{} + py::self);
+    py::class_<ReverseB>(m, "ReverseB")
+        .def(py::init())
+        .def(py::self + ReverseA{})
+        .def(ReverseA{} + py::self);
 }
 
 #ifndef _MSC_VER

tests/test_operator_overloading.py

@@ -143,3 +143,9 @@ def test_overriding_eq_reset_hash():
 
         assert hash(hashable(15)) == 15
         assert hash(hashable(15)) == hash(hashable(15))
+
+
+def test_reverse_operator_ambiguity():
+    assert int() + m.ReverseA() == 1
+    assert m.ReverseB() + m.ReverseA() == 2
+    assert m.ReverseA() + m.ReverseB() == 3