Permit nb::implicitly_convertible involving opaque enums (#1107)

Author: riclarsson

include/nanobind/nb_class.h

@@ -838,7 +838,10 @@ template <typename T> class enum_ : public object {
 template <typename Source, typename Target> void implicitly_convertible() {
     if constexpr (!std::is_same_v<Source, Target>) {
         using Caster = detail::make_caster<Source>;
-        static_assert(!std::is_enum_v<Target>, "implicitly_convertible(): 'Target' cannot be an enumeration.");
+        static_assert(
+            !std::is_enum_v<Target> || !detail::is_base_caster_v<Target>,
+            "implicitly_convertible(): 'Target' cannot be an enumeration "
+            "unless it is opaque.");
 
         if constexpr (detail::is_base_caster_v<Caster>) {
             detail::implicitly_convertible(&typeid(Source), &typeid(Target));

tests/test_enum.cpp

@@ -1,4 +1,6 @@
 #include <nanobind/nanobind.h>
+#include <nanobind/operators.h>
+#include <nanobind/stl/string.h>
 
 namespace nb = nanobind;
 
@@ -14,6 +16,9 @@ enum ClassicEnum { Item1, Item2 };
 
 struct EnumProperty { Enum get_enum() { return Enum::A; } };
 
+enum class OpaqueEnum { X, Y };
+NB_MAKE_OPAQUE(OpaqueEnum)
+
 NB_MODULE(test_enum_ext, m) {
     nb::enum_<Enum>(m, "Enum", "enum-level docstring")
         .value("A", Enum::A, "Value A")
@@ -67,4 +72,17 @@ NB_MODULE(test_enum_ext, m) {
     nb::class_<EnumProperty>(m, "EnumProperty")
         .def(nb::init<>())
         .def_prop_ro("read_enum", &EnumProperty::get_enum);
+
+
+    auto oe = nb::class_<OpaqueEnum>(m, "OpaqueEnum")
+        .def_prop_ro_static("X", [](nb::object&){return OpaqueEnum::X;})
+        .def_prop_ro_static("Y", [](nb::object&){return OpaqueEnum::Y;})
+        .def(nb::init<>())
+        .def("__init__", [](OpaqueEnum* p, std::string v){
+            if (v == "X") new (p) OpaqueEnum{OpaqueEnum::X};
+            else if (v == "Y") new (p) OpaqueEnum{OpaqueEnum::Y};
+            else throw std::runtime_error(v);
+        })
+        .def(nb::self == nb::self);
+    nb::implicitly_convertible<std::string, OpaqueEnum>();
 }

tests/test_enum.py

@@ -184,3 +184,6 @@ def test09_enum_methods():
     assert t.Item1.get_value() == 0 and t.Item2.get_value() == 1
     assert t.Item1.foo() == t.Item1
     assert t.ClassicEnum.bar(t.Item1) == t.Item1
+
+def test10_enum_opaque():
+    assert t.OpaqueEnum.X == t.OpaqueEnum("X") and t.OpaqueEnum.Y == t.OpaqueEnum("Y")

tests/test_enum_ext.pyi.ref

@@ -105,3 +105,18 @@ class EnumProperty:
 
     @property
     def read_enum(self) -> Enum: ...
+
+class OpaqueEnum:
+    @overload
+    def __init__(self) -> None: ...
+
+    @overload
+    def __init__(self, arg: str, /) -> None: ...
+
+    X: test_enum_ext.OpaqueEnum = ...
+    """(arg: object, /) -> test_enum_ext.OpaqueEnum"""
+
+    Y: test_enum_ext.OpaqueEnum = ...
+    """(arg: object, /) -> test_enum_ext.OpaqueEnum"""
+
+    def __eq__(self, arg: OpaqueEnum, /) -> bool: ...