Throw earlier PyErr instead of throwing cast_error (#1137)

Author: hpkfft

docs/api_core.rst

@@ -1610,7 +1610,10 @@ Casting
    When the `convert` argument is set to ``true`` (the default), the
    implementation may also attempt *implicit conversions* to perform the cast.
 
-   The function raises a :cpp:type:`cast_error` when the conversion fails.
+   The function raises an exception when the conversion fails.
+   If the type caster uses the CPython error API (e.g., ``PyErr_SetString()``
+   or ``PyErr_Format()``) to report a failure, then :cpp:class:`python_error`
+   is raised.  Otherwise, :cpp:type:`cast_error` is raised.
    See :cpp:func:`try_cast()` for an alternative that never raises.
 
 .. cpp:function:: template <typename T, typename Derived> bool try_cast(const detail::api<Derived> &value, T &out, bool convert = true) noexcept
@@ -1632,7 +1635,10 @@ Casting
    policy `policy` is used to handle ownership-related questions when a new
    Python object must be created.
 
-   The function raises a :cpp:type:`cast_error` when the conversion fails.
+   The function raises an exception when the conversion fails.
+   If the type caster uses the CPython error API (e.g., ``PyErr_SetString()``
+   or ``PyErr_Format()``) to report a failure, then :cpp:class:`python_error`
+   is raised.  Otherwise, :cpp:type:`cast_error` is raised.
 
 .. cpp:function:: template <typename T> object cast(T &&value, rv_policy policy, handle parent)
 
@@ -1641,7 +1647,10 @@ Casting
    Python object must be created. A valid `parent` object is required when
    specifying a `reference_internal` return value policy.
 
-   The function raises a :cpp:type:`cast_error` when the conversion fails.
+   The function raises an exception when the conversion fails.
+   If the type caster uses the CPython error API (e.g., ``PyErr_SetString()``
+   or ``PyErr_Format()``) to report a failure, then :cpp:class:`python_error`
+   is raised.  Otherwise, :cpp:type:`cast_error` is raised.
 
 .. cpp:function:: template <typename T> object find(const T &value) noexcept
 
@@ -1655,7 +1664,10 @@ Casting
    value policy `policy` is used to handle ownership-related questions when a
    new Python objects must be created.
 
-   The function raises a :cpp:type:`cast_error` when the conversion fails.
+   The function raises an exception when the conversion fails.
+   If the type caster uses the CPython error API (e.g., ``PyErr_SetString()``
+   or ``PyErr_Format()``) to report a failure, then :cpp:class:`python_error`
+   is raised.  Otherwise, :cpp:type:`cast_error` is raised.
 
 Common binding annotations
 --------------------------

docs/porting.rst

@@ -294,15 +294,16 @@ conditions caused by a conversion should instead be caught *within* the
 function body and handled as follows:
 
 - ``from_python()``: return ``false``. That's it. (Failed Python to C++
-  conversion occur all the time while dispatching calls, causing nanobind
+  conversions occur all the time while dispatching calls, causing nanobind
   to simply move to the next function overload. Dedicated error reporting would
   add undesirable overheads). In case of a severe internal error, use the
   CPython warning API (e.g., ``PyErr_Warn()``) to notify the user.
 
 - ``from_cpp()``: a failure here is more serious, since a return value of a
-  successfully evaluated cannot be converted, causing the call to fail. To
-  provide further detail, use the CPython error API (e.g., ``PyErr_Format()``)
-  and return an invalid handle (``return nb::handle();``).
+  successfully evaluated function cannot be converted, causing the call to
+  fail.  To provide further detail, use the CPython error API (e.g.,
+  ``PyErr_SetString()`` or ``PyErr_Format()``) and return an invalid handle
+  (``return nb::handle();``).
 
 The ``std::pair<T1, T2>`` type caster (`link
 <https://github.com/wjakob/nanobind/blob/master/include/nanobind/stl/pair.h>`_)

include/nanobind/nb_cast.h

@@ -573,12 +573,12 @@ T cast_impl(handle h) {
                                 ((uint8_t) cast_flags::manual),
                                 &cleanup.list);
         if (!rv)
-            detail::raise_cast_error();
+            detail::raise_python_or_cast_error();
         return caster.operator cast_t<T>();
     } else {
         rv = caster.from_python(h.ptr(), (uint8_t) cast_flags::manual, nullptr);
         if (!rv)
-            detail::raise_cast_error();
+            detail::raise_python_or_cast_error();
         return caster.operator cast_t<T>();
     }
 }
@@ -647,7 +647,7 @@ object cast(T &&value, rv_policy policy = rv_policy::automatic_reference) {
     handle h = detail::make_caster<T>::from_cpp((detail::forward_t<T>) value,
                                                 policy, nullptr);
     if (!h.is_valid())
-        detail::raise_cast_error();
+        detail::raise_python_or_cast_error();
 
     return steal(h);
 }
@@ -661,7 +661,7 @@ object cast(T &&value, rv_policy policy, handle parent) {
     cleanup.release();
 
     if (!h.is_valid())
-        detail::raise_cast_error();
+        detail::raise_python_or_cast_error();
 
     return steal(h);
 }

include/nanobind/nb_class.h

@@ -415,7 +415,7 @@ namespace detail {
                 cpp_function_def(
                     [](handle type) {
                         if (!type_check(type))
-                            detail::raise_cast_error();
+                            throw cast_error();
                         return inst_alloc(type);
                     },
                     scope(cls), name("__new__"));

include/nanobind/nb_lib.h

@@ -103,7 +103,7 @@ NB_CORE void fail(const char *fmt, ...) noexcept;
 NB_CORE void raise_next_overload_if_null(void *p);
 
 /// Raise nanobind::cast_error
-[[noreturn]] NB_CORE void raise_cast_error();
+[[noreturn]] NB_CORE void raise_python_or_cast_error();
 
 // ========================================================================
 

src/common.cpp

@@ -110,7 +110,9 @@ void raise_next_overload_if_null(void *p) {
         throw next_overload();
 }
 
-void raise_cast_error() {
+void raise_python_or_cast_error() {
+    if (PyErr_Occurred())
+        throw python_error();
     throw cast_error();
 }
 
@@ -325,7 +327,7 @@ PyObject *obj_vectorcall(PyObject *base, PyObject *const *args, size_t nargsf,
 
     if (!res) {
         if (cast_error)
-            raise_cast_error();
+            raise_python_or_cast_error();
         else if (gil_error)
             raise("nanobind::detail::obj_vectorcall(): PyGILState_Check() failure.");
         else
@@ -917,7 +919,7 @@ void property_install_static(PyObject *scope, const char *name,
 void tuple_check(PyObject *tuple, size_t nargs) {
     for (size_t i = 0; i < nargs; ++i) {
         if (!NB_TUPLE_GET_ITEM(tuple, i))
-            raise_cast_error();
+            raise_python_or_cast_error();
     }
 }
 

src/nb_ndarray.cpp

@@ -800,9 +800,8 @@ PyObject *ndarray_export(ndarray_handle *th, int framework,
                 o = module_::import_(pkg_name).attr("from_dlpack")(o);
         }
     } catch (const std::exception &e) {
-        PyErr_Format(PyExc_RuntimeError,
-                     "nanobind::detail::ndarray_export(): could not "
-                     "import ndarray: %s",
+        PyErr_Format(PyExc_TypeError,
+                     "could not export nb::ndarray: %s",
                      e.what());
         return nullptr;
     }