fix: only add string_view life support for transient sources

Refine the previous commit. Best-effort registration (try_add_patient)
silently produces a dangling view when a container of views is built from
a generator outside a bound function: there the materialized temporary is
released before the view is used, and with no frame nothing keeps it
alive. Such a cast cannot be made safe, so it should fail loudly, while a
view into a durable, caller-owned object needs no life support at all.

The view caster cannot tell a durable source from a pybind11-managed
transient one; that provenance lives in the container caster. Introduce an
ambient transient_source_guard that the list, set, map, and array casters
set around their generator/materialized paths, and have the string caster
keep the source alive only when loading from a transient source (via the
throwing add_patient, so try_add_patient is no longer needed). This means:

- views into durable sources (direct arguments, sequences, manual casts)
  add no life support and no longer throw outside a bound function, and
- a generator used outside a frame throws, rather than silently dangling.

The guard restores (rather than clears) the previous value, so a durable
container nested in a transient one is correctly treated as transient.

Verified with AddressSanitizer: the in-frame generator case is clean, the
out-of-frame durable cases succeed, and the out-of-frame generator case
throws.

Assisted-by: ClaudeCode:claude-opus-4.8

Author: henryiii

include/pybind11/cast.h

@@ -525,10 +525,10 @@ struct string_caster {
                 return false;
             }
             value = StringType(buffer, static_cast<size_t>(size));
-            if (IsView) {
-                // `src` owns the buffer; keep it alive if inside a bound function,
-                // otherwise the caller is responsible for its lifetime.
-                loader_life_support::try_add_patient(src);
+            if (IsView && loading_from_transient_source()) {
+                // The view points into `src`, which is owned by a transient source that
+                // will be released before the view is used, so keep `src` alive.
+                loader_life_support::add_patient(src);
             }
             return true;
         }
@@ -607,8 +607,8 @@ struct string_caster {
                 pybind11_fail("Unexpected PYBIND11_BYTES_AS_STRING() failure.");
             }
             value = StringType(bytes, (size_t) PYBIND11_BYTES_SIZE(src.ptr()));
-            if (IsView) {
-                loader_life_support::try_add_patient(src);
+            if (IsView && loading_from_transient_source()) {
+                loader_life_support::add_patient(src);
             }
             return true;
         }
@@ -620,8 +620,8 @@ struct string_caster {
                 pybind11_fail("Unexpected PyByteArray_AsString() failure.");
             }
             value = StringType(bytearray, (size_t) PyByteArray_Size(src.ptr()));
-            if (IsView) {
-                loader_life_support::try_add_patient(src);
+            if (IsView && loading_from_transient_source()) {
+                loader_life_support::add_patient(src);
             }
             return true;
         }

include/pybind11/detail/type_caster_base.h

@@ -81,26 +81,11 @@ class loader_life_support {
         }
     }
 
-    /// Keep `h` alive until the current patient frame is destroyed, if there is one.
-    /// Returns false when called outside a bound function (no frame). Use this, rather
-    /// than `add_patient`, when failing to register is acceptable because the caller
-    /// owns the source's lifetime outside the call framework (e.g. a view that points
-    /// into an existing Python object, as opposed to a freshly created temporary).
-    PYBIND11_NOINLINE static bool try_add_patient(handle h) {
-        loader_life_support *frame = tls_current_frame();
-        if (!frame) {
-            return false;
-        }
-        if (frame->keep_alive.insert(h.ptr()).second) {
-            Py_INCREF(h.ptr());
-        }
-        return true;
-    }
-
     /// This can only be used inside a pybind11-bound function, either by `argument_loader`
     /// at argument preparation time or by `py::cast()` at execution time.
     PYBIND11_NOINLINE static void add_patient(handle h) {
-        if (!try_add_patient(h)) {
+        loader_life_support *frame = tls_current_frame();
+        if (!frame) {
             // NOTE: It would be nice to include the stack frames here, as this indicates
             // use of pybind11::cast<> outside the normal call framework, finding such
             // a location is challenging. Developers could consider printing out
@@ -109,7 +94,39 @@ class loader_life_support {
                              "do Python -> C++ conversions which require the creation "
                              "of temporary values");
         }
+
+        if (frame->keep_alive.insert(h.ptr()).second) {
+            Py_INCREF(h.ptr());
+        }
+    }
+};
+
+// While set, a type caster is converting elements borrowed from a *transient* source --
+// a generator/iterator, or a temporary container materialized from one -- whose items are
+// released before the converted C++ value is used. A view caster (e.g. for std::string_view)
+// consults this to decide whether the viewed Python object needs life support: a view into a
+// durable, caller-owned object does not, whereas a view into a transient source does. Outside
+// a bound function (no life support frame) the latter cannot be made safe, so `add_patient`
+// rightly throws rather than producing a dangling view.
+inline bool &loading_from_transient_source() {
+    static thread_local bool flag = false;
+    return flag;
+}
+
+// RAII guard marking the dynamic scope in which elements are loaded from a transient source.
+// Restores (rather than clears) the previous value so that nesting is transitive: a durable
+// container nested inside a transient one is itself transient.
+class transient_source_guard {
+public:
+    transient_source_guard() : prev(loading_from_transient_source()) {
+        loading_from_transient_source() = true;
     }
+    ~transient_source_guard() { loading_from_transient_source() = prev; }
+    transient_source_guard(const transient_source_guard &) = delete;
+    transient_source_guard &operator=(const transient_source_guard &) = delete;
+
+private:
+    bool prev;
 };
 
 // Gets the cache entry for the given type, creating it if necessary.  The return value is the pair

include/pybind11/stl.h

@@ -198,6 +198,9 @@ struct set_caster {
         }
         assert(isinstance<iterable>(src));
         value.clear();
+        // Elements are borrowed from the iterator and released as it advances, so views
+        // into them need life support.
+        transient_source_guard guard;
         return convert_iterable(reinterpret_borrow<iterable>(src), convert);
     }
 
@@ -264,6 +267,9 @@ struct map_caster {
             throw error_already_set();
         }
         assert(isinstance<iterable>(items));
+        // The materialized dict is transient (released when load() returns), so views into
+        // its keys/values need life support.
+        transient_source_guard guard;
         return convert_elements(dict(reinterpret_borrow<iterable>(items)), convert);
     }
 
@@ -314,6 +320,9 @@ struct list_caster {
         // the generator is not left in an unpredictable (to the caller) partially-consumed
         // state.
         assert(isinstance<iterable>(src));
+        // The materialized tuple is transient (released when load() returns), so views into
+        // its elements need life support.
+        transient_source_guard guard;
         return convert_elements(tuple(reinterpret_borrow<iterable>(src)), convert);
     }
 
@@ -449,6 +458,9 @@ struct array_caster {
         // the generator is not left in an unpredictable (to the caller) partially-consumed
         // state.
         assert(isinstance<iterable>(src));
+        // The materialized tuple is transient (released when load() returns), so views into
+        // its elements need life support.
+        transient_source_guard guard;
         return convert_elements(tuple(reinterpret_borrow<iterable>(src)), convert);
     }
 

tests/test_with_catch/test_interpreter.cpp

@@ -1,5 +1,6 @@
 #include <pybind11/critical_section.h>
 #include <pybind11/embed.h>
+#include <pybind11/stl.h>
 
 // Silence MSVC C++17 deprecation warning from Catch regarding std::uncaught_exceptions (up to
 // catch 2.0.1; this should be fixed in the next catch release after 2.0.1).
@@ -11,8 +12,10 @@ PYBIND11_WARNING_DISABLE_MSVC(4996)
 #include <cstdlib>
 #include <fstream>
 #include <functional>
+#include <string_view>
 #include <thread>
 #include <utility>
+#include <vector>
 
 namespace py = pybind11;
 using namespace py::literals;
@@ -511,10 +514,10 @@ TEST_CASE("make_iterator can be called before then after finalizing an interpret
 }
 
 #ifdef PYBIND11_HAS_STRING_VIEW
-TEST_CASE("Casting to a string_view outside a bound function") {
-    // Regression for PR #6092: view casters add the source to loader_life_support, but
-    // outside a bound function there is no frame. The caller owns the source's lifetime
-    // here, so the cast must succeed rather than throw.
+TEST_CASE("Casting to a string_view from a durable source outside a bound function") {
+    // Outside a bound function there is no loader_life_support frame. When the source is a
+    // durable, caller-owned object the view does not need life support, so the cast must
+    // succeed rather than throw (regression from PR #6092).
     py::str unicode("hello");
     py::bytes bytes_obj("world", 5);
     auto bytearray_obj
@@ -523,5 +526,22 @@ TEST_CASE("Casting to a string_view outside a bound function") {
     REQUIRE(py::cast<std::string_view>(unicode) == "hello");
     REQUIRE(py::cast<std::string_view>(bytes_obj) == "world");
     REQUIRE(py::cast<std::string_view>(bytearray_obj) == "bytes");
+
+    // A list is durable too: the views point into elements the list keeps alive.
+    py::list durable;
+    durable.append("a");
+    durable.append("b");
+    auto from_list = py::cast<std::vector<std::string_view>>(durable);
+    REQUIRE(from_list.size() == 2);
+    REQUIRE(from_list[0] == "a");
+    REQUIRE(from_list[1] == "b");
+}
+
+TEST_CASE("Casting to a string_view from a transient source outside a bound function") {
+    // A generator is a transient source: the materialized temporary backing the views is
+    // released when the cast returns, and there is no frame to keep it alive. This cannot
+    // be made safe, so it must throw rather than produce dangling views.
+    auto gen = py::eval("('transient_' + str(x) for x in range(5))");
+    REQUIRE_THROWS_AS(py::cast<std::vector<std::string_view>>(gen), py::cast_error);
 }
 #endif