Disable implicit conversion of 0 to pybind11::handle.

include/pybind11/pytypes.h

@@ -211,9 +211,27 @@ class handle : public detail::object_api<handle> {
 public:
     /// The default constructor creates a handle with a ``nullptr``-valued pointer
     handle() = default;
-    /// Creates a ``handle`` from the given raw Python object pointer
+
+    /// Enable implicit conversion from ``PyObject *`` and ``nullptr``.
+    /// Not using ``handle(PyObject *ptr)`` to avoid implicit conversion from ``0``.
+    template <typename T,
+              detail::enable_if_t<detail::any_of<std::is_same<T, PyObject *>,
+                                                 std::is_same<T, std::nullptr_t>>::value,
+                                  int> = 0>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    handle(T ptr) : m_ptr(ptr) {}
+
+    /// Enable implicit conversion through ``T::operator PyObject *()``.
+    template <typename T,
+              detail::enable_if_t<
+                  detail::all_of<detail::negation<detail::any_of<std::is_base_of<handle, T>,
+                                                                 std::is_same<T, PyObject *>,
+                                                                 std::is_same<T, PyObject *const>,
+                                                                 std::is_same<T, std::nullptr_t>>>,
+                                 std::is_convertible<T, PyObject *>>::value,
+                  int> = 0>
     // NOLINTNEXTLINE(google-explicit-constructor)
-    handle(PyObject *ptr) : m_ptr(ptr) {} // Allow implicit conversion from PyObject*
+    handle(T &obj) : m_ptr(obj) {}
 
     /// Return the underlying ``PyObject *`` pointer
     PyObject *ptr() const { return m_ptr; }

tests/test_pytypes.cpp

@@ -39,7 +39,42 @@ class float_ : public py::object {
 };
 } // namespace external
 
+namespace implicit_conversion_from_0_to_handle {
+// Uncomment to trigger compiler error. Note: Before PR #4008 this used to compile successfully.
+// void expected_to_trigger_compiler_error() { py::handle(0); }
+} // namespace implicit_conversion_from_0_to_handle
+
+namespace pytorch_object_ptr_h_reduced {
+
+// Reduced from
+// https://github.com/pytorch/pytorch/blob/279634f384662b7c3a9f8bf7ccc3a6afd2f05657/torch/csrc/utils/object_ptr.h
+template <class T>
+class THPPointer {
+public:
+    explicit THPPointer(T *ptr) noexcept : ptr(ptr){};
+    THPPointer(THPPointer &&p) { // NOLINT(performance-noexcept-move-constructor)
+        // free();
+        ptr = p.ptr;
+        p.ptr = nullptr;
+    };
+    operator T *() { return ptr; } // NOLINT(google-explicit-constructor)
+private:
+    T *ptr = nullptr;
+};
+
+using THPObjectPtr = THPPointer<PyObject>;
+
+bool handle_from_obj_ptr() {
+    THPObjectPtr obj_ptr(Py_None);
+    auto h = py::handle(obj_ptr); // Critical part of test: does this compile?
+    return h.ptr() == Py_None;    // Just something.
+}
+
+} // namespace pytorch_object_ptr_h_reduced
+
 TEST_SUBMODULE(pytypes, m) {
+    m.def("handle_from_pytorch_obj_ptr", pytorch_object_ptr_h_reduced::handle_from_obj_ptr);
+
     // test_bool
     m.def("get_bool", [] { return py::bool_(false); });
     // test_int

tests/test_pytypes.py

@@ -9,6 +9,10 @@
 from pybind11_tests import pytypes as m
 
 
+def test_handle_from_pytorch_obj_ptr():
+    assert m.handle_from_pytorch_obj_ptr()
+
+
 def test_bool(doc):
     assert doc(m.get_bool) == "get_bool() -> bool"