error_already_set::what() is now constructed lazily

.github/workflows/ci.yml

@@ -402,7 +402,8 @@ jobs:
                             -DCMAKE_CXX_STANDARD=11 \
                             -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") \
                             -DCMAKE_CXX_FLAGS="-Wc,--pending_instantiations=0" \
-                            -DPYBIND11_TEST_FILTER="test_smart_ptr.cpp;test_virtual_functions.cpp"
+                            -DPYBIND11_TEST_FILTER="test_smart_ptr.cpp;test_virtual_functions.cpp" \
+                            -DCMAKE_BUILD_TYPE=Debug
 
     # Building before installing Pip should produce a warning but not an error
     - name: Build

include/pybind11/detail/type_caster_base.h

@@ -469,40 +469,30 @@ PYBIND11_NOINLINE bool isinstance_generic(handle obj, const std::type_info &tp)
     return isinstance(obj, type);
 }
 
-PYBIND11_NOINLINE std::string error_string() {
-    if (!PyErr_Occurred()) {
+PYBIND11_NOINLINE std::string error_string(PyObject *type, PyObject *value, PyObject *trace) {
+    if (!type) {
         PyErr_SetString(PyExc_RuntimeError, "Unknown internal error occurred");
         return "Unknown internal error occurred";
     }
 
-    error_scope scope; // Preserve error state
-
-    std::string errorString;
-    if (scope.type) {
-        errorString += handle(scope.type).attr("__name__").cast<std::string>();
-        errorString += ": ";
-    }
-    if (scope.value) {
-        errorString += (std::string) str(scope.value);
-    }
-
-    PyErr_NormalizeException(&scope.type, &scope.value, &scope.trace);
+    auto result = handle(type).attr("__name__").cast<std::string>();
+    result += ": ";
 
-    if (scope.trace != nullptr) {
-        PyException_SetTraceback(scope.value, scope.trace);
+    if (value) {
+        result += str(value).cast<std::string>();
     }
 
+    if (trace) {
 #if !defined(PYPY_VERSION)
-    if (scope.trace) {
-        auto *trace = (PyTracebackObject *) scope.trace;
+        auto *tb = (PyTracebackObject *) trace;
 
-        /* Get the deepest trace possible */
-        while (trace->tb_next) {
-            trace = trace->tb_next;
+        // Get the deepest trace possible.
+        while (tb->tb_next) {
+            tb = tb->tb_next;
         }
 
-        PyFrameObject *frame = trace->tb_frame;
-        errorString += "\n\nAt:\n";
+        PyFrameObject *frame = tb->tb_frame;
+        result += "\n\nAt:\n";
         while (frame) {
 #    if PY_VERSION_HEX >= 0x03090000
             PyCodeObject *f_code = PyFrame_GetCode(frame);
@@ -511,16 +501,24 @@ PYBIND11_NOINLINE std::string error_string() {
             Py_INCREF(f_code);
 #    endif
             int lineno = PyFrame_GetLineNumber(frame);
-            errorString += "  " + handle(f_code->co_filename).cast<std::string>() + "("
-                           + std::to_string(lineno)
-                           + "): " + handle(f_code->co_name).cast<std::string>() + "\n";
+            result += std::string("  ") + handle(f_code->co_filename).cast<std::string>() + '('
+                      + std::to_string(lineno)
+                      + "): " + handle(f_code->co_name).cast<std::string>() + '\n';
             frame = frame->f_back;
             Py_DECREF(f_code);
         }
-    }
 #endif
+    }
+
+    return result;
+}
 
-    return errorString;
+PYBIND11_NOINLINE std::string error_string() {
+    error_scope scope; // Preserve error state.
+    if (scope.type) {
+        PyErr_NormalizeException(&scope.type, &scope.value, &scope.trace);
+    }
+    return error_string(scope.type, scope.value, scope.trace);
 }
 
 PYBIND11_NOINLINE handle get_object_handle(const void *ptr, const detail::type_info *type) {

include/pybind11/pytypes.h

@@ -364,6 +364,7 @@ T reinterpret_steal(handle h) {
 
 PYBIND11_NAMESPACE_BEGIN(detail)
 std::string error_string();
+std::string error_string(PyObject *, PyObject *, PyObject *);
 PYBIND11_NAMESPACE_END(detail)
 
 #if defined(_MSC_VER)
@@ -380,20 +381,38 @@ class PYBIND11_EXPORT_EXCEPTION error_already_set : public std::runtime_error {
 public:
     /// Constructs a new exception from the current Python error indicator, if any.  The current
     /// Python error indicator will be cleared.
-    error_already_set() : std::runtime_error(detail::error_string()) {
+    error_already_set() : std::runtime_error(""), m_lazy_what() {
         PyErr_Fetch(&m_type.ptr(), &m_value.ptr(), &m_trace.ptr());
+        if (m_type) {
+            PyErr_NormalizeException(&m_type.ptr(), &m_value.ptr(), &m_trace.ptr());
+        }
     }
 
     error_already_set(const error_already_set &) = default;
     error_already_set(error_already_set &&) = default;
 
     inline ~error_already_set() override;
 
+    const char *what() const noexcept override {
+        if (m_lazy_what.empty()) {
+            try {
+                m_lazy_what = detail::error_string(m_type.ptr(), m_value.ptr(), m_trace.ptr());
+            } catch (...) {
+                return "Unknown internal error occurred";
+            }
+        }
+        return m_lazy_what.c_str();
+    }
+
     /// Give the currently-held error back to Python, if any.  If there is currently a Python error
     /// already set it is cleared first.  After this call, the current object no longer stores the
     /// error variables (but the `.what()` string is still available).
     void restore() {
-        PyErr_Restore(m_type.release().ptr(), m_value.release().ptr(), m_trace.release().ptr());
+        what(); // Force-build `.what()`.
+        if (m_type) {
+            PyErr_Restore(
+                m_type.release().ptr(), m_value.release().ptr(), m_trace.release().ptr());
+        }
     }
 
     /// If it is impossible to raise the currently-held error, such as in a destructor, we can
@@ -428,7 +447,8 @@ class PYBIND11_EXPORT_EXCEPTION error_already_set : public std::runtime_error {
     const object &trace() const { return m_trace; }
 
 private:
-    object m_type, m_value, m_trace;
+    mutable std::string m_lazy_what;
+    mutable object m_type, m_value, m_trace;
 };
 #if defined(_MSC_VER)
 #    pragma warning(pop)