Add pybind11/native_enum.h, building the native enum type. Not used by any type_caster yet.

Author: rwgk

include/pybind11/detail/internals.h

@@ -34,7 +34,7 @@
 /// further ABI-incompatible changes may be made before the ABI is officially
 /// changed to the new version.
 #ifndef PYBIND11_INTERNALS_VERSION
-#    define PYBIND11_INTERNALS_VERSION 4
+#    define PYBIND11_INTERNALS_VERSION 5
 #endif
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
@@ -209,6 +209,9 @@ struct internals {
         PYBIND11_TLS_FREE(tstate);
     }
 #endif
+#if PYBIND11_INTERNALS_VERSION > 4
+    type_map<PyObject *> native_enum_types;
+#endif
 };
 
 /// Additional type information which does not fit into the PyTypeObject.

include/pybind11/native_enum.h

@@ -0,0 +1,67 @@
+// Copyright (c) 2022 The pybind Community.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#pragma once
+
+#include "pybind11.h"
+
+#include <type_traits>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+/// Conversions between Python's native (stdlib) enum types and C++ enums.
+template <typename Type>
+class native_enum {
+public:
+    using Underlying = typename std::underlying_type<Type>::type;
+    // Scalar is the integer representation of underlying type
+    using Scalar = detail::conditional_t<detail::any_of<detail::is_std_char_type<Underlying>,
+                                                        std::is_same<Underlying, bool>>::value,
+                                         detail::equivalent_integer_t<Underlying>,
+                                         Underlying>;
+
+    template <typename... Extra>
+    native_enum(const handle &scope, const char *name, const Extra &.../*extra*/)
+        : m_scope(reinterpret_borrow<object>(scope)), m_name(name) {
+        constexpr bool is_arithmetic = detail::any_of<std::is_same<arithmetic, Extra>...>::value;
+        constexpr bool is_convertible = std::is_convertible<Type, Underlying>::value;
+        if (is_arithmetic || is_convertible) {
+            // IGNORED.
+        }
+    }
+
+    /// Export enumeration entries into the parent scope
+    native_enum &export_values() { return *this; }
+
+    /// Add an enumeration entry
+    native_enum &value(char const *name, Type value, const char *doc = nullptr) {
+        if (doc) {
+            // IGNORED.
+        }
+        m_members.append(make_tuple(name, static_cast<Scalar>(value)));
+        return *this;
+    }
+
+    native_enum(const native_enum &) = delete;
+    native_enum &operator=(const native_enum &) = delete;
+
+    ~native_enum() {
+        // Any exception here will terminate the process.
+        auto enum_module = module_::import("enum");
+        auto int_enum = enum_module.attr("IntEnum");
+        auto int_enum_color = int_enum(m_name, m_members);
+        int_enum_color.attr("__module__") = m_scope;
+        m_scope.attr(m_name) = int_enum_color;
+        // Intentionally leak Python reference.
+        detail::get_internals().native_enum_types[std::type_index(typeid(Type))]
+            = int_enum_color.release().ptr();
+    }
+
+private:
+    object m_scope;
+    str m_name;
+    list m_members;
+};
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

tests/CMakeLists.txt

@@ -142,6 +142,7 @@ set(PYBIND11_TEST_FILES
     test_methods_and_attributes
     test_modules
     test_multiple_inheritance
+    test_native_enum
     test_numpy_array
     test_numpy_dtypes
     test_numpy_vectorize

tests/extra_python_package/test_files.py

@@ -36,6 +36,7 @@
     "include/pybind11/functional.h",
     "include/pybind11/gil.h",
     "include/pybind11/iostream.h",
+    "include/pybind11/native_enum.h",
     "include/pybind11/numpy.h",
     "include/pybind11/operators.h",
     "include/pybind11/options.h",

tests/test_native_enum.cpp

@@ -1,4 +1,4 @@
-// #include <pybind11/native_enum.h>
+#include <pybind11/native_enum.h>
 
 #include "pybind11_tests.h"
 
@@ -77,4 +77,10 @@ TEST_SUBMODULE(native_enum, m) {
 
     m.def("pass_color", pass_color);
     m.def("return_color", return_color);
+
+    py::native_enum<color>(m, "WIPcolor")
+        .value("red", color::red)
+        .value("yellow", color::yellow)
+        .value("green", color::green)
+        .value("blue", color::blue);
 }

tests/test_native_enum.py

@@ -43,3 +43,9 @@ def test_return_color_fail():
     with pytest.raises(ValueError) as excinfo_cast:
         m.return_color(2)
     assert str(excinfo_cast.value) == str(excinfo_direct.value)
+
+
+def test_wip_color():
+    assert isinstance(m.WIPcolor, enum.EnumMeta)
+    for name, value in COLOR_MEMBERS:
+        assert m.WIPcolor[name] == value