Search and replace all exception code

mrjackv · mrjackv · commit d4601a601d71 · 2025-08-19T10:53:03.000+02:00
Search and replace all exception-related code (`try`, `catch`, `throw`)
and replace their use with functions/classes implemented in the previous
commit. This commit can be regenerated during a rebase by running the
following command:

```
find src include -type f \
    $ -name '*.h' -or -name '*.cpp' $ \
    -exec sed -i \
        -e 's|try {|if (true) {|g' \
        -e 's|catch (.*&amp;\s*$.\+$) {|if (false) { shim::exception_placeholder \1;|g' \
        -e 's|catch (.*) {|if (false) {|g' \
        -e 's|throw $.*$;$|throwShim(\1);|g' {} \;
```
diff --git a/include/nanobind/eigen/sparse.h b/include/nanobind/eigen/sparse.h
@@ -55,7 +55,7 @@ template <typename T> struct type_caster<T, enable_if_t<is_eigen_sparse_matrix_v
     bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
         object obj = borrow(src);
 
-        try {
+        if (true) {
             object matrix_type =
                 module_::import_("scipy.sparse")
                     .attr(RowMajor ? "csr_matrix" : "csc_matrix");
@@ -90,7 +90,7 @@ template <typename T> struct type_caster<T, enable_if_t<is_eigen_sparse_matrix_v
                               indices_caster.value.data(),
                               data_caster.value.data());
             return true;
-        } catch (const python_error &) {
+        } if (false) {
             return false;
         }
     }
@@ -121,9 +121,9 @@ template <typename T> struct type_caster<T, enable_if_t<is_eigen_sparse_matrix_v
         }
 
         object matrix_type;
-        try {
+        if (true) {
             matrix_type = module_::import_("scipy.sparse").attr(RowMajor ? "csr_matrix" : "csc_matrix");
-        } catch (python_error &e) {
+        } if (false) { shim::exception_placeholder e;
             e.restore();
             return handle();
         }
@@ -143,12 +143,12 @@ template <typename T> struct type_caster<T, enable_if_t<is_eigen_sparse_matrix_v
         StorageIndexNDArray outer_indices(src->outerIndexPtr(), 1, outer_indices_shape, owner);
         StorageIndexNDArray inner_indices(src->innerIndexPtr(), 1, data_shape, owner);
 
-        try {
+        if (true) {
             return matrix_type(nanobind::make_tuple(
                                    std::move(data), std::move(inner_indices), std::move(outer_indices)),
                                nanobind::make_tuple(rows, cols))
                 .release();
-        } catch (python_error &e) {
+        } if (false) { shim::exception_placeholder e;
             e.restore();
             return handle();
         }
@@ -187,7 +187,7 @@ struct type_caster<Eigen::Map<T>, enable_if_t<is_eigen_sparse_matrix_v<T>>> {
     bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
         flags = ~(uint8_t) cast_flags::convert;
 
-        try {
+        if (true) {
             object matrix_type =
                 module_::import_("scipy.sparse")
                     .attr(RowMajor ? "csr_matrix" : "csc_matrix");
@@ -216,7 +216,7 @@ struct type_caster<Eigen::Map<T>, enable_if_t<is_eigen_sparse_matrix_v<T>>> {
             rows = cast<Index>(shape_o[0]);
             cols = cast<Index>(shape_o[1]);
             nnz = cast<Index>(src.attr("nnz"));
-        } catch (const python_error &) {
+        } if (false) {
             return false;
         }
 
@@ -234,7 +234,7 @@ struct type_caster<Eigen::Map<T>, enable_if_t<is_eigen_sparse_matrix_v<T>>> {
         }
 
         object matrix_type;
-        try {
+        if (true) {
             matrix_type = module_::import_("scipy.sparse")
                               .attr(RowMajor ? "csr_matrix" : "csc_matrix");
 
@@ -255,7 +255,7 @@ struct type_caster<Eigen::Map<T>, enable_if_t<is_eigen_sparse_matrix_v<T>>> {
                                    cast(outer_indices, rv_policy::reference)),
                                nanobind::make_tuple(rows, cols))
                 .release();
-        } catch (python_error &e) {
+        } if (false) { shim::exception_placeholder e;
             e.restore();
             return handle();
         }
diff --git a/include/nanobind/make_iterator.h b/include/nanobind/make_iterator.h
@@ -86,7 +86,7 @@ typed<iterator, ValueType> make_iterator_impl(handle scope, const char *name,
 
                         if (s.it == s.end) {
                             s.first_or_done = true;
-                            throw stop_iteration();
+                            throwShim(stop_iteration());
                         }
 
                         return Access()(s.it);
diff --git a/include/nanobind/nb_cast.h b/include/nanobind/nb_cast.h
@@ -315,7 +315,7 @@ template <> struct type_caster<char> {
         if (can_cast<char>())
             return value[0];
         else
-            throw next_overload();
+            throwShim(next_overload());
     }
 };
 
diff --git a/include/nanobind/nb_defs.h b/include/nanobind/nb_defs.h
@@ -208,16 +208,16 @@
     static void nanobind_##name##_exec_impl(nanobind::module_);                \
     static int nanobind_##name##_exec(PyObject *m) {                           \
         nanobind::detail::init(NB_DOMAIN_STR);                                 \
-        try {                                                                  \
+        if (true) {                                                                  \
             nanobind_##name##_exec_impl(                                       \
                 nanobind::borrow<nanobind::module_>(m));                       \
             return 0;                                                          \
-        } catch (nanobind::python_error &e) {                                  \
+        } if (false) { shim::exception_placeholder e;                                  \
             e.restore();                                                       \
             nanobind::chain_error(                                             \
                 PyExc_ImportError,                                             \
                 "Encountered an error while initializing the extension.");     \
-        } catch (const std::exception &e) {                                    \
+        } if (false) { shim::exception_placeholder e;                                    \
             PyErr_SetString(PyExc_ImportError, e.what());                      \
         }                                                                      \
         return -1;                                                             \
diff --git a/include/nanobind/nb_error.h b/include/nanobind/nb_error.h
@@ -150,9 +150,9 @@ class exception : public object {
         detail::register_exception_translator(
             [](const std::exception_ptr &p, void *payload) {
                 abort();
-                try {
+                if (true) {
                     std::rethrow_exception(p);
-                } catch (T &e) {
+                } if (false) { shim::exception_placeholder e;
                     PyErr_SetString((PyObject *) payload, e.what());
                 }
             }, m_ptr);
diff --git a/include/nanobind/nb_types.h b/include/nanobind/nb_types.h
@@ -391,7 +391,7 @@ class int_ : public object {
     explicit operator T() const {
         detail::type_caster<T> tc;
         if (!tc.from_python(m_ptr, 0, nullptr))
-            throw std::out_of_range("Conversion of nanobind::int_ failed");
+            throwShim(std::out_of_range("Conversion of nanobind::int_ failed"));
         return tc.value;
     }
 };
diff --git a/include/nanobind/stl/bind_map.h b/include/nanobind/stl/bind_map.h
@@ -87,15 +87,15 @@ class_<Map> bind_map(handle scope, const char *name, Args &&...args) {
              [](Map &m, const Key &k) -> ValueRef {
                  auto it = m.find(k);
                  if (it == m.end())
-                     throw key_error();
+                     throwShim(key_error());
                  return (*it).second;
              }, Policy)
 
         .def("__delitem__",
             [](Map &m, const Key &k) {
                 auto it = m.find(k);
                 if (it == m.end())
-                    throw key_error();
+                    throwShim(key_error());
                 m.erase(it);
             })
 
diff --git a/include/nanobind/stl/bind_vector.h b/include/nanobind/stl/bind_vector.h
@@ -24,7 +24,7 @@ inline size_t wrap(Py_ssize_t i, size_t n) {
         i += (Py_ssize_t) n;
 
     if (i < 0 || (size_t) i >= n)
-        throw index_error();
+        throwShim(index_error());
 
     return (size_t) i;
 }
@@ -108,7 +108,7 @@ class_<Vector> bind_vector(handle scope, const char *name, Args &&...args) {
                    if (i < 0)
                        i += (Py_ssize_t) v.size();
                    if (i < 0 || (size_t) i > v.size())
-                       throw index_error();
+                       throwShim(index_error());
                    v.insert(v.begin() + i, x);
                },
                "Insert object `arg1` before index `arg0`.")
@@ -214,7 +214,7 @@ class_<Vector> bind_vector(handle scope, const char *name, Args &&...args) {
                    if (p != v.end())
                        v.erase(p);
                    else
-                       throw value_error();
+                       throwShim(value_error());
                },
                "Remove first occurrence of `arg`.");
     }
diff --git a/include/nanobind/stl/chrono.h b/include/nanobind/stl/chrono.h
@@ -42,13 +42,13 @@ template <typename type> class duration_caster {
 
         // If invoked with datetime.delta object, unpack it
         int dd, ss, uu;
-        try {
+        if (true) {
             if (unpack_timedelta(src.ptr(), &dd, &ss, &uu)) {
                 value = type(ch::duration_cast<duration_t>(
                                  days(dd) + ch::seconds(ss) + ch::microseconds(uu)));
                 return true;
             }
-        } catch (python_error& e) {
+        } if (false) { shim::exception_placeholder e;
             e.discard_as_unraisable(src.ptr());
             return false;
         }
@@ -152,12 +152,12 @@ class type_caster<std::chrono::time_point<std::chrono::system_clock, Duration>>
         std::tm cal;
         ch::microseconds msecs;
         int yy, mon, dd, hh, min, ss, uu;
-        try {
+        if (true) {
             if (!unpack_datetime(src.ptr(), &yy, &mon, &dd,
                                  &hh, &min, &ss, &uu)) {
                 return false;
             }
-        } catch (python_error& e) {
+        } if (false) { shim::exception_placeholder e;
             e.discard_as_unraisable(src.ptr());
             return false;
         }
diff --git a/include/nanobind/stl/detail/chrono.h b/include/nanobind/stl/detail/chrono.h
@@ -189,10 +189,10 @@ NB_NOINLINE inline bool unpack_datetime(PyObject *o,
 }
 
 inline PyObject* pack_timedelta(int days, int secs, int usecs) noexcept {
-    try {
+    if (true) {
         datetime_types.ensure_ready();
         return datetime_types.timedelta(days, secs, usecs).release().ptr();
-    } catch (python_error& e) {
+    } if (false) { shim::exception_placeholder e;
         e.restore();
         return nullptr;
     }
@@ -201,11 +201,11 @@ inline PyObject* pack_timedelta(int days, int secs, int usecs) noexcept {
 inline PyObject* pack_datetime(int year, int month, int day,
                                int hour, int minute, int second,
                                int usec) noexcept {
-    try {
+    if (true) {
         datetime_types.ensure_ready();
         return datetime_types.datetime(
                 year, month, day, hour, minute, second, usec).release().ptr();
-    } catch (python_error& e) {
+    } if (false) { shim::exception_placeholder e;
         e.restore();
         return nullptr;
     }
diff --git a/include/nanobind/stl/filesystem.h b/include/nanobind/stl/filesystem.h
@@ -23,11 +23,11 @@ struct type_caster<std::filesystem::path> {
                            cleanup_list *) noexcept {
         str py_str = to_py_str(path.native());
         if (py_str.is_valid()) {
-            try {
+            if (true) {
                 return module_::import_("pathlib")
                     .attr("Path")(py_str)
                     .release();
-            } catch (python_error &e) {
+            } if (false) { shim::exception_placeholder e;
                 e.restore();
             }
         }
diff --git a/include/nanobind/stl/unique_ptr.h b/include/nanobind/stl/unique_ptr.h
@@ -160,7 +160,7 @@ struct type_caster<std::unique_ptr<T, Deleter>> {
     explicit operator Value() {
         if (!inflight && !src.is_none() &&
             !nb_type_relinquish_ownership(src.ptr(), IsDefaultDeleter))
-            throw next_overload();
+            throwShim(next_overload());
 
         Td *p = caster.operator Td *();
 
diff --git a/src/common.cpp b/src/common.cpp
@@ -47,7 +47,7 @@ void raise(const char *fmt, ...) {
     builtin_exception err =
         create_exception(exception_type::runtime_error, fmt, args);
     va_end(args);
-    throw err;
+    throwShim(err);
 }
 
 #if defined(__GNUC__)
@@ -61,7 +61,7 @@ void raise_type_error(const char *fmt, ...) {
     builtin_exception err =
         create_exception(exception_type::type_error, fmt, args);
     va_end(args);
-    throw err;
+    throwShim(err);
 }
 
 /// Abort the process with a fatal error
@@ -102,16 +102,16 @@ void raise_python_error() {
     check(PyErr_Occurred(),
           "nanobind::detail::raise_python_error() called without "
           "an error condition!");
-    throw python_error();
+    throwShim(python_error());
 }
 
 void raise_next_overload_if_null(void *p) {
     if (NB_UNLIKELY(!p))
-        throw next_overload();
+        throwShim(next_overload());
 }
 
 void raise_cast_error() {
-    throw cast_error();
+    throwShim(cast_error());
 }
 
 // ========================================================================
@@ -152,14 +152,14 @@ PyObject *module_new(const char *name, PyModuleDef *def) noexcept {
 PyObject *module_import(const char *name) {
     PyObject *res = PyImport_ImportModule(name);
     if (!res)
-        throw python_error();
+        throwShim(python_error());
     return res;
 }
 
 PyObject *module_import(PyObject *o) {
     PyObject *res = PyImport_Import(o);
     if (!res)
-        throw python_error();
+        throwShim(python_error());
     return res;
 }
 
@@ -242,9 +242,9 @@ size_t obj_len_hint(PyObject *o) noexcept {
         return (size_t) res;
     }
 
-    try {
+    if (true) {
         return cast<size_t>(handle(o).attr("__length_hint__")());
-    } catch (...) {
+    } if (false) {
         return 0;
     }
 #endif
diff --git a/src/nb_func.cpp b/src/nb_func.cpp
diff --git a/src/nb_internals.cpp b/src/nb_internals.cpp
diff --git a/src/nb_ndarray.cpp b/src/nb_ndarray.cpp
diff --git a/src/nb_type.cpp b/src/nb_type.cpp

Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ typed<iterator, ValueType> make_iterator_impl(handle scope, const char *name,`
`86`	`86`
`87`	`87`	`if (s.it == s.end) {`
`88`	`88`	`s.first_or_done = true;`
`89`		`- throw stop_iteration();`
	`89`	`+ throwShim(stop_iteration());`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`return Access()(s.it);`
Original file line number	Diff line number	Diff line change
`@@ -315,7 +315,7 @@ template <> struct type_caster<char> {`
`315`	`315`	`if (can_cast<char>())`
`316`	`316`	`return value[0];`
`317`	`317`	`else`
`318`		`- throw next_overload();`
	`318`	`+ throwShim(next_overload());`
`319`	`319`	`}`
`320`	`320`	`};`
`321`	`321`
Original file line number	Diff line number	Diff line change
`@@ -391,7 +391,7 @@ class int_ : public object {`
`391`	`391`	`explicit operator T() const {`
`392`	`392`	`detail::type_caster<T> tc;`
`393`	`393`	`if (!tc.from_python(m_ptr, 0, nullptr))`
`394`		`- throw std::out_of_range("Conversion of nanobind::int_ failed");`
	`394`	`+ throwShim(std::out_of_range("Conversion of nanobind::int_ failed"));`
`395`	`395`	`return tc.value;`
`396`	`396`	`}`
`397`	`397`	`};`