From dcc440bb931b1838fac58e8ce53e1e2e88855964 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 17 Nov 2020 12:19:19 -0800
Subject: [PATCH 001/206] Adding test_unique_ptr_member (for desired PyCLIF
 behavior).

See also: https://github.com/pybind/pybind11/issues/2583

Does not build with upstream master or
https://github.com/pybind/pybind11/pull/2047, but builds with
https://github.com/RobotLocomotion/pybind11 and almost runs:

```
Running tests in directory "/usr/local/google/home/rwgk/forked/EricCousineau-TRI/pybind11/tests":
================================================================================= test session starts =================================================================================
platform linux -- Python 3.8.5, pytest-5.4.3, py-1.9.0, pluggy-0.13.1
rootdir: /usr/local/google/home/rwgk/forked/EricCousineau-TRI/pybind11/tests, inifile: pytest.ini
collected 2 items

test_unique_ptr_member.py .F                                                                                                                                                    [100%]

====================================================================================== FAILURES =======================================================================================
_____________________________________________________________________________ test_pointee_and_ptr_owner ______________________________________________________________________________

    def test_pointee_and_ptr_owner():
        obj = m.pointee()
        assert obj.get_int() == 213
        m.ptr_owner(obj)
        with pytest.raises(ValueError) as exc_info:
>           obj.get_int()
E           Failed: DID NOT RAISE <class 'ValueError'>

test_unique_ptr_member.py:17: Failed
============================================================================= 1 failed, 1 passed in 0.06s =============================================================================
```
---
 tests/test_unique_ptr_member.cpp | 53 ++++++++++++++++++++++++++++++++
 tests/test_unique_ptr_member.py  | 18 +++++++++++
 2 files changed, 71 insertions(+)
 create mode 100644 tests/test_unique_ptr_member.cpp
 create mode 100644 tests/test_unique_ptr_member.py

diff --git a/tests/test_unique_ptr_member.cpp b/tests/test_unique_ptr_member.cpp
new file mode 100644
index 0000000000..96edf77c52
--- /dev/null
+++ b/tests/test_unique_ptr_member.cpp
@@ -0,0 +1,53 @@
+#include "pybind11_tests.h"
+
+#include <memory>
+
+namespace pybind11_tests {
+namespace unique_ptr_member {
+
+class pointee { // NOT copyable.
+  public:
+    pointee() = default;
+
+    int get_int() const { return 213; }
+
+  private:
+    pointee(const pointee &) = delete;
+    pointee(pointee &&) = delete;
+    pointee &operator=(const pointee &) = delete;
+    pointee &operator=(pointee &&) = delete;
+};
+
+class ptr_owner {
+  public:
+    explicit ptr_owner(std::unique_ptr<pointee> ptr) : ptr_(std::move(ptr)) {}
+
+  private:
+    std::unique_ptr<pointee> ptr_;
+};
+
+// Just to have a minimal example of a typical C++ pattern.
+inline int cpp_pattern() {
+    auto obj = std::unique_ptr<pointee>(new pointee);
+    int result = (obj ? 10 : 0);
+    ptr_owner owner(std::move(obj));
+    result += (obj ? 1 : 0);
+    return result;
+}
+
+TEST_SUBMODULE(unique_ptr_member, m) {
+    m.def("cpp_pattern", cpp_pattern);
+
+    py::class_<pointee>(m, "pointee")
+        .def(py::init<>())
+        .def("get_int", &pointee::get_int);
+
+    py::class_<ptr_owner>(m, "ptr_owner")
+#ifdef FEAT_UNIQUE_PTR_ARG
+        .def(py::init<std::unique_ptr<pointee>>(), py::arg("ptr"))
+#endif
+        ;
+}
+
+} // namespace unique_ptr_member
+} // namespace pybind11_tests
diff --git a/tests/test_unique_ptr_member.py b/tests/test_unique_ptr_member.py
new file mode 100644
index 0000000000..121b8ef051
--- /dev/null
+++ b/tests/test_unique_ptr_member.py
@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+from pybind11_tests import unique_ptr_member as m
+
+
+def test_cpp_pattern():
+    res = m.cpp_pattern()
+    assert res == 10
+
+
+def test_pointee_and_ptr_owner():
+    obj = m.pointee()
+    assert obj.get_int() == 213
+    m.ptr_owner(obj)
+    with pytest.raises(ValueError) as exc_info:
+        obj.get_int()
+    assert str(exc_info.value).startswith("Missing value for wrapped C++ type ")

From e96a1863a4769183d637a584936c124125fba6af Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 19 Nov 2020 18:33:37 -0800
Subject: [PATCH 002/206] unique_ptr or shared_ptr return

---
 tests/test_unique_ptr_member.cpp | 57 ++++++++++++++++++++++++++------
 tests/test_unique_ptr_member.py  | 32 ++++++++++++++----
 2 files changed, 73 insertions(+), 16 deletions(-)

diff --git a/tests/test_unique_ptr_member.cpp b/tests/test_unique_ptr_member.cpp
index 96edf77c52..316dac44e5 100644
--- a/tests/test_unique_ptr_member.cpp
+++ b/tests/test_unique_ptr_member.cpp
@@ -1,15 +1,23 @@
 #include "pybind11_tests.h"
 
+#include <iostream>
 #include <memory>
 
 namespace pybind11_tests {
 namespace unique_ptr_member {
 
+inline void to_cout(std::string text) { std::cout << text << std::endl; }
+
 class pointee { // NOT copyable.
   public:
     pointee() = default;
 
-    int get_int() const { return 213; }
+    int get_int() const {
+        to_cout("pointee::get_int()");
+        return 213;
+    }
+
+    ~pointee() { to_cout("~pointee()"); }
 
   private:
     pointee(const pointee &) = delete;
@@ -18,35 +26,64 @@ class pointee { // NOT copyable.
     pointee &operator=(pointee &&) = delete;
 };
 
+inline std::unique_ptr<pointee> make_unique_pointee() {
+    return std::unique_ptr<pointee>(new pointee);
+}
+
 class ptr_owner {
   public:
     explicit ptr_owner(std::unique_ptr<pointee> ptr) : ptr_(std::move(ptr)) {}
 
+    bool is_owner() const { return bool(ptr_); }
+
+    std::unique_ptr<pointee> give_up_ownership_via_unique_ptr() {
+        return std::move(ptr_);
+    }
+    std::shared_ptr<pointee> give_up_ownership_via_shared_ptr() {
+        return std::move(ptr_);
+    }
+
   private:
     std::unique_ptr<pointee> ptr_;
 };
 
 // Just to have a minimal example of a typical C++ pattern.
 inline int cpp_pattern() {
-    auto obj = std::unique_ptr<pointee>(new pointee);
-    int result = (obj ? 10 : 0);
+    auto obj = make_unique_pointee();
+    int result = (obj ? 1 : 8);
+    obj->get_int();
     ptr_owner owner(std::move(obj));
-    result += (obj ? 1 : 0);
+    result = result * 10 + (obj ? 8 : 1);
+    result = result * 10 + (owner.is_owner() ? 1 : 8);
+    to_cout("before give up");
+    auto reclaimed = owner.give_up_ownership_via_shared_ptr();
+    to_cout("after give up");
+    result = result * 10 + (owner.is_owner() ? 8 : 1);
+    result = result * 10 + (reclaimed ? 1 : 8);
+    reclaimed.reset();
+    to_cout("after del");
+    result = result * 10 + (reclaimed ? 8 : 1);
     return result;
 }
 
 TEST_SUBMODULE(unique_ptr_member, m) {
-    m.def("cpp_pattern", cpp_pattern);
+    m.def("to_cout", to_cout);
 
-    py::class_<pointee>(m, "pointee")
+    py::class_<pointee, std::shared_ptr<pointee>>(m, "pointee")
         .def(py::init<>())
         .def("get_int", &pointee::get_int);
 
+    m.def("make_unique_pointee", make_unique_pointee);
+
     py::class_<ptr_owner>(m, "ptr_owner")
-#ifdef FEAT_UNIQUE_PTR_ARG
-        .def(py::init<std::unique_ptr<pointee>>(), py::arg("ptr"))
-#endif
-        ;
+        //.def(py::init<std::unique_ptr<pointee>>(), py::arg("ptr"))
+        .def("is_owner", &ptr_owner::is_owner)
+        .def("give_up_ownership_via_unique_ptr",
+             &ptr_owner::give_up_ownership_via_unique_ptr)
+        .def("give_up_ownership_via_shared_ptr",
+             &ptr_owner::give_up_ownership_via_shared_ptr);
+
+    m.def("cpp_pattern", cpp_pattern);
 }
 
 } // namespace unique_ptr_member
diff --git a/tests/test_unique_ptr_member.py b/tests/test_unique_ptr_member.py
index 121b8ef051..85b07f6099 100644
--- a/tests/test_unique_ptr_member.py
+++ b/tests/test_unique_ptr_member.py
@@ -4,15 +4,35 @@
 from pybind11_tests import unique_ptr_member as m
 
 
-def test_cpp_pattern():
-    res = m.cpp_pattern()
-    assert res == 10
+def test_make_unique_pointee():
+    m.to_cout("")
+    obj = m.make_unique_pointee()
+    assert obj.get_int() == 213
+    m.to_cout("")
 
 
 def test_pointee_and_ptr_owner():
+    m.to_cout("")
     obj = m.pointee()
     assert obj.get_int() == 213
-    m.ptr_owner(obj)
-    with pytest.raises(ValueError) as exc_info:
+    owner = m.ptr_owner(obj)
+    with pytest.raises(RuntimeError) as exc_info:
         obj.get_int()
-    assert str(exc_info.value).startswith("Missing value for wrapped C++ type ")
+    assert str(exc_info.value) == "Invalid object instance"
+    assert owner.is_owner()
+    m.to_cout("before give up")
+    reclaimed = owner.give_up_ownership_via_shared_ptr()
+    m.to_cout("after give up")
+    assert not owner.is_owner()
+    # assert reclaimed.get_int() == 213
+    del reclaimed
+    m.to_cout("after del")
+    m.to_cout("3")
+    m.to_cout("")
+
+
+def test_cpp_pattern():
+    m.to_cout("")
+    res = m.cpp_pattern()
+    assert res == 111111
+    m.to_cout("")

From cd1f6101b80ed36b222163a1ef81ecfc3a8a2109 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 19 Nov 2020 21:51:11 -0800
Subject: [PATCH 003/206] new test_variant_unique_shared with vptr_holder
 prototype

---
 tests/test_variant_unique_shared.cpp | 101 +++++++++++++++++++++++++++
 tests/test_variant_unique_shared.py  |  50 +++++++++++++
 2 files changed, 151 insertions(+)
 create mode 100644 tests/test_variant_unique_shared.cpp
 create mode 100644 tests/test_variant_unique_shared.py

diff --git a/tests/test_variant_unique_shared.cpp b/tests/test_variant_unique_shared.cpp
new file mode 100644
index 0000000000..7d7f0c9456
--- /dev/null
+++ b/tests/test_variant_unique_shared.cpp
@@ -0,0 +1,101 @@
+#include <memory>
+#include <variant>
+
+#include "pybind11_tests.h"
+
+namespace pybind11_tests {
+
+// Could this be a holder for a `class_`-like `vclass`?
+// To enable passing of unique_ptr as in pure C++.
+template <typename T> class vptr_holder {
+  public:
+    explicit vptr_holder(T *ptr = nullptr) : vptr_{std::unique_ptr<T>(ptr)} {}
+    explicit vptr_holder(std::unique_ptr<T> u) : vptr_{std::move(u)} {}
+    explicit vptr_holder(std::shared_ptr<T> s) : vptr_{s} {}
+
+    int ownership_type() const {
+        if (std::get_if<0>(&vptr_)) {
+            return 0;
+        }
+        if (std::get_if<1>(&vptr_)) {
+            return 1;
+        }
+        return -1;
+    }
+
+    T *get() {
+        auto u = std::get_if<0>(&vptr_);
+        if (u) {
+            return u->get();
+        }
+        auto s = std::get_if<1>(&vptr_);
+        if (s) {
+            return s->get();
+        }
+        return nullptr;
+    }
+
+    std::unique_ptr<T> get_unique() {
+        auto u = std::get_if<0>(&vptr_);
+        if (u) {
+            return std::move(*u);
+        }
+        throw std::runtime_error("get_unique failure.");
+    }
+
+    std::shared_ptr<T> get_shared() {
+        auto s = std::get_if<1>(&vptr_);
+        if (s) {
+            return *s;
+        }
+        auto u = std::get_if<0>(&vptr_);
+        if (u) {
+            auto result = std::shared_ptr<T>(std::move(*u));
+            vptr_ = result;
+            return result;
+        }
+        throw std::runtime_error("get_shared failure.");
+    }
+
+  private:
+    std::variant<std::unique_ptr<T>, std::shared_ptr<T>> vptr_;
+};
+
+vptr_holder<double> from_raw() { return vptr_holder<double>{new double{3}}; }
+
+vptr_holder<double> from_unique() {
+    return vptr_holder<double>{std::unique_ptr<double>(new double{5})};
+}
+
+vptr_holder<double> from_shared() {
+    return vptr_holder<double>{std::shared_ptr<double>(new double{7})};
+}
+
+TEST_SUBMODULE(variant_unique_shared, m) {
+
+    m.def("from_raw", from_raw);
+    m.def("from_unique", from_unique);
+    m.def("from_shared", from_shared);
+
+    py::class_<vptr_holder<double>>(m, "vptr_holder_double")
+        .def(py::init<>())
+        .def("ownership_type", &vptr_holder<double>::ownership_type)
+        .def("get_value",
+             [](vptr_holder<double> &v) {
+                 auto p = v.get();
+                 if (p)
+                     return *p;
+                 return -1.;
+             })
+        .def("get_unique",
+             [](vptr_holder<double> &v) {
+                 v.get_unique();
+                 return;
+             })
+        .def("get_shared", [](vptr_holder<double> &v) {
+            v.get_shared();
+            return;
+        });
+}
+
+} // namespace pybind11_tests
diff --git a/tests/test_variant_unique_shared.py b/tests/test_variant_unique_shared.py
new file mode 100644
index 0000000000..84dc2491bd
--- /dev/null
+++ b/tests/test_variant_unique_shared.py
@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+from pybind11_tests import variant_unique_shared as m
+
+
+def test_default_constructed():
+    v = m.vptr_holder_double()
+    assert v.ownership_type() == 0
+    assert v.get_value() == -1
+
+
+def test_from_raw():
+    v = m.from_raw()
+    assert v.ownership_type() == 0
+    assert v.get_value() == 3
+
+
+def test_from_unique():
+    v = m.from_unique()
+    assert v.ownership_type() == 0
+    assert v.get_value() == 5
+
+
+def test_from_shared():
+    v = m.from_shared()
+    assert v.ownership_type() == 1
+    assert v.get_value() == 7
+
+
+def test_promotion_to_shared():
+    v = m.from_raw()
+    v.get_unique()
+    assert v.ownership_type() == 0
+    v.get_shared()  # Promotion to shared_ptr.
+    assert v.ownership_type() == 1
+    v.get_shared()  # Existing shared_ptr.
+    with pytest.raises(RuntimeError) as exc_info:
+        v.get_unique()
+    assert str(exc_info.value) == "get_unique failure."
+    v.get_shared()  # Still works.
+
+
+def test_shared_from_birth():
+    v = m.from_shared()
+    assert v.ownership_type() == 1
+    with pytest.raises(RuntimeError) as exc_info:
+        v.get_unique()
+    assert str(exc_info.value) == "get_unique failure."
+    v.get_shared()  # Still works.

From 9447b506e7c7e434a8a70c1f5acddd063855a5d5 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 20 Nov 2020 11:24:40 -0800
Subject: [PATCH 004/206] moving prototype code to pybind11/vptr_holder.h,
 adding type_caster specialization to make the bindings involving unique_ptr
 passing compile, but load and cast implementations are missing

---
 include/pybind11/vptr_holder.h       | 72 ++++++++++++++++++++++++
 tests/test_unique_ptr_member.cpp     | 35 +++++++++++-
 tests/test_variant_unique_shared.cpp | 82 +++++-----------------------
 tests/test_variant_unique_shared.py  |  2 +-
 4 files changed, 121 insertions(+), 70 deletions(-)
 create mode 100644 include/pybind11/vptr_holder.h

diff --git a/include/pybind11/vptr_holder.h b/include/pybind11/vptr_holder.h
new file mode 100644
index 0000000000..39ef5206d3
--- /dev/null
+++ b/include/pybind11/vptr_holder.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+#include <memory>
+#include <variant>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+// Could this be a holder for a `class_`-like `vclass`?
+// To enable passing of unique_ptr as in pure C++.
+template <typename T> class vptr {
+  public:
+    explicit vptr(T *ptr = nullptr) : vptr_{std::unique_ptr<T>(ptr)} {}
+    explicit vptr(std::unique_ptr<T> u) : vptr_{std::move(u)} {}
+    explicit vptr(std::shared_ptr<T> s) : vptr_{s} {}
+
+    int ownership_type() const {
+        if (std::get_if<0>(&vptr_)) {
+            return 0;
+        }
+        if (std::get_if<1>(&vptr_)) {
+            return 1;
+        }
+        return -1;
+    }
+
+    T *get() {
+        auto u = std::get_if<0>(&vptr_);
+        if (u) {
+            return u->get();
+        }
+        auto s = std::get_if<1>(&vptr_);
+        if (s) {
+            return s->get();
+        }
+        return nullptr;
+    }
+
+    std::unique_ptr<T> get_unique() {
+        auto u = std::get_if<0>(&vptr_);
+        if (u) {
+            return std::move(*u);
+        }
+        throw std::runtime_error("get_unique failure.");
+    }
+
+    std::shared_ptr<T> get_shared() {
+        auto s = std::get_if<1>(&vptr_);
+        if (s) {
+            return *s;
+        }
+        auto u = std::get_if<0>(&vptr_);
+        if (u) {
+            auto result = std::shared_ptr<T>(std::move(*u));
+            vptr_ = result;
+            return result;
+        }
+        throw std::runtime_error("get_shared failure.");
+    }
+
+  private:
+    std::variant<std::unique_ptr<T>, std::shared_ptr<T>> vptr_;
+};
+
+template <typename T> class vptr_holder : public vptr<T> {
+    using vptr<T>::vptr;
+};
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
+
+PYBIND11_DECLARE_HOLDER_TYPE(T, pybind11::vptr_holder<T>);
diff --git a/tests/test_unique_ptr_member.cpp b/tests/test_unique_ptr_member.cpp
index 316dac44e5..38a99a6799 100644
--- a/tests/test_unique_ptr_member.cpp
+++ b/tests/test_unique_ptr_member.cpp
@@ -1,5 +1,7 @@
 #include "pybind11_tests.h"
 
+#include <pybind11/vptr_holder.h>
+
 #include <iostream>
 #include <memory>
 
@@ -66,17 +68,46 @@ inline int cpp_pattern() {
     return result;
 }
 
+} // namespace unique_ptr_member
+} // namespace pybind11_tests
+
+namespace pybind11 {
+namespace detail {
+template <>
+struct type_caster<
+    std::unique_ptr<pybind11_tests::unique_ptr_member::pointee>> {
+  public:
+    PYBIND11_TYPE_CASTER(
+        std::unique_ptr<pybind11_tests::unique_ptr_member::pointee>,
+        _("std::unique_ptr<pybind11_tests::unique_ptr_member::pointee>"));
+
+    bool load(handle /* src */, bool) {
+        throw std::runtime_error("Not implemented: load");
+    }
+
+    static handle
+    cast(std::unique_ptr<pybind11_tests::unique_ptr_member::pointee> /* src */,
+         return_value_policy /* policy */, handle /* parent */) {
+        throw std::runtime_error("Not implemented: cast");
+    }
+};
+} // namespace detail
+} // namespace pybind11
+
+namespace pybind11_tests {
+namespace unique_ptr_member {
+
 TEST_SUBMODULE(unique_ptr_member, m) {
     m.def("to_cout", to_cout);
 
-    py::class_<pointee, std::shared_ptr<pointee>>(m, "pointee")
+    py::class_<pointee, py::vptr_holder<pointee>>(m, "pointee")
         .def(py::init<>())
         .def("get_int", &pointee::get_int);
 
     m.def("make_unique_pointee", make_unique_pointee);
 
     py::class_<ptr_owner>(m, "ptr_owner")
-        //.def(py::init<std::unique_ptr<pointee>>(), py::arg("ptr"))
+        .def(py::init<std::unique_ptr<pointee>>(), py::arg("ptr"))
         .def("is_owner", &ptr_owner::is_owner)
         .def("give_up_ownership_via_unique_ptr",
              &ptr_owner::give_up_ownership_via_unique_ptr)
diff --git a/tests/test_variant_unique_shared.cpp b/tests/test_variant_unique_shared.cpp
index 7d7f0c9456..40f3fa928c 100644
--- a/tests/test_variant_unique_shared.cpp
+++ b/tests/test_variant_unique_shared.cpp
@@ -1,74 +1,22 @@
-#include <memory>
-#include <variant>
-
 #include "pybind11_tests.h"
 
-namespace pybind11_tests {
-
-// Could this be a holder for a `class_`-like `vclass`?
-// To enable passing of unique_ptr as in pure C++.
-template <typename T> class vptr_holder {
-  public:
-    explicit vptr_holder(T *ptr = nullptr) : vptr_{std::unique_ptr<T>(ptr)} {}
-    explicit vptr_holder(std::unique_ptr<T> u) : vptr_{std::move(u)} {}
-    explicit vptr_holder(std::shared_ptr<T> s) : vptr_{s} {}
+#include <pybind11/vptr_holder.h>
 
-    int ownership_type() const {
-        if (std::get_if<0>(&vptr_)) {
-            return 0;
-        }
-        if (std::get_if<1>(&vptr_)) {
-            return 1;
-        }
-        return -1;
-    }
-
-    T *get() {
-        auto u = std::get_if<0>(&vptr_);
-        if (u) {
-            return u->get();
-        }
-        auto s = std::get_if<1>(&vptr_);
-        if (s) {
-            return s->get();
-        }
-        return nullptr;
-    }
-
-    std::unique_ptr<T> get_unique() {
-        auto u = std::get_if<0>(&vptr_);
-        if (u) {
-            return std::move(*u);
-        }
-        throw std::runtime_error("get_unique failure.");
-    }
+#include <memory>
+#include <variant>
 
-    std::shared_ptr<T> get_shared() {
-        auto s = std::get_if<1>(&vptr_);
-        if (s) {
-            return *s;
-        }
-        auto u = std::get_if<0>(&vptr_);
-        if (u) {
-            auto result = std::shared_ptr<T>(std::move(*u));
-            vptr_ = result;
-            return result;
-        }
-        throw std::runtime_error("get_shared failure.");
-    }
+namespace pybind11_tests {
 
-  private:
-    std::variant<std::unique_ptr<T>, std::shared_ptr<T>> vptr_;
-};
+using pybind11::vptr;
 
-vptr_holder<double> from_raw() { return vptr_holder<double>{new double{3}}; }
+vptr<double> from_raw() { return vptr<double>{new double{3}}; }
 
-vptr_holder<double> from_unique() {
-    return vptr_holder<double>{std::unique_ptr<double>(new double{5})};
+vptr<double> from_unique() {
+    return vptr<double>{std::unique_ptr<double>(new double{5})};
 }
 
-vptr_holder<double> from_shared() {
-    return vptr_holder<double>{std::shared_ptr<double>(new double{7})};
+vptr<double> from_shared() {
+    return vptr<double>{std::shared_ptr<double>(new double{7})};
 }
 
 TEST_SUBMODULE(variant_unique_shared, m) {
@@ -77,22 +25,22 @@ TEST_SUBMODULE(variant_unique_shared, m) {
     m.def("from_unique", from_unique);
     m.def("from_shared", from_shared);
 
-    py::class_<vptr_holder<double>>(m, "vptr_holder_double")
+    py::class_<vptr<double>>(m, "vptr_double")
         .def(py::init<>())
-        .def("ownership_type", &vptr_holder<double>::ownership_type)
+        .def("ownership_type", &vptr<double>::ownership_type)
         .def("get_value",
-             [](vptr_holder<double> &v) {
+             [](vptr<double> &v) {
                  auto p = v.get();
                  if (p)
                      return *p;
                  return -1.;
              })
         .def("get_unique",
-             [](vptr_holder<double> &v) {
+             [](vptr<double> &v) {
                  v.get_unique();
                  return;
              })
-        .def("get_shared", [](vptr_holder<double> &v) {
+        .def("get_shared", [](vptr<double> &v) {
             v.get_shared();
             return;
         });
diff --git a/tests/test_variant_unique_shared.py b/tests/test_variant_unique_shared.py
index 84dc2491bd..7f5733be66 100644
--- a/tests/test_variant_unique_shared.py
+++ b/tests/test_variant_unique_shared.py
@@ -5,7 +5,7 @@
 
 
 def test_default_constructed():
-    v = m.vptr_holder_double()
+    v = m.vptr_double()
     assert v.ownership_type() == 0
     assert v.get_value() == -1
 

From c518aac65911e3aaa9ea4556ad472b492a9e709a Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 20 Nov 2020 12:40:46 -0800
Subject: [PATCH 005/206] disabling GitHub Actions on pull_request (for this
 PR)

---
 .github/workflows/ci.yml        | 2 +-
 .github/workflows/configure.yml | 2 +-
 .github/workflows/format.yml    | 2 +-
 .github/workflows/pip.yml       | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a1bdec7bd7..aed9bfb3d5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,7 +2,7 @@ name: CI
 
 on:
   workflow_dispatch:
-  pull_request:
+  # pull_request:
   push:
     branches:
       - master
diff --git a/.github/workflows/configure.yml b/.github/workflows/configure.yml
index 0f3117be99..1b9336052f 100644
--- a/.github/workflows/configure.yml
+++ b/.github/workflows/configure.yml
@@ -2,7 +2,7 @@ name: Config
 
 on:
   workflow_dispatch:
-  pull_request:
+  # pull_request:
   push:
     branches:
       - master
diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
index 5cebed17da..5e8792ee03 100644
--- a/.github/workflows/format.yml
+++ b/.github/workflows/format.yml
@@ -5,7 +5,7 @@ name: Format
 
 on:
   workflow_dispatch:
-  pull_request:
+  # pull_request:
   push:
     branches:
     - master
diff --git a/.github/workflows/pip.yml b/.github/workflows/pip.yml
index 5547a5e285..0bed204a2c 100644
--- a/.github/workflows/pip.yml
+++ b/.github/workflows/pip.yml
@@ -2,7 +2,7 @@ name: Pip
 
 on:
   workflow_dispatch:
-  pull_request:
+  # pull_request:
   push:
     branches:
     - master

From 0f783571daa1afe3eb12d8c5b7b4996c7b855eb0 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 20 Nov 2020 12:53:52 -0800
Subject: [PATCH 006/206] disabling AppVeyor (for this PR)

---
 .appveyor.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.appveyor.yml b/.appveyor.yml
index 85445d41a2..9a1d69a6af 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -1,6 +1,9 @@
 version: 1.0.{build}
 image:
 - Visual Studio 2015
+branches:
+  only:
+    - will_never_exist
 test: off
 skip_branch_with_pr: true
 build:

From b0806e760adbe8b2f63d575196b9afec0d5a10f8 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 23 Nov 2020 10:34:11 -0800
Subject: [PATCH 007/206] TRIGGER_SEGSEV macro, annotations for GET_STACK
 (vptr::get), GET_INT_STACK (pointee)

---
 include/pybind11/cast.h          |  4 ++--
 include/pybind11/pybind11.h      | 18 ++++++++++--------
 include/pybind11/vptr_holder.h   | 13 +++++++++----
 tests/test_unique_ptr_member.cpp |  1 +
 tests/work.py                    | 12 ++++++++++++
 5 files changed, 34 insertions(+), 14 deletions(-)
 create mode 100644 tests/work.py

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 0ad10e9a93..64b4022be3 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1133,7 +1133,7 @@ class argument_loader {
 
     template <typename Return, typename Guard, typename Func>
     enable_if_t<!std::is_void<Return>::value, Return> call(Func &&f) && {
-        return std::move(*this).template call_impl<Return>(std::forward<Func>(f), indices{}, Guard{});
+        return std::move(*this).template call_impl<Return>(std::forward<Func>(f), indices{}, Guard{});  // GET_INT_STACK -3
     }
 
     template <typename Return, typename Guard, typename Func>
@@ -1161,7 +1161,7 @@ class argument_loader {
 
     template <typename Return, typename Func, size_t... Is, typename Guard>
     Return call_impl(Func &&f, index_sequence<Is...>, Guard &&) && {
-        return std::forward<Func>(f)(cast_op<Args>(std::move(std::get<Is>(argcasters)))...);
+        return std::forward<Func>(f)(cast_op<Args>(std::move(std::get<Is>(argcasters)))...);  // GET_INT_STACK -2
     }
 
     std::tuple<make_caster<Args>...> argcasters;
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 648300eef2..f9c92df12b 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -57,6 +57,8 @@
 #  include <cxxabi.h>
 #endif
 
+#define TRIGGER_SEGSEV { unsigned long *bad = nullptr; *bad = -1; }
+
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 
 /// Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object
@@ -98,7 +100,7 @@ class cpp_function : public function {
     /// Construct a cpp_function from a class method (const, no ref-qualifier)
     template <typename Return, typename Class, typename... Arg, typename... Extra>
     cpp_function(Return (Class::*f)(Arg...) const, const Extra&... extra) {
-        initialize([f](const Class *c, Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
+        initialize([f](const Class *c, Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },  // GET_INT_STACK -1
                    (Return (*)(const Class *, Arg ...)) nullptr, extra...);
     }
 
@@ -168,7 +170,7 @@ class cpp_function : public function {
                       "The number of argument annotations does not match the number of function arguments");
 
         /* Dispatch code which converts function arguments and performs the actual function call */
-        rec->impl = [](function_call &call) -> handle {
+        rec->impl = [](function_call &call) -> handle {  // GET_INT_STACK -5
             cast_in args_converter;
 
             /* Try to cast the function arguments into the C++ domain */
@@ -191,7 +193,7 @@ class cpp_function : public function {
 
             /* Perform the function call */
             handle result = cast_out::cast(
-                std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
+                std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);  // GET_INT_STACK -4
 
             /* Invoke call policy post-call hook */
             process_attributes<Extra...>::postcall(call, result);
@@ -553,7 +555,7 @@ class cpp_function : public function {
         handle parent = n_args_in > 0 ? PyTuple_GET_ITEM(args_in, 0) : nullptr,
                result = PYBIND11_TRY_NEXT_OVERLOAD;
 
-        auto self_value_and_holder = value_and_holder();
+        auto self_value_and_holder = value_and_holder(); // cast.h
         if (overloads->is_constructor) {
             if (!PyObject_TypeCheck(parent.ptr(), (PyTypeObject *) overloads->scope.ptr())) {
                 PyErr_SetString(PyExc_TypeError, "__init__(self, ...) called with invalid `self` argument");
@@ -765,7 +767,7 @@ class cpp_function : public function {
                 // 6. Call the function.
                 try {
                     loader_life_support guard{};
-                    result = func.impl(call);
+                    result = func.impl(call);  // GET_INT_STACK -6
                 } catch (reference_cast_error &) {
                     result = PYBIND11_TRY_NEXT_OVERLOAD;
                 }
@@ -931,7 +933,7 @@ class cpp_function : public function {
         } else {
             if (overloads->is_constructor && !self_value_and_holder.holder_constructed()) {
                 auto *pi = reinterpret_cast<instance *>(parent.ptr());
-                self_value_and_holder.type->init_instance(pi, nullptr);
+                self_value_and_holder.type->init_instance(pi, nullptr);  // GET_STACK -4
             }
             return result.ptr();
         }
@@ -1537,7 +1539,7 @@ class class_ : public detail::generic_type {
             init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
             v_h.set_holder_constructed();
         } else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());  // GET_STACK -2
             v_h.set_holder_constructed();
         }
     }
@@ -1552,7 +1554,7 @@ class class_ : public detail::generic_type {
             register_instance(inst, v_h.value_ptr(), v_h.type);
             v_h.set_instance_registered();
         }
-        init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
+        init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());  // GET_STACK -3
     }
 
     /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.
diff --git a/include/pybind11/vptr_holder.h b/include/pybind11/vptr_holder.h
index 39ef5206d3..1de37adc8f 100644
--- a/include/pybind11/vptr_holder.h
+++ b/include/pybind11/vptr_holder.h
@@ -2,6 +2,7 @@
 
 #include <pybind11/pybind11.h>
 
+#include <iostream>
 #include <memory>
 #include <variant>
 
@@ -11,9 +12,12 @@ PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 // To enable passing of unique_ptr as in pure C++.
 template <typename T> class vptr {
   public:
-    explicit vptr(T *ptr = nullptr) : vptr_{std::unique_ptr<T>(ptr)} {}
-    explicit vptr(std::unique_ptr<T> u) : vptr_{std::move(u)} {}
-    explicit vptr(std::shared_ptr<T> s) : vptr_{s} {}
+    explicit vptr(T *ptr = nullptr) : vptr_{std::unique_ptr<T>(ptr)} {
+        std::cout << std::endl << "explicit vptr(T *ptr = nullptr)" << std::endl;
+        //TRIGGER_SEGSEV
+    }
+    explicit vptr(std::unique_ptr<T> u) : vptr_{std::move(u)} { std::cout << std::endl << "explicit vptr(std::unique_ptr<T> u)" << std::endl; }
+    explicit vptr(std::shared_ptr<T> s) : vptr_{s} { std::cout << std::endl << "explicit vptr(std::shared_ptr<T> s)" << std::endl; }
 
     int ownership_type() const {
         if (std::get_if<0>(&vptr_)) {
@@ -26,6 +30,7 @@ template <typename T> class vptr {
     }
 
     T *get() {
+        std::cout << std::endl << "vptr::get" << std::endl;
         auto u = std::get_if<0>(&vptr_);
         if (u) {
             return u->get();
@@ -64,7 +69,7 @@ template <typename T> class vptr {
 };
 
 template <typename T> class vptr_holder : public vptr<T> {
-    using vptr<T>::vptr;
+    using vptr<T>::vptr;  // GET_STACK -1
 };
 
 PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/tests/test_unique_ptr_member.cpp b/tests/test_unique_ptr_member.cpp
index 38a99a6799..ebe5e09ee8 100644
--- a/tests/test_unique_ptr_member.cpp
+++ b/tests/test_unique_ptr_member.cpp
@@ -16,6 +16,7 @@ class pointee { // NOT copyable.
 
     int get_int() const {
         to_cout("pointee::get_int()");
+        //TRIGGER_SEGSEV
         return 213;
     }
 
diff --git a/tests/work.py b/tests/work.py
new file mode 100644
index 0000000000..11dd213b46
--- /dev/null
+++ b/tests/work.py
@@ -0,0 +1,12 @@
+from pybind11_tests import unique_ptr_member as m
+
+
+def test_pointee_and_ptr_owner():
+    m.to_cout("")
+    obj = m.pointee()
+    assert obj.get_int() == 213
+    del obj
+    print("DONE.", flush=True)
+
+
+test_pointee_and_ptr_owner()

From e82720e54bb19827329608db4f0313d8c3de5643 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 4 Dec 2020 14:17:17 -0800
Subject: [PATCH 008/206] adding test_promotion_of_disowned_to_shared

---
 tests/test_variant_unique_shared.cpp |  9 +++++++--
 tests/test_variant_unique_shared.py  | 11 +++++++++++
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/tests/test_variant_unique_shared.cpp b/tests/test_variant_unique_shared.cpp
index 40f3fa928c..9f083dafbd 100644
--- a/tests/test_variant_unique_shared.cpp
+++ b/tests/test_variant_unique_shared.cpp
@@ -40,8 +40,13 @@ TEST_SUBMODULE(variant_unique_shared, m) {
                  v.get_unique();
                  return;
              })
-        .def("get_shared", [](vptr<double> &v) {
-            v.get_shared();
+        .def("get_shared",
+             [](vptr<double> &v) {
+                 v.get_shared();
+                 return;
+             })
+        .def("disown_unique", [](vptr<double> &v) {
+            v.get_unique().reset();
             return;
         });
 }
diff --git a/tests/test_variant_unique_shared.py b/tests/test_variant_unique_shared.py
index 7f5733be66..2ef0e40a7b 100644
--- a/tests/test_variant_unique_shared.py
+++ b/tests/test_variant_unique_shared.py
@@ -48,3 +48,14 @@ def test_shared_from_birth():
         v.get_unique()
     assert str(exc_info.value) == "get_unique failure."
     v.get_shared()  # Still works.
+
+
+def test_promotion_of_disowned_to_shared():
+    v = m.from_unique()
+    assert v.get_value() == 5
+    v.disown_unique()
+    assert v.ownership_type() == 0
+    assert v.get_value() == -1
+    v.get_shared()  # Promotion of disowned to shared_ptr.
+    assert v.ownership_type() == 1
+    assert v.get_value() == -1

From e839ffb75417ff2a28e1703a6133c1a77aba47af Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 18 Dec 2020 15:09:42 -0800
Subject: [PATCH 009/206] Copying tests as-is from xxx_value_ptr_xxx_holder
 branch.

https://github.com/rwgk/pybind11/tree/xxx_value_ptr_xxx_holder

Systematically exercising returning and passing unique_ptr<T>, shared_ptr<T>
with unique_ptr, shared_ptr holder.

Observations:

test_holder_unique_ptr:
  make_unique_pointee  OK
  pass_unique_pointee  BUILD_FAIL (as documented)
  make_shared_pointee  Abort free(): double free detected
  pass_shared_pointee  RuntimeError: Unable to load a custom holder type from a default-holder instance

test_holder_shared_ptr:
  make_unique_pointee  Segmentation fault (#1138)
  pass_unique_pointee  BUILD_FAIL (as documented)
  make_shared_pointee  OK
  pass_shared_pointee  OK
---
 tests/test_holder_shared_ptr.cpp | 69 ++++++++++++++++++++++++++++++++
 tests/test_holder_shared_ptr.py  | 56 ++++++++++++++++++++++++++
 tests/test_holder_unique_ptr.cpp | 69 ++++++++++++++++++++++++++++++++
 tests/test_holder_unique_ptr.py  | 56 ++++++++++++++++++++++++++
 4 files changed, 250 insertions(+)
 create mode 100644 tests/test_holder_shared_ptr.cpp
 create mode 100644 tests/test_holder_shared_ptr.py
 create mode 100644 tests/test_holder_unique_ptr.cpp
 create mode 100644 tests/test_holder_unique_ptr.py

diff --git a/tests/test_holder_shared_ptr.cpp b/tests/test_holder_shared_ptr.cpp
new file mode 100644
index 0000000000..ff248310e4
--- /dev/null
+++ b/tests/test_holder_shared_ptr.cpp
@@ -0,0 +1,69 @@
+// KEEP IN SYNC WITH test_holder_unique_ptr.cpp
+
+#include "pybind11_tests.h"
+
+#include <iostream>
+#include <memory>
+
+namespace pybind11_tests {
+namespace holder_shared_ptr {
+
+inline void to_cout(std::string text) { std::cout << text << std::endl; }
+
+class pointee { // NOT copyable.
+  public:
+    pointee() { to_cout("pointee::pointee()"); }
+
+    int get_int() const {
+        to_cout("pointee::get_int()");
+        return 213;
+    }
+
+    ~pointee() { to_cout("~pointee()"); }
+
+  private:
+    pointee(const pointee &) = delete;
+    pointee(pointee &&) = delete;
+    pointee &operator=(const pointee &) = delete;
+    pointee &operator=(pointee &&) = delete;
+};
+
+inline std::unique_ptr<pointee> make_unique_pointee() {
+    return std::unique_ptr<pointee>(new pointee);
+}
+
+inline std::shared_ptr<pointee> make_shared_pointee() {
+    return std::unique_ptr<pointee>(new pointee);
+}
+
+inline int pass_unique_pointee(std::unique_ptr<pointee> ptr) {
+    return 4000 + ptr->get_int();
+}
+
+inline int pass_shared_pointee(std::shared_ptr<pointee> ptr) {
+    return 5000 + ptr->get_int();
+}
+
+inline pointee* get_static_pointee() {
+  static pointee cpp_instance;
+  return &cpp_instance;
+}
+
+TEST_SUBMODULE(holder_shared_ptr, m) {
+    m.def("to_cout", to_cout);
+
+    py::class_<pointee, std::shared_ptr<pointee>>(m, "pointee")
+        .def(py::init<>())
+        .def("get_int", &pointee::get_int);
+
+    m.def("make_unique_pointee", make_unique_pointee);
+    m.def("make_shared_pointee", make_shared_pointee);
+    // m.def("pass_unique_pointee", pass_unique_pointee);
+    m.def("pass_shared_pointee", pass_shared_pointee);
+
+    m.def("get_static_pointee",
+          get_static_pointee, py::return_value_policy::reference);
+}
+
+} // namespace holder_shared_ptr
+} // namespace pybind11_tests
diff --git a/tests/test_holder_shared_ptr.py b/tests/test_holder_shared_ptr.py
new file mode 100644
index 0000000000..78aa2d1a58
--- /dev/null
+++ b/tests/test_holder_shared_ptr.py
@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# KEEP IN SYNC WITH test_holder_unique_ptr.py
+import pytest
+
+from pybind11_tests import holder_shared_ptr as m
+
+
+def test_make_unique_pointee():
+    m.to_cout("")
+    m.to_cout("")
+    m.to_cout("make_unique_pointee")
+    obj = m.make_unique_pointee()
+    assert obj.get_int() == 213
+    m.to_cout("")
+
+
+def test_make_shared_pointee():
+    m.to_cout("")
+    m.to_cout("")
+    m.to_cout("make_shared_pointee")
+    obj = m.make_shared_pointee()
+    assert obj.get_int() == 213
+    m.to_cout("")
+
+
+def test_pass_unique_pointee():
+    m.to_cout("")
+    m.to_cout("")
+    m.to_cout("pass_unique_pointee")
+    obj = m.make_shared_pointee()
+    assert obj.get_int() == 213
+    i = m.pass_unique_pointee(obj)
+    assert i == 4213
+    m.to_cout("")
+
+
+def test_pass_shared_pointee():
+    m.to_cout("")
+    m.to_cout("")
+    m.to_cout("pass_shared_pointee")
+    obj = m.make_shared_pointee()
+    assert obj.get_int() == 213
+    i = m.pass_shared_pointee(obj)
+    assert i == 5213
+    m.to_cout("")
+
+
+def test_get_static_pointee():
+    m.to_cout("")
+    m.to_cout("")
+    m.to_cout("get_static_pointee")
+    obj = m.get_static_pointee()
+    assert obj.get_int() == 213
+    with pytest.raises(RuntimeError) as excinfo:
+        m.pass_shared_pointee(obj)
+    assert "Unable to cast from non-held to held instance" in str(excinfo.value)
diff --git a/tests/test_holder_unique_ptr.cpp b/tests/test_holder_unique_ptr.cpp
new file mode 100644
index 0000000000..d59066416a
--- /dev/null
+++ b/tests/test_holder_unique_ptr.cpp
@@ -0,0 +1,69 @@
+// KEEP IN SYNC WITH test_holder_shared_ptr.cpp
+
+#include "pybind11_tests.h"
+
+#include <iostream>
+#include <memory>
+
+namespace pybind11_tests {
+namespace holder_unique_ptr {
+
+inline void to_cout(std::string text) { std::cout << text << std::endl; }
+
+class pointee { // NOT copyable.
+  public:
+    pointee() { to_cout("pointee::pointee()"); }
+
+    int get_int() const {
+        to_cout("pointee::get_int()");
+        return 213;
+    }
+
+    ~pointee() { to_cout("~pointee()"); }
+
+  private:
+    pointee(const pointee &) = delete;
+    pointee(pointee &&) = delete;
+    pointee &operator=(const pointee &) = delete;
+    pointee &operator=(pointee &&) = delete;
+};
+
+inline std::unique_ptr<pointee> make_unique_pointee() {
+    return std::unique_ptr<pointee>(new pointee);
+}
+
+inline std::shared_ptr<pointee> make_shared_pointee() {
+    return std::unique_ptr<pointee>(new pointee);
+}
+
+inline int pass_unique_pointee(std::unique_ptr<pointee> ptr) {
+    return 4000 + ptr->get_int();
+}
+
+inline int pass_shared_pointee(std::shared_ptr<pointee> ptr) {
+    return 5000 + ptr->get_int();
+}
+
+inline pointee* get_static_pointee() {
+  static pointee cpp_instance;
+  return &cpp_instance;
+}
+
+TEST_SUBMODULE(holder_unique_ptr, m) {
+    m.def("to_cout", to_cout);
+
+    py::class_<pointee>(m, "pointee")
+        .def(py::init<>())
+        .def("get_int", &pointee::get_int);
+
+    m.def("make_unique_pointee", make_unique_pointee);
+    m.def("make_shared_pointee", make_shared_pointee);
+    // m.def("pass_unique_pointee", pass_unique_pointee);
+    m.def("pass_shared_pointee", pass_shared_pointee);
+
+    m.def("get_static_pointee",
+          get_static_pointee, py::return_value_policy::reference);
+}
+
+} // namespace holder_unique_ptr
+} // namespace pybind11_tests
diff --git a/tests/test_holder_unique_ptr.py b/tests/test_holder_unique_ptr.py
new file mode 100644
index 0000000000..a82c3fda2c
--- /dev/null
+++ b/tests/test_holder_unique_ptr.py
@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# KEEP IN SYNC WITH test_holder_shared_ptr.py
+import pytest
+
+from pybind11_tests import holder_unique_ptr as m
+
+
+def test_make_unique_pointee():
+    m.to_cout("")
+    m.to_cout("")
+    m.to_cout("make_unique_pointee")
+    obj = m.make_unique_pointee()
+    assert obj.get_int() == 213
+    m.to_cout("")
+
+
+def test_make_shared_pointee():
+    m.to_cout("")
+    m.to_cout("")
+    m.to_cout("make_shared_pointee")
+    obj = m.make_shared_pointee()
+    assert obj.get_int() == 213
+    m.to_cout("")
+
+
+def test_pass_unique_pointee():
+    m.to_cout("")
+    m.to_cout("")
+    m.to_cout("pass_unique_pointee")
+    obj = m.make_unique_pointee()
+    assert obj.get_int() == 213
+    i = m.pass_unique_pointee(obj)
+    assert i == 4213
+    m.to_cout("")
+
+
+def test_pass_shared_pointee():
+    m.to_cout("")
+    m.to_cout("")
+    m.to_cout("pass_shared_pointee")
+    obj = m.make_unique_pointee()
+    assert obj.get_int() == 213
+    i = m.pass_shared_pointee(obj)
+    assert i == 5213
+    m.to_cout("")
+
+
+def test_get_static_pointee():
+    m.to_cout("")
+    m.to_cout("")
+    m.to_cout("get_static_pointee")
+    obj = m.get_static_pointee()
+    assert obj.get_int() == 213
+    with pytest.raises(RuntimeError) as excinfo:
+        m.pass_unique_pointee(obj)
+    assert "Unable to cast from non-held to held instance" in str(excinfo.value)

From 971d61195b796dab668e6849be3c05ae1df66067 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 18 Dec 2020 15:36:12 -0800
Subject: [PATCH 010/206] Copying tests as-is from xxx_value_ptr_xxx_holder
 branch.

https://github.com/rwgk/pybind11/tree/xxx_value_ptr_xxx_holder

Systematically exercising casting between shared_ptr<base>, shared_ptr<derived>.
---
 tests/test_smart_ptr_base_derived.cpp | 160 ++++++++++++++++++++++++++
 tests/test_smart_ptr_base_derived.py  |  40 +++++++
 2 files changed, 200 insertions(+)
 create mode 100644 tests/test_smart_ptr_base_derived.cpp
 create mode 100644 tests/test_smart_ptr_base_derived.py

diff --git a/tests/test_smart_ptr_base_derived.cpp b/tests/test_smart_ptr_base_derived.cpp
new file mode 100644
index 0000000000..844bbd0517
--- /dev/null
+++ b/tests/test_smart_ptr_base_derived.cpp
@@ -0,0 +1,160 @@
+#include "pybind11_tests.h"
+
+#include <iostream>
+#include <memory>
+
+namespace pybind11_tests {
+namespace smart_ptr_base_derived {
+
+inline void to_cout(std::string text) { std::cout << text << std::endl; }
+
+class cbase {
+ public:
+  int get_int() const { return 90146438; }
+};
+
+class cderived : public cbase {
+ public:
+  // Printing from constructor & destructor for simple external validation.
+  cderived() {
+    std::cout << std::endl << "cderived+" << std::endl;
+  }
+  ~cderived() {
+    std::cout << std::endl << "cderived-" << std::endl;
+  }
+  int get_int() const { return 31607978; }
+  int base_get_int(const cbase& base) { return get_int() + base.get_int(); }
+};
+
+class vbase {
+ public:
+  virtual ~vbase() {}
+  virtual int get_int() const = 0;
+};
+
+class vderived : public vbase {
+ public:
+  // Printing from constructor & destructor for simple external validation.
+  vderived() {
+    std::cout << std::endl << "vderived+" << std::endl;
+  }
+  ~vderived() {
+    std::cout << std::endl << "vderived-" << std::endl;
+  }
+  int get_int() const override { return 29852452; }
+  int base_get_int(const vbase& base) { return get_int() + base.get_int(); }
+};
+
+class vrederived : public vderived {};
+
+inline std::unique_ptr<cbase>
+make_unique_cderived_up_cast() {
+  // Undefined Behavior (pure C++ problem, NOT a pybind11 problem):
+  // cderived destructor does not run.
+  return std::unique_ptr<cderived>(new cderived);
+}
+
+inline std::shared_ptr<cderived>
+make_shared_cderived(bool use_custom_deleter = false) {
+  if (use_custom_deleter) {
+    return std::shared_ptr<cderived>(
+        new cderived, [](cderived *p) { delete p; });
+  }
+  return std::shared_ptr<cderived>(new cderived);
+}
+
+inline std::shared_ptr<cbase>
+make_shared_cderived_up_cast(bool use_custom_deleter = false) {
+  return make_shared_cderived(use_custom_deleter);
+}
+
+inline int pass_unique_cbase(std::unique_ptr<cbase> cb) {
+  return cb->get_int();
+}
+
+inline int pass_shared_cbase(std::shared_ptr<cbase> cb) {
+  return cb->get_int();
+}
+
+inline int pass_shared_cderived(std::shared_ptr<cderived> cd) {
+  return cd->get_int();
+}
+
+inline std::unique_ptr<vbase>
+make_unique_vderived_up_cast() {
+  // Well-defined behavior because vderived has a virtual destructor.
+  return std::unique_ptr<vderived>(new vderived);
+}
+
+inline std::shared_ptr<vderived>
+make_shared_vderived(bool use_custom_deleter = false) {
+  if (use_custom_deleter) {
+    return std::shared_ptr<vderived>(
+        new vderived, [](vderived *p) { delete p; });
+  }
+  return std::shared_ptr<vderived>(new vderived);
+}
+
+inline std::shared_ptr<vbase>
+make_shared_vderived_up_cast(bool use_custom_deleter = false) {
+  return make_shared_vderived(use_custom_deleter);
+}
+
+inline int pass_unique_vbase(std::unique_ptr<vbase> vb) {
+  return vb->get_int();
+}
+
+inline int pass_shared_vbase(std::shared_ptr<vbase> vb) {
+  return vb->get_int();
+}
+
+inline int pass_shared_vderived(std::shared_ptr<vderived> vd) {
+  return vd->get_int();
+}
+
+inline int pass_shared_vrederived(std::shared_ptr<vrederived> vr) {
+  return vr->get_int();
+}
+
+TEST_SUBMODULE(smart_ptr_base_derived, m) {
+    m.def("to_cout", to_cout);
+
+    py::class_<cbase, std::shared_ptr<cbase>>(m, "cbase")
+        .def(py::init<>())
+        .def("get_int", &cbase::get_int);
+
+    py::class_<cderived, cbase, std::shared_ptr<cderived>>(m, "cderived")
+        .def(py::init<>())
+        .def("get_int", &cderived::get_int);
+
+    py::class_<vbase, std::shared_ptr<vbase>>(m, "vbase")
+        .def("get_int", &vbase::get_int);
+
+    py::class_<vderived, vbase, std::shared_ptr<vderived>>(m, "vderived")
+        .def(py::init<>());
+
+    py::class_<vrederived, vderived, std::shared_ptr<vrederived>>(m, "vrederived")
+        .def(py::init<>());
+
+    m.def("make_shared_cderived",
+          make_shared_cderived,
+          py::arg("use_custom_deleter") = false);
+    m.def("make_shared_cderived_up_cast",
+          make_shared_cderived_up_cast,
+          py::arg("use_custom_deleter") = false);
+    m.def("pass_shared_cbase", pass_shared_cbase);
+    m.def("pass_shared_cderived", pass_shared_cderived);
+
+    m.def("make_shared_vderived",
+          make_shared_vderived,
+          py::arg("use_custom_deleter") = false);
+    m.def("make_shared_vderived_up_cast",
+          make_shared_vderived_up_cast,
+          py::arg("use_custom_deleter") = false);
+    m.def("pass_shared_vbase", pass_shared_vbase);
+    m.def("pass_shared_vderived", pass_shared_vderived);
+    m.def("pass_shared_vrederived", pass_shared_vrederived);
+}
+
+}  // namespace smart_ptr_base_derived
+}  // namespace pybind11_tests
diff --git a/tests/test_smart_ptr_base_derived.py b/tests/test_smart_ptr_base_derived.py
new file mode 100644
index 0000000000..b57c364da8
--- /dev/null
+++ b/tests/test_smart_ptr_base_derived.py
@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+from pybind11_tests import smart_ptr_base_derived as m
+
+CBASE_GET_INT_RESULT = 90146438
+CDERIVED_GET_INT_RESULT = 31607978
+VDERIVED_GET_INT_RESULT = 29852452
+
+def test_concrete():
+    m.to_cout("")
+    m.to_cout("")
+    m.to_cout("make_shared_cderived")
+    cd = m.make_shared_cderived()
+    assert cd.get_int() == CDERIVED_GET_INT_RESULT
+    m.pass_shared_cderived(cd)
+    m.pass_shared_cbase(cd)
+    cb = m.make_shared_cderived_up_cast()
+    assert cb.get_int() == CBASE_GET_INT_RESULT
+    m.pass_shared_cbase(cb)
+    with pytest.raises(TypeError):
+        m.pass_shared_cderived(cb)
+    m.to_cout("")
+
+def test_virtual():
+    m.to_cout("")
+    m.to_cout("")
+    m.to_cout("make_shared_vderived")
+    vd = m.make_shared_vderived()
+    assert vd.get_int() == VDERIVED_GET_INT_RESULT
+    m.pass_shared_vderived(vd)
+    m.pass_shared_vbase(vd)
+    vd_uc = m.make_shared_vderived_up_cast()
+    assert vd_uc.get_int() == VDERIVED_GET_INT_RESULT
+    assert isinstance(vd_uc, m.vderived)  # pybind11 un-did upcast.
+    m.pass_shared_vbase(vd_uc)
+    m.pass_shared_vderived(vd_uc)
+    with pytest.raises(TypeError):
+        m.pass_shared_vrederived(vd_uc)
+    m.to_cout("")

From 46a15af25135fe7495eb64c27324acd12ce71a3e Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 19 Dec 2020 16:11:39 -0800
Subject: [PATCH 011/206] Demonstration of Undefined Behavior in handling of
 shared_ptr holder.

Based on https://godbolt.org/z/4fdjaW by jorgbrown@ (thanks Jorg!).
---
 tests/test_smart_ptr_private_first_base.cpp | 47 +++++++++++++++++++++
 tests/test_smart_ptr_private_first_base.py  |  9 ++++
 2 files changed, 56 insertions(+)
 create mode 100644 tests/test_smart_ptr_private_first_base.cpp
 create mode 100644 tests/test_smart_ptr_private_first_base.py

diff --git a/tests/test_smart_ptr_private_first_base.cpp b/tests/test_smart_ptr_private_first_base.cpp
new file mode 100644
index 0000000000..862effb853
--- /dev/null
+++ b/tests/test_smart_ptr_private_first_base.cpp
@@ -0,0 +1,47 @@
+// Demonstration of Undefined Behavior in handling of shared_ptr holder,
+// specifically:
+// https://github.com/pybind/pybind11/blob/30eb39ed79d1e2eeff15219ac00773034300a5e6/include/pybind11/cast.h#L235
+//     `return reinterpret_cast<H &>(vh[1]);`
+// indirectly casts a `shared_ptr<drvd>` reference to a `shared_ptr<base>`.
+// `test_smart_ptr_private_first_base.py` fails with an AssertionError and
+// a subsequent Segmentation Fault (Linux, clang++ -std=c++17).
+
+#include <memory>
+
+#include "pybind11_tests.h"
+
+namespace pybind11_tests {
+namespace smart_ptr_private_first_base {
+
+struct base {
+  base() : base_id(100) {}
+  virtual ~base() = default;
+  virtual int id() const { return base_id; }
+  int base_id;
+};
+
+struct private_first_base {  // Any class with a virtual function will do.
+  virtual void some_other_virtual_function() const {}
+  virtual ~private_first_base() = default;
+};
+
+struct drvd : private private_first_base, public base {
+  int id() const override { return 2 * base_id; }
+};
+
+inline std::shared_ptr<drvd> make_shared_drvd() {
+  return std::shared_ptr<drvd>(new drvd);
+}
+
+inline int pass_shared_base(std::shared_ptr<base> b) { return b->id(); }
+
+TEST_SUBMODULE(smart_ptr_private_first_base, m) {
+  py::class_<base, std::shared_ptr<base>>(m, "base");
+  py::class_<drvd, base, std::shared_ptr<drvd>>(m, "drvd");
+
+  m.def("make_shared_drvd", make_shared_drvd);
+  m.def("pass_shared_base", pass_shared_base);
+}
+
+}  // namespace smart_ptr_private_first_base
+}  // namespace pybind11_tests
diff --git a/tests/test_smart_ptr_private_first_base.py b/tests/test_smart_ptr_private_first_base.py
new file mode 100644
index 0000000000..75ecfe6f1a
--- /dev/null
+++ b/tests/test_smart_ptr_private_first_base.py
@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+from pybind11_tests import smart_ptr_private_first_base as m
+
+def test_make_pass():
+    d = m.make_shared_drvd()
+    i = m.pass_shared_base(d)
+    assert i == 200

From 204e71343192334a60738aeec9406f1813ad65a4 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 22 Dec 2020 12:18:47 -0800
Subject: [PATCH 012/206] Additional demonstration of Undefined Behavior in
 handling of shared_ptr holder.

---
 tests/test_smart_ptr_private_first_base.cpp | 15 +++++++++++++--
 tests/test_smart_ptr_private_first_base.py  | 11 ++++++++++-
 2 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/tests/test_smart_ptr_private_first_base.cpp b/tests/test_smart_ptr_private_first_base.cpp
index 862effb853..9ccc5edea0 100644
--- a/tests/test_smart_ptr_private_first_base.cpp
+++ b/tests/test_smart_ptr_private_first_base.cpp
@@ -3,8 +3,12 @@
 // https://github.com/pybind/pybind11/blob/30eb39ed79d1e2eeff15219ac00773034300a5e6/include/pybind11/cast.h#L235
 //     `return reinterpret_cast<H &>(vh[1]);`
 // indirectly casts a `shared_ptr<drvd>` reference to a `shared_ptr<base>`.
-// `test_smart_ptr_private_first_base.py` fails with an AssertionError and
-// a subsequent Segmentation Fault (Linux, clang++ -std=c++17).
+// Similarly:
+// https://github.com/pybind/pybind11/blob/30eb39ed79d1e2eeff15219ac00773034300a5e6/include/pybind11/pybind11.h#L1505
+//     `init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());`
+// explictly casts a `shared_ptr<base>` reference to a `shared_ptr<drvd>`.
+// Both tests in `test_smart_ptr_private_first_base.py` fail with a
+// Segmentation Fault (Linux, clang++ -std=c++17).
 
 #include <memory>
 
@@ -33,14 +37,21 @@ inline std::shared_ptr<drvd> make_shared_drvd() {
   return std::shared_ptr<drvd>(new drvd);
 }
 
+inline std::shared_ptr<base> make_shared_drvd_up_cast() {
+  return std::shared_ptr<base>(new drvd);
+}
+
 inline int pass_shared_base(std::shared_ptr<base> b) { return b->id(); }
+inline int pass_shared_drvd(std::shared_ptr<drvd> d) { return d->id(); }
 
 TEST_SUBMODULE(smart_ptr_private_first_base, m) {
   py::class_<base, std::shared_ptr<base>>(m, "base");
   py::class_<drvd, base, std::shared_ptr<drvd>>(m, "drvd");
 
   m.def("make_shared_drvd", make_shared_drvd);
+  m.def("make_shared_drvd_up_cast", make_shared_drvd_up_cast);
   m.def("pass_shared_base", pass_shared_base);
+  m.def("pass_shared_drvd", pass_shared_drvd);
 }
 
 }  // namespace smart_ptr_private_first_base
diff --git a/tests/test_smart_ptr_private_first_base.py b/tests/test_smart_ptr_private_first_base.py
index 75ecfe6f1a..a749a46658 100644
--- a/tests/test_smart_ptr_private_first_base.py
+++ b/tests/test_smart_ptr_private_first_base.py
@@ -3,7 +3,16 @@
 
 from pybind11_tests import smart_ptr_private_first_base as m
 
-def test_make_pass():
+
+def test_make_drvd_pass_base():
     d = m.make_shared_drvd()
     i = m.pass_shared_base(d)
     assert i == 200
+
+
+def test_make_drvd_up_cast_pass_drvd():
+    b = m.make_shared_drvd_up_cast()
+    # the base return is up-cast immediately.
+    assert b.__class__.__name__ == "drvd"
+    i = m.pass_shared_drvd(b)
+    assert i == 200

From 47e46c4418c0f441302ef571fbca029ce21559c1 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 24 Dec 2020 03:56:48 -0800
Subject: [PATCH 013/206] fixing up-down mixup in comment

---
 tests/test_smart_ptr_private_first_base.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_smart_ptr_private_first_base.py b/tests/test_smart_ptr_private_first_base.py
index a749a46658..e085646a95 100644
--- a/tests/test_smart_ptr_private_first_base.py
+++ b/tests/test_smart_ptr_private_first_base.py
@@ -12,7 +12,7 @@ def test_make_drvd_pass_base():
 
 def test_make_drvd_up_cast_pass_drvd():
     b = m.make_shared_drvd_up_cast()
-    # the base return is up-cast immediately.
+    # the base return is down-cast immediately.
     assert b.__class__.__name__ == "drvd"
     i = m.pass_shared_drvd(b)
     assert i == 200

From aa9899345b7b07d3066d5819b6cedb6414d71627 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 24 Dec 2020 05:09:55 -0800
Subject: [PATCH 014/206] Demonstration of Undefined Behavior in handling of
 polymorphic pointers.

(This demo does NOT involve smart pointers at all, unlike the otherwise similar test_smart_ptr_private_first_base.)
---
 tests/test_private_first_base.cpp | 66 +++++++++++++++++++++++++++++++
 tests/test_private_first_base.py  | 18 +++++++++
 2 files changed, 84 insertions(+)
 create mode 100644 tests/test_private_first_base.cpp
 create mode 100644 tests/test_private_first_base.py

diff --git a/tests/test_private_first_base.cpp b/tests/test_private_first_base.cpp
new file mode 100644
index 0000000000..3e4f3e3a46
--- /dev/null
+++ b/tests/test_private_first_base.cpp
@@ -0,0 +1,66 @@
+// Demonstration of UB (Undefined Behavior) in handling of polymorphic pointers,
+// specifically:
+// https://github.com/pybind/pybind11/blob/30eb39ed79d1e2eeff15219ac00773034300a5e6/include/pybind11/cast.h#L229
+//     `return reinterpret_cast<V *&>(vh[0]);`
+// casts a `void` pointer to a `base`. The `void` pointer is obtained through
+// a `dynamic_cast` here:
+// https://github.com/pybind/pybind11/blob/30eb39ed79d1e2eeff15219ac00773034300a5e6/include/pybind11/cast.h#L852
+//     `return dynamic_cast<const void*>(src);`
+// The `dynamic_cast` is well-defined:
+// https://en.cppreference.com/w/cpp/language/dynamic_cast
+//     4) If expression is a pointer to a polymorphic type, and new-type
+//        is a pointer to void, the result is a pointer to the most derived
+//        object pointed or referenced by expression.
+// But the `reinterpret_cast` above is UB: `test_make_drvd_pass_base` in
+// `test_private_first_base.py` fails with a Segmentation Fault (Linux,
+// clang++ -std=c++17).
+// The only well-defined cast is back to a `drvd` pointer (`static_cast` can be
+// used), which can then safely be cast up to a `base` pointer. Note that
+// `test_make_drvd_up_cast_pass_drvd` passes because the `void` pointer is cast
+// to `drvd` pointer in this situation.
+
+#include "pybind11_tests.h"
+
+namespace pybind11_tests {
+namespace private_first_base {
+
+struct base {
+  base() : base_id(100) {}
+  virtual ~base() = default;
+  virtual int id() const { return base_id; }
+  base(const base&) = default;
+  int base_id;
+};
+
+struct private_first_base {  // Any class with a virtual function will do.
+  private_first_base() {}
+  virtual void some_other_virtual_function() const {}
+  virtual ~private_first_base() = default;
+  private_first_base(const private_first_base&) = default;
+};
+
+struct drvd : private private_first_base, public base {
+  drvd() {}
+  int id() const override { return 2 * base_id; }
+};
+
+inline drvd* make_drvd() { return new drvd; }
+inline base* make_drvd_up_cast() { return new drvd; }
+
+inline int pass_base(const base* b) { return b->id(); }
+inline int pass_drvd(const drvd* d) { return d->id(); }
+
+TEST_SUBMODULE(private_first_base, m) {
+  py::class_<base>(m, "base");
+  py::class_<drvd, base>(m, "drvd");
+
+  m.def("make_drvd", make_drvd,
+        py::return_value_policy::take_ownership);
+  m.def("make_drvd_up_cast", make_drvd_up_cast,
+        py::return_value_policy::take_ownership);
+  m.def("pass_base", pass_base);
+  m.def("pass_drvd", pass_drvd);
+}
+
+}  // namespace private_first_base
+}  // namespace pybind11_tests
diff --git a/tests/test_private_first_base.py b/tests/test_private_first_base.py
new file mode 100644
index 0000000000..7004da50e4
--- /dev/null
+++ b/tests/test_private_first_base.py
@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+from pybind11_tests import private_first_base as m
+
+
+def test_make_drvd_pass_base():
+    d = m.make_drvd()
+    i = m.pass_base(d)
+    assert i == 200
+
+
+def test_make_drvd_up_cast_pass_drvd():
+    b = m.make_drvd_up_cast()
+    # the base return is down-cast immediately.
+    assert b.__class__.__name__ == "drvd"
+    i = m.pass_drvd(b)
+    assert i == 200

From cd645e43530cb23464de15cf71c40a25a0d43857 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 25 Dec 2020 08:31:07 -0800
Subject: [PATCH 015/206] minor test_private_first_base.cpp simplification
 (after discovering that this can be wrapped with Boost.Python, using
 boost::noncopyable)

---
 tests/test_private_first_base.cpp | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/tests/test_private_first_base.cpp b/tests/test_private_first_base.cpp
index 3e4f3e3a46..16aa8c361a 100644
--- a/tests/test_private_first_base.cpp
+++ b/tests/test_private_first_base.cpp
@@ -28,19 +28,16 @@ struct base {
   base() : base_id(100) {}
   virtual ~base() = default;
   virtual int id() const { return base_id; }
-  base(const base&) = default;
+  base(const base&) = delete;
   int base_id;
 };
 
 struct private_first_base {  // Any class with a virtual function will do.
-  private_first_base() {}
   virtual void some_other_virtual_function() const {}
   virtual ~private_first_base() = default;
-  private_first_base(const private_first_base&) = default;
 };
 
 struct drvd : private private_first_base, public base {
-  drvd() {}
   int id() const override { return 2 * base_id; }
 };
 

From d4a9613b7b8cf8028bd4f4a9b6d043e5bb5e8fb1 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 30 Dec 2020 11:43:09 -0800
Subject: [PATCH 016/206] pybind11 equivalent of Boost.Python test similar to
 reproducer under #1333

---
 tests/test_cpp_base_py_derived.cpp | 57 ++++++++++++++++++++++++++++++
 tests/test_cpp_base_py_derived.py  | 38 ++++++++++++++++++++
 2 files changed, 95 insertions(+)
 create mode 100644 tests/test_cpp_base_py_derived.cpp
 create mode 100644 tests/test_cpp_base_py_derived.py

diff --git a/tests/test_cpp_base_py_derived.cpp b/tests/test_cpp_base_py_derived.cpp
new file mode 100644
index 0000000000..cbc117f44a
--- /dev/null
+++ b/tests/test_cpp_base_py_derived.cpp
@@ -0,0 +1,57 @@
+// pybind11 equivalent of Boost.Python test:
+// https://github.com/rwgk/rwgk_tbx/blob/6c9a6d6bc72d5c1b8609724433259c5b47178680/cpp_base_py_derived_ext.cpp
+// See also: https://github.com/pybind/pybind11/issues/1333 (this was the starting point)
+
+#include "pybind11_tests.h"
+
+namespace pybind11_tests {
+namespace cpp_base_py_derived {
+
+struct base {
+  base() : base_num(100) {}
+
+  virtual int get_num() const { return base_num; }
+
+  virtual std::shared_ptr<base> clone() const {
+    return std::shared_ptr<base>(new base(150));
+  }
+
+  virtual ~base() = default;
+
+ private:
+  explicit base(int num) : base_num(num) {}
+  int base_num;
+};
+
+inline int get_num(std::shared_ptr<base> b) { return b->get_num(); }
+
+inline int clone_get_num(std::shared_ptr<base> b) {
+  std::shared_ptr<base> c = b->clone();
+  return (b->get_num() + 3) * 1000 + (c->get_num() + 7);
+}
+
+struct base_trampoline : public base {
+  using base::base;
+
+  int get_num() const override {
+    PYBIND11_OVERRIDE(int, base, get_num);
+  }
+
+  std::shared_ptr<base> clone() const override {
+    PYBIND11_OVERRIDE(std::shared_ptr<base>, base, clone);
+  }
+};
+
+TEST_SUBMODULE(cpp_base_py_derived, m) {
+  py::class_<base, base_trampoline, std::shared_ptr<base>>(m, "base")
+    .def(py::init<>())
+    .def("get_num", &base::get_num)
+    .def("clone", &base::clone)
+  ;
+
+  m.def("get_num", get_num);
+  m.def("clone_get_num", clone_get_num);
+}
+
+}  // namespace cpp_base_py_derived
+}  // namespace pybind11_tests
diff --git a/tests/test_cpp_base_py_derived.py b/tests/test_cpp_base_py_derived.py
new file mode 100644
index 0000000000..3a36c81fe9
--- /dev/null
+++ b/tests/test_cpp_base_py_derived.py
@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# pybind11 equivalent of Boost.Python test:
+# https://github.com/rwgk/rwgk_tbx/blob/6c9a6d6bc72d5c1b8609724433259c5b47178680/tst_cpp_base_py_derived.py
+# See also: https://github.com/pybind/pybind11/issues/1333 (this was the starting point)
+import pytest
+
+from pybind11_tests import cpp_base_py_derived as m
+
+
+class drvd(m.base):
+
+  def __init__(self, _num = 200):
+    super().__init__()
+    self._drvd_num = _num
+
+  def get_num(self):
+    return self._drvd_num
+
+  def clone(self):
+    return drvd(250)
+
+
+def test_base():
+  b = m.base()
+  assert b.get_num() == 100
+  m.get_num(b) == 100
+  bc = b.clone()
+  assert bc.get_num() == 150
+  assert m.clone_get_num(b) == 103157
+
+
+def test_drvd():
+  d = drvd()
+  assert d.get_num() == 200
+  assert m.get_num(d) == 200
+  dc = d.clone()
+  assert dc.get_num() == 250
+  assert m.clone_get_num(d) == 203257

From 0ef2c5554ebc44a9e68288a971673922bf102c0f Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 5 Jan 2021 09:45:31 -0800
Subject: [PATCH 017/206] Snapshot of WIP, TODO: shared_ptr deleter with on/off
 switch

---
 include/pybind11/smart_holder_poc.h | 75 +++++++++++++++++++++++++++++
 tests/test_smart_holder_poc.cpp     | 32 ++++++++++++
 tests/test_smart_holder_poc.py      |  8 +++
 3 files changed, 115 insertions(+)
 create mode 100644 include/pybind11/smart_holder_poc.h
 create mode 100644 tests/test_smart_holder_poc.cpp
 create mode 100644 tests/test_smart_holder_poc.py

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
new file mode 100644
index 0000000000..1f14fba92b
--- /dev/null
+++ b/include/pybind11/smart_holder_poc.h
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <memory>
+#include <typeinfo>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+struct smart_holder {
+  std::shared_ptr<void> vptr;
+  const std::type_info* rtti_held;
+  const std::type_info* rtti_uqp_del;
+  bool have_external_shp;
+
+  smart_holder()
+      : rtti_held{nullptr}, rtti_uqp_del{nullptr}, have_external_shp(false) {}
+
+  template <typename T>
+  void ensure_compatible_rtti(const char* context) {
+    const std::type_info* rtti_requested = &typeid(T);
+    if (!(*rtti_requested == *rtti_held)) {
+      throw std::runtime_error(std::string("Incompatible RTTI (") + context +
+                               ").");
+    }
+  }
+
+  void ensure_use_count_1(const char* context) {
+    if (vptr.use_count() != 1) {
+      throw std::runtime_error(std::string("Cannot disown use_count != 1 (") +
+                               context + ").");
+    }
+  }
+
+  void ensure_unique_ptr_default_deleter(const char* context) {
+    if (rtti_uqp_del != nullptr) {
+      throw std::runtime_error(
+          std::string("Cannot disown unique_ptr deleter (") + context + ").");
+    }
+  }
+
+  void ensure_internal_shared_ptr(const char* context) {
+    if (have_external_shp) {
+      throw std::runtime_error(
+          std::string("Cannot disown external shared_ptr (") + context + ").");
+    }
+  }
+
+  template <typename T>
+  void from_raw_ptr_owned(T* raw_ptr) {
+    vptr.reset(raw_ptr);
+    rtti_held = &typeid(T);
+  }
+
+  template <typename T>
+  T* as_raw_ptr_owned() {
+    static const char* context = "as_raw_ptr_owned";
+    ensure_compatible_rtti<T>(context);
+    ensure_use_count_1(context);
+    ensure_unique_ptr_default_deleter(context);
+    ensure_internal_shared_ptr(context);
+    std::shared_ptr<T> tptr = std::static_pointer_cast<T>(vptr);
+    vptr.reset();
+    T* result = tptr.get();
+    // TODO tptr.release();
+    return result;
+  }
+
+  template <typename T>
+  std::shared_ptr<T> as_shared_ptr() {
+    static const char* context = "as_shared_ptr";
+    ensure_compatible_rtti<T>(context);
+    return std::static_pointer_cast<T>(vptr);
+  }
+};
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/tests/test_smart_holder_poc.cpp b/tests/test_smart_holder_poc.cpp
new file mode 100644
index 0000000000..09db276bb4
--- /dev/null
+++ b/tests/test_smart_holder_poc.cpp
@@ -0,0 +1,32 @@
+#include "pybind11_tests.h"
+
+#include <pybind11/smart_holder_poc.h>
+
+#include <iostream>
+#include <string>
+
+namespace pybind11_tests {
+namespace smart_holder_poc {
+
+inline void to_cout(std::string msg) { std::cout << msg << std::endl; }
+
+inline void exercise() {
+  to_cout("");
+  namespace py = pybind11;
+  py::smart_holder hld;
+  hld.from_raw_ptr_owned(new int(13));
+  to_cout(hld.rtti_held->name());
+  {
+    std::shared_ptr<int> val = hld.as_shared_ptr<int>();
+    to_cout(std::to_string(*val));
+  }
+  {
+    std::unique_ptr<int> val(hld.as_raw_ptr_owned<int>());
+    to_cout(std::to_string(*val));
+  }
+}
+
+TEST_SUBMODULE(smart_holder_poc, m) { m.def("exercise", exercise); }
+
+}  // namespace smart_holder_poc
+}  // namespace pybind11_tests
diff --git a/tests/test_smart_holder_poc.py b/tests/test_smart_holder_poc.py
new file mode 100644
index 0000000000..1606e0cf41
--- /dev/null
+++ b/tests/test_smart_holder_poc.py
@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+from pybind11_tests import smart_holder_poc as m
+
+
+def test_exercise():
+    m.exercise()

From c5e112c2d4f86d6a7f29111689d5ef20120ba858 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 5 Jan 2021 10:38:00 -0800
Subject: [PATCH 018/206] Adding vptr_deleter.

---
 include/pybind11/smart_holder_poc.h | 34 +++++++++++++++--------------
 1 file changed, 18 insertions(+), 16 deletions(-)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index 1f14fba92b..43759ed2db 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -9,10 +9,19 @@ struct smart_holder {
   std::shared_ptr<void> vptr;
   const std::type_info* rtti_held;
   const std::type_info* rtti_uqp_del;
-  bool have_external_shp;
+  bool vptr_deleter_flag;
+
+  template <typename T>
+  struct vptr_deleter {
+    bool* flag_ptr;
+    explicit vptr_deleter(bool* flag_ptr_) : flag_ptr{flag_ptr_} {}
+    void operator()(T* raw_ptr) {
+      if (*flag_ptr) delete raw_ptr;
+    }
+  };
 
   smart_holder()
-      : rtti_held{nullptr}, rtti_uqp_del{nullptr}, have_external_shp(false) {}
+      : rtti_held{nullptr}, rtti_uqp_del{nullptr}, vptr_deleter_flag{false} {}
 
   template <typename T>
   void ensure_compatible_rtti(const char* context) {
@@ -30,23 +39,17 @@ struct smart_holder {
     }
   }
 
-  void ensure_unique_ptr_default_deleter(const char* context) {
+  void ensure_vptr_deleter_flag_true(const char* context) {
     if (rtti_uqp_del != nullptr) {
-      throw std::runtime_error(
-          std::string("Cannot disown unique_ptr deleter (") + context + ").");
-    }
-  }
-
-  void ensure_internal_shared_ptr(const char* context) {
-    if (have_external_shp) {
-      throw std::runtime_error(
-          std::string("Cannot disown external shared_ptr (") + context + ").");
+      throw std::runtime_error(std::string("Cannot disown this shared_ptr (") +
+                               context + ").");
     }
   }
 
   template <typename T>
   void from_raw_ptr_owned(T* raw_ptr) {
-    vptr.reset(raw_ptr);
+    vptr_deleter_flag = true;
+    vptr.reset(raw_ptr, vptr_deleter<T>(&vptr_deleter_flag));
     rtti_held = &typeid(T);
   }
 
@@ -55,12 +58,11 @@ struct smart_holder {
     static const char* context = "as_raw_ptr_owned";
     ensure_compatible_rtti<T>(context);
     ensure_use_count_1(context);
-    ensure_unique_ptr_default_deleter(context);
-    ensure_internal_shared_ptr(context);
+    ensure_vptr_deleter_flag_true(context);
     std::shared_ptr<T> tptr = std::static_pointer_cast<T>(vptr);
     vptr.reset();
     T* result = tptr.get();
-    // TODO tptr.release();
+    vptr_deleter_flag = false;
     return result;
   }
 

From 3c0c2e9daddc8076405dcb40111d4e1a157930e0 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 5 Jan 2021 16:25:25 -0800
Subject: [PATCH 019/206] Adding from/as unique_ptr<T> and unique_ptr<T, D>.

---
 include/pybind11/smart_holder_poc.h | 127 ++++++++++++++++++++++------
 tests/test_smart_holder_poc.cpp     |  49 +++++++++--
 2 files changed, 143 insertions(+), 33 deletions(-)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index 43759ed2db..6ea0aa24d5 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -5,26 +5,42 @@
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 
+template <typename T>
+struct guarded_builtin_delete {
+  bool* flag_ptr;
+  explicit guarded_builtin_delete(bool* flag_ptr_) : flag_ptr{flag_ptr_} {}
+  void operator()(T* raw_ptr) {
+    if (*flag_ptr) delete raw_ptr;
+  }
+};
+
+template <typename T, typename D>
+struct guarded_custom_deleter {
+  bool* flag_ptr;
+  explicit guarded_custom_deleter(bool* flag_ptr_) : flag_ptr{flag_ptr_} {}
+  void operator()(T* raw_ptr) {
+    if (*flag_ptr) D()(raw_ptr);
+  }
+};
+
 struct smart_holder {
   std::shared_ptr<void> vptr;
   const std::type_info* rtti_held;
   const std::type_info* rtti_uqp_del;
   bool vptr_deleter_flag;
 
-  template <typename T>
-  struct vptr_deleter {
-    bool* flag_ptr;
-    explicit vptr_deleter(bool* flag_ptr_) : flag_ptr{flag_ptr_} {}
-    void operator()(T* raw_ptr) {
-      if (*flag_ptr) delete raw_ptr;
-    }
-  };
+  void clear() {
+    vptr.reset();
+    vptr_deleter_flag = false;
+    rtti_held = nullptr;
+    rtti_uqp_del = nullptr;
+  }
 
   smart_holder()
       : rtti_held{nullptr}, rtti_uqp_del{nullptr}, vptr_deleter_flag{false} {}
 
   template <typename T>
-  void ensure_compatible_rtti(const char* context) {
+  void ensure_compatible_rtti_held(const char* context) {
     const std::type_info* rtti_requested = &typeid(T);
     if (!(*rtti_requested == *rtti_held)) {
       throw std::runtime_error(std::string("Incompatible RTTI (") + context +
@@ -32,10 +48,12 @@ struct smart_holder {
     }
   }
 
-  void ensure_use_count_1(const char* context) {
-    if (vptr.use_count() != 1) {
-      throw std::runtime_error(std::string("Cannot disown use_count != 1 (") +
-                               context + ").");
+  template <typename D>
+  void ensure_compatible_rtti_uqp_del(const char* context) {
+    const std::type_info* rtti_requested = &typeid(D);
+    if (!(*rtti_requested == *rtti_uqp_del)) {
+      throw std::runtime_error(
+          std::string("Incompatible unique_ptr deleter (") + context + ").");
     }
   }
 
@@ -46,31 +64,88 @@ struct smart_holder {
     }
   }
 
+  void ensure_use_count_1(const char* context) {
+    if (vptr.use_count() != 1) {
+      throw std::runtime_error(std::string("Cannot disown use_count != 1 (") +
+                               context + ").");
+    }
+  }
+
+  template <typename T>
+  std::shared_ptr<T> as_shared_ptr() {
+    static const char* context = "as_shared_ptr";
+    ensure_compatible_rtti_held<T>(context);
+    return std::static_pointer_cast<T>(vptr);
+  }
+
   template <typename T>
   void from_raw_ptr_owned(T* raw_ptr) {
+    clear();
+    rtti_held = &typeid(T);
     vptr_deleter_flag = true;
-    vptr.reset(raw_ptr, vptr_deleter<T>(&vptr_deleter_flag));
+    vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_flag));
+  }
+
+  template <typename T>
+  void from_raw_ptr_unowned(T* raw_ptr) {
+    clear();
     rtti_held = &typeid(T);
+    vptr_deleter_flag = false;
+    vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_flag));
   }
 
   template <typename T>
-  T* as_raw_ptr_owned() {
-    static const char* context = "as_raw_ptr_owned";
-    ensure_compatible_rtti<T>(context);
-    ensure_use_count_1(context);
+  T* as_raw_ptr_owned(const char* context = "as_raw_ptr_owned") {
+    ensure_compatible_rtti_held<T>(context);
     ensure_vptr_deleter_flag_true(context);
-    std::shared_ptr<T> tptr = std::static_pointer_cast<T>(vptr);
-    vptr.reset();
-    T* result = tptr.get();
+    ensure_use_count_1(context);
+    T* raw_ptr = static_cast<T*>(vptr.get());
     vptr_deleter_flag = false;
-    return result;
+    vptr.reset();
+    return raw_ptr;
   }
 
   template <typename T>
-  std::shared_ptr<T> as_shared_ptr() {
-    static const char* context = "as_shared_ptr";
-    ensure_compatible_rtti<T>(context);
-    return std::static_pointer_cast<T>(vptr);
+  T* as_raw_ptr_unowned() {
+    static const char* context = "as_raw_ptr_unowned";
+    ensure_compatible_rtti_held<T>(context);
+    return static_cast<T*>(vptr.get());
+  }
+
+  template <typename T>
+  void from_unique_ptr(std::unique_ptr<T>&& unq_ptr) {
+    clear();
+    rtti_held = &typeid(T);
+    vptr_deleter_flag = true;
+    vptr.reset(unq_ptr.get(), guarded_builtin_delete<T>(&vptr_deleter_flag));
+    unq_ptr.release();
+  }
+
+  template <typename T>
+  std::unique_ptr<T> as_unique_ptr() {
+    return std::unique_ptr<T>(as_raw_ptr_owned<T>("as_unique_ptr"));
+  }
+
+  template <typename T, typename D>
+  void from_unique_ptr_with_deleter(std::unique_ptr<T, D>&& unq_ptr) {
+    clear();
+    rtti_held = &typeid(T);
+    rtti_uqp_del = &typeid(D);
+    vptr_deleter_flag = true;
+    vptr.reset(unq_ptr.get(), guarded_custom_deleter<T, D>(&vptr_deleter_flag));
+    unq_ptr.release();
+  }
+
+  template <typename T, typename D>
+  std::unique_ptr<T, D> as_unique_ptr_with_deleter() {
+    static const char* context = "as_unique_ptr_with_deleter";
+    ensure_compatible_rtti_held<T>(context);
+    ensure_compatible_rtti_uqp_del<D>(context);
+    ensure_use_count_1(context);
+    T* raw_ptr = static_cast<T*>(vptr.get());
+    vptr_deleter_flag = false;
+    vptr.reset();
+    return std::unique_ptr<T, D>(raw_ptr);
   }
 };
 
diff --git a/tests/test_smart_holder_poc.cpp b/tests/test_smart_holder_poc.cpp
index 09db276bb4..b26363b374 100644
--- a/tests/test_smart_holder_poc.cpp
+++ b/tests/test_smart_holder_poc.cpp
@@ -10,19 +10,54 @@ namespace smart_holder_poc {
 
 inline void to_cout(std::string msg) { std::cout << msg << std::endl; }
 
+template <typename T>
+struct functor_builtin_delete {
+  void operator()(T* ptr) { delete ptr; }
+};
+
 inline void exercise() {
   to_cout("");
   namespace py = pybind11;
-  py::smart_holder hld;
-  hld.from_raw_ptr_owned(new int(13));
-  to_cout(hld.rtti_held->name());
   {
-    std::shared_ptr<int> val = hld.as_shared_ptr<int>();
-    to_cout(std::to_string(*val));
+    py::smart_holder hld;
+    hld.from_raw_ptr_owned(new int(13));
+    to_cout(hld.rtti_held->name());
+    {
+      std::shared_ptr<int> val = hld.as_shared_ptr<int>();
+      to_cout(std::to_string(*val));
+    }
+    {
+      std::unique_ptr<int> val(hld.as_raw_ptr_owned<int>());
+      to_cout(std::to_string(*val));
+    }
+  }  // namespace ;
+  {
+    std::unique_ptr<int> val(new int(13));
+    py::smart_holder hld;
+    hld.from_raw_ptr_unowned(val.get());
+    to_cout(std::to_string(*hld.as_raw_ptr_unowned<int>()));
+  }
+  {
+    std::unique_ptr<int> val(new int(13));
+    py::smart_holder hld;
+    hld.from_unique_ptr(std::move(val));
+    to_cout(std::to_string(*hld.as_raw_ptr_unowned<int>()));
+  }
+  {
+    py::smart_holder hld;
+    hld.from_raw_ptr_owned(new int(13));
+    to_cout(std::to_string(*hld.as_unique_ptr<int>()));
   }
   {
-    std::unique_ptr<int> val(hld.as_raw_ptr_owned<int>());
-    to_cout(std::to_string(*val));
+    std::unique_ptr<int, functor_builtin_delete<int>> unq_ptr(new int(13));
+    py::smart_holder hld;
+    hld.from_unique_ptr_with_deleter(std::move(unq_ptr));
+    to_cout(std::to_string(unq_ptr.get() == nullptr));
+    to_cout(std::to_string(*hld.as_raw_ptr_unowned<int>()));
+    auto unq_ptr_retrieved =
+        hld.as_unique_ptr_with_deleter<int, functor_builtin_delete<int>>();
+    to_cout(std::to_string(hld.vptr.get() == nullptr));
+    to_cout(std::to_string(*unq_ptr_retrieved));
   }
 }
 

From 06151c759a4e03c2af5150c043d69fd2d7ca1321 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 6 Jan 2021 12:46:19 -0800
Subject: [PATCH 020/206] Adding from_shared_ptr. Some polishing.

---
 include/pybind11/smart_holder_poc.h | 69 ++++++++++++++++++-----------
 tests/test_smart_holder_poc.cpp     | 18 +++++---
 2 files changed, 54 insertions(+), 33 deletions(-)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index 6ea0aa24d5..8216eaeab3 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -3,12 +3,14 @@
 #include <memory>
 #include <typeinfo>
 
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+namespace pybindit {
+namespace memory {
 
 template <typename T>
 struct guarded_builtin_delete {
   bool* flag_ptr;
-  explicit guarded_builtin_delete(bool* flag_ptr_) : flag_ptr{flag_ptr_} {}
+  explicit guarded_builtin_delete(bool* guard_flag_ptr)
+      : flag_ptr{guard_flag_ptr} {}
   void operator()(T* raw_ptr) {
     if (*flag_ptr) delete raw_ptr;
   }
@@ -17,27 +19,30 @@ struct guarded_builtin_delete {
 template <typename T, typename D>
 struct guarded_custom_deleter {
   bool* flag_ptr;
-  explicit guarded_custom_deleter(bool* flag_ptr_) : flag_ptr{flag_ptr_} {}
+  explicit guarded_custom_deleter(bool* guard_flag_ptr)
+      : flag_ptr{guard_flag_ptr} {}
   void operator()(T* raw_ptr) {
     if (*flag_ptr) D()(raw_ptr);
   }
 };
 
 struct smart_holder {
-  std::shared_ptr<void> vptr;
   const std::type_info* rtti_held;
   const std::type_info* rtti_uqp_del;
-  bool vptr_deleter_flag;
+  std::shared_ptr<void> vptr;
+  bool vptr_deleter_guard_flag;
 
   void clear() {
     vptr.reset();
-    vptr_deleter_flag = false;
+    vptr_deleter_guard_flag = false;
     rtti_held = nullptr;
     rtti_uqp_del = nullptr;
   }
 
   smart_holder()
-      : rtti_held{nullptr}, rtti_uqp_del{nullptr}, vptr_deleter_flag{false} {}
+      : rtti_held{nullptr},
+        rtti_uqp_del{nullptr},
+        vptr_deleter_guard_flag{false} {}
 
   template <typename T>
   void ensure_compatible_rtti_held(const char* context) {
@@ -57,7 +62,7 @@ struct smart_holder {
     }
   }
 
-  void ensure_vptr_deleter_flag_true(const char* context) {
+  void ensure_vptr_deleter_guard_flag_true(const char* context) {
     if (rtti_uqp_del != nullptr) {
       throw std::runtime_error(std::string("Cannot disown this shared_ptr (") +
                                context + ").");
@@ -71,36 +76,29 @@ struct smart_holder {
     }
   }
 
-  template <typename T>
-  std::shared_ptr<T> as_shared_ptr() {
-    static const char* context = "as_shared_ptr";
-    ensure_compatible_rtti_held<T>(context);
-    return std::static_pointer_cast<T>(vptr);
-  }
-
   template <typename T>
   void from_raw_ptr_owned(T* raw_ptr) {
     clear();
     rtti_held = &typeid(T);
-    vptr_deleter_flag = true;
-    vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_flag));
+    vptr_deleter_guard_flag = true;
+    vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
   }
 
   template <typename T>
   void from_raw_ptr_unowned(T* raw_ptr) {
     clear();
     rtti_held = &typeid(T);
-    vptr_deleter_flag = false;
-    vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_flag));
+    vptr_deleter_guard_flag = false;
+    vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
   }
 
   template <typename T>
   T* as_raw_ptr_owned(const char* context = "as_raw_ptr_owned") {
     ensure_compatible_rtti_held<T>(context);
-    ensure_vptr_deleter_flag_true(context);
+    ensure_vptr_deleter_guard_flag_true(context);
     ensure_use_count_1(context);
     T* raw_ptr = static_cast<T*>(vptr.get());
-    vptr_deleter_flag = false;
+    vptr_deleter_guard_flag = false;
     vptr.reset();
     return raw_ptr;
   }
@@ -116,8 +114,9 @@ struct smart_holder {
   void from_unique_ptr(std::unique_ptr<T>&& unq_ptr) {
     clear();
     rtti_held = &typeid(T);
-    vptr_deleter_flag = true;
-    vptr.reset(unq_ptr.get(), guarded_builtin_delete<T>(&vptr_deleter_flag));
+    vptr_deleter_guard_flag = true;
+    vptr.reset(unq_ptr.get(),
+               guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
     unq_ptr.release();
   }
 
@@ -131,8 +130,9 @@ struct smart_holder {
     clear();
     rtti_held = &typeid(T);
     rtti_uqp_del = &typeid(D);
-    vptr_deleter_flag = true;
-    vptr.reset(unq_ptr.get(), guarded_custom_deleter<T, D>(&vptr_deleter_flag));
+    vptr_deleter_guard_flag = true;
+    vptr.reset(unq_ptr.get(),
+               guarded_custom_deleter<T, D>(&vptr_deleter_guard_flag));
     unq_ptr.release();
   }
 
@@ -143,10 +143,25 @@ struct smart_holder {
     ensure_compatible_rtti_uqp_del<D>(context);
     ensure_use_count_1(context);
     T* raw_ptr = static_cast<T*>(vptr.get());
-    vptr_deleter_flag = false;
+    vptr_deleter_guard_flag = false;
     vptr.reset();
     return std::unique_ptr<T, D>(raw_ptr);
   }
+
+  template <typename T>
+  void from_shared_ptr(std::shared_ptr<T> shd_ptr) {
+    clear();
+    rtti_held = &typeid(T);
+    vptr = std::static_pointer_cast<void>(shd_ptr);
+  }
+
+  template <typename T>
+  std::shared_ptr<T> as_shared_ptr() {
+    static const char* context = "as_shared_ptr";
+    ensure_compatible_rtti_held<T>(context);
+    return std::static_pointer_cast<T>(vptr);
+  }
 };
 
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
+}  // namespace memory
+}  // namespace pybindit
diff --git a/tests/test_smart_holder_poc.cpp b/tests/test_smart_holder_poc.cpp
index b26363b374..8a750c444f 100644
--- a/tests/test_smart_holder_poc.cpp
+++ b/tests/test_smart_holder_poc.cpp
@@ -17,9 +17,9 @@ struct functor_builtin_delete {
 
 inline void exercise() {
   to_cout("");
-  namespace py = pybind11;
+  using pybindit::memory::smart_holder;
   {
-    py::smart_holder hld;
+    smart_holder hld;
     hld.from_raw_ptr_owned(new int(13));
     to_cout(hld.rtti_held->name());
     {
@@ -33,24 +33,24 @@ inline void exercise() {
   }  // namespace ;
   {
     std::unique_ptr<int> val(new int(13));
-    py::smart_holder hld;
+    smart_holder hld;
     hld.from_raw_ptr_unowned(val.get());
     to_cout(std::to_string(*hld.as_raw_ptr_unowned<int>()));
   }
   {
     std::unique_ptr<int> val(new int(13));
-    py::smart_holder hld;
+    smart_holder hld;
     hld.from_unique_ptr(std::move(val));
     to_cout(std::to_string(*hld.as_raw_ptr_unowned<int>()));
   }
   {
-    py::smart_holder hld;
+    smart_holder hld;
     hld.from_raw_ptr_owned(new int(13));
     to_cout(std::to_string(*hld.as_unique_ptr<int>()));
   }
   {
     std::unique_ptr<int, functor_builtin_delete<int>> unq_ptr(new int(13));
-    py::smart_holder hld;
+    smart_holder hld;
     hld.from_unique_ptr_with_deleter(std::move(unq_ptr));
     to_cout(std::to_string(unq_ptr.get() == nullptr));
     to_cout(std::to_string(*hld.as_raw_ptr_unowned<int>()));
@@ -59,6 +59,12 @@ inline void exercise() {
     to_cout(std::to_string(hld.vptr.get() == nullptr));
     to_cout(std::to_string(*unq_ptr_retrieved));
   }
+  {
+    std::shared_ptr<int> val(new int(13));
+    smart_holder hld;
+    hld.from_shared_ptr(val);
+    to_cout(std::to_string(*hld.as_raw_ptr_unowned<int>()));
+  }
 }
 
 TEST_SUBMODULE(smart_holder_poc, m) { m.def("exercise", exercise); }

From 6830a31a89ad226f7977f03e500af8728900110a Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 6 Jan 2021 16:45:49 -0800
Subject: [PATCH 021/206] New tests/core/smart_holder_poc_test.cpp, using
 Catch2.

---
 include/pybind11/smart_holder_poc.h  | 38 ++++++++---
 tests/core/smart_holder_poc_test.cpp | 99 ++++++++++++++++++++++++++++
 2 files changed, 128 insertions(+), 9 deletions(-)
 create mode 100644 tests/core/smart_holder_poc_test.cpp

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index 8216eaeab3..efc89cea4c 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -1,6 +1,8 @@
 #pragma once
 
 #include <memory>
+#include <stdexcept>
+#include <string>
 #include <typeinfo>
 
 namespace pybindit {
@@ -44,8 +46,10 @@ struct smart_holder {
         rtti_uqp_del{nullptr},
         vptr_deleter_guard_flag{false} {}
 
+  bool has_pointee() const { return vptr.get() != nullptr; }
+
   template <typename T>
-  void ensure_compatible_rtti_held(const char* context) {
+  void ensure_compatible_rtti_held(const char* context) const {
     const std::type_info* rtti_requested = &typeid(T);
     if (!(*rtti_requested == *rtti_held)) {
       throw std::runtime_error(std::string("Incompatible RTTI (") + context +
@@ -54,7 +58,7 @@ struct smart_holder {
   }
 
   template <typename D>
-  void ensure_compatible_rtti_uqp_del(const char* context) {
+  void ensure_compatible_rtti_uqp_del(const char* context) const {
     const std::type_info* rtti_requested = &typeid(D);
     if (!(*rtti_requested == *rtti_uqp_del)) {
       throw std::runtime_error(
@@ -62,14 +66,21 @@ struct smart_holder {
     }
   }
 
-  void ensure_vptr_deleter_guard_flag_true(const char* context) {
+  void ensure_has_pointee(const char* context) const {
+    if (!has_pointee()) {
+      throw std::runtime_error(std::string("Disowned holder (") + context +
+                               ").");
+    }
+  }
+
+  void ensure_vptr_deleter_guard_flag_true(const char* context) const {
     if (rtti_uqp_del != nullptr) {
       throw std::runtime_error(std::string("Cannot disown this shared_ptr (") +
                                context + ").");
     }
   }
 
-  void ensure_use_count_1(const char* context) {
+  void ensure_use_count_1(const char* context) const {
     if (vptr.use_count() != 1) {
       throw std::runtime_error(std::string("Cannot disown use_count != 1 (") +
                                context + ").");
@@ -77,7 +88,15 @@ struct smart_holder {
   }
 
   template <typename T>
-  void from_raw_ptr_owned(T* raw_ptr) {
+  const T& const_value_ref() const {
+    static const char* context = "const_value_ref";
+    ensure_compatible_rtti_held<T>(context);
+    ensure_has_pointee(context);
+    return *static_cast<T*>(vptr.get());
+  }
+
+  template <typename T>
+  void from_raw_ptr_take_ownership(T* raw_ptr) {
     clear();
     rtti_held = &typeid(T);
     vptr_deleter_guard_flag = true;
@@ -93,7 +112,8 @@ struct smart_holder {
   }
 
   template <typename T>
-  T* as_raw_ptr_owned(const char* context = "as_raw_ptr_owned") {
+  T* as_raw_ptr_release_ownership(
+      const char* context = "as_raw_ptr_release_ownership") {
     ensure_compatible_rtti_held<T>(context);
     ensure_vptr_deleter_guard_flag_true(context);
     ensure_use_count_1(context);
@@ -104,7 +124,7 @@ struct smart_holder {
   }
 
   template <typename T>
-  T* as_raw_ptr_unowned() {
+  T* as_raw_ptr_unowned() const {
     static const char* context = "as_raw_ptr_unowned";
     ensure_compatible_rtti_held<T>(context);
     return static_cast<T*>(vptr.get());
@@ -122,7 +142,7 @@ struct smart_holder {
 
   template <typename T>
   std::unique_ptr<T> as_unique_ptr() {
-    return std::unique_ptr<T>(as_raw_ptr_owned<T>("as_unique_ptr"));
+    return std::unique_ptr<T>(as_raw_ptr_release_ownership<T>("as_unique_ptr"));
   }
 
   template <typename T, typename D>
@@ -156,7 +176,7 @@ struct smart_holder {
   }
 
   template <typename T>
-  std::shared_ptr<T> as_shared_ptr() {
+  std::shared_ptr<T> as_shared_ptr() const {
     static const char* context = "as_shared_ptr";
     ensure_compatible_rtti_held<T>(context);
     return std::static_pointer_cast<T>(vptr);
diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/core/smart_holder_poc_test.cpp
new file mode 100644
index 0000000000..6f91b6d181
--- /dev/null
+++ b/tests/core/smart_holder_poc_test.cpp
@@ -0,0 +1,99 @@
+#include "pybind11/smart_holder_poc.h"
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+using pybindit::memory::smart_holder;
+
+namespace helpers {
+
+template <typename T>
+struct functor_builtin_delete {
+  void operator()(T* ptr) { delete ptr; }
+};
+
+}  // namespace helpers
+
+TEST_CASE("from_raw_ptr_take_ownership=const_value_ref") {
+  smart_holder hld;
+  REQUIRE(!hld.has_pointee());
+  hld.from_raw_ptr_take_ownership(new int(19));
+  REQUIRE(hld.has_pointee());
+  REQUIRE(hld.const_value_ref<int>() == 19);
+}
+
+TEST_CASE("from_raw_ptr_unowned=const_value_ref") {
+  static int value = 19;
+  smart_holder hld;
+  hld.from_raw_ptr_unowned(&value);
+  REQUIRE(hld.const_value_ref<int>() == 19);
+}
+
+TEST_CASE("as_raw_ptr_release_ownership") {
+  smart_holder hld;
+  hld.from_raw_ptr_take_ownership(new int(19));
+  auto new_owner =
+      std::unique_ptr<int>(hld.as_raw_ptr_release_ownership<int>());
+  REQUIRE(!hld.has_pointee());
+}
+
+TEST_CASE("as_raw_ptr_unowned") {
+  smart_holder hld;
+  hld.from_raw_ptr_take_ownership(new int(19));
+  int* raw_ptr = hld.as_raw_ptr_unowned<int>();
+  REQUIRE(hld.has_pointee());
+  REQUIRE(*raw_ptr == 19);
+}
+
+TEST_CASE("from_unique_ptr=const_value_ref") {
+  std::unique_ptr<int> orig_owner(new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr(std::move(orig_owner));
+  REQUIRE(orig_owner.get() == nullptr);
+  REQUIRE(hld.const_value_ref<int>() == 19);
+}
+
+TEST_CASE("as_unique_ptr") {
+  smart_holder hld;
+  hld.from_raw_ptr_take_ownership(new int(19));
+  auto new_owner = hld.as_unique_ptr<int>();
+  REQUIRE(!hld.has_pointee());
+  REQUIRE(*new_owner == 19);
+}
+
+TEST_CASE("from_unique_ptr_with_deleter=const_value_ref") {
+  std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
+      new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr_with_deleter(std::move(orig_owner));
+  REQUIRE(orig_owner.get() == nullptr);
+  REQUIRE(hld.const_value_ref<int>() == 19);
+}
+
+TEST_CASE("as_unique_ptr_with_deleter") {
+  std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
+      new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr_with_deleter(std::move(orig_owner));
+  auto new_owner =
+      hld.as_unique_ptr_with_deleter<int,
+                                     helpers::functor_builtin_delete<int>>();
+  REQUIRE(!hld.has_pointee());
+  REQUIRE(*new_owner == 19);
+}
+
+TEST_CASE("from_shared_ptr=const_value_ref") {
+  std::shared_ptr<int> orig_owner(new int(19));
+  smart_holder hld;
+  hld.from_shared_ptr(orig_owner);
+  REQUIRE(orig_owner.get() != nullptr);
+  REQUIRE(hld.const_value_ref<int>() == 19);
+}
+
+TEST_CASE("as_shared_ptr") {
+  smart_holder hld;
+  hld.from_raw_ptr_take_ownership(new int(19));
+  auto new_owner = hld.as_shared_ptr<int>();
+  REQUIRE(hld.has_pointee());
+  REQUIRE(*new_owner == 19);
+}

From e20abab35f5f7d03de8a64a98e1622df866ee889 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 6 Jan 2021 19:23:00 -0800
Subject: [PATCH 022/206] Adding in vptr_deleter_guard_flag.

---
 include/pybind11/smart_holder_poc.h | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index efc89cea4c..bdde8d8916 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -33,18 +33,21 @@ struct smart_holder {
   const std::type_info* rtti_uqp_del;
   std::shared_ptr<void> vptr;
   bool vptr_deleter_guard_flag;
+  bool vptr_is_using_builtin_delete;
 
   void clear() {
-    vptr.reset();
-    vptr_deleter_guard_flag = false;
     rtti_held = nullptr;
     rtti_uqp_del = nullptr;
+    vptr.reset();
+    vptr_deleter_guard_flag = false;
+    vptr_is_using_builtin_delete = false;
   }
 
   smart_holder()
       : rtti_held{nullptr},
         rtti_uqp_del{nullptr},
-        vptr_deleter_guard_flag{false} {}
+        vptr_deleter_guard_flag{false},
+        vptr_is_using_builtin_delete{false} {}
 
   bool has_pointee() const { return vptr.get() != nullptr; }
 
@@ -52,7 +55,7 @@ struct smart_holder {
   void ensure_compatible_rtti_held(const char* context) const {
     const std::type_info* rtti_requested = &typeid(T);
     if (!(*rtti_requested == *rtti_held)) {
-      throw std::runtime_error(std::string("Incompatible RTTI (") + context +
+      throw std::runtime_error(std::string("Incompatible type (") + context +
                                ").");
     }
   }
@@ -73,9 +76,9 @@ struct smart_holder {
     }
   }
 
-  void ensure_vptr_deleter_guard_flag_true(const char* context) const {
-    if (rtti_uqp_del != nullptr) {
-      throw std::runtime_error(std::string("Cannot disown this shared_ptr (") +
+  void ensure_vptr_is_using_builtin_delete(const char* context) const {
+    if (!vptr_is_using_builtin_delete) {
+      throw std::runtime_error(std::string("Cannot disown custom deleter (") +
                                context + ").");
     }
   }
@@ -100,6 +103,7 @@ struct smart_holder {
     clear();
     rtti_held = &typeid(T);
     vptr_deleter_guard_flag = true;
+    vptr_is_using_builtin_delete = true;
     vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
   }
 
@@ -107,7 +111,6 @@ struct smart_holder {
   void from_raw_ptr_unowned(T* raw_ptr) {
     clear();
     rtti_held = &typeid(T);
-    vptr_deleter_guard_flag = false;
     vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
   }
 
@@ -115,7 +118,7 @@ struct smart_holder {
   T* as_raw_ptr_release_ownership(
       const char* context = "as_raw_ptr_release_ownership") {
     ensure_compatible_rtti_held<T>(context);
-    ensure_vptr_deleter_guard_flag_true(context);
+    ensure_vptr_is_using_builtin_delete(context);
     ensure_use_count_1(context);
     T* raw_ptr = static_cast<T*>(vptr.get());
     vptr_deleter_guard_flag = false;
@@ -135,6 +138,7 @@ struct smart_holder {
     clear();
     rtti_held = &typeid(T);
     vptr_deleter_guard_flag = true;
+    vptr_is_using_builtin_delete = true;
     vptr.reset(unq_ptr.get(),
                guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
     unq_ptr.release();

From fea0ebfd3dfd5ea0073ab1b980dc8cb8e06fa574 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 6 Jan 2021 19:44:30 -0800
Subject: [PATCH 023/206] Improved labeling of TEST_CASEs.

---
 tests/core/smart_holder_poc_test.cpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/core/smart_holder_poc_test.cpp
index 6f91b6d181..ded88e0016 100644
--- a/tests/core/smart_holder_poc_test.cpp
+++ b/tests/core/smart_holder_poc_test.cpp
@@ -14,7 +14,7 @@ struct functor_builtin_delete {
 
 }  // namespace helpers
 
-TEST_CASE("from_raw_ptr_take_ownership=const_value_ref") {
+TEST_CASE("from_raw_ptr_take_ownership+const_value_ref", "[feasible]") {
   smart_holder hld;
   REQUIRE(!hld.has_pointee());
   hld.from_raw_ptr_take_ownership(new int(19));
@@ -22,14 +22,14 @@ TEST_CASE("from_raw_ptr_take_ownership=const_value_ref") {
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("from_raw_ptr_unowned=const_value_ref") {
+TEST_CASE("from_raw_ptr_unowned+const_value_ref", "[feasible]") {
   static int value = 19;
   smart_holder hld;
   hld.from_raw_ptr_unowned(&value);
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("as_raw_ptr_release_ownership") {
+TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership", "[feasible]") {
   smart_holder hld;
   hld.from_raw_ptr_take_ownership(new int(19));
   auto new_owner =
@@ -37,7 +37,7 @@ TEST_CASE("as_raw_ptr_release_ownership") {
   REQUIRE(!hld.has_pointee());
 }
 
-TEST_CASE("as_raw_ptr_unowned") {
+TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_unowned", "[feasible]") {
   smart_holder hld;
   hld.from_raw_ptr_take_ownership(new int(19));
   int* raw_ptr = hld.as_raw_ptr_unowned<int>();
@@ -45,7 +45,7 @@ TEST_CASE("as_raw_ptr_unowned") {
   REQUIRE(*raw_ptr == 19);
 }
 
-TEST_CASE("from_unique_ptr=const_value_ref") {
+TEST_CASE("from_unique_ptr+const_value_ref+const_value_ref", "[feasible]") {
   std::unique_ptr<int> orig_owner(new int(19));
   smart_holder hld;
   hld.from_unique_ptr(std::move(orig_owner));
@@ -53,7 +53,7 @@ TEST_CASE("from_unique_ptr=const_value_ref") {
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("as_unique_ptr") {
+TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr", "[feasible]") {
   smart_holder hld;
   hld.from_raw_ptr_take_ownership(new int(19));
   auto new_owner = hld.as_unique_ptr<int>();
@@ -61,7 +61,7 @@ TEST_CASE("as_unique_ptr") {
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_unique_ptr_with_deleter=const_value_ref") {
+TEST_CASE("from_unique_ptr_with_deleter+const_value_ref", "[feasible]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
       new int(19));
   smart_holder hld;
@@ -70,7 +70,7 @@ TEST_CASE("from_unique_ptr_with_deleter=const_value_ref") {
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("as_unique_ptr_with_deleter") {
+TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter", "[feasible]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
       new int(19));
   smart_holder hld;
@@ -82,7 +82,7 @@ TEST_CASE("as_unique_ptr_with_deleter") {
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_shared_ptr=const_value_ref") {
+TEST_CASE("from_shared_ptr+const_value_ref", "[feasible]") {
   std::shared_ptr<int> orig_owner(new int(19));
   smart_holder hld;
   hld.from_shared_ptr(orig_owner);
@@ -90,7 +90,7 @@ TEST_CASE("from_shared_ptr=const_value_ref") {
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("as_shared_ptr") {
+TEST_CASE("from_raw_ptr_take_ownership+as_shared_ptr", "[feasible]") {
   smart_holder hld;
   hld.from_raw_ptr_take_ownership(new int(19));
   auto new_owner = hld.as_shared_ptr<int>();

From b9428a8bcdb12eac6ce8d788b6af12d6fd894fbe Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 6 Jan 2021 20:47:42 -0800
Subject: [PATCH 024/206] Shuffling existing TEST_CASEs into systematic matrix.

---
 include/pybind11/smart_holder_poc.h  |  28 +++----
 tests/core/smart_holder_poc_test.cpp | 114 ++++++++++++++++++++-------
 2 files changed, 101 insertions(+), 41 deletions(-)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index bdde8d8916..a3a85243cf 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -90,6 +90,20 @@ struct smart_holder {
     }
   }
 
+  template <typename T>
+  void from_raw_ptr_unowned(T* raw_ptr) {
+    clear();
+    rtti_held = &typeid(T);
+    vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
+  }
+
+  template <typename T>
+  T* as_raw_ptr_unowned() const {
+    static const char* context = "as_raw_ptr_unowned";
+    ensure_compatible_rtti_held<T>(context);
+    return static_cast<T*>(vptr.get());
+  }
+
   template <typename T>
   const T& const_value_ref() const {
     static const char* context = "const_value_ref";
@@ -107,13 +121,6 @@ struct smart_holder {
     vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
   }
 
-  template <typename T>
-  void from_raw_ptr_unowned(T* raw_ptr) {
-    clear();
-    rtti_held = &typeid(T);
-    vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
-  }
-
   template <typename T>
   T* as_raw_ptr_release_ownership(
       const char* context = "as_raw_ptr_release_ownership") {
@@ -126,13 +133,6 @@ struct smart_holder {
     return raw_ptr;
   }
 
-  template <typename T>
-  T* as_raw_ptr_unowned() const {
-    static const char* context = "as_raw_ptr_unowned";
-    ensure_compatible_rtti_held<T>(context);
-    return static_cast<T*>(vptr.get());
-  }
-
   template <typename T>
   void from_unique_ptr(std::unique_ptr<T>&& unq_ptr) {
     clear();
diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/core/smart_holder_poc_test.cpp
index ded88e0016..9dad8c2bb1 100644
--- a/tests/core/smart_holder_poc_test.cpp
+++ b/tests/core/smart_holder_poc_test.cpp
@@ -14,22 +14,36 @@ struct functor_builtin_delete {
 
 }  // namespace helpers
 
-TEST_CASE("from_raw_ptr_take_ownership+const_value_ref", "[feasible]") {
-  smart_holder hld;
-  REQUIRE(!hld.has_pointee());
-  hld.from_raw_ptr_take_ownership(new int(19));
-  REQUIRE(hld.has_pointee());
-  REQUIRE(hld.const_value_ref<int>() == 19);
+TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_unowned", "[S]") {
 }
 
-TEST_CASE("from_raw_ptr_unowned+const_value_ref", "[feasible]") {
+TEST_CASE("from_raw_ptr_unowned+const_value_ref", "[S]") {
   static int value = 19;
   smart_holder hld;
   hld.from_raw_ptr_unowned(&value);
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership", "[feasible]") {
+TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_release_ownership", "[E]") {
+}
+
+TEST_CASE("from_raw_ptr_unowned+as_unique_ptr", "[E]") {
+}
+
+TEST_CASE("from_raw_ptr_unowned+as_unique_ptr_with_deleter", "[E]") {
+}
+
+TEST_CASE("from_raw_ptr_unowned+as_shared_ptr", "[S]") {
+}
+
+TEST_CASE("from_raw_ptr_take_ownership+const_value_ref", "[S]") {
+  smart_holder hld;
+  hld.from_raw_ptr_take_ownership(new int(19));
+  REQUIRE(hld.has_pointee());
+  REQUIRE(hld.const_value_ref<int>() == 19);
+}
+
+TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership1", "[S]") {
   smart_holder hld;
   hld.from_raw_ptr_take_ownership(new int(19));
   auto new_owner =
@@ -37,15 +51,32 @@ TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership", "[feasible
   REQUIRE(!hld.has_pointee());
 }
 
-TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_unowned", "[feasible]") {
+TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership2", "[E]") {
+}
+
+TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr1", "[S]") {
   smart_holder hld;
   hld.from_raw_ptr_take_ownership(new int(19));
-  int* raw_ptr = hld.as_raw_ptr_unowned<int>();
+  auto new_owner = hld.as_unique_ptr<int>();
+  REQUIRE(!hld.has_pointee());
+  REQUIRE(*new_owner == 19);
+}
+
+TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr2", "[E]") {
+}
+
+TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr_with_deleter", "[E]") {
+}
+
+TEST_CASE("from_raw_ptr_take_ownership+as_shared_ptr", "[S]") {
+  smart_holder hld;
+  hld.from_raw_ptr_take_ownership(new int(19));
+  auto new_owner = hld.as_shared_ptr<int>();
   REQUIRE(hld.has_pointee());
-  REQUIRE(*raw_ptr == 19);
+  REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_unique_ptr+const_value_ref+const_value_ref", "[feasible]") {
+TEST_CASE("from_unique_ptr+const_value_ref", "[S]") {
   std::unique_ptr<int> orig_owner(new int(19));
   smart_holder hld;
   hld.from_unique_ptr(std::move(orig_owner));
@@ -53,15 +84,25 @@ TEST_CASE("from_unique_ptr+const_value_ref+const_value_ref", "[feasible]") {
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr", "[feasible]") {
-  smart_holder hld;
-  hld.from_raw_ptr_take_ownership(new int(19));
-  auto new_owner = hld.as_unique_ptr<int>();
-  REQUIRE(!hld.has_pointee());
-  REQUIRE(*new_owner == 19);
+TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership1", "[S]") {
+}
+
+TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership2", "[E]") {
+}
+
+TEST_CASE("from_unique_ptr+as_unique_ptr1", "[S]") {
+}
+
+TEST_CASE("from_unique_ptr+as_unique_ptr2", "[E]") {
+}
+
+TEST_CASE("from_unique_ptr+as_unique_ptr_with_deleter", "[E]") {
+}
+
+TEST_CASE("from_unique_ptr+as_shared_ptr", "[S]") {
 }
 
-TEST_CASE("from_unique_ptr_with_deleter+const_value_ref", "[feasible]") {
+TEST_CASE("from_unique_ptr_with_deleter+const_value_ref", "[S]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
       new int(19));
   smart_holder hld;
@@ -70,7 +111,13 @@ TEST_CASE("from_unique_ptr_with_deleter+const_value_ref", "[feasible]") {
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter", "[feasible]") {
+TEST_CASE("from_unique_ptr_with_deleter+as_raw_ptr_release_ownership", "[E]") {
+}
+
+TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr", "[E]") {
+}
+
+TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter1", "[S]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
       new int(19));
   smart_holder hld;
@@ -82,7 +129,13 @@ TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter", "[feasible]
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_shared_ptr+const_value_ref", "[feasible]") {
+TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter2", "[E]") {
+}
+
+TEST_CASE("from_unique_ptr_with_deleter+as_shared_ptr", "[S]") {
+}
+
+TEST_CASE("from_shared_ptr+const_value_ref", "[S]") {
   std::shared_ptr<int> orig_owner(new int(19));
   smart_holder hld;
   hld.from_shared_ptr(orig_owner);
@@ -90,10 +143,17 @@ TEST_CASE("from_shared_ptr+const_value_ref", "[feasible]") {
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("from_raw_ptr_take_ownership+as_shared_ptr", "[feasible]") {
-  smart_holder hld;
-  hld.from_raw_ptr_take_ownership(new int(19));
-  auto new_owner = hld.as_shared_ptr<int>();
-  REQUIRE(hld.has_pointee());
-  REQUIRE(*new_owner == 19);
+TEST_CASE("from_shared_ptr+as_raw_ptr_release_ownership1", "[S]") {
+}
+
+TEST_CASE("from_shared_ptr+as_raw_ptr_release_ownership2", "[E]") {
+}
+
+TEST_CASE("from_shared_ptr+as_unique_ptr", "[E]") {
+}
+
+TEST_CASE("from_shared_ptr+as_unique_ptr_with_deleter", "[E]") {
+}
+
+TEST_CASE("from_shared_ptr+as_shared_ptr", "[S]") {
 }

From a4e03515eb4b7a31106b009f45be4d810aadda9d Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 6 Jan 2021 21:51:05 -0800
Subject: [PATCH 025/206] Implementing all [S]uccess tests.

---
 tests/core/smart_holder_poc_test.cpp | 99 +++++++++++++++++-----------
 1 file changed, 62 insertions(+), 37 deletions(-)

diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/core/smart_holder_poc_test.cpp
index 9dad8c2bb1..bff9eb6bfe 100644
--- a/tests/core/smart_holder_poc_test.cpp
+++ b/tests/core/smart_holder_poc_test.cpp
@@ -15,6 +15,10 @@ struct functor_builtin_delete {
 }  // namespace helpers
 
 TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_unowned", "[S]") {
+  static int value = 19;
+  smart_holder hld;
+  hld.from_raw_ptr_unowned(&value);
+  REQUIRE(*hld.as_raw_ptr_unowned<int>() == 19);
 }
 
 TEST_CASE("from_raw_ptr_unowned+const_value_ref", "[S]") {
@@ -24,16 +28,17 @@ TEST_CASE("from_raw_ptr_unowned+const_value_ref", "[S]") {
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_release_ownership", "[E]") {
-}
+TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_release_ownership", "[E]") {}
 
-TEST_CASE("from_raw_ptr_unowned+as_unique_ptr", "[E]") {
-}
+TEST_CASE("from_raw_ptr_unowned+as_unique_ptr", "[E]") {}
 
-TEST_CASE("from_raw_ptr_unowned+as_unique_ptr_with_deleter", "[E]") {
-}
+TEST_CASE("from_raw_ptr_unowned+as_unique_ptr_with_deleter", "[E]") {}
 
 TEST_CASE("from_raw_ptr_unowned+as_shared_ptr", "[S]") {
+  static int value = 19;
+  smart_holder hld;
+  hld.from_raw_ptr_unowned(&value);
+  REQUIRE(*hld.as_shared_ptr<int>() == 19);
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+const_value_ref", "[S]") {
@@ -49,29 +54,27 @@ TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership1", "[S]") {
   auto new_owner =
       std::unique_ptr<int>(hld.as_raw_ptr_release_ownership<int>());
   REQUIRE(!hld.has_pointee());
+  REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership2", "[E]") {
-}
+TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership2", "[E]") {}
 
 TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr1", "[S]") {
   smart_holder hld;
   hld.from_raw_ptr_take_ownership(new int(19));
-  auto new_owner = hld.as_unique_ptr<int>();
+  std::unique_ptr<int> new_owner = hld.as_unique_ptr<int>();
   REQUIRE(!hld.has_pointee());
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr2", "[E]") {
-}
+TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr2", "[E]") {}
 
-TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr_with_deleter", "[E]") {
-}
+TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr_with_deleter", "[E]") {}
 
 TEST_CASE("from_raw_ptr_take_ownership+as_shared_ptr", "[S]") {
   smart_holder hld;
   hld.from_raw_ptr_take_ownership(new int(19));
-  auto new_owner = hld.as_shared_ptr<int>();
+  std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
   REQUIRE(hld.has_pointee());
   REQUIRE(*new_owner == 19);
 }
@@ -85,21 +88,40 @@ TEST_CASE("from_unique_ptr+const_value_ref", "[S]") {
 }
 
 TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership1", "[S]") {
+  std::unique_ptr<int> orig_owner(new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr(std::move(orig_owner));
+  REQUIRE(orig_owner.get() == nullptr);
+  auto new_owner =
+      std::unique_ptr<int>(hld.as_raw_ptr_release_ownership<int>());
+  REQUIRE(!hld.has_pointee());
+  REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership2", "[E]") {
-}
+TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership2", "[E]") {}
 
 TEST_CASE("from_unique_ptr+as_unique_ptr1", "[S]") {
+  std::unique_ptr<int> orig_owner(new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr(std::move(orig_owner));
+  REQUIRE(orig_owner.get() == nullptr);
+  std::unique_ptr<int> new_owner = hld.as_unique_ptr<int>();
+  REQUIRE(!hld.has_pointee());
+  REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_unique_ptr+as_unique_ptr2", "[E]") {
-}
+TEST_CASE("from_unique_ptr+as_unique_ptr2", "[E]") {}
 
-TEST_CASE("from_unique_ptr+as_unique_ptr_with_deleter", "[E]") {
-}
+TEST_CASE("from_unique_ptr+as_unique_ptr_with_deleter", "[E]") {}
 
 TEST_CASE("from_unique_ptr+as_shared_ptr", "[S]") {
+  std::unique_ptr<int> orig_owner(new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr(std::move(orig_owner));
+  REQUIRE(orig_owner.get() == nullptr);
+  std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
+  REQUIRE(hld.has_pointee());
+  REQUIRE(*new_owner == 19);
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+const_value_ref", "[S]") {
@@ -111,49 +133,52 @@ TEST_CASE("from_unique_ptr_with_deleter+const_value_ref", "[S]") {
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("from_unique_ptr_with_deleter+as_raw_ptr_release_ownership", "[E]") {
-}
+TEST_CASE("from_unique_ptr_with_deleter+as_raw_ptr_release_ownership", "[E]") {}
 
-TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr", "[E]") {
-}
+TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr", "[E]") {}
 
 TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter1", "[S]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
       new int(19));
   smart_holder hld;
   hld.from_unique_ptr_with_deleter(std::move(orig_owner));
-  auto new_owner =
+  REQUIRE(orig_owner.get() == nullptr);
+  std::unique_ptr<int, helpers::functor_builtin_delete<int>> new_owner =
       hld.as_unique_ptr_with_deleter<int,
                                      helpers::functor_builtin_delete<int>>();
   REQUIRE(!hld.has_pointee());
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter2", "[E]") {
-}
+TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter2", "[E]") {}
 
 TEST_CASE("from_unique_ptr_with_deleter+as_shared_ptr", "[S]") {
+  std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
+      new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr_with_deleter(std::move(orig_owner));
+  REQUIRE(orig_owner.get() == nullptr);
+  std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
+  REQUIRE(hld.has_pointee());
+  REQUIRE(*new_owner == 19);
 }
 
 TEST_CASE("from_shared_ptr+const_value_ref", "[S]") {
   std::shared_ptr<int> orig_owner(new int(19));
   smart_holder hld;
   hld.from_shared_ptr(orig_owner);
-  REQUIRE(orig_owner.get() != nullptr);
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("from_shared_ptr+as_raw_ptr_release_ownership1", "[S]") {
-}
-
-TEST_CASE("from_shared_ptr+as_raw_ptr_release_ownership2", "[E]") {
-}
+TEST_CASE("from_shared_ptr+as_raw_ptr_release_ownership", "[E]") {}
 
-TEST_CASE("from_shared_ptr+as_unique_ptr", "[E]") {
-}
+TEST_CASE("from_shared_ptr+as_unique_ptr", "[E]") {}
 
-TEST_CASE("from_shared_ptr+as_unique_ptr_with_deleter", "[E]") {
-}
+TEST_CASE("from_shared_ptr+as_unique_ptr_with_deleter", "[E]") {}
 
 TEST_CASE("from_shared_ptr+as_shared_ptr", "[S]") {
+  std::shared_ptr<int> orig_owner(new int(19));
+  smart_holder hld;
+  hld.from_shared_ptr(orig_owner);
+  REQUIRE(*hld.as_shared_ptr<int>() == 19);
 }

From 673ef13dc63249ba1bc98cd3a2621855a03891d2 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 7 Jan 2021 00:10:57 -0800
Subject: [PATCH 026/206] Implementing all [E]xception tests.

---
 include/pybind11/smart_holder_poc.h  |  28 ++++-
 tests/core/smart_holder_poc_test.cpp | 158 ++++++++++++++++++++++++---
 2 files changed, 169 insertions(+), 17 deletions(-)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index a3a85243cf..31dacb82a7 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -33,26 +33,36 @@ struct smart_holder {
   const std::type_info* rtti_uqp_del;
   std::shared_ptr<void> vptr;
   bool vptr_deleter_guard_flag;
-  bool vptr_is_using_builtin_delete;
+  bool vptr_is_using_noop_deleter : 1;
+  bool vptr_is_using_builtin_delete : 1;
+  bool vptr_is_external_shared_ptr : 1;
 
   void clear() {
     rtti_held = nullptr;
     rtti_uqp_del = nullptr;
     vptr.reset();
     vptr_deleter_guard_flag = false;
+    vptr_is_using_noop_deleter = false;
     vptr_is_using_builtin_delete = false;
+    vptr_is_external_shared_ptr = false;
   }
 
   smart_holder()
       : rtti_held{nullptr},
         rtti_uqp_del{nullptr},
         vptr_deleter_guard_flag{false},
-        vptr_is_using_builtin_delete{false} {}
+        vptr_is_using_noop_deleter{false},
+        vptr_is_using_builtin_delete{false},
+        vptr_is_external_shared_ptr{false} {}
 
   bool has_pointee() const { return vptr.get() != nullptr; }
 
   template <typename T>
   void ensure_compatible_rtti_held(const char* context) const {
+    if (!rtti_held) {
+      throw std::runtime_error(std::string("Unpopulated holder (") + context +
+                               ").");
+    }
     const std::type_info* rtti_requested = &typeid(T);
     if (!(*rtti_requested == *rtti_held)) {
       throw std::runtime_error(std::string("Incompatible type (") + context +
@@ -62,6 +72,10 @@ struct smart_holder {
 
   template <typename D>
   void ensure_compatible_rtti_uqp_del(const char* context) const {
+    if (!rtti_uqp_del) {
+      throw std::runtime_error(std::string("Missing unique_ptr deleter (") +
+                               context + ").");
+    }
     const std::type_info* rtti_requested = &typeid(D);
     if (!(*rtti_requested == *rtti_uqp_del)) {
       throw std::runtime_error(
@@ -77,6 +91,14 @@ struct smart_holder {
   }
 
   void ensure_vptr_is_using_builtin_delete(const char* context) const {
+    if (vptr_is_external_shared_ptr) {
+      throw std::runtime_error(
+          std::string("Cannot disown external shared_ptr (") + context + ").");
+    }
+    if (vptr_is_using_noop_deleter) {
+      throw std::runtime_error(
+          std::string("Cannot disown non-owning holder (") + context + ").");
+    }
     if (!vptr_is_using_builtin_delete) {
       throw std::runtime_error(std::string("Cannot disown custom deleter (") +
                                context + ").");
@@ -94,6 +116,7 @@ struct smart_holder {
   void from_raw_ptr_unowned(T* raw_ptr) {
     clear();
     rtti_held = &typeid(T);
+    vptr_is_using_noop_deleter = true;
     vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
   }
 
@@ -176,6 +199,7 @@ struct smart_holder {
   void from_shared_ptr(std::shared_ptr<T> shd_ptr) {
     clear();
     rtti_held = &typeid(T);
+    vptr_is_external_shared_ptr = true;
     vptr = std::static_pointer_cast<void>(shd_ptr);
   }
 
diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/core/smart_holder_poc_test.cpp
index bff9eb6bfe..87fda21807 100644
--- a/tests/core/smart_holder_poc_test.cpp
+++ b/tests/core/smart_holder_poc_test.cpp
@@ -12,6 +12,9 @@ struct functor_builtin_delete {
   void operator()(T* ptr) { delete ptr; }
 };
 
+template <typename T>
+struct functor_other_delete : functor_builtin_delete<T> {};
+
 }  // namespace helpers
 
 TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_unowned", "[S]") {
@@ -28,11 +31,34 @@ TEST_CASE("from_raw_ptr_unowned+const_value_ref", "[S]") {
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_release_ownership", "[E]") {}
+TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_release_ownership", "[E]") {
+  static int value = 19;
+  smart_holder hld;
+  hld.from_raw_ptr_unowned(&value);
+  REQUIRE_THROWS_WITH(
+      hld.as_raw_ptr_release_ownership<int>(),
+      "Cannot disown non-owning holder (as_raw_ptr_release_ownership).");
+}
 
-TEST_CASE("from_raw_ptr_unowned+as_unique_ptr", "[E]") {}
+TEST_CASE("from_raw_ptr_unowned+as_unique_ptr", "[E]") {
+  static int value = 19;
+  smart_holder hld;
+  hld.from_raw_ptr_unowned(&value);
+  REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
+                      "Cannot disown non-owning holder (as_unique_ptr).");
+}
 
-TEST_CASE("from_raw_ptr_unowned+as_unique_ptr_with_deleter", "[E]") {}
+TEST_CASE("from_raw_ptr_unowned+as_unique_ptr_with_deleter", "[E]") {
+  static int value = 19;
+  smart_holder hld;
+  hld.from_raw_ptr_unowned(&value);
+  auto condense_for_macro = [](smart_holder& hld) {
+    hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+  };
+  REQUIRE_THROWS_WITH(
+      condense_for_macro(hld),
+      "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
+}
 
 TEST_CASE("from_raw_ptr_unowned+as_shared_ptr", "[S]") {
   static int value = 19;
@@ -57,7 +83,14 @@ TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership1", "[S]") {
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership2", "[E]") {}
+TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership2", "[E]") {
+  smart_holder hld;
+  hld.from_raw_ptr_take_ownership(new int(19));
+  auto shd_ptr = hld.as_shared_ptr<int>();
+  REQUIRE_THROWS_WITH(
+      hld.as_raw_ptr_release_ownership<int>(),
+      "Cannot disown use_count != 1 (as_raw_ptr_release_ownership).");
+}
 
 TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr1", "[S]") {
   smart_holder hld;
@@ -67,9 +100,24 @@ TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr1", "[S]") {
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr2", "[E]") {}
+TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr2", "[E]") {
+  smart_holder hld;
+  hld.from_raw_ptr_take_ownership(new int(19));
+  auto shd_ptr = hld.as_shared_ptr<int>();
+  REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
+                      "Cannot disown use_count != 1 (as_unique_ptr).");
+}
 
-TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr_with_deleter", "[E]") {}
+TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr_with_deleter", "[E]") {
+  smart_holder hld;
+  hld.from_raw_ptr_take_ownership(new int(19));
+  auto condense_for_macro = [](smart_holder& hld) {
+    hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+  };
+  REQUIRE_THROWS_WITH(
+      condense_for_macro(hld),
+      "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
+}
 
 TEST_CASE("from_raw_ptr_take_ownership+as_shared_ptr", "[S]") {
   smart_holder hld;
@@ -98,7 +146,16 @@ TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership1", "[S]") {
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership2", "[E]") {}
+TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership2", "[E]") {
+  std::unique_ptr<int> orig_owner(new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr(std::move(orig_owner));
+  REQUIRE(orig_owner.get() == nullptr);
+  auto shd_ptr = hld.as_shared_ptr<int>();
+  REQUIRE_THROWS_WITH(
+      hld.as_raw_ptr_release_ownership<int>(),
+      "Cannot disown use_count != 1 (as_raw_ptr_release_ownership).");
+}
 
 TEST_CASE("from_unique_ptr+as_unique_ptr1", "[S]") {
   std::unique_ptr<int> orig_owner(new int(19));
@@ -110,9 +167,28 @@ TEST_CASE("from_unique_ptr+as_unique_ptr1", "[S]") {
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_unique_ptr+as_unique_ptr2", "[E]") {}
+TEST_CASE("from_unique_ptr+as_unique_ptr2", "[E]") {
+  std::unique_ptr<int> orig_owner(new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr(std::move(orig_owner));
+  REQUIRE(orig_owner.get() == nullptr);
+  auto shd_ptr = hld.as_shared_ptr<int>();
+  REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
+                      "Cannot disown use_count != 1 (as_unique_ptr).");
+}
 
-TEST_CASE("from_unique_ptr+as_unique_ptr_with_deleter", "[E]") {}
+TEST_CASE("from_unique_ptr+as_unique_ptr_with_deleter", "[E]") {
+  std::unique_ptr<int> orig_owner(new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr(std::move(orig_owner));
+  REQUIRE(orig_owner.get() == nullptr);
+  auto condense_for_macro = [](smart_holder& hld) {
+    hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+  };
+  REQUIRE_THROWS_WITH(
+      condense_for_macro(hld),
+      "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
+}
 
 TEST_CASE("from_unique_ptr+as_shared_ptr", "[S]") {
   std::unique_ptr<int> orig_owner(new int(19));
@@ -133,9 +209,26 @@ TEST_CASE("from_unique_ptr_with_deleter+const_value_ref", "[S]") {
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("from_unique_ptr_with_deleter+as_raw_ptr_release_ownership", "[E]") {}
+TEST_CASE("from_unique_ptr_with_deleter+as_raw_ptr_release_ownership", "[E]") {
+  std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
+      new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr_with_deleter(std::move(orig_owner));
+  REQUIRE(orig_owner.get() == nullptr);
+  REQUIRE_THROWS_WITH(
+      hld.as_raw_ptr_release_ownership<int>(),
+      "Cannot disown custom deleter (as_raw_ptr_release_ownership).");
+}
 
-TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr", "[E]") {}
+TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr", "[E]") {
+  std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
+      new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr_with_deleter(std::move(orig_owner));
+  REQUIRE(orig_owner.get() == nullptr);
+  REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
+                      "Cannot disown custom deleter (as_unique_ptr).");
+}
 
 TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter1", "[S]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
@@ -150,7 +243,19 @@ TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter1", "[S]") {
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter2", "[E]") {}
+TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter2", "[E]") {
+  std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
+      new int(19));
+  smart_holder hld;
+  hld.from_unique_ptr_with_deleter(std::move(orig_owner));
+  REQUIRE(orig_owner.get() == nullptr);
+  auto condense_for_macro = [](smart_holder& hld) {
+    hld.as_unique_ptr_with_deleter<int, helpers::functor_other_delete<int>>();
+  };
+  REQUIRE_THROWS_WITH(
+      condense_for_macro(hld),
+      "Incompatible unique_ptr deleter (as_unique_ptr_with_deleter).");
+}
 
 TEST_CASE("from_unique_ptr_with_deleter+as_shared_ptr", "[S]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
@@ -170,11 +275,34 @@ TEST_CASE("from_shared_ptr+const_value_ref", "[S]") {
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
-TEST_CASE("from_shared_ptr+as_raw_ptr_release_ownership", "[E]") {}
+TEST_CASE("from_shared_ptr+as_raw_ptr_release_ownership", "[E]") {
+  std::shared_ptr<int> orig_owner(new int(19));
+  smart_holder hld;
+  hld.from_shared_ptr(orig_owner);
+  REQUIRE_THROWS_WITH(
+      hld.as_raw_ptr_release_ownership<int>(),
+      "Cannot disown external shared_ptr (as_raw_ptr_release_ownership).");
+}
 
-TEST_CASE("from_shared_ptr+as_unique_ptr", "[E]") {}
+TEST_CASE("from_shared_ptr+as_unique_ptr", "[E]") {
+  std::shared_ptr<int> orig_owner(new int(19));
+  smart_holder hld;
+  hld.from_shared_ptr(orig_owner);
+  REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
+                      "Cannot disown external shared_ptr (as_unique_ptr).");
+}
 
-TEST_CASE("from_shared_ptr+as_unique_ptr_with_deleter", "[E]") {}
+TEST_CASE("from_shared_ptr+as_unique_ptr_with_deleter", "[E]") {
+  std::shared_ptr<int> orig_owner(new int(19));
+  smart_holder hld;
+  hld.from_shared_ptr(orig_owner);
+  auto condense_for_macro = [](smart_holder& hld) {
+    hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+  };
+  REQUIRE_THROWS_WITH(
+      condense_for_macro(hld),
+      "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
+}
 
 TEST_CASE("from_shared_ptr+as_shared_ptr", "[S]") {
   std::shared_ptr<int> orig_owner(new int(19));

From 149738adc480877372a3f9225c0bc51146131e9f Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 7 Jan 2021 00:29:34 -0800
Subject: [PATCH 027/206] Testing of exceptions not covered by the from-as
 matrix.

---
 tests/core/smart_holder_poc_test.cpp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/core/smart_holder_poc_test.cpp
index 87fda21807..e014757a9e 100644
--- a/tests/core/smart_holder_poc_test.cpp
+++ b/tests/core/smart_holder_poc_test.cpp
@@ -310,3 +310,25 @@ TEST_CASE("from_shared_ptr+as_shared_ptr", "[S]") {
   hld.from_shared_ptr(orig_owner);
   REQUIRE(*hld.as_shared_ptr<int>() == 19);
 }
+
+TEST_CASE("error_unpopulated_holder", "[E]") {
+  smart_holder hld;
+  REQUIRE_THROWS_WITH(hld.as_raw_ptr_unowned<int>(),
+                      "Unpopulated holder (as_raw_ptr_unowned).");
+}
+
+TEST_CASE("error_incompatible_type", "[E]") {
+  static int value = 19;
+  smart_holder hld;
+  hld.from_raw_ptr_unowned(&value);
+  REQUIRE_THROWS_WITH(hld.as_unique_ptr<std::string>(),
+                      "Incompatible type (as_unique_ptr).");
+}
+
+TEST_CASE("error_disowned_holder", "[E]") {
+  smart_holder hld;
+  hld.from_raw_ptr_take_ownership(new int(19));
+  hld.as_unique_ptr<int>();
+  REQUIRE_THROWS_WITH(hld.const_value_ref<int>(),
+                      "Disowned holder (const_value_ref).");
+}

From d5bb169ca868f6aa53ad2ff9d1f26c94fa108102 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 7 Jan 2021 11:59:01 -0800
Subject: [PATCH 028/206] Adding top-level comment.

---
 include/pybind11/smart_holder_poc.h | 38 +++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index 31dacb82a7..5a30b77961 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -1,3 +1,38 @@
+/* Proof-of-Concept for smart pointer interoperability.
+
+High-level aspects:
+
+* Support all `unique_ptr`, `shared_ptr` interops that are feasible.
+
+* Cleanly and clearly report all interops that are infeasible.
+
+* Meant to fit into a `PyObject`, as a holder for C++ objects.
+
+* Support a system design that makes it impossible to trigger
+  C++ Undefined Behavior, especially from Python.
+
+* Support a system design with clean runtime inheritance casting. From this
+  it follows that the `smart_holder` needs to be type-erased (`void*`, RTTI).
+
+Details:
+
+* The "root holder" chosen here is a `shared_ptr<void>` (named `vptr` in this
+  implementation). This choice is practically inevitable because `shared_ptr`
+  has only very limited support for inspecting and accessing its deleter.
+
+* If created from a raw pointer, or a `unique_ptr` without a custom deleter,
+  `vptr` always uses a custom deleter, to support `unique_ptr`-like disowning.
+  The custom deleters can be extended to included life-time managment for
+  external objects (e.g. `PyObject`).
+
+* If created from an external `shared_ptr`, or a `unique_ptr` with a custom
+  deleter, including life-time management for external objects is infeasible.
+
+* The `typename T` between `from` and `as` calls must match exactly.
+  Inheritance casting needs to be handled in a different layer (similar
+  to the code organization in boost/python/object/inheritance.hpp).
+*/
+
 #pragma once
 
 #include <memory>
@@ -5,6 +40,9 @@
 #include <string>
 #include <typeinfo>
 
+// pybindit = Python Bindings Innovation Track.
+// Currently not in pybind11 namespace to signal that this POC does not depend
+// on any existing pybind11 functionality.
 namespace pybindit {
 namespace memory {
 

From b667d32447f6680771f5d694d2c9a7cfdc2c724f Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 7 Jan 2021 12:55:01 -0800
Subject: [PATCH 029/206] Converting from methods to factory functions (no
 functional change).

---
 include/pybind11/smart_holder_poc.h  | 78 +++++++++++-----------
 tests/core/smart_holder_poc_test.cpp | 99 ++++++++++------------------
 2 files changed, 71 insertions(+), 106 deletions(-)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index 5a30b77961..4d14409cfe 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -75,16 +75,6 @@ struct smart_holder {
   bool vptr_is_using_builtin_delete : 1;
   bool vptr_is_external_shared_ptr : 1;
 
-  void clear() {
-    rtti_held = nullptr;
-    rtti_uqp_del = nullptr;
-    vptr.reset();
-    vptr_deleter_guard_flag = false;
-    vptr_is_using_noop_deleter = false;
-    vptr_is_using_builtin_delete = false;
-    vptr_is_external_shared_ptr = false;
-  }
-
   smart_holder()
       : rtti_held{nullptr},
         rtti_uqp_del{nullptr},
@@ -151,11 +141,13 @@ struct smart_holder {
   }
 
   template <typename T>
-  void from_raw_ptr_unowned(T* raw_ptr) {
-    clear();
-    rtti_held = &typeid(T);
-    vptr_is_using_noop_deleter = true;
-    vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
+  static smart_holder from_raw_ptr_unowned(T* raw_ptr) {
+    smart_holder hld;
+    hld.rtti_held = &typeid(T);
+    hld.vptr_is_using_noop_deleter = true;
+    hld.vptr.reset(raw_ptr,
+                   guarded_builtin_delete<T>(&hld.vptr_deleter_guard_flag));
+    return hld;
   }
 
   template <typename T>
@@ -174,12 +166,14 @@ struct smart_holder {
   }
 
   template <typename T>
-  void from_raw_ptr_take_ownership(T* raw_ptr) {
-    clear();
-    rtti_held = &typeid(T);
-    vptr_deleter_guard_flag = true;
-    vptr_is_using_builtin_delete = true;
-    vptr.reset(raw_ptr, guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
+  static smart_holder from_raw_ptr_take_ownership(T* raw_ptr) {
+    smart_holder hld;
+    hld.rtti_held = &typeid(T);
+    hld.vptr_deleter_guard_flag = true;
+    hld.vptr_is_using_builtin_delete = true;
+    hld.vptr.reset(raw_ptr,
+                   guarded_builtin_delete<T>(&hld.vptr_deleter_guard_flag));
+    return hld;
   }
 
   template <typename T>
@@ -195,14 +189,15 @@ struct smart_holder {
   }
 
   template <typename T>
-  void from_unique_ptr(std::unique_ptr<T>&& unq_ptr) {
-    clear();
-    rtti_held = &typeid(T);
-    vptr_deleter_guard_flag = true;
-    vptr_is_using_builtin_delete = true;
-    vptr.reset(unq_ptr.get(),
-               guarded_builtin_delete<T>(&vptr_deleter_guard_flag));
+  static smart_holder from_unique_ptr(std::unique_ptr<T>&& unq_ptr) {
+    smart_holder hld;
+    hld.rtti_held = &typeid(T);
+    hld.vptr_deleter_guard_flag = true;
+    hld.vptr_is_using_builtin_delete = true;
+    hld.vptr.reset(unq_ptr.get(),
+                   guarded_builtin_delete<T>(&hld.vptr_deleter_guard_flag));
     unq_ptr.release();
+    return hld;
   }
 
   template <typename T>
@@ -211,14 +206,16 @@ struct smart_holder {
   }
 
   template <typename T, typename D>
-  void from_unique_ptr_with_deleter(std::unique_ptr<T, D>&& unq_ptr) {
-    clear();
-    rtti_held = &typeid(T);
-    rtti_uqp_del = &typeid(D);
-    vptr_deleter_guard_flag = true;
-    vptr.reset(unq_ptr.get(),
-               guarded_custom_deleter<T, D>(&vptr_deleter_guard_flag));
+  static smart_holder from_unique_ptr_with_deleter(
+      std::unique_ptr<T, D>&& unq_ptr) {
+    smart_holder hld;
+    hld.rtti_held = &typeid(T);
+    hld.rtti_uqp_del = &typeid(D);
+    hld.vptr_deleter_guard_flag = true;
+    hld.vptr.reset(unq_ptr.get(),
+                   guarded_custom_deleter<T, D>(&hld.vptr_deleter_guard_flag));
     unq_ptr.release();
+    return hld;
   }
 
   template <typename T, typename D>
@@ -234,11 +231,12 @@ struct smart_holder {
   }
 
   template <typename T>
-  void from_shared_ptr(std::shared_ptr<T> shd_ptr) {
-    clear();
-    rtti_held = &typeid(T);
-    vptr_is_external_shared_ptr = true;
-    vptr = std::static_pointer_cast<void>(shd_ptr);
+  static smart_holder from_shared_ptr(std::shared_ptr<T> shd_ptr) {
+    smart_holder hld;
+    hld.rtti_held = &typeid(T);
+    hld.vptr_is_external_shared_ptr = true;
+    hld.vptr = std::static_pointer_cast<void>(shd_ptr);
+    return hld;
   }
 
   template <typename T>
diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/core/smart_holder_poc_test.cpp
index e014757a9e..9aebba62fb 100644
--- a/tests/core/smart_holder_poc_test.cpp
+++ b/tests/core/smart_holder_poc_test.cpp
@@ -19,22 +19,19 @@ struct functor_other_delete : functor_builtin_delete<T> {};
 
 TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_unowned", "[S]") {
   static int value = 19;
-  smart_holder hld;
-  hld.from_raw_ptr_unowned(&value);
+  auto hld = smart_holder::from_raw_ptr_unowned(&value);
   REQUIRE(*hld.as_raw_ptr_unowned<int>() == 19);
 }
 
 TEST_CASE("from_raw_ptr_unowned+const_value_ref", "[S]") {
   static int value = 19;
-  smart_holder hld;
-  hld.from_raw_ptr_unowned(&value);
+  auto hld = smart_holder::from_raw_ptr_unowned(&value);
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
 TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_release_ownership", "[E]") {
   static int value = 19;
-  smart_holder hld;
-  hld.from_raw_ptr_unowned(&value);
+  auto hld = smart_holder::from_raw_ptr_unowned(&value);
   REQUIRE_THROWS_WITH(
       hld.as_raw_ptr_release_ownership<int>(),
       "Cannot disown non-owning holder (as_raw_ptr_release_ownership).");
@@ -42,16 +39,14 @@ TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_release_ownership", "[E]") {
 
 TEST_CASE("from_raw_ptr_unowned+as_unique_ptr", "[E]") {
   static int value = 19;
-  smart_holder hld;
-  hld.from_raw_ptr_unowned(&value);
+  auto hld = smart_holder::from_raw_ptr_unowned(&value);
   REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
                       "Cannot disown non-owning holder (as_unique_ptr).");
 }
 
 TEST_CASE("from_raw_ptr_unowned+as_unique_ptr_with_deleter", "[E]") {
   static int value = 19;
-  smart_holder hld;
-  hld.from_raw_ptr_unowned(&value);
+  auto hld = smart_holder::from_raw_ptr_unowned(&value);
   auto condense_for_macro = [](smart_holder& hld) {
     hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
   };
@@ -62,21 +57,18 @@ TEST_CASE("from_raw_ptr_unowned+as_unique_ptr_with_deleter", "[E]") {
 
 TEST_CASE("from_raw_ptr_unowned+as_shared_ptr", "[S]") {
   static int value = 19;
-  smart_holder hld;
-  hld.from_raw_ptr_unowned(&value);
+  auto hld = smart_holder::from_raw_ptr_unowned(&value);
   REQUIRE(*hld.as_shared_ptr<int>() == 19);
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+const_value_ref", "[S]") {
-  smart_holder hld;
-  hld.from_raw_ptr_take_ownership(new int(19));
+  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
   REQUIRE(hld.has_pointee());
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership1", "[S]") {
-  smart_holder hld;
-  hld.from_raw_ptr_take_ownership(new int(19));
+  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
   auto new_owner =
       std::unique_ptr<int>(hld.as_raw_ptr_release_ownership<int>());
   REQUIRE(!hld.has_pointee());
@@ -84,8 +76,7 @@ TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership1", "[S]") {
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership2", "[E]") {
-  smart_holder hld;
-  hld.from_raw_ptr_take_ownership(new int(19));
+  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
   auto shd_ptr = hld.as_shared_ptr<int>();
   REQUIRE_THROWS_WITH(
       hld.as_raw_ptr_release_ownership<int>(),
@@ -93,24 +84,21 @@ TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership2", "[E]") {
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr1", "[S]") {
-  smart_holder hld;
-  hld.from_raw_ptr_take_ownership(new int(19));
+  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
   std::unique_ptr<int> new_owner = hld.as_unique_ptr<int>();
   REQUIRE(!hld.has_pointee());
   REQUIRE(*new_owner == 19);
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr2", "[E]") {
-  smart_holder hld;
-  hld.from_raw_ptr_take_ownership(new int(19));
+  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
   auto shd_ptr = hld.as_shared_ptr<int>();
   REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
                       "Cannot disown use_count != 1 (as_unique_ptr).");
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr_with_deleter", "[E]") {
-  smart_holder hld;
-  hld.from_raw_ptr_take_ownership(new int(19));
+  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
   auto condense_for_macro = [](smart_holder& hld) {
     hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
   };
@@ -120,8 +108,7 @@ TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr_with_deleter", "[E]") {
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_shared_ptr", "[S]") {
-  smart_holder hld;
-  hld.from_raw_ptr_take_ownership(new int(19));
+  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
   std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
   REQUIRE(hld.has_pointee());
   REQUIRE(*new_owner == 19);
@@ -129,16 +116,14 @@ TEST_CASE("from_raw_ptr_take_ownership+as_shared_ptr", "[S]") {
 
 TEST_CASE("from_unique_ptr+const_value_ref", "[S]") {
   std::unique_ptr<int> orig_owner(new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
 TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership1", "[S]") {
   std::unique_ptr<int> orig_owner(new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   auto new_owner =
       std::unique_ptr<int>(hld.as_raw_ptr_release_ownership<int>());
@@ -148,8 +133,7 @@ TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership1", "[S]") {
 
 TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership2", "[E]") {
   std::unique_ptr<int> orig_owner(new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   auto shd_ptr = hld.as_shared_ptr<int>();
   REQUIRE_THROWS_WITH(
@@ -159,8 +143,7 @@ TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership2", "[E]") {
 
 TEST_CASE("from_unique_ptr+as_unique_ptr1", "[S]") {
   std::unique_ptr<int> orig_owner(new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   std::unique_ptr<int> new_owner = hld.as_unique_ptr<int>();
   REQUIRE(!hld.has_pointee());
@@ -169,8 +152,7 @@ TEST_CASE("from_unique_ptr+as_unique_ptr1", "[S]") {
 
 TEST_CASE("from_unique_ptr+as_unique_ptr2", "[E]") {
   std::unique_ptr<int> orig_owner(new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   auto shd_ptr = hld.as_shared_ptr<int>();
   REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
@@ -179,8 +161,7 @@ TEST_CASE("from_unique_ptr+as_unique_ptr2", "[E]") {
 
 TEST_CASE("from_unique_ptr+as_unique_ptr_with_deleter", "[E]") {
   std::unique_ptr<int> orig_owner(new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   auto condense_for_macro = [](smart_holder& hld) {
     hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
@@ -192,8 +173,7 @@ TEST_CASE("from_unique_ptr+as_unique_ptr_with_deleter", "[E]") {
 
 TEST_CASE("from_unique_ptr+as_shared_ptr", "[S]") {
   std::unique_ptr<int> orig_owner(new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
   REQUIRE(hld.has_pointee());
@@ -203,8 +183,7 @@ TEST_CASE("from_unique_ptr+as_shared_ptr", "[S]") {
 TEST_CASE("from_unique_ptr_with_deleter+const_value_ref", "[S]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
       new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr_with_deleter(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
@@ -212,8 +191,7 @@ TEST_CASE("from_unique_ptr_with_deleter+const_value_ref", "[S]") {
 TEST_CASE("from_unique_ptr_with_deleter+as_raw_ptr_release_ownership", "[E]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
       new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr_with_deleter(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   REQUIRE_THROWS_WITH(
       hld.as_raw_ptr_release_ownership<int>(),
@@ -223,8 +201,7 @@ TEST_CASE("from_unique_ptr_with_deleter+as_raw_ptr_release_ownership", "[E]") {
 TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr", "[E]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
       new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr_with_deleter(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
                       "Cannot disown custom deleter (as_unique_ptr).");
@@ -233,8 +210,7 @@ TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr", "[E]") {
 TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter1", "[S]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
       new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr_with_deleter(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> new_owner =
       hld.as_unique_ptr_with_deleter<int,
@@ -246,8 +222,7 @@ TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter1", "[S]") {
 TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter2", "[E]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
       new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr_with_deleter(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   auto condense_for_macro = [](smart_holder& hld) {
     hld.as_unique_ptr_with_deleter<int, helpers::functor_other_delete<int>>();
@@ -260,8 +235,7 @@ TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter2", "[E]") {
 TEST_CASE("from_unique_ptr_with_deleter+as_shared_ptr", "[S]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
       new int(19));
-  smart_holder hld;
-  hld.from_unique_ptr_with_deleter(std::move(orig_owner));
+  auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
   std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
   REQUIRE(hld.has_pointee());
@@ -270,15 +244,13 @@ TEST_CASE("from_unique_ptr_with_deleter+as_shared_ptr", "[S]") {
 
 TEST_CASE("from_shared_ptr+const_value_ref", "[S]") {
   std::shared_ptr<int> orig_owner(new int(19));
-  smart_holder hld;
-  hld.from_shared_ptr(orig_owner);
+  auto hld = smart_holder::from_shared_ptr(orig_owner);
   REQUIRE(hld.const_value_ref<int>() == 19);
 }
 
 TEST_CASE("from_shared_ptr+as_raw_ptr_release_ownership", "[E]") {
   std::shared_ptr<int> orig_owner(new int(19));
-  smart_holder hld;
-  hld.from_shared_ptr(orig_owner);
+  auto hld = smart_holder::from_shared_ptr(orig_owner);
   REQUIRE_THROWS_WITH(
       hld.as_raw_ptr_release_ownership<int>(),
       "Cannot disown external shared_ptr (as_raw_ptr_release_ownership).");
@@ -286,16 +258,14 @@ TEST_CASE("from_shared_ptr+as_raw_ptr_release_ownership", "[E]") {
 
 TEST_CASE("from_shared_ptr+as_unique_ptr", "[E]") {
   std::shared_ptr<int> orig_owner(new int(19));
-  smart_holder hld;
-  hld.from_shared_ptr(orig_owner);
+  auto hld = smart_holder::from_shared_ptr(orig_owner);
   REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
                       "Cannot disown external shared_ptr (as_unique_ptr).");
 }
 
 TEST_CASE("from_shared_ptr+as_unique_ptr_with_deleter", "[E]") {
   std::shared_ptr<int> orig_owner(new int(19));
-  smart_holder hld;
-  hld.from_shared_ptr(orig_owner);
+  auto hld = smart_holder::from_shared_ptr(orig_owner);
   auto condense_for_macro = [](smart_holder& hld) {
     hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
   };
@@ -306,8 +276,7 @@ TEST_CASE("from_shared_ptr+as_unique_ptr_with_deleter", "[E]") {
 
 TEST_CASE("from_shared_ptr+as_shared_ptr", "[S]") {
   std::shared_ptr<int> orig_owner(new int(19));
-  smart_holder hld;
-  hld.from_shared_ptr(orig_owner);
+  auto hld = smart_holder::from_shared_ptr(orig_owner);
   REQUIRE(*hld.as_shared_ptr<int>() == 19);
 }
 
@@ -319,15 +288,13 @@ TEST_CASE("error_unpopulated_holder", "[E]") {
 
 TEST_CASE("error_incompatible_type", "[E]") {
   static int value = 19;
-  smart_holder hld;
-  hld.from_raw_ptr_unowned(&value);
+  auto hld = smart_holder::from_raw_ptr_unowned(&value);
   REQUIRE_THROWS_WITH(hld.as_unique_ptr<std::string>(),
                       "Incompatible type (as_unique_ptr).");
 }
 
 TEST_CASE("error_disowned_holder", "[E]") {
-  smart_holder hld;
-  hld.from_raw_ptr_take_ownership(new int(19));
+  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
   hld.as_unique_ptr<int>();
   REQUIRE_THROWS_WITH(hld.const_value_ref<int>(),
                       "Disowned holder (const_value_ref).");

From 739aead88d27c8c1d1dffa8d1599d16adc51d558 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 8 Jan 2021 16:43:35 -0800
Subject: [PATCH 030/206] Removing obsolete and very incomplete test (replaced
 by Catch2-based test).

---
 tests/test_smart_holder_poc.cpp | 73 ---------------------------------
 tests/test_smart_holder_poc.py  |  8 ----
 2 files changed, 81 deletions(-)
 delete mode 100644 tests/test_smart_holder_poc.cpp
 delete mode 100644 tests/test_smart_holder_poc.py

diff --git a/tests/test_smart_holder_poc.cpp b/tests/test_smart_holder_poc.cpp
deleted file mode 100644
index 8a750c444f..0000000000
--- a/tests/test_smart_holder_poc.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#include "pybind11_tests.h"
-
-#include <pybind11/smart_holder_poc.h>
-
-#include <iostream>
-#include <string>
-
-namespace pybind11_tests {
-namespace smart_holder_poc {
-
-inline void to_cout(std::string msg) { std::cout << msg << std::endl; }
-
-template <typename T>
-struct functor_builtin_delete {
-  void operator()(T* ptr) { delete ptr; }
-};
-
-inline void exercise() {
-  to_cout("");
-  using pybindit::memory::smart_holder;
-  {
-    smart_holder hld;
-    hld.from_raw_ptr_owned(new int(13));
-    to_cout(hld.rtti_held->name());
-    {
-      std::shared_ptr<int> val = hld.as_shared_ptr<int>();
-      to_cout(std::to_string(*val));
-    }
-    {
-      std::unique_ptr<int> val(hld.as_raw_ptr_owned<int>());
-      to_cout(std::to_string(*val));
-    }
-  }  // namespace ;
-  {
-    std::unique_ptr<int> val(new int(13));
-    smart_holder hld;
-    hld.from_raw_ptr_unowned(val.get());
-    to_cout(std::to_string(*hld.as_raw_ptr_unowned<int>()));
-  }
-  {
-    std::unique_ptr<int> val(new int(13));
-    smart_holder hld;
-    hld.from_unique_ptr(std::move(val));
-    to_cout(std::to_string(*hld.as_raw_ptr_unowned<int>()));
-  }
-  {
-    smart_holder hld;
-    hld.from_raw_ptr_owned(new int(13));
-    to_cout(std::to_string(*hld.as_unique_ptr<int>()));
-  }
-  {
-    std::unique_ptr<int, functor_builtin_delete<int>> unq_ptr(new int(13));
-    smart_holder hld;
-    hld.from_unique_ptr_with_deleter(std::move(unq_ptr));
-    to_cout(std::to_string(unq_ptr.get() == nullptr));
-    to_cout(std::to_string(*hld.as_raw_ptr_unowned<int>()));
-    auto unq_ptr_retrieved =
-        hld.as_unique_ptr_with_deleter<int, functor_builtin_delete<int>>();
-    to_cout(std::to_string(hld.vptr.get() == nullptr));
-    to_cout(std::to_string(*unq_ptr_retrieved));
-  }
-  {
-    std::shared_ptr<int> val(new int(13));
-    smart_holder hld;
-    hld.from_shared_ptr(val);
-    to_cout(std::to_string(*hld.as_raw_ptr_unowned<int>()));
-  }
-}
-
-TEST_SUBMODULE(smart_holder_poc, m) { m.def("exercise", exercise); }
-
-}  // namespace smart_holder_poc
-}  // namespace pybind11_tests
diff --git a/tests/test_smart_holder_poc.py b/tests/test_smart_holder_poc.py
deleted file mode 100644
index 1606e0cf41..0000000000
--- a/tests/test_smart_holder_poc.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-from pybind11_tests import smart_holder_poc as m
-
-
-def test_exercise():
-    m.exercise()

From a76d5ebfee5d6cf48561614101a5118bd6811e22 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 8 Jan 2021 16:44:35 -0800
Subject: [PATCH 031/206] Removing stray file.

---
 tests/work.py | 12 ------------
 1 file changed, 12 deletions(-)
 delete mode 100644 tests/work.py

diff --git a/tests/work.py b/tests/work.py
deleted file mode 100644
index 11dd213b46..0000000000
--- a/tests/work.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from pybind11_tests import unique_ptr_member as m
-
-
-def test_pointee_and_ptr_owner():
-    m.to_cout("")
-    obj = m.pointee()
-    assert obj.get_int() == 213
-    del obj
-    print("DONE.", flush=True)
-
-
-test_pointee_and_ptr_owner()

From 179466e4b669d6489103530c97e00d53bcb69a1e Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 10 Jan 2021 12:22:23 -0800
Subject: [PATCH 032/206] Adding type_caster_bare_interface_demo.

---
 .../test_type_caster_bare_interface_demo.cpp  | 115 ++++++++++++++++++
 tests/test_type_caster_bare_interface_demo.py |  22 ++++
 2 files changed, 137 insertions(+)
 create mode 100644 tests/test_type_caster_bare_interface_demo.cpp
 create mode 100644 tests/test_type_caster_bare_interface_demo.py

diff --git a/tests/test_type_caster_bare_interface_demo.cpp b/tests/test_type_caster_bare_interface_demo.cpp
new file mode 100644
index 0000000000..35ebaf88b4
--- /dev/null
+++ b/tests/test_type_caster_bare_interface_demo.cpp
@@ -0,0 +1,115 @@
+#include "pybind11_tests.h"
+
+namespace pybind11_tests {
+namespace type_caster_bare_interface_demo {
+
+struct mpty {};
+
+mpty        rtrn_mpty_valu() { mpty obj; return obj; }
+mpty&&      rtrn_mpty_rref() { mpty obj; return std::move(obj); }
+mpty const& rtrn_mpty_cref() { static mpty obj; return obj; }
+mpty&       rtrn_mpty_mref() { static mpty obj; return obj; }
+mpty const* rtrn_mpty_cptr() { static mpty obj; return &obj; }
+mpty*       rtrn_mpty_mptr() { static mpty obj; return &obj; }
+
+const char* pass_mpty_valu(mpty)        { return "load_valu"; }
+const char* pass_mpty_rref(mpty&&)      { return "load_rref"; }
+const char* pass_mpty_cref(mpty const&) { return "load_cref"; }
+const char* pass_mpty_mref(mpty&)       { return "load_mref"; }
+const char* pass_mpty_cptr(mpty const*) { return "load_cptr"; }
+const char* pass_mpty_mptr(mpty*)       { return "load_mptr"; }
+
+}  // namespace type_caster_bare_interface_demo
+}  // namespace pybind11_tests
+
+namespace pybind11 {
+namespace detail {
+
+using namespace pybind11_tests::type_caster_bare_interface_demo;
+
+template <>
+struct type_caster<mpty> {
+    static constexpr auto name = _<mpty>();
+
+    // static handle cast(mpty, ...)
+    // is redundant (leads to ambiguous overloads).
+
+    static handle cast(mpty&& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_rref").release();
+    }
+
+    static handle cast(mpty const& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_cref").release();
+    }
+
+    static handle cast(mpty& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_mref").release();
+    }
+
+    static handle cast(mpty const* /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_cptr").release();
+    }
+
+    static handle cast(mpty* /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_mptr").release();
+    }
+
+    template <typename T_>
+    using cast_op_type = conditional_t<
+        std::is_same<remove_reference_t<T_>, const mpty*>::value, const mpty*,
+        conditional_t<
+            std::is_same<remove_reference_t<T_>, mpty*>::value, mpty*,
+            conditional_t<
+                std::is_same<T_, const mpty&>::value, const mpty&,
+                conditional_t<
+                    std::is_same<T_, mpty&>::value, mpty&,
+                    conditional_t<
+                        std::is_same<T_, mpty&&>::value, mpty&&,
+                        mpty>>>>>;
+
+    operator mpty()        { return rtrn_mpty_valu(); }
+    operator mpty&&() &&   { return rtrn_mpty_rref(); }
+    operator mpty const&() { return rtrn_mpty_cref(); }
+    operator mpty&()       { return rtrn_mpty_mref(); }
+    operator mpty const*() { return rtrn_mpty_cptr(); }
+    operator mpty*()       { return rtrn_mpty_mptr(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+      return true;
+    }
+};
+
+}  // namespace detail
+}  // namespace pybind11
+
+namespace pybind11_tests {
+namespace type_caster_bare_interface_demo {
+
+TEST_SUBMODULE(type_caster_bare_interface_demo, m) {
+  m.def("rtrn_mpty_valu", rtrn_mpty_valu);
+  m.def("rtrn_mpty_rref", rtrn_mpty_rref);
+  m.def("rtrn_mpty_cref", rtrn_mpty_cref);
+  m.def("rtrn_mpty_mref", rtrn_mpty_mref);
+  m.def("rtrn_mpty_cptr", rtrn_mpty_cptr);
+  m.def("rtrn_mpty_mptr", rtrn_mpty_mptr);
+
+  m.def("pass_mpty_valu", pass_mpty_valu);
+  m.def("pass_mpty_rref", pass_mpty_rref);
+  m.def("pass_mpty_cref", pass_mpty_cref);
+  m.def("pass_mpty_mref", pass_mpty_mref);
+  m.def("pass_mpty_cptr", pass_mpty_cptr);
+  m.def("pass_mpty_mptr", pass_mpty_mptr);
+}
+
+}  // namespace type_caster_bare_interface_demo
+}  // namespace pybind11_tests
diff --git a/tests/test_type_caster_bare_interface_demo.py b/tests/test_type_caster_bare_interface_demo.py
new file mode 100644
index 0000000000..a166b2684c
--- /dev/null
+++ b/tests/test_type_caster_bare_interface_demo.py
@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+from pybind11_tests import type_caster_bare_interface_demo as m
+
+
+def test_cast():
+    assert m.rtrn_mpty_valu() == "cast_rref"
+    assert m.rtrn_mpty_rref() == "cast_rref"
+    assert m.rtrn_mpty_cref() == "cast_cref"
+    assert m.rtrn_mpty_mref() == "cast_mref"
+    assert m.rtrn_mpty_cptr() == "cast_cptr"
+    assert m.rtrn_mpty_mptr() == "cast_mptr"
+
+
+def test_load():
+    assert m.pass_mpty_valu(None) == "load_valu"
+    assert m.pass_mpty_rref(None) == "load_rref"
+    assert m.pass_mpty_cref(None) == "load_cref"
+    assert m.pass_mpty_mref(None) == "load_mref"
+    assert m.pass_mpty_cptr(None) == "load_cptr"
+    assert m.pass_mpty_mptr(None) == "load_mptr"

From 1c9b8ebb804df42f91027d3476b2c411b646fad2 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 10 Jan 2021 13:09:30 -0800
Subject: [PATCH 033/206] Adding shared_ptr<mpty>, shared_ptr<mpty const>
 casters.

---
 .../test_type_caster_bare_interface_demo.cpp  | 84 +++++++++++++++----
 tests/test_type_caster_bare_interface_demo.py | 10 +++
 2 files changed, 78 insertions(+), 16 deletions(-)

diff --git a/tests/test_type_caster_bare_interface_demo.cpp b/tests/test_type_caster_bare_interface_demo.cpp
index 35ebaf88b4..78f6fb5ddb 100644
--- a/tests/test_type_caster_bare_interface_demo.cpp
+++ b/tests/test_type_caster_bare_interface_demo.cpp
@@ -1,5 +1,7 @@
 #include "pybind11_tests.h"
 
+#include <memory>
+
 namespace pybind11_tests {
 namespace type_caster_bare_interface_demo {
 
@@ -19,6 +21,12 @@ const char* pass_mpty_mref(mpty&)       { return "load_mref"; }
 const char* pass_mpty_cptr(mpty const*) { return "load_cptr"; }
 const char* pass_mpty_mptr(mpty*)       { return "load_mptr"; }
 
+std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty>(new mpty); }
+std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const>(new mpty); }
+
+const char* pass_mpty_shmp(std::shared_ptr<mpty>)       { return "load_shmp"; }
+const char* pass_mpty_shcp(std::shared_ptr<mpty const>) { return "load_shcp"; }
+
 }  // namespace type_caster_bare_interface_demo
 }  // namespace pybind11_tests
 
@@ -66,11 +74,11 @@ struct type_caster<mpty> {
 
     template <typename T_>
     using cast_op_type = conditional_t<
-        std::is_same<remove_reference_t<T_>, const mpty*>::value, const mpty*,
+        std::is_same<remove_reference_t<T_>, mpty const*>::value, mpty const*,
         conditional_t<
             std::is_same<remove_reference_t<T_>, mpty*>::value, mpty*,
             conditional_t<
-                std::is_same<T_, const mpty&>::value, const mpty&,
+                std::is_same<T_, mpty const&>::value, mpty const&,
                 conditional_t<
                     std::is_same<T_, mpty&>::value, mpty&,
                     conditional_t<
@@ -85,7 +93,45 @@ struct type_caster<mpty> {
     operator mpty*()       { return rtrn_mpty_mptr(); }
 
     bool load(handle /*src*/, bool /*convert*/) {
-      return true;
+        return true;
+    }
+};
+
+template <>
+struct type_caster<std::shared_ptr<mpty>> {
+    static constexpr auto name = _<std::shared_ptr<mpty>>();
+
+    static handle cast(const std::shared_ptr<mpty>& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_shmp").release();
+    }
+
+    template <typename> using cast_op_type = std::shared_ptr<mpty>;
+
+    operator std::shared_ptr<mpty>() { return rtrn_mpty_shmp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
+template <>
+struct type_caster<std::shared_ptr<mpty const>> {
+    static constexpr auto name = _<std::shared_ptr<mpty const>>();
+
+    static handle cast(const std::shared_ptr<mpty const>& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_shcp").release();
+    }
+
+    template <typename> using cast_op_type = std::shared_ptr<mpty const>;
+
+    operator std::shared_ptr<mpty const>() { return rtrn_mpty_shcp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
     }
 };
 
@@ -96,19 +142,25 @@ namespace pybind11_tests {
 namespace type_caster_bare_interface_demo {
 
 TEST_SUBMODULE(type_caster_bare_interface_demo, m) {
-  m.def("rtrn_mpty_valu", rtrn_mpty_valu);
-  m.def("rtrn_mpty_rref", rtrn_mpty_rref);
-  m.def("rtrn_mpty_cref", rtrn_mpty_cref);
-  m.def("rtrn_mpty_mref", rtrn_mpty_mref);
-  m.def("rtrn_mpty_cptr", rtrn_mpty_cptr);
-  m.def("rtrn_mpty_mptr", rtrn_mpty_mptr);
-
-  m.def("pass_mpty_valu", pass_mpty_valu);
-  m.def("pass_mpty_rref", pass_mpty_rref);
-  m.def("pass_mpty_cref", pass_mpty_cref);
-  m.def("pass_mpty_mref", pass_mpty_mref);
-  m.def("pass_mpty_cptr", pass_mpty_cptr);
-  m.def("pass_mpty_mptr", pass_mpty_mptr);
+    m.def("rtrn_mpty_valu", rtrn_mpty_valu);
+    m.def("rtrn_mpty_rref", rtrn_mpty_rref);
+    m.def("rtrn_mpty_cref", rtrn_mpty_cref);
+    m.def("rtrn_mpty_mref", rtrn_mpty_mref);
+    m.def("rtrn_mpty_cptr", rtrn_mpty_cptr);
+    m.def("rtrn_mpty_mptr", rtrn_mpty_mptr);
+
+    m.def("pass_mpty_valu", pass_mpty_valu);
+    m.def("pass_mpty_rref", pass_mpty_rref);
+    m.def("pass_mpty_cref", pass_mpty_cref);
+    m.def("pass_mpty_mref", pass_mpty_mref);
+    m.def("pass_mpty_cptr", pass_mpty_cptr);
+    m.def("pass_mpty_mptr", pass_mpty_mptr);
+
+    m.def("rtrn_mpty_shmp", rtrn_mpty_shmp);
+    m.def("rtrn_mpty_shcp", rtrn_mpty_shcp);
+
+    m.def("pass_mpty_shmp", pass_mpty_shmp);
+    m.def("pass_mpty_shcp", pass_mpty_shcp);
 }
 
 }  // namespace type_caster_bare_interface_demo
diff --git a/tests/test_type_caster_bare_interface_demo.py b/tests/test_type_caster_bare_interface_demo.py
index a166b2684c..97e34c8dfe 100644
--- a/tests/test_type_caster_bare_interface_demo.py
+++ b/tests/test_type_caster_bare_interface_demo.py
@@ -20,3 +20,13 @@ def test_load():
     assert m.pass_mpty_mref(None) == "load_mref"
     assert m.pass_mpty_cptr(None) == "load_cptr"
     assert m.pass_mpty_mptr(None) == "load_mptr"
+
+
+def test_cast_shared_ptr():
+    assert m.rtrn_mpty_shmp() == "cast_shmp"
+    assert m.rtrn_mpty_shcp() == "cast_shcp"
+
+
+def test_load_shared_ptr():
+    assert m.pass_mpty_shmp(None) == "load_shmp"
+    assert m.pass_mpty_shcp(None) == "load_shcp"

From c599d3c14e59ba450bf9832ed5b7a956df774184 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 10 Jan 2021 13:35:13 -0800
Subject: [PATCH 034/206] Adding unique_ptr<mpty>, unique_ptr<mpty const>
 casters.

---
 .../test_type_caster_bare_interface_demo.cpp  | 50 +++++++++++++++++++
 tests/test_type_caster_bare_interface_demo.py | 10 ++++
 2 files changed, 60 insertions(+)

diff --git a/tests/test_type_caster_bare_interface_demo.cpp b/tests/test_type_caster_bare_interface_demo.cpp
index 78f6fb5ddb..12e98f5d2e 100644
--- a/tests/test_type_caster_bare_interface_demo.cpp
+++ b/tests/test_type_caster_bare_interface_demo.cpp
@@ -27,6 +27,12 @@ std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const
 const char* pass_mpty_shmp(std::shared_ptr<mpty>)       { return "load_shmp"; }
 const char* pass_mpty_shcp(std::shared_ptr<mpty const>) { return "load_shcp"; }
 
+std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty>(new mpty); }
+std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty); }
+
+const char* pass_mpty_uqmp(std::unique_ptr<mpty>)       { return "load_uqmp"; }
+const char* pass_mpty_uqcp(std::unique_ptr<mpty const>) { return "load_uqcp"; }
+
 }  // namespace type_caster_bare_interface_demo
 }  // namespace pybind11_tests
 
@@ -135,6 +141,44 @@ struct type_caster<std::shared_ptr<mpty const>> {
     }
 };
 
+template <>
+struct type_caster<std::unique_ptr<mpty>> {
+    static constexpr auto name = _<std::unique_ptr<mpty>>();
+
+    static handle cast(std::unique_ptr<mpty>&& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_uqmp").release();
+    }
+
+    template <typename> using cast_op_type = std::unique_ptr<mpty>;
+
+    operator std::unique_ptr<mpty>() { return rtrn_mpty_uqmp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
+template <>
+struct type_caster<std::unique_ptr<mpty const>> {
+    static constexpr auto name = _<std::unique_ptr<mpty const>>();
+
+    static handle cast(std::unique_ptr<mpty const>&& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_uqcp").release();
+    }
+
+    template <typename> using cast_op_type = std::unique_ptr<mpty const>;
+
+    operator std::unique_ptr<mpty const>() { return rtrn_mpty_uqcp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
 }  // namespace detail
 }  // namespace pybind11
 
@@ -161,6 +205,12 @@ TEST_SUBMODULE(type_caster_bare_interface_demo, m) {
 
     m.def("pass_mpty_shmp", pass_mpty_shmp);
     m.def("pass_mpty_shcp", pass_mpty_shcp);
+
+    m.def("rtrn_mpty_uqmp", rtrn_mpty_uqmp);
+    m.def("rtrn_mpty_uqcp", rtrn_mpty_uqcp);
+
+    m.def("pass_mpty_uqmp", pass_mpty_uqmp);
+    m.def("pass_mpty_uqcp", pass_mpty_uqcp);
 }
 
 }  // namespace type_caster_bare_interface_demo
diff --git a/tests/test_type_caster_bare_interface_demo.py b/tests/test_type_caster_bare_interface_demo.py
index 97e34c8dfe..35ae0ee293 100644
--- a/tests/test_type_caster_bare_interface_demo.py
+++ b/tests/test_type_caster_bare_interface_demo.py
@@ -30,3 +30,13 @@ def test_cast_shared_ptr():
 def test_load_shared_ptr():
     assert m.pass_mpty_shmp(None) == "load_shmp"
     assert m.pass_mpty_shcp(None) == "load_shcp"
+
+
+def test_cast_unique_ptr():
+    assert m.rtrn_mpty_uqmp() == "cast_uqmp"
+    assert m.rtrn_mpty_uqcp() == "cast_uqcp"
+
+
+def test_load_unique_ptr():
+    assert m.pass_mpty_uqmp(None) == "load_uqmp"
+    assert m.pass_mpty_uqcp(None) == "load_uqcp"

From c225f4014d8d0d681f627b1d2423a4ad0582f9ec Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 11 Jan 2021 11:39:01 -0800
Subject: [PATCH 035/206] Pure copy of `class class_` implementation in
 pybind11.h (master commit 98f1bbb8004f654ba9e26717bdf5912fb899b05a).

---
 include/pybind11/classh.h | 344 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 344 insertions(+)
 create mode 100644 include/pybind11/classh.h

diff --git a/include/pybind11/classh.h b/include/pybind11/classh.h
new file mode 100644
index 0000000000..db1970081c
--- /dev/null
+++ b/include/pybind11/classh.h
@@ -0,0 +1,344 @@
+template <typename type_, typename... options>
+class class_ : public detail::generic_type {
+    template <typename T> using is_holder = detail::is_holder_type<type_, T>;
+    template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>;
+    template <typename T> using is_base = detail::is_strict_base_of<T, type_>;
+    // struct instead of using here to help MSVC:
+    template <typename T> struct is_valid_class_option :
+        detail::any_of<is_holder<T>, is_subtype<T>, is_base<T>> {};
+
+public:
+    using type = type_;
+    using type_alias = detail::exactly_one_t<is_subtype, void, options...>;
+    constexpr static bool has_alias = !std::is_void<type_alias>::value;
+    using holder_type = detail::exactly_one_t<is_holder, std::unique_ptr<type>, options...>;
+
+    static_assert(detail::all_of<is_valid_class_option<options>...>::value,
+            "Unknown/invalid class_ template parameters provided");
+
+    static_assert(!has_alias || std::is_polymorphic<type>::value,
+            "Cannot use an alias class with a non-polymorphic type");
+
+    PYBIND11_OBJECT(class_, generic_type, PyType_Check)
+
+    template <typename... Extra>
+    class_(handle scope, const char *name, const Extra &... extra) {
+        using namespace detail;
+
+        // MI can only be specified via class_ template options, not constructor parameters
+        static_assert(
+            none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
+            (   constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
+                constexpr_sum(is_base<options>::value...)   == 0 && // no template option bases
+                none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
+            "Error: multiple inheritance bases must be specified via class_ template options");
+
+        type_record record;
+        record.scope = scope;
+        record.name = name;
+        record.type = &typeid(type);
+        record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
+        record.type_align = alignof(conditional_t<has_alias, type_alias, type>&);
+        record.holder_size = sizeof(holder_type);
+        record.init_instance = init_instance;
+        record.dealloc = dealloc;
+        record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
+
+        set_operator_new<type>(&record);
+
+        /* Register base classes specified via template arguments to class_, if any */
+        PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
+
+        /* Process optional arguments, if any */
+        process_attributes<Extra...>::init(extra..., &record);
+
+        generic_type::initialize(record);
+
+        if (has_alias) {
+            auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
+            instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
+        }
+    }
+
+    template <typename Base, detail::enable_if_t<is_base<Base>::value, int> = 0>
+    static void add_base(detail::type_record &rec) {
+        rec.add_base(typeid(Base), [](void *src) -> void * {
+            return static_cast<Base *>(reinterpret_cast<type *>(src));
+        });
+    }
+
+    template <typename Base, detail::enable_if_t<!is_base<Base>::value, int> = 0>
+    static void add_base(detail::type_record &) { }
+
+    template <typename Func, typename... Extra>
+    class_ &def(const char *name_, Func&& f, const Extra&... extra) {
+        cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
+                        sibling(getattr(*this, name_, none())), extra...);
+        add_class_method(*this, name_, cf);
+        return *this;
+    }
+
+    template <typename Func, typename... Extra> class_ &
+    def_static(const char *name_, Func &&f, const Extra&... extra) {
+        static_assert(!std::is_member_function_pointer<Func>::value,
+                "def_static(...) called with a non-static member function pointer");
+        cpp_function cf(std::forward<Func>(f), name(name_), scope(*this),
+                        sibling(getattr(*this, name_, none())), extra...);
+        attr(cf.name()) = staticmethod(cf);
+        return *this;
+    }
+
+    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
+    class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
+        op.execute(*this, extra...);
+        return *this;
+    }
+
+    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
+    class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
+        op.execute_cast(*this, extra...);
+        return *this;
+    }
+
+    template <typename... Args, typename... Extra>
+    class_ &def(const detail::initimpl::constructor<Args...> &init, const Extra&... extra) {
+        init.execute(*this, extra...);
+        return *this;
+    }
+
+    template <typename... Args, typename... Extra>
+    class_ &def(const detail::initimpl::alias_constructor<Args...> &init, const Extra&... extra) {
+        init.execute(*this, extra...);
+        return *this;
+    }
+
+    template <typename... Args, typename... Extra>
+    class_ &def(detail::initimpl::factory<Args...> &&init, const Extra&... extra) {
+        std::move(init).execute(*this, extra...);
+        return *this;
+    }
+
+    template <typename... Args, typename... Extra>
+    class_ &def(detail::initimpl::pickle_factory<Args...> &&pf, const Extra &...extra) {
+        std::move(pf).execute(*this, extra...);
+        return *this;
+    }
+
+    template <typename Func>
+    class_& def_buffer(Func &&func) {
+        struct capture { Func func; };
+        auto *ptr = new capture { std::forward<Func>(func) };
+        install_buffer_funcs([](PyObject *obj, void *ptr) -> buffer_info* {
+            detail::make_caster<type> caster;
+            if (!caster.load(obj, false))
+                return nullptr;
+            return new buffer_info(((capture *) ptr)->func(caster));
+        }, ptr);
+        weakref(m_ptr, cpp_function([ptr](handle wr) {
+            delete ptr;
+            wr.dec_ref();
+        })).release();
+        return *this;
+    }
+
+    template <typename Return, typename Class, typename... Args>
+    class_ &def_buffer(Return (Class::*func)(Args...)) {
+        return def_buffer([func] (type &obj) { return (obj.*func)(); });
+    }
+
+    template <typename Return, typename Class, typename... Args>
+    class_ &def_buffer(Return (Class::*func)(Args...) const) {
+        return def_buffer([func] (const type &obj) { return (obj.*func)(); });
+    }
+
+    template <typename C, typename D, typename... Extra>
+    class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
+        static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readwrite() requires a class member (or base class member)");
+        cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this)),
+                     fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
+        def_property(name, fget, fset, return_value_policy::reference_internal, extra...);
+        return *this;
+    }
+
+    template <typename C, typename D, typename... Extra>
+    class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
+        static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readonly() requires a class member (or base class member)");
+        cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this));
+        def_property_readonly(name, fget, return_value_policy::reference_internal, extra...);
+        return *this;
+    }
+
+    template <typename D, typename... Extra>
+    class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
+        cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this)),
+                     fset([pm](object, const D &value) { *pm = value; }, scope(*this));
+        def_property_static(name, fget, fset, return_value_policy::reference, extra...);
+        return *this;
+    }
+
+    template <typename D, typename... Extra>
+    class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
+        cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this));
+        def_property_readonly_static(name, fget, return_value_policy::reference, extra...);
+        return *this;
+    }
+
+    /// Uses return_value_policy::reference_internal by default
+    template <typename Getter, typename... Extra>
+    class_ &def_property_readonly(const char *name, const Getter &fget, const Extra& ...extra) {
+        return def_property_readonly(name, cpp_function(method_adaptor<type>(fget)),
+                                     return_value_policy::reference_internal, extra...);
+    }
+
+    /// Uses cpp_function's return_value_policy by default
+    template <typename... Extra>
+    class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
+        return def_property(name, fget, nullptr, extra...);
+    }
+
+    /// Uses return_value_policy::reference by default
+    template <typename Getter, typename... Extra>
+    class_ &def_property_readonly_static(const char *name, const Getter &fget, const Extra& ...extra) {
+        return def_property_readonly_static(name, cpp_function(fget), return_value_policy::reference, extra...);
+    }
+
+    /// Uses cpp_function's return_value_policy by default
+    template <typename... Extra>
+    class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
+        return def_property_static(name, fget, nullptr, extra...);
+    }
+
+    /// Uses return_value_policy::reference_internal by default
+    template <typename Getter, typename Setter, typename... Extra>
+    class_ &def_property(const char *name, const Getter &fget, const Setter &fset, const Extra& ...extra) {
+        return def_property(name, fget, cpp_function(method_adaptor<type>(fset)), extra...);
+    }
+    template <typename Getter, typename... Extra>
+    class_ &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
+        return def_property(name, cpp_function(method_adaptor<type>(fget)), fset,
+                            return_value_policy::reference_internal, extra...);
+    }
+
+    /// Uses cpp_function's return_value_policy by default
+    template <typename... Extra>
+    class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
+        return def_property_static(name, fget, fset, is_method(*this), extra...);
+    }
+
+    /// Uses return_value_policy::reference by default
+    template <typename Getter, typename... Extra>
+    class_ &def_property_static(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
+        return def_property_static(name, cpp_function(fget), fset, return_value_policy::reference, extra...);
+    }
+
+    /// Uses cpp_function's return_value_policy by default
+    template <typename... Extra>
+    class_ &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
+        static_assert( 0 == detail::constexpr_sum(std::is_base_of<arg, Extra>::value...),
+                      "Argument annotations are not allowed for properties");
+        auto rec_fget = get_function_record(fget), rec_fset = get_function_record(fset);
+        auto *rec_active = rec_fget;
+        if (rec_fget) {
+           char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific documentation string */
+           detail::process_attributes<Extra...>::init(extra..., rec_fget);
+           if (rec_fget->doc && rec_fget->doc != doc_prev) {
+              free(doc_prev);
+              rec_fget->doc = strdup(rec_fget->doc);
+           }
+        }
+        if (rec_fset) {
+            char *doc_prev = rec_fset->doc;
+            detail::process_attributes<Extra...>::init(extra..., rec_fset);
+            if (rec_fset->doc && rec_fset->doc != doc_prev) {
+                free(doc_prev);
+                rec_fset->doc = strdup(rec_fset->doc);
+            }
+            if (! rec_active) rec_active = rec_fset;
+        }
+        def_property_static_impl(name, fget, fset, rec_active);
+        return *this;
+    }
+
+private:
+    /// Initialize holder object, variant 1: object derives from enable_shared_from_this
+    template <typename T>
+    static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
+            const holder_type * /* unused */, const std::enable_shared_from_this<T> * /* dummy */) {
+        try {
+            auto sh = std::dynamic_pointer_cast<typename holder_type::element_type>(
+                    v_h.value_ptr<type>()->shared_from_this());
+            if (sh) {
+                new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(sh));
+                v_h.set_holder_constructed();
+            }
+        } catch (const std::bad_weak_ptr &) {}
+
+        if (!v_h.holder_constructed() && inst->owned) {
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
+            v_h.set_holder_constructed();
+        }
+    }
+
+    static void init_holder_from_existing(const detail::value_and_holder &v_h,
+            const holder_type *holder_ptr, std::true_type /*is_copy_constructible*/) {
+        new (std::addressof(v_h.holder<holder_type>())) holder_type(*reinterpret_cast<const holder_type *>(holder_ptr));
+    }
+
+    static void init_holder_from_existing(const detail::value_and_holder &v_h,
+            const holder_type *holder_ptr, std::false_type /*is_copy_constructible*/) {
+        new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*const_cast<holder_type *>(holder_ptr)));
+    }
+
+    /// Initialize holder object, variant 2: try to construct from existing holder object, if possible
+    static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
+            const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
+        if (holder_ptr) {
+            init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
+            v_h.set_holder_constructed();
+        } else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
+            v_h.set_holder_constructed();
+        }
+    }
+
+    /// Performs instance initialization including constructing a holder and registering the known
+    /// instance.  Should be called as soon as the `type` value_ptr is set for an instance.  Takes an
+    /// optional pointer to an existing holder to use; if not specified and the instance is
+    /// `.owned`, a new holder will be constructed to manage the value pointer.
+    static void init_instance(detail::instance *inst, const void *holder_ptr) {
+        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
+        if (!v_h.instance_registered()) {
+            register_instance(inst, v_h.value_ptr(), v_h.type);
+            v_h.set_instance_registered();
+        }
+        init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
+    }
+
+    /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.
+    static void dealloc(detail::value_and_holder &v_h) {
+        // We could be deallocating because we are cleaning up after a Python exception.
+        // If so, the Python error indicator will be set. We need to clear that before
+        // running the destructor, in case the destructor code calls more Python.
+        // If we don't, the Python API will exit with an exception, and pybind11 will
+        // throw error_already_set from the C++ destructor which is forbidden and triggers
+        // std::terminate().
+        error_scope scope;
+        if (v_h.holder_constructed()) {
+            v_h.holder<holder_type>().~holder_type();
+            v_h.set_holder_constructed(false);
+        }
+        else {
+            detail::call_operator_delete(v_h.value_ptr<type>(),
+                v_h.type->type_size,
+                v_h.type->type_align
+            );
+        }
+        v_h.value_ptr() = nullptr;
+    }
+
+    static detail::function_record *get_function_record(handle h) {
+        h = detail::get_function(h);
+        return h ? (detail::function_record *) reinterpret_borrow<capsule>(PyCFunction_GET_SELF(h.ptr()))
+                 : nullptr;
+    }
+};

From 1bedec6d2bfef9180cc046265e83958df8f989c6 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 11 Jan 2021 11:55:03 -0800
Subject: [PATCH 036/206] classh.h: renaming of class_ to classh + namespace;
 forking test_classh_wip from test_type_caster_bare_interface_demo.

---
 include/pybind11/classh.h |  70 ++++++------
 tests/test_classh_wip.cpp | 225 ++++++++++++++++++++++++++++++++++++++
 tests/test_classh_wip.py  |  47 ++++++++
 3 files changed, 311 insertions(+), 31 deletions(-)
 create mode 100644 tests/test_classh_wip.cpp
 create mode 100644 tests/test_classh_wip.py

diff --git a/include/pybind11/classh.h b/include/pybind11/classh.h
index db1970081c..fc3ffabb65 100644
--- a/include/pybind11/classh.h
+++ b/include/pybind11/classh.h
@@ -1,5 +1,11 @@
+#pragma once
+
+#include "pybind11.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
 template <typename type_, typename... options>
-class class_ : public detail::generic_type {
+class classh : public detail::generic_type {
     template <typename T> using is_holder = detail::is_holder_type<type_, T>;
     template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>;
     template <typename T> using is_base = detail::is_strict_base_of<T, type_>;
@@ -14,24 +20,24 @@ class class_ : public detail::generic_type {
     using holder_type = detail::exactly_one_t<is_holder, std::unique_ptr<type>, options...>;
 
     static_assert(detail::all_of<is_valid_class_option<options>...>::value,
-            "Unknown/invalid class_ template parameters provided");
+            "Unknown/invalid classh template parameters provided");
 
     static_assert(!has_alias || std::is_polymorphic<type>::value,
             "Cannot use an alias class with a non-polymorphic type");
 
-    PYBIND11_OBJECT(class_, generic_type, PyType_Check)
+    PYBIND11_OBJECT(classh, generic_type, PyType_Check)
 
     template <typename... Extra>
-    class_(handle scope, const char *name, const Extra &... extra) {
+    classh(handle scope, const char *name, const Extra &... extra) {
         using namespace detail;
 
-        // MI can only be specified via class_ template options, not constructor parameters
+        // MI can only be specified via classh template options, not constructor parameters
         static_assert(
             none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
             (   constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
                 constexpr_sum(is_base<options>::value...)   == 0 && // no template option bases
                 none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
-            "Error: multiple inheritance bases must be specified via class_ template options");
+            "Error: multiple inheritance bases must be specified via classh template options");
 
         type_record record;
         record.scope = scope;
@@ -46,7 +52,7 @@ class class_ : public detail::generic_type {
 
         set_operator_new<type>(&record);
 
-        /* Register base classes specified via template arguments to class_, if any */
+        /* Register base classes specified via template arguments to classh, if any */
         PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
 
         /* Process optional arguments, if any */
@@ -71,14 +77,14 @@ class class_ : public detail::generic_type {
     static void add_base(detail::type_record &) { }
 
     template <typename Func, typename... Extra>
-    class_ &def(const char *name_, Func&& f, const Extra&... extra) {
+    classh &def(const char *name_, Func&& f, const Extra&... extra) {
         cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
                         sibling(getattr(*this, name_, none())), extra...);
         add_class_method(*this, name_, cf);
         return *this;
     }
 
-    template <typename Func, typename... Extra> class_ &
+    template <typename Func, typename... Extra> classh &
     def_static(const char *name_, Func &&f, const Extra&... extra) {
         static_assert(!std::is_member_function_pointer<Func>::value,
                 "def_static(...) called with a non-static member function pointer");
@@ -89,43 +95,43 @@ class class_ : public detail::generic_type {
     }
 
     template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
-    class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
+    classh &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
         op.execute(*this, extra...);
         return *this;
     }
 
     template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
-    class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
+    classh & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
         op.execute_cast(*this, extra...);
         return *this;
     }
 
     template <typename... Args, typename... Extra>
-    class_ &def(const detail::initimpl::constructor<Args...> &init, const Extra&... extra) {
+    classh &def(const detail::initimpl::constructor<Args...> &init, const Extra&... extra) {
         init.execute(*this, extra...);
         return *this;
     }
 
     template <typename... Args, typename... Extra>
-    class_ &def(const detail::initimpl::alias_constructor<Args...> &init, const Extra&... extra) {
+    classh &def(const detail::initimpl::alias_constructor<Args...> &init, const Extra&... extra) {
         init.execute(*this, extra...);
         return *this;
     }
 
     template <typename... Args, typename... Extra>
-    class_ &def(detail::initimpl::factory<Args...> &&init, const Extra&... extra) {
+    classh &def(detail::initimpl::factory<Args...> &&init, const Extra&... extra) {
         std::move(init).execute(*this, extra...);
         return *this;
     }
 
     template <typename... Args, typename... Extra>
-    class_ &def(detail::initimpl::pickle_factory<Args...> &&pf, const Extra &...extra) {
+    classh &def(detail::initimpl::pickle_factory<Args...> &&pf, const Extra &...extra) {
         std::move(pf).execute(*this, extra...);
         return *this;
     }
 
     template <typename Func>
-    class_& def_buffer(Func &&func) {
+    classh& def_buffer(Func &&func) {
         struct capture { Func func; };
         auto *ptr = new capture { std::forward<Func>(func) };
         install_buffer_funcs([](PyObject *obj, void *ptr) -> buffer_info* {
@@ -142,17 +148,17 @@ class class_ : public detail::generic_type {
     }
 
     template <typename Return, typename Class, typename... Args>
-    class_ &def_buffer(Return (Class::*func)(Args...)) {
+    classh &def_buffer(Return (Class::*func)(Args...)) {
         return def_buffer([func] (type &obj) { return (obj.*func)(); });
     }
 
     template <typename Return, typename Class, typename... Args>
-    class_ &def_buffer(Return (Class::*func)(Args...) const) {
+    classh &def_buffer(Return (Class::*func)(Args...) const) {
         return def_buffer([func] (const type &obj) { return (obj.*func)(); });
     }
 
     template <typename C, typename D, typename... Extra>
-    class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
+    classh &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
         static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readwrite() requires a class member (or base class member)");
         cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this)),
                      fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
@@ -161,7 +167,7 @@ class class_ : public detail::generic_type {
     }
 
     template <typename C, typename D, typename... Extra>
-    class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
+    classh &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
         static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readonly() requires a class member (or base class member)");
         cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this));
         def_property_readonly(name, fget, return_value_policy::reference_internal, extra...);
@@ -169,7 +175,7 @@ class class_ : public detail::generic_type {
     }
 
     template <typename D, typename... Extra>
-    class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
+    classh &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
         cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this)),
                      fset([pm](object, const D &value) { *pm = value; }, scope(*this));
         def_property_static(name, fget, fset, return_value_policy::reference, extra...);
@@ -177,7 +183,7 @@ class class_ : public detail::generic_type {
     }
 
     template <typename D, typename... Extra>
-    class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
+    classh &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
         cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this));
         def_property_readonly_static(name, fget, return_value_policy::reference, extra...);
         return *this;
@@ -185,55 +191,55 @@ class class_ : public detail::generic_type {
 
     /// Uses return_value_policy::reference_internal by default
     template <typename Getter, typename... Extra>
-    class_ &def_property_readonly(const char *name, const Getter &fget, const Extra& ...extra) {
+    classh &def_property_readonly(const char *name, const Getter &fget, const Extra& ...extra) {
         return def_property_readonly(name, cpp_function(method_adaptor<type>(fget)),
                                      return_value_policy::reference_internal, extra...);
     }
 
     /// Uses cpp_function's return_value_policy by default
     template <typename... Extra>
-    class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
+    classh &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
         return def_property(name, fget, nullptr, extra...);
     }
 
     /// Uses return_value_policy::reference by default
     template <typename Getter, typename... Extra>
-    class_ &def_property_readonly_static(const char *name, const Getter &fget, const Extra& ...extra) {
+    classh &def_property_readonly_static(const char *name, const Getter &fget, const Extra& ...extra) {
         return def_property_readonly_static(name, cpp_function(fget), return_value_policy::reference, extra...);
     }
 
     /// Uses cpp_function's return_value_policy by default
     template <typename... Extra>
-    class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
+    classh &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
         return def_property_static(name, fget, nullptr, extra...);
     }
 
     /// Uses return_value_policy::reference_internal by default
     template <typename Getter, typename Setter, typename... Extra>
-    class_ &def_property(const char *name, const Getter &fget, const Setter &fset, const Extra& ...extra) {
+    classh &def_property(const char *name, const Getter &fget, const Setter &fset, const Extra& ...extra) {
         return def_property(name, fget, cpp_function(method_adaptor<type>(fset)), extra...);
     }
     template <typename Getter, typename... Extra>
-    class_ &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
+    classh &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
         return def_property(name, cpp_function(method_adaptor<type>(fget)), fset,
                             return_value_policy::reference_internal, extra...);
     }
 
     /// Uses cpp_function's return_value_policy by default
     template <typename... Extra>
-    class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
+    classh &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
         return def_property_static(name, fget, fset, is_method(*this), extra...);
     }
 
     /// Uses return_value_policy::reference by default
     template <typename Getter, typename... Extra>
-    class_ &def_property_static(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
+    classh &def_property_static(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
         return def_property_static(name, cpp_function(fget), fset, return_value_policy::reference, extra...);
     }
 
     /// Uses cpp_function's return_value_policy by default
     template <typename... Extra>
-    class_ &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
+    classh &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
         static_assert( 0 == detail::constexpr_sum(std::is_base_of<arg, Extra>::value...),
                       "Argument annotations are not allowed for properties");
         auto rec_fget = get_function_record(fget), rec_fset = get_function_record(fset);
@@ -342,3 +348,5 @@ class class_ : public detail::generic_type {
                  : nullptr;
     }
 };
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
new file mode 100644
index 0000000000..381b59b601
--- /dev/null
+++ b/tests/test_classh_wip.cpp
@@ -0,0 +1,225 @@
+#include "pybind11_tests.h"
+
+#include <pybind11/classh.h>
+
+#include <memory>
+
+namespace pybind11_tests {
+namespace classh_wip {
+
+struct mpty {};
+
+mpty        rtrn_mpty_valu() { mpty obj; return obj; }
+mpty&&      rtrn_mpty_rref() { mpty obj; return std::move(obj); }
+mpty const& rtrn_mpty_cref() { static mpty obj; return obj; }
+mpty&       rtrn_mpty_mref() { static mpty obj; return obj; }
+mpty const* rtrn_mpty_cptr() { static mpty obj; return &obj; }
+mpty*       rtrn_mpty_mptr() { static mpty obj; return &obj; }
+
+const char* pass_mpty_valu(mpty)        { return "load_valu"; }
+const char* pass_mpty_rref(mpty&&)      { return "load_rref"; }
+const char* pass_mpty_cref(mpty const&) { return "load_cref"; }
+const char* pass_mpty_mref(mpty&)       { return "load_mref"; }
+const char* pass_mpty_cptr(mpty const*) { return "load_cptr"; }
+const char* pass_mpty_mptr(mpty*)       { return "load_mptr"; }
+
+std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty>(new mpty); }
+std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const>(new mpty); }
+
+const char* pass_mpty_shmp(std::shared_ptr<mpty>)       { return "load_shmp"; }
+const char* pass_mpty_shcp(std::shared_ptr<mpty const>) { return "load_shcp"; }
+
+std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty>(new mpty); }
+std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty); }
+
+const char* pass_mpty_uqmp(std::unique_ptr<mpty>)       { return "load_uqmp"; }
+const char* pass_mpty_uqcp(std::unique_ptr<mpty const>) { return "load_uqcp"; }
+
+}  // namespace classh_wip
+}  // namespace pybind11_tests
+
+namespace pybind11 {
+namespace detail {
+
+using namespace pybind11_tests::classh_wip;
+
+template <>
+struct type_caster<mpty> {
+    static constexpr auto name = _<mpty>();
+
+    // static handle cast(mpty, ...)
+    // is redundant (leads to ambiguous overloads).
+
+    static handle cast(mpty&& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_rref").release();
+    }
+
+    static handle cast(mpty const& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_cref").release();
+    }
+
+    static handle cast(mpty& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_mref").release();
+    }
+
+    static handle cast(mpty const* /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_cptr").release();
+    }
+
+    static handle cast(mpty* /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_mptr").release();
+    }
+
+    template <typename T_>
+    using cast_op_type = conditional_t<
+        std::is_same<remove_reference_t<T_>, mpty const*>::value, mpty const*,
+        conditional_t<
+            std::is_same<remove_reference_t<T_>, mpty*>::value, mpty*,
+            conditional_t<
+                std::is_same<T_, mpty const&>::value, mpty const&,
+                conditional_t<
+                    std::is_same<T_, mpty&>::value, mpty&,
+                    conditional_t<
+                        std::is_same<T_, mpty&&>::value, mpty&&,
+                        mpty>>>>>;
+
+    operator mpty()        { return rtrn_mpty_valu(); }
+    operator mpty&&() &&   { return rtrn_mpty_rref(); }
+    operator mpty const&() { return rtrn_mpty_cref(); }
+    operator mpty&()       { return rtrn_mpty_mref(); }
+    operator mpty const*() { return rtrn_mpty_cptr(); }
+    operator mpty*()       { return rtrn_mpty_mptr(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
+template <>
+struct type_caster<std::shared_ptr<mpty>> {
+    static constexpr auto name = _<std::shared_ptr<mpty>>();
+
+    static handle cast(const std::shared_ptr<mpty>& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_shmp").release();
+    }
+
+    template <typename> using cast_op_type = std::shared_ptr<mpty>;
+
+    operator std::shared_ptr<mpty>() { return rtrn_mpty_shmp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
+template <>
+struct type_caster<std::shared_ptr<mpty const>> {
+    static constexpr auto name = _<std::shared_ptr<mpty const>>();
+
+    static handle cast(const std::shared_ptr<mpty const>& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_shcp").release();
+    }
+
+    template <typename> using cast_op_type = std::shared_ptr<mpty const>;
+
+    operator std::shared_ptr<mpty const>() { return rtrn_mpty_shcp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
+template <>
+struct type_caster<std::unique_ptr<mpty>> {
+    static constexpr auto name = _<std::unique_ptr<mpty>>();
+
+    static handle cast(std::unique_ptr<mpty>&& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_uqmp").release();
+    }
+
+    template <typename> using cast_op_type = std::unique_ptr<mpty>;
+
+    operator std::unique_ptr<mpty>() { return rtrn_mpty_uqmp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
+template <>
+struct type_caster<std::unique_ptr<mpty const>> {
+    static constexpr auto name = _<std::unique_ptr<mpty const>>();
+
+    static handle cast(std::unique_ptr<mpty const>&& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_uqcp").release();
+    }
+
+    template <typename> using cast_op_type = std::unique_ptr<mpty const>;
+
+    operator std::unique_ptr<mpty const>() { return rtrn_mpty_uqcp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
+}  // namespace detail
+}  // namespace pybind11
+
+namespace pybind11_tests {
+namespace classh_wip {
+
+TEST_SUBMODULE(classh_wip, m) {
+    namespace py = pybind11;
+
+    py::classh<mpty>(m, "mpty")
+        .def(py::init<>())
+    ;
+
+    m.def("rtrn_mpty_valu", rtrn_mpty_valu);
+    m.def("rtrn_mpty_rref", rtrn_mpty_rref);
+    m.def("rtrn_mpty_cref", rtrn_mpty_cref);
+    m.def("rtrn_mpty_mref", rtrn_mpty_mref);
+    m.def("rtrn_mpty_cptr", rtrn_mpty_cptr);
+    m.def("rtrn_mpty_mptr", rtrn_mpty_mptr);
+
+    m.def("pass_mpty_valu", pass_mpty_valu);
+    m.def("pass_mpty_rref", pass_mpty_rref);
+    m.def("pass_mpty_cref", pass_mpty_cref);
+    m.def("pass_mpty_mref", pass_mpty_mref);
+    m.def("pass_mpty_cptr", pass_mpty_cptr);
+    m.def("pass_mpty_mptr", pass_mpty_mptr);
+
+    m.def("rtrn_mpty_shmp", rtrn_mpty_shmp);
+    m.def("rtrn_mpty_shcp", rtrn_mpty_shcp);
+
+    m.def("pass_mpty_shmp", pass_mpty_shmp);
+    m.def("pass_mpty_shcp", pass_mpty_shcp);
+
+    m.def("rtrn_mpty_uqmp", rtrn_mpty_uqmp);
+    m.def("rtrn_mpty_uqcp", rtrn_mpty_uqcp);
+
+    m.def("pass_mpty_uqmp", pass_mpty_uqmp);
+    m.def("pass_mpty_uqcp", pass_mpty_uqcp);
+}
+
+}  // namespace classh_wip
+}  // namespace pybind11_tests
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
new file mode 100644
index 0000000000..0c07eae011
--- /dev/null
+++ b/tests/test_classh_wip.py
@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+from pybind11_tests import classh_wip as m
+
+
+def test_mpty():
+    e = m.mpty()
+    assert e.__class__.__name__ == "mpty"
+
+
+def test_cast():
+    assert m.rtrn_mpty_valu() == "cast_rref"
+    assert m.rtrn_mpty_rref() == "cast_rref"
+    assert m.rtrn_mpty_cref() == "cast_cref"
+    assert m.rtrn_mpty_mref() == "cast_mref"
+    assert m.rtrn_mpty_cptr() == "cast_cptr"
+    assert m.rtrn_mpty_mptr() == "cast_mptr"
+
+
+def test_load():
+    assert m.pass_mpty_valu(None) == "load_valu"
+    assert m.pass_mpty_rref(None) == "load_rref"
+    assert m.pass_mpty_cref(None) == "load_cref"
+    assert m.pass_mpty_mref(None) == "load_mref"
+    assert m.pass_mpty_cptr(None) == "load_cptr"
+    assert m.pass_mpty_mptr(None) == "load_mptr"
+
+
+def test_cast_shared_ptr():
+    assert m.rtrn_mpty_shmp() == "cast_shmp"
+    assert m.rtrn_mpty_shcp() == "cast_shcp"
+
+
+def test_load_shared_ptr():
+    assert m.pass_mpty_shmp(None) == "load_shmp"
+    assert m.pass_mpty_shcp(None) == "load_shcp"
+
+
+def test_cast_unique_ptr():
+    assert m.rtrn_mpty_uqmp() == "cast_uqmp"
+    assert m.rtrn_mpty_uqcp() == "cast_uqcp"
+
+
+def test_load_unique_ptr():
+    assert m.pass_mpty_uqmp(None) == "load_uqmp"
+    assert m.pass_mpty_uqcp(None) == "load_uqcp"

From 1c5c52f2125ae8c7de379c394ccdec506d2a505c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 11 Jan 2021 15:37:23 -0800
Subject: [PATCH 037/206] Hard-coding smart_holder into classh.

---
 include/pybind11/classh.h | 25 ++++++++-----------------
 1 file changed, 8 insertions(+), 17 deletions(-)

diff --git a/include/pybind11/classh.h b/include/pybind11/classh.h
index fc3ffabb65..61bc50d4b9 100644
--- a/include/pybind11/classh.h
+++ b/include/pybind11/classh.h
@@ -1,23 +1,23 @@
 #pragma once
 
+#include "smart_holder_poc.h"
 #include "pybind11.h"
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 
 template <typename type_, typename... options>
 class classh : public detail::generic_type {
-    template <typename T> using is_holder = detail::is_holder_type<type_, T>;
     template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>;
     template <typename T> using is_base = detail::is_strict_base_of<T, type_>;
     // struct instead of using here to help MSVC:
     template <typename T> struct is_valid_class_option :
-        detail::any_of<is_holder<T>, is_subtype<T>, is_base<T>> {};
+        detail::any_of<is_subtype<T>, is_base<T>> {};
 
 public:
     using type = type_;
     using type_alias = detail::exactly_one_t<is_subtype, void, options...>;
     constexpr static bool has_alias = !std::is_void<type_alias>::value;
-    using holder_type = detail::exactly_one_t<is_holder, std::unique_ptr<type>, options...>;
+    using holder_type = pybindit::memory::smart_holder;
 
     static_assert(detail::all_of<is_valid_class_option<options>...>::value,
             "Unknown/invalid classh template parameters provided");
@@ -48,7 +48,7 @@ class classh : public detail::generic_type {
         record.holder_size = sizeof(holder_type);
         record.init_instance = init_instance;
         record.dealloc = dealloc;
-        record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
+        record.default_holder = false;
 
         set_operator_new<type>(&record);
 
@@ -271,7 +271,7 @@ class classh : public detail::generic_type {
     static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
             const holder_type * /* unused */, const std::enable_shared_from_this<T> * /* dummy */) {
         try {
-            auto sh = std::dynamic_pointer_cast<typename holder_type::element_type>(
+            auto sh = std::dynamic_pointer_cast<type>(  // Was: typename holder_type::element_type
                     v_h.value_ptr<type>()->shared_from_this());
             if (sh) {
                 new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(sh));
@@ -285,24 +285,15 @@ class classh : public detail::generic_type {
         }
     }
 
-    static void init_holder_from_existing(const detail::value_and_holder &v_h,
-            const holder_type *holder_ptr, std::true_type /*is_copy_constructible*/) {
-        new (std::addressof(v_h.holder<holder_type>())) holder_type(*reinterpret_cast<const holder_type *>(holder_ptr));
-    }
-
-    static void init_holder_from_existing(const detail::value_and_holder &v_h,
-            const holder_type *holder_ptr, std::false_type /*is_copy_constructible*/) {
-        new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*const_cast<holder_type *>(holder_ptr)));
-    }
-
     /// Initialize holder object, variant 2: try to construct from existing holder object, if possible
     static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
             const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
         if (holder_ptr) {
-            init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(*reinterpret_cast<const holder_type *>(holder_ptr));
             v_h.set_holder_constructed();
         } else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(
+                std::move(holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<type>())));
             v_h.set_holder_constructed();
         }
     }

From 83ef538f5933871daf8992f7d96f00874fd7b4a2 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 11 Jan 2021 15:58:14 -0800
Subject: [PATCH 038/206] Adding mpty::mtxt string member.

---
 tests/test_classh_wip.cpp | 5 ++++-
 tests/test_classh_wip.py  | 6 +++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 381b59b601..f9dc6e57e9 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -3,11 +3,12 @@
 #include <pybind11/classh.h>
 
 #include <memory>
+#include <string>
 
 namespace pybind11_tests {
 namespace classh_wip {
 
-struct mpty {};
+struct mpty { std::string mtxt; };
 
 mpty        rtrn_mpty_valu() { mpty obj; return obj; }
 mpty&&      rtrn_mpty_rref() { mpty obj; return std::move(obj); }
@@ -192,6 +193,8 @@ TEST_SUBMODULE(classh_wip, m) {
 
     py::classh<mpty>(m, "mpty")
         .def(py::init<>())
+        .def(py::init([](const std::string& mtxt) {
+            mpty obj; obj.mtxt = mtxt; return obj; }))
     ;
 
     m.def("rtrn_mpty_valu", rtrn_mpty_valu);
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index 0c07eae011..00eafce08e 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -4,9 +4,13 @@
 from pybind11_tests import classh_wip as m
 
 
-def test_mpty():
+def test_mpty_constructors():
     e = m.mpty()
     assert e.__class__.__name__ == "mpty"
+    e = m.mpty("")
+    assert e.__class__.__name__ == "mpty"
+    e = m.mpty("txtm")
+    assert e.__class__.__name__ == "mpty"
 
 
 def test_cast():

From 6cb94e4e027eccd43a62b2b9e214bf65fc7e9ca8 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 11 Jan 2021 16:16:24 -0800
Subject: [PATCH 039/206] Adding isinstance<mpty> in type_caster::load
 functions.

---
 tests/test_classh_wip.cpp | 15 ++++++++++-----
 tests/test_classh_wip.py  | 20 ++++++++++----------
 2 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index f9dc6e57e9..9501d514ed 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -101,7 +101,8 @@ struct type_caster<mpty> {
     operator mpty const*() { return rtrn_mpty_cptr(); }
     operator mpty*()       { return rtrn_mpty_mptr(); }
 
-    bool load(handle /*src*/, bool /*convert*/) {
+    bool load(handle src, bool /*convert*/) {
+        if (!isinstance<mpty>(src)) return false;
         return true;
     }
 };
@@ -120,7 +121,8 @@ struct type_caster<std::shared_ptr<mpty>> {
 
     operator std::shared_ptr<mpty>() { return rtrn_mpty_shmp(); }
 
-    bool load(handle /*src*/, bool /*convert*/) {
+    bool load(handle src, bool /*convert*/) {
+        if (!isinstance<mpty>(src)) return false;
         return true;
     }
 };
@@ -139,7 +141,8 @@ struct type_caster<std::shared_ptr<mpty const>> {
 
     operator std::shared_ptr<mpty const>() { return rtrn_mpty_shcp(); }
 
-    bool load(handle /*src*/, bool /*convert*/) {
+    bool load(handle src, bool /*convert*/) {
+        if (!isinstance<mpty>(src)) return false;
         return true;
     }
 };
@@ -158,7 +161,8 @@ struct type_caster<std::unique_ptr<mpty>> {
 
     operator std::unique_ptr<mpty>() { return rtrn_mpty_uqmp(); }
 
-    bool load(handle /*src*/, bool /*convert*/) {
+    bool load(handle src, bool /*convert*/) {
+        if (!isinstance<mpty>(src)) return false;
         return true;
     }
 };
@@ -177,7 +181,8 @@ struct type_caster<std::unique_ptr<mpty const>> {
 
     operator std::unique_ptr<mpty const>() { return rtrn_mpty_uqcp(); }
 
-    bool load(handle /*src*/, bool /*convert*/) {
+    bool load(handle src, bool /*convert*/) {
+        if (!isinstance<mpty>(src)) return false;
         return true;
     }
 };
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index 00eafce08e..492f5a2f2d 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -23,12 +23,12 @@ def test_cast():
 
 
 def test_load():
-    assert m.pass_mpty_valu(None) == "load_valu"
-    assert m.pass_mpty_rref(None) == "load_rref"
-    assert m.pass_mpty_cref(None) == "load_cref"
-    assert m.pass_mpty_mref(None) == "load_mref"
-    assert m.pass_mpty_cptr(None) == "load_cptr"
-    assert m.pass_mpty_mptr(None) == "load_mptr"
+    assert m.pass_mpty_valu(m.mpty()) == "load_valu"
+    assert m.pass_mpty_rref(m.mpty()) == "load_rref"
+    assert m.pass_mpty_cref(m.mpty()) == "load_cref"
+    assert m.pass_mpty_mref(m.mpty()) == "load_mref"
+    assert m.pass_mpty_cptr(m.mpty()) == "load_cptr"
+    assert m.pass_mpty_mptr(m.mpty()) == "load_mptr"
 
 
 def test_cast_shared_ptr():
@@ -37,8 +37,8 @@ def test_cast_shared_ptr():
 
 
 def test_load_shared_ptr():
-    assert m.pass_mpty_shmp(None) == "load_shmp"
-    assert m.pass_mpty_shcp(None) == "load_shcp"
+    assert m.pass_mpty_shmp(m.mpty()) == "load_shmp"
+    assert m.pass_mpty_shcp(m.mpty()) == "load_shcp"
 
 
 def test_cast_unique_ptr():
@@ -47,5 +47,5 @@ def test_cast_unique_ptr():
 
 
 def test_load_unique_ptr():
-    assert m.pass_mpty_uqmp(None) == "load_uqmp"
-    assert m.pass_mpty_uqcp(None) == "load_uqcp"
+    assert m.pass_mpty_uqmp(m.mpty()) == "load_uqmp"
+    assert m.pass_mpty_uqcp(m.mpty()) == "load_uqcp"

From 8ed0206f6ac7e6e93b64a53271fedcf9a3e10693 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 11 Jan 2021 20:34:23 -0800
Subject: [PATCH 040/206] Adding rvalue_ref, renaming const_value_ref to
 lvalue_ref & removing const.

---
 include/pybind11/smart_holder_poc.h  | 12 ++++++--
 tests/core/smart_holder_poc_test.cpp | 42 ++++++++++++++++++++--------
 2 files changed, 40 insertions(+), 14 deletions(-)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index 4d14409cfe..f3374f103f 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -158,13 +158,21 @@ struct smart_holder {
   }
 
   template <typename T>
-  const T& const_value_ref() const {
-    static const char* context = "const_value_ref";
+  T& lvalue_ref() const {
+    static const char* context = "lvalue_ref";
     ensure_compatible_rtti_held<T>(context);
     ensure_has_pointee(context);
     return *static_cast<T*>(vptr.get());
   }
 
+  template <typename T>
+  T&& rvalue_ref() const {
+    static const char* context = "rvalue_ref";
+    ensure_compatible_rtti_held<T>(context);
+    ensure_has_pointee(context);
+    return std::move(*static_cast<T*>(vptr.get()));
+  }
+
   template <typename T>
   static smart_holder from_raw_ptr_take_ownership(T* raw_ptr) {
     smart_holder hld;
diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/core/smart_holder_poc_test.cpp
index 9aebba62fb..e696d9e534 100644
--- a/tests/core/smart_holder_poc_test.cpp
+++ b/tests/core/smart_holder_poc_test.cpp
@@ -7,6 +7,15 @@ using pybindit::memory::smart_holder;
 
 namespace helpers {
 
+struct movable_int {
+  int valu;
+  movable_int(int v) : valu{v} {}
+  movable_int(movable_int&& other) {
+    valu = other.valu;
+    other.valu = 91;
+  }
+};
+
 template <typename T>
 struct functor_builtin_delete {
   void operator()(T* ptr) { delete ptr; }
@@ -23,10 +32,20 @@ TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_unowned", "[S]") {
   REQUIRE(*hld.as_raw_ptr_unowned<int>() == 19);
 }
 
-TEST_CASE("from_raw_ptr_unowned+const_value_ref", "[S]") {
+TEST_CASE("from_raw_ptr_unowned+lvalue_ref", "[S]") {
   static int value = 19;
   auto hld = smart_holder::from_raw_ptr_unowned(&value);
-  REQUIRE(hld.const_value_ref<int>() == 19);
+  REQUIRE(hld.lvalue_ref<int>() == 19);
+}
+
+TEST_CASE("from_raw_ptr_unowned+rvalue_ref", "[S]") {
+  helpers::movable_int orig(19);
+  {
+    auto hld = smart_holder::from_raw_ptr_unowned(&orig);
+    helpers::movable_int othr(hld.rvalue_ref<helpers::movable_int>());
+    REQUIRE(othr.valu == 19);
+    REQUIRE(orig.valu == 91);
+  }
 }
 
 TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_release_ownership", "[E]") {
@@ -61,10 +80,10 @@ TEST_CASE("from_raw_ptr_unowned+as_shared_ptr", "[S]") {
   REQUIRE(*hld.as_shared_ptr<int>() == 19);
 }
 
-TEST_CASE("from_raw_ptr_take_ownership+const_value_ref", "[S]") {
+TEST_CASE("from_raw_ptr_take_ownership+lvalue_ref", "[S]") {
   auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
   REQUIRE(hld.has_pointee());
-  REQUIRE(hld.const_value_ref<int>() == 19);
+  REQUIRE(hld.lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership1", "[S]") {
@@ -114,11 +133,11 @@ TEST_CASE("from_raw_ptr_take_ownership+as_shared_ptr", "[S]") {
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_unique_ptr+const_value_ref", "[S]") {
+TEST_CASE("from_unique_ptr+lvalue_ref", "[S]") {
   std::unique_ptr<int> orig_owner(new int(19));
   auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
-  REQUIRE(hld.const_value_ref<int>() == 19);
+  REQUIRE(hld.lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership1", "[S]") {
@@ -180,12 +199,12 @@ TEST_CASE("from_unique_ptr+as_shared_ptr", "[S]") {
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_unique_ptr_with_deleter+const_value_ref", "[S]") {
+TEST_CASE("from_unique_ptr_with_deleter+lvalue_ref", "[S]") {
   std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
       new int(19));
   auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
   REQUIRE(orig_owner.get() == nullptr);
-  REQUIRE(hld.const_value_ref<int>() == 19);
+  REQUIRE(hld.lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+as_raw_ptr_release_ownership", "[E]") {
@@ -242,10 +261,10 @@ TEST_CASE("from_unique_ptr_with_deleter+as_shared_ptr", "[S]") {
   REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_shared_ptr+const_value_ref", "[S]") {
+TEST_CASE("from_shared_ptr+lvalue_ref", "[S]") {
   std::shared_ptr<int> orig_owner(new int(19));
   auto hld = smart_holder::from_shared_ptr(orig_owner);
-  REQUIRE(hld.const_value_ref<int>() == 19);
+  REQUIRE(hld.lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_shared_ptr+as_raw_ptr_release_ownership", "[E]") {
@@ -296,6 +315,5 @@ TEST_CASE("error_incompatible_type", "[E]") {
 TEST_CASE("error_disowned_holder", "[E]") {
   auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
   hld.as_unique_ptr<int>();
-  REQUIRE_THROWS_WITH(hld.const_value_ref<int>(),
-                      "Disowned holder (const_value_ref).");
+  REQUIRE_THROWS_WITH(hld.lvalue_ref<int>(), "Disowned holder (lvalue_ref).");
 }

From e90f6b0a85f7f2dfaf5790683d6cd34d2fc9b0ba Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 11 Jan 2021 20:38:11 -0800
Subject: [PATCH 041/206] Retrieving smart_holder pointer in
 type_caster<mpty>::load, and using it cast_op operators.

---
 tests/test_classh_wip.cpp | 30 ++++++++++++++++++------------
 tests/test_classh_wip.py  | 12 ++++++------
 2 files changed, 24 insertions(+), 18 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 9501d514ed..bdcd3323c5 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -17,12 +17,12 @@ mpty&       rtrn_mpty_mref() { static mpty obj; return obj; }
 mpty const* rtrn_mpty_cptr() { static mpty obj; return &obj; }
 mpty*       rtrn_mpty_mptr() { static mpty obj; return &obj; }
 
-const char* pass_mpty_valu(mpty)        { return "load_valu"; }
-const char* pass_mpty_rref(mpty&&)      { return "load_rref"; }
-const char* pass_mpty_cref(mpty const&) { return "load_cref"; }
-const char* pass_mpty_mref(mpty&)       { return "load_mref"; }
-const char* pass_mpty_cptr(mpty const*) { return "load_cptr"; }
-const char* pass_mpty_mptr(mpty*)       { return "load_mptr"; }
+std::string pass_mpty_valu(mpty obj)        { return "pass_valu:" + obj.mtxt; }
+std::string pass_mpty_rref(mpty&& obj)      { return "pass_rref:" + obj.mtxt; }
+std::string pass_mpty_cref(mpty const& obj) { return "pass_cref:" + obj.mtxt; }
+std::string pass_mpty_mref(mpty& obj)       { return "pass_mref:" + obj.mtxt; }
+std::string pass_mpty_cptr(mpty const* obj) { return "pass_cptr:" + obj->mtxt; }
+std::string pass_mpty_mptr(mpty* obj)       { return "pass_mptr:" + obj->mtxt; }
 
 std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty>(new mpty); }
 std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const>(new mpty); }
@@ -94,17 +94,23 @@ struct type_caster<mpty> {
                         std::is_same<T_, mpty&&>::value, mpty&&,
                         mpty>>>>>;
 
-    operator mpty()        { return rtrn_mpty_valu(); }
-    operator mpty&&() &&   { return rtrn_mpty_rref(); }
-    operator mpty const&() { return rtrn_mpty_cref(); }
-    operator mpty&()       { return rtrn_mpty_mref(); }
-    operator mpty const*() { return rtrn_mpty_cptr(); }
-    operator mpty*()       { return rtrn_mpty_mptr(); }
+    operator mpty()        { return smhldr_ptr->lvalue_ref<mpty>(); }
+    operator mpty&&() &&   { return smhldr_ptr->rvalue_ref<mpty>(); }
+    operator mpty const&() { return smhldr_ptr->lvalue_ref<mpty>(); }
+    operator mpty&()       { return smhldr_ptr->lvalue_ref<mpty>(); }
+    operator mpty const*() { return smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
+    operator mpty*()       { return smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
 
     bool load(handle src, bool /*convert*/) {
         if (!isinstance<mpty>(src)) return false;
+        auto inst = reinterpret_cast<instance *>(src.ptr());
+        auto v_h = inst->get_value_and_holder(get_type_info(typeid(mpty)));
+        smhldr_ptr = &v_h.holder<pybindit::memory::smart_holder>();
         return true;
     }
+
+  private:
+    pybindit::memory::smart_holder* smhldr_ptr = nullptr;
 };
 
 template <>
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index 492f5a2f2d..d938897041 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -23,12 +23,12 @@ def test_cast():
 
 
 def test_load():
-    assert m.pass_mpty_valu(m.mpty()) == "load_valu"
-    assert m.pass_mpty_rref(m.mpty()) == "load_rref"
-    assert m.pass_mpty_cref(m.mpty()) == "load_cref"
-    assert m.pass_mpty_mref(m.mpty()) == "load_mref"
-    assert m.pass_mpty_cptr(m.mpty()) == "load_cptr"
-    assert m.pass_mpty_mptr(m.mpty()) == "load_mptr"
+    assert m.pass_mpty_valu(m.mpty("Valu")) == "pass_valu:Valu"
+    assert m.pass_mpty_rref(m.mpty("Rref")) == "pass_rref:Rref"
+    assert m.pass_mpty_cref(m.mpty("Cref")) == "pass_cref:Cref"
+    assert m.pass_mpty_mref(m.mpty("Mref")) == "pass_mref:Mref"
+    assert m.pass_mpty_cptr(m.mpty("Cptr")) == "pass_cptr:Cptr"
+    assert m.pass_mpty_mptr(m.mpty("Mptr")) == "pass_mptr:Mptr"
 
 
 def test_cast_shared_ptr():

From f98322ccf662ba9dbd05e9c06ec226cd111a610b Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 11 Jan 2021 21:15:07 -0800
Subject: [PATCH 042/206] Factoring out smart_holder_type_caster_load.

---
 tests/test_classh_wip.cpp | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index bdcd3323c5..a6e20e6335 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -44,8 +44,22 @@ namespace detail {
 
 using namespace pybind11_tests::classh_wip;
 
+template <typename T>
+struct smart_holder_type_caster_load {
+    bool load(handle src, bool /*convert*/) {
+        if (!isinstance<T>(src)) return false;
+        auto inst = reinterpret_cast<instance *>(src.ptr());
+        auto v_h = inst->get_value_and_holder(get_type_info(typeid(T)));
+        smhldr_ptr = &v_h.holder<pybindit::memory::smart_holder>();
+        return true;
+    }
+
+  protected:
+    pybindit::memory::smart_holder* smhldr_ptr = nullptr;
+};
+
 template <>
-struct type_caster<mpty> {
+struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<mpty>();
 
     // static handle cast(mpty, ...)
@@ -100,17 +114,6 @@ struct type_caster<mpty> {
     operator mpty&()       { return smhldr_ptr->lvalue_ref<mpty>(); }
     operator mpty const*() { return smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
     operator mpty*()       { return smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
-
-    bool load(handle src, bool /*convert*/) {
-        if (!isinstance<mpty>(src)) return false;
-        auto inst = reinterpret_cast<instance *>(src.ptr());
-        auto v_h = inst->get_value_and_holder(get_type_info(typeid(mpty)));
-        smhldr_ptr = &v_h.holder<pybindit::memory::smart_holder>();
-        return true;
-    }
-
-  private:
-    pybindit::memory::smart_holder* smhldr_ptr = nullptr;
 };
 
 template <>

From f91e754ac5e690f1ff8d06b1f4fc2e80e15601f3 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 11 Jan 2021 21:27:23 -0800
Subject: [PATCH 043/206] Retrieving smart_holder pointer in
 type_caster<std::shared_ptr<mpty[ const]>>::load, and using it cast_op
 operators.

---
 tests/test_classh_wip.cpp | 22 ++++++----------------
 tests/test_classh_wip.py  |  4 ++--
 2 files changed, 8 insertions(+), 18 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index a6e20e6335..3de45a438e 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -27,8 +27,8 @@ std::string pass_mpty_mptr(mpty* obj)       { return "pass_mptr:" + obj->mtxt; }
 std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty>(new mpty); }
 std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const>(new mpty); }
 
-const char* pass_mpty_shmp(std::shared_ptr<mpty>)       { return "load_shmp"; }
-const char* pass_mpty_shcp(std::shared_ptr<mpty const>) { return "load_shcp"; }
+std::string pass_mpty_shmp(std::shared_ptr<mpty> obj)       { return "pass_shmp:" + obj->mtxt; }
+std::string pass_mpty_shcp(std::shared_ptr<mpty const> obj) { return "pass_shcp:" + obj->mtxt; }
 
 std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty>(new mpty); }
 std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty); }
@@ -117,7 +117,7 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
 };
 
 template <>
-struct type_caster<std::shared_ptr<mpty>> {
+struct type_caster<std::shared_ptr<mpty>> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<std::shared_ptr<mpty>>();
 
     static handle cast(const std::shared_ptr<mpty>& /*src*/,
@@ -128,16 +128,11 @@ struct type_caster<std::shared_ptr<mpty>> {
 
     template <typename> using cast_op_type = std::shared_ptr<mpty>;
 
-    operator std::shared_ptr<mpty>() { return rtrn_mpty_shmp(); }
-
-    bool load(handle src, bool /*convert*/) {
-        if (!isinstance<mpty>(src)) return false;
-        return true;
-    }
+    operator std::shared_ptr<mpty>() { return smhldr_ptr->as_shared_ptr<mpty>(); }
 };
 
 template <>
-struct type_caster<std::shared_ptr<mpty const>> {
+struct type_caster<std::shared_ptr<mpty const>> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<std::shared_ptr<mpty const>>();
 
     static handle cast(const std::shared_ptr<mpty const>& /*src*/,
@@ -148,12 +143,7 @@ struct type_caster<std::shared_ptr<mpty const>> {
 
     template <typename> using cast_op_type = std::shared_ptr<mpty const>;
 
-    operator std::shared_ptr<mpty const>() { return rtrn_mpty_shcp(); }
-
-    bool load(handle src, bool /*convert*/) {
-        if (!isinstance<mpty>(src)) return false;
-        return true;
-    }
+    operator std::shared_ptr<mpty const>() { return smhldr_ptr->as_shared_ptr<mpty>(); }
 };
 
 template <>
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index d938897041..7d6d0bb0f2 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -37,8 +37,8 @@ def test_cast_shared_ptr():
 
 
 def test_load_shared_ptr():
-    assert m.pass_mpty_shmp(m.mpty()) == "load_shmp"
-    assert m.pass_mpty_shcp(m.mpty()) == "load_shcp"
+    assert m.pass_mpty_shmp(m.mpty("Shmp")) == "pass_shmp:Shmp"
+    assert m.pass_mpty_shcp(m.mpty("Shcp")) == "pass_shcp:Shcp"
 
 
 def test_cast_unique_ptr():

From efb5cf29004db1a1014d8d9fa27f0c37b19766e6 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 11 Jan 2021 22:04:18 -0800
Subject: [PATCH 044/206] Improved error messaging: Cannot disown nullptr
 (as_unique_ptr).

---
 include/pybind11/smart_holder_poc.h  | 4 ++++
 tests/core/smart_holder_poc_test.cpp | 7 +++++++
 2 files changed, 11 insertions(+)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index f3374f103f..8f7b626513 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -134,6 +134,10 @@ struct smart_holder {
   }
 
   void ensure_use_count_1(const char* context) const {
+    if (vptr.get() == nullptr) {
+      throw std::runtime_error(std::string("Cannot disown nullptr (") +
+                               context + ").");
+    }
     if (vptr.use_count() != 1) {
       throw std::runtime_error(std::string("Cannot disown use_count != 1 (") +
                                context + ").");
diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/core/smart_holder_poc_test.cpp
index e696d9e534..dbd836b6f1 100644
--- a/tests/core/smart_holder_poc_test.cpp
+++ b/tests/core/smart_holder_poc_test.cpp
@@ -317,3 +317,10 @@ TEST_CASE("error_disowned_holder", "[E]") {
   hld.as_unique_ptr<int>();
   REQUIRE_THROWS_WITH(hld.lvalue_ref<int>(), "Disowned holder (lvalue_ref).");
 }
+
+TEST_CASE("error_cannot_disown_nullptr", "[E]") {
+  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
+  hld.as_unique_ptr<int>();
+  REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
+                      "Cannot disown nullptr (as_unique_ptr).");
+}

From 4ba4faa073290572ff0042e3e68aa2582317ab26 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 11 Jan 2021 22:06:18 -0800
Subject: [PATCH 045/206] Retrieving smart_holder pointer in
 type_caster<std::unique_ptr<mpty[ const]>>::load, and using it cast_op
 operators.

---
 tests/test_classh_wip.cpp | 22 ++++++----------------
 tests/test_classh_wip.py  | 19 +++++++++++++++++--
 2 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 3de45a438e..1767af9d31 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -33,8 +33,8 @@ std::string pass_mpty_shcp(std::shared_ptr<mpty const> obj) { return "pass_shcp:
 std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty>(new mpty); }
 std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty); }
 
-const char* pass_mpty_uqmp(std::unique_ptr<mpty>)       { return "load_uqmp"; }
-const char* pass_mpty_uqcp(std::unique_ptr<mpty const>) { return "load_uqcp"; }
+std::string pass_mpty_uqmp(std::unique_ptr<mpty> obj)       { return "pass_uqmp:" + obj->mtxt; }
+std::string pass_mpty_uqcp(std::unique_ptr<mpty const> obj) { return "pass_uqcp:" + obj->mtxt; }
 
 }  // namespace classh_wip
 }  // namespace pybind11_tests
@@ -147,7 +147,7 @@ struct type_caster<std::shared_ptr<mpty const>> : smart_holder_type_caster_load<
 };
 
 template <>
-struct type_caster<std::unique_ptr<mpty>> {
+struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<std::unique_ptr<mpty>>();
 
     static handle cast(std::unique_ptr<mpty>&& /*src*/,
@@ -158,16 +158,11 @@ struct type_caster<std::unique_ptr<mpty>> {
 
     template <typename> using cast_op_type = std::unique_ptr<mpty>;
 
-    operator std::unique_ptr<mpty>() { return rtrn_mpty_uqmp(); }
-
-    bool load(handle src, bool /*convert*/) {
-        if (!isinstance<mpty>(src)) return false;
-        return true;
-    }
+    operator std::unique_ptr<mpty>() { return smhldr_ptr->as_unique_ptr<mpty>(); }
 };
 
 template <>
-struct type_caster<std::unique_ptr<mpty const>> {
+struct type_caster<std::unique_ptr<mpty const>> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<std::unique_ptr<mpty const>>();
 
     static handle cast(std::unique_ptr<mpty const>&& /*src*/,
@@ -178,12 +173,7 @@ struct type_caster<std::unique_ptr<mpty const>> {
 
     template <typename> using cast_op_type = std::unique_ptr<mpty const>;
 
-    operator std::unique_ptr<mpty const>() { return rtrn_mpty_uqcp(); }
-
-    bool load(handle src, bool /*convert*/) {
-        if (!isinstance<mpty>(src)) return false;
-        return true;
-    }
+    operator std::unique_ptr<mpty const>() { return smhldr_ptr->as_unique_ptr<mpty>(); }
 };
 
 }  // namespace detail
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index 7d6d0bb0f2..4ecdee8b64 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -47,5 +47,20 @@ def test_cast_unique_ptr():
 
 
 def test_load_unique_ptr():
-    assert m.pass_mpty_uqmp(m.mpty()) == "load_uqmp"
-    assert m.pass_mpty_uqcp(m.mpty()) == "load_uqcp"
+    assert m.pass_mpty_uqmp(m.mpty("Uqmp")) == "pass_uqmp:Uqmp"
+    assert m.pass_mpty_uqcp(m.mpty("Uqcp")) == "pass_uqcp:Uqcp"
+
+
+@pytest.mark.parametrize(
+    "pass_mpty, argm, rtrn",
+    [
+        (m.pass_mpty_uqmp, "Uqmp", "pass_uqmp:Uqmp"),
+        (m.pass_mpty_uqcp, "Uqcp", "pass_uqcp:Uqcp"),
+    ],
+)
+def test_pass_unique_ptr_disowns(pass_mpty, argm, rtrn):
+    obj = m.mpty(argm)
+    assert pass_mpty(obj) == rtrn
+    with pytest.raises(RuntimeError) as exc_info:
+        m.pass_mpty_uqmp(obj)
+    assert str(exc_info.value) == "Cannot disown nullptr (as_unique_ptr)."

From 4aedb5109bfd94c4fa87916161d6d8b4214728b8 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 12 Jan 2021 10:28:17 -0800
Subject: [PATCH 046/206] Pure `clang-format --style=file -i` change.

---
 include/pybind11/smart_holder_poc.h  | 366 +++++++++++++-------------
 tests/core/smart_holder_poc_test.cpp | 373 +++++++++++++--------------
 2 files changed, 350 insertions(+), 389 deletions(-)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index 8f7b626513..0b70c719ce 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -48,216 +48,202 @@ namespace memory {
 
 template <typename T>
 struct guarded_builtin_delete {
-  bool* flag_ptr;
-  explicit guarded_builtin_delete(bool* guard_flag_ptr)
-      : flag_ptr{guard_flag_ptr} {}
-  void operator()(T* raw_ptr) {
-    if (*flag_ptr) delete raw_ptr;
-  }
+    bool *flag_ptr;
+    explicit guarded_builtin_delete(bool *guard_flag_ptr) : flag_ptr{guard_flag_ptr} {}
+    void operator()(T *raw_ptr) {
+        if (*flag_ptr)
+            delete raw_ptr;
+    }
 };
 
 template <typename T, typename D>
 struct guarded_custom_deleter {
-  bool* flag_ptr;
-  explicit guarded_custom_deleter(bool* guard_flag_ptr)
-      : flag_ptr{guard_flag_ptr} {}
-  void operator()(T* raw_ptr) {
-    if (*flag_ptr) D()(raw_ptr);
-  }
+    bool *flag_ptr;
+    explicit guarded_custom_deleter(bool *guard_flag_ptr) : flag_ptr{guard_flag_ptr} {}
+    void operator()(T *raw_ptr) {
+        if (*flag_ptr)
+            D()(raw_ptr);
+    }
 };
 
 struct smart_holder {
-  const std::type_info* rtti_held;
-  const std::type_info* rtti_uqp_del;
-  std::shared_ptr<void> vptr;
-  bool vptr_deleter_guard_flag;
-  bool vptr_is_using_noop_deleter : 1;
-  bool vptr_is_using_builtin_delete : 1;
-  bool vptr_is_external_shared_ptr : 1;
-
-  smart_holder()
-      : rtti_held{nullptr},
-        rtti_uqp_del{nullptr},
-        vptr_deleter_guard_flag{false},
-        vptr_is_using_noop_deleter{false},
-        vptr_is_using_builtin_delete{false},
-        vptr_is_external_shared_ptr{false} {}
-
-  bool has_pointee() const { return vptr.get() != nullptr; }
-
-  template <typename T>
-  void ensure_compatible_rtti_held(const char* context) const {
-    if (!rtti_held) {
-      throw std::runtime_error(std::string("Unpopulated holder (") + context +
-                               ").");
+    const std::type_info *rtti_held;
+    const std::type_info *rtti_uqp_del;
+    std::shared_ptr<void> vptr;
+    bool vptr_deleter_guard_flag;
+    bool vptr_is_using_noop_deleter : 1;
+    bool vptr_is_using_builtin_delete : 1;
+    bool vptr_is_external_shared_ptr : 1;
+
+    smart_holder()
+        : rtti_held{nullptr}, rtti_uqp_del{nullptr}, vptr_deleter_guard_flag{false},
+          vptr_is_using_noop_deleter{false}, vptr_is_using_builtin_delete{false},
+          vptr_is_external_shared_ptr{false} {}
+
+    bool has_pointee() const { return vptr.get() != nullptr; }
+
+    template <typename T>
+    void ensure_compatible_rtti_held(const char *context) const {
+        if (!rtti_held) {
+            throw std::runtime_error(std::string("Unpopulated holder (") + context + ").");
+        }
+        const std::type_info *rtti_requested = &typeid(T);
+        if (!(*rtti_requested == *rtti_held)) {
+            throw std::runtime_error(std::string("Incompatible type (") + context + ").");
+        }
     }
-    const std::type_info* rtti_requested = &typeid(T);
-    if (!(*rtti_requested == *rtti_held)) {
-      throw std::runtime_error(std::string("Incompatible type (") + context +
-                               ").");
+
+    template <typename D>
+    void ensure_compatible_rtti_uqp_del(const char *context) const {
+        if (!rtti_uqp_del) {
+            throw std::runtime_error(std::string("Missing unique_ptr deleter (") + context + ").");
+        }
+        const std::type_info *rtti_requested = &typeid(D);
+        if (!(*rtti_requested == *rtti_uqp_del)) {
+            throw std::runtime_error(std::string("Incompatible unique_ptr deleter (") + context
+                                     + ").");
+        }
     }
-  }
 
-  template <typename D>
-  void ensure_compatible_rtti_uqp_del(const char* context) const {
-    if (!rtti_uqp_del) {
-      throw std::runtime_error(std::string("Missing unique_ptr deleter (") +
-                               context + ").");
+    void ensure_has_pointee(const char *context) const {
+        if (!has_pointee()) {
+            throw std::runtime_error(std::string("Disowned holder (") + context + ").");
+        }
     }
-    const std::type_info* rtti_requested = &typeid(D);
-    if (!(*rtti_requested == *rtti_uqp_del)) {
-      throw std::runtime_error(
-          std::string("Incompatible unique_ptr deleter (") + context + ").");
+
+    void ensure_vptr_is_using_builtin_delete(const char *context) const {
+        if (vptr_is_external_shared_ptr) {
+            throw std::runtime_error(std::string("Cannot disown external shared_ptr (") + context
+                                     + ").");
+        }
+        if (vptr_is_using_noop_deleter) {
+            throw std::runtime_error(std::string("Cannot disown non-owning holder (") + context
+                                     + ").");
+        }
+        if (!vptr_is_using_builtin_delete) {
+            throw std::runtime_error(std::string("Cannot disown custom deleter (") + context
+                                     + ").");
+        }
     }
-  }
 
-  void ensure_has_pointee(const char* context) const {
-    if (!has_pointee()) {
-      throw std::runtime_error(std::string("Disowned holder (") + context +
-                               ").");
+    void ensure_use_count_1(const char *context) const {
+        if (vptr.get() == nullptr) {
+            throw std::runtime_error(std::string("Cannot disown nullptr (") + context + ").");
+        }
+        if (vptr.use_count() != 1) {
+            throw std::runtime_error(std::string("Cannot disown use_count != 1 (") + context
+                                     + ").");
+        }
     }
-  }
 
-  void ensure_vptr_is_using_builtin_delete(const char* context) const {
-    if (vptr_is_external_shared_ptr) {
-      throw std::runtime_error(
-          std::string("Cannot disown external shared_ptr (") + context + ").");
+    template <typename T>
+    static smart_holder from_raw_ptr_unowned(T *raw_ptr) {
+        smart_holder hld;
+        hld.rtti_held                  = &typeid(T);
+        hld.vptr_is_using_noop_deleter = true;
+        hld.vptr.reset(raw_ptr, guarded_builtin_delete<T>(&hld.vptr_deleter_guard_flag));
+        return hld;
     }
-    if (vptr_is_using_noop_deleter) {
-      throw std::runtime_error(
-          std::string("Cannot disown non-owning holder (") + context + ").");
+
+    template <typename T>
+    T *as_raw_ptr_unowned() const {
+        static const char *context = "as_raw_ptr_unowned";
+        ensure_compatible_rtti_held<T>(context);
+        return static_cast<T *>(vptr.get());
     }
-    if (!vptr_is_using_builtin_delete) {
-      throw std::runtime_error(std::string("Cannot disown custom deleter (") +
-                               context + ").");
+
+    template <typename T>
+    T &lvalue_ref() const {
+        static const char *context = "lvalue_ref";
+        ensure_compatible_rtti_held<T>(context);
+        ensure_has_pointee(context);
+        return *static_cast<T *>(vptr.get());
     }
-  }
 
-  void ensure_use_count_1(const char* context) const {
-    if (vptr.get() == nullptr) {
-      throw std::runtime_error(std::string("Cannot disown nullptr (") +
-                               context + ").");
+    template <typename T>
+    T &&rvalue_ref() const {
+        static const char *context = "rvalue_ref";
+        ensure_compatible_rtti_held<T>(context);
+        ensure_has_pointee(context);
+        return std::move(*static_cast<T *>(vptr.get()));
     }
-    if (vptr.use_count() != 1) {
-      throw std::runtime_error(std::string("Cannot disown use_count != 1 (") +
-                               context + ").");
+
+    template <typename T>
+    static smart_holder from_raw_ptr_take_ownership(T *raw_ptr) {
+        smart_holder hld;
+        hld.rtti_held                    = &typeid(T);
+        hld.vptr_deleter_guard_flag      = true;
+        hld.vptr_is_using_builtin_delete = true;
+        hld.vptr.reset(raw_ptr, guarded_builtin_delete<T>(&hld.vptr_deleter_guard_flag));
+        return hld;
+    }
+
+    template <typename T>
+    T *as_raw_ptr_release_ownership(const char *context = "as_raw_ptr_release_ownership") {
+        ensure_compatible_rtti_held<T>(context);
+        ensure_vptr_is_using_builtin_delete(context);
+        ensure_use_count_1(context);
+        T *raw_ptr              = static_cast<T *>(vptr.get());
+        vptr_deleter_guard_flag = false;
+        vptr.reset();
+        return raw_ptr;
+    }
+
+    template <typename T>
+    static smart_holder from_unique_ptr(std::unique_ptr<T> &&unq_ptr) {
+        smart_holder hld;
+        hld.rtti_held                    = &typeid(T);
+        hld.vptr_deleter_guard_flag      = true;
+        hld.vptr_is_using_builtin_delete = true;
+        hld.vptr.reset(unq_ptr.get(), guarded_builtin_delete<T>(&hld.vptr_deleter_guard_flag));
+        unq_ptr.release();
+        return hld;
+    }
+
+    template <typename T>
+    std::unique_ptr<T> as_unique_ptr() {
+        return std::unique_ptr<T>(as_raw_ptr_release_ownership<T>("as_unique_ptr"));
+    }
+
+    template <typename T, typename D>
+    static smart_holder from_unique_ptr_with_deleter(std::unique_ptr<T, D> &&unq_ptr) {
+        smart_holder hld;
+        hld.rtti_held               = &typeid(T);
+        hld.rtti_uqp_del            = &typeid(D);
+        hld.vptr_deleter_guard_flag = true;
+        hld.vptr.reset(unq_ptr.get(), guarded_custom_deleter<T, D>(&hld.vptr_deleter_guard_flag));
+        unq_ptr.release();
+        return hld;
+    }
+
+    template <typename T, typename D>
+    std::unique_ptr<T, D> as_unique_ptr_with_deleter() {
+        static const char *context = "as_unique_ptr_with_deleter";
+        ensure_compatible_rtti_held<T>(context);
+        ensure_compatible_rtti_uqp_del<D>(context);
+        ensure_use_count_1(context);
+        T *raw_ptr              = static_cast<T *>(vptr.get());
+        vptr_deleter_guard_flag = false;
+        vptr.reset();
+        return std::unique_ptr<T, D>(raw_ptr);
+    }
+
+    template <typename T>
+    static smart_holder from_shared_ptr(std::shared_ptr<T> shd_ptr) {
+        smart_holder hld;
+        hld.rtti_held                   = &typeid(T);
+        hld.vptr_is_external_shared_ptr = true;
+        hld.vptr                        = std::static_pointer_cast<void>(shd_ptr);
+        return hld;
+    }
+
+    template <typename T>
+    std::shared_ptr<T> as_shared_ptr() const {
+        static const char *context = "as_shared_ptr";
+        ensure_compatible_rtti_held<T>(context);
+        return std::static_pointer_cast<T>(vptr);
     }
-  }
-
-  template <typename T>
-  static smart_holder from_raw_ptr_unowned(T* raw_ptr) {
-    smart_holder hld;
-    hld.rtti_held = &typeid(T);
-    hld.vptr_is_using_noop_deleter = true;
-    hld.vptr.reset(raw_ptr,
-                   guarded_builtin_delete<T>(&hld.vptr_deleter_guard_flag));
-    return hld;
-  }
-
-  template <typename T>
-  T* as_raw_ptr_unowned() const {
-    static const char* context = "as_raw_ptr_unowned";
-    ensure_compatible_rtti_held<T>(context);
-    return static_cast<T*>(vptr.get());
-  }
-
-  template <typename T>
-  T& lvalue_ref() const {
-    static const char* context = "lvalue_ref";
-    ensure_compatible_rtti_held<T>(context);
-    ensure_has_pointee(context);
-    return *static_cast<T*>(vptr.get());
-  }
-
-  template <typename T>
-  T&& rvalue_ref() const {
-    static const char* context = "rvalue_ref";
-    ensure_compatible_rtti_held<T>(context);
-    ensure_has_pointee(context);
-    return std::move(*static_cast<T*>(vptr.get()));
-  }
-
-  template <typename T>
-  static smart_holder from_raw_ptr_take_ownership(T* raw_ptr) {
-    smart_holder hld;
-    hld.rtti_held = &typeid(T);
-    hld.vptr_deleter_guard_flag = true;
-    hld.vptr_is_using_builtin_delete = true;
-    hld.vptr.reset(raw_ptr,
-                   guarded_builtin_delete<T>(&hld.vptr_deleter_guard_flag));
-    return hld;
-  }
-
-  template <typename T>
-  T* as_raw_ptr_release_ownership(
-      const char* context = "as_raw_ptr_release_ownership") {
-    ensure_compatible_rtti_held<T>(context);
-    ensure_vptr_is_using_builtin_delete(context);
-    ensure_use_count_1(context);
-    T* raw_ptr = static_cast<T*>(vptr.get());
-    vptr_deleter_guard_flag = false;
-    vptr.reset();
-    return raw_ptr;
-  }
-
-  template <typename T>
-  static smart_holder from_unique_ptr(std::unique_ptr<T>&& unq_ptr) {
-    smart_holder hld;
-    hld.rtti_held = &typeid(T);
-    hld.vptr_deleter_guard_flag = true;
-    hld.vptr_is_using_builtin_delete = true;
-    hld.vptr.reset(unq_ptr.get(),
-                   guarded_builtin_delete<T>(&hld.vptr_deleter_guard_flag));
-    unq_ptr.release();
-    return hld;
-  }
-
-  template <typename T>
-  std::unique_ptr<T> as_unique_ptr() {
-    return std::unique_ptr<T>(as_raw_ptr_release_ownership<T>("as_unique_ptr"));
-  }
-
-  template <typename T, typename D>
-  static smart_holder from_unique_ptr_with_deleter(
-      std::unique_ptr<T, D>&& unq_ptr) {
-    smart_holder hld;
-    hld.rtti_held = &typeid(T);
-    hld.rtti_uqp_del = &typeid(D);
-    hld.vptr_deleter_guard_flag = true;
-    hld.vptr.reset(unq_ptr.get(),
-                   guarded_custom_deleter<T, D>(&hld.vptr_deleter_guard_flag));
-    unq_ptr.release();
-    return hld;
-  }
-
-  template <typename T, typename D>
-  std::unique_ptr<T, D> as_unique_ptr_with_deleter() {
-    static const char* context = "as_unique_ptr_with_deleter";
-    ensure_compatible_rtti_held<T>(context);
-    ensure_compatible_rtti_uqp_del<D>(context);
-    ensure_use_count_1(context);
-    T* raw_ptr = static_cast<T*>(vptr.get());
-    vptr_deleter_guard_flag = false;
-    vptr.reset();
-    return std::unique_ptr<T, D>(raw_ptr);
-  }
-
-  template <typename T>
-  static smart_holder from_shared_ptr(std::shared_ptr<T> shd_ptr) {
-    smart_holder hld;
-    hld.rtti_held = &typeid(T);
-    hld.vptr_is_external_shared_ptr = true;
-    hld.vptr = std::static_pointer_cast<void>(shd_ptr);
-    return hld;
-  }
-
-  template <typename T>
-  std::shared_ptr<T> as_shared_ptr() const {
-    static const char* context = "as_shared_ptr";
-    ensure_compatible_rtti_held<T>(context);
-    return std::static_pointer_cast<T>(vptr);
-  }
 };
 
-}  // namespace memory
-}  // namespace pybindit
+} // namespace memory
+} // namespace pybindit
diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/core/smart_holder_poc_test.cpp
index dbd836b6f1..e97cadbc9d 100644
--- a/tests/core/smart_holder_poc_test.cpp
+++ b/tests/core/smart_holder_poc_test.cpp
@@ -8,319 +8,294 @@ using pybindit::memory::smart_holder;
 namespace helpers {
 
 struct movable_int {
-  int valu;
-  movable_int(int v) : valu{v} {}
-  movable_int(movable_int&& other) {
-    valu = other.valu;
-    other.valu = 91;
-  }
+    int valu;
+    movable_int(int v) : valu{v} {}
+    movable_int(movable_int &&other) {
+        valu       = other.valu;
+        other.valu = 91;
+    }
 };
 
 template <typename T>
 struct functor_builtin_delete {
-  void operator()(T* ptr) { delete ptr; }
+    void operator()(T *ptr) { delete ptr; }
 };
 
 template <typename T>
 struct functor_other_delete : functor_builtin_delete<T> {};
 
-}  // namespace helpers
+} // namespace helpers
 
 TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_unowned", "[S]") {
-  static int value = 19;
-  auto hld = smart_holder::from_raw_ptr_unowned(&value);
-  REQUIRE(*hld.as_raw_ptr_unowned<int>() == 19);
+    static int value = 19;
+    auto hld         = smart_holder::from_raw_ptr_unowned(&value);
+    REQUIRE(*hld.as_raw_ptr_unowned<int>() == 19);
 }
 
 TEST_CASE("from_raw_ptr_unowned+lvalue_ref", "[S]") {
-  static int value = 19;
-  auto hld = smart_holder::from_raw_ptr_unowned(&value);
-  REQUIRE(hld.lvalue_ref<int>() == 19);
+    static int value = 19;
+    auto hld         = smart_holder::from_raw_ptr_unowned(&value);
+    REQUIRE(hld.lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_raw_ptr_unowned+rvalue_ref", "[S]") {
-  helpers::movable_int orig(19);
-  {
-    auto hld = smart_holder::from_raw_ptr_unowned(&orig);
-    helpers::movable_int othr(hld.rvalue_ref<helpers::movable_int>());
-    REQUIRE(othr.valu == 19);
-    REQUIRE(orig.valu == 91);
-  }
+    helpers::movable_int orig(19);
+    {
+        auto hld = smart_holder::from_raw_ptr_unowned(&orig);
+        helpers::movable_int othr(hld.rvalue_ref<helpers::movable_int>());
+        REQUIRE(othr.valu == 19);
+        REQUIRE(orig.valu == 91);
+    }
 }
 
 TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_release_ownership", "[E]") {
-  static int value = 19;
-  auto hld = smart_holder::from_raw_ptr_unowned(&value);
-  REQUIRE_THROWS_WITH(
-      hld.as_raw_ptr_release_ownership<int>(),
-      "Cannot disown non-owning holder (as_raw_ptr_release_ownership).");
+    static int value = 19;
+    auto hld         = smart_holder::from_raw_ptr_unowned(&value);
+    REQUIRE_THROWS_WITH(hld.as_raw_ptr_release_ownership<int>(),
+                        "Cannot disown non-owning holder (as_raw_ptr_release_ownership).");
 }
 
 TEST_CASE("from_raw_ptr_unowned+as_unique_ptr", "[E]") {
-  static int value = 19;
-  auto hld = smart_holder::from_raw_ptr_unowned(&value);
-  REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
-                      "Cannot disown non-owning holder (as_unique_ptr).");
+    static int value = 19;
+    auto hld         = smart_holder::from_raw_ptr_unowned(&value);
+    REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
+                        "Cannot disown non-owning holder (as_unique_ptr).");
 }
 
 TEST_CASE("from_raw_ptr_unowned+as_unique_ptr_with_deleter", "[E]") {
-  static int value = 19;
-  auto hld = smart_holder::from_raw_ptr_unowned(&value);
-  auto condense_for_macro = [](smart_holder& hld) {
-    hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
-  };
-  REQUIRE_THROWS_WITH(
-      condense_for_macro(hld),
-      "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
+    static int value        = 19;
+    auto hld                = smart_holder::from_raw_ptr_unowned(&value);
+    auto condense_for_macro = [](smart_holder &hld) {
+        hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+    };
+    REQUIRE_THROWS_WITH(condense_for_macro(hld),
+                        "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
 }
 
 TEST_CASE("from_raw_ptr_unowned+as_shared_ptr", "[S]") {
-  static int value = 19;
-  auto hld = smart_holder::from_raw_ptr_unowned(&value);
-  REQUIRE(*hld.as_shared_ptr<int>() == 19);
+    static int value = 19;
+    auto hld         = smart_holder::from_raw_ptr_unowned(&value);
+    REQUIRE(*hld.as_shared_ptr<int>() == 19);
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+lvalue_ref", "[S]") {
-  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
-  REQUIRE(hld.has_pointee());
-  REQUIRE(hld.lvalue_ref<int>() == 19);
+    auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
+    REQUIRE(hld.has_pointee());
+    REQUIRE(hld.lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership1", "[S]") {
-  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
-  auto new_owner =
-      std::unique_ptr<int>(hld.as_raw_ptr_release_ownership<int>());
-  REQUIRE(!hld.has_pointee());
-  REQUIRE(*new_owner == 19);
+    auto hld       = smart_holder::from_raw_ptr_take_ownership(new int(19));
+    auto new_owner = std::unique_ptr<int>(hld.as_raw_ptr_release_ownership<int>());
+    REQUIRE(!hld.has_pointee());
+    REQUIRE(*new_owner == 19);
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership2", "[E]") {
-  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
-  auto shd_ptr = hld.as_shared_ptr<int>();
-  REQUIRE_THROWS_WITH(
-      hld.as_raw_ptr_release_ownership<int>(),
-      "Cannot disown use_count != 1 (as_raw_ptr_release_ownership).");
+    auto hld     = smart_holder::from_raw_ptr_take_ownership(new int(19));
+    auto shd_ptr = hld.as_shared_ptr<int>();
+    REQUIRE_THROWS_WITH(hld.as_raw_ptr_release_ownership<int>(),
+                        "Cannot disown use_count != 1 (as_raw_ptr_release_ownership).");
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr1", "[S]") {
-  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
-  std::unique_ptr<int> new_owner = hld.as_unique_ptr<int>();
-  REQUIRE(!hld.has_pointee());
-  REQUIRE(*new_owner == 19);
+    auto hld                       = smart_holder::from_raw_ptr_take_ownership(new int(19));
+    std::unique_ptr<int> new_owner = hld.as_unique_ptr<int>();
+    REQUIRE(!hld.has_pointee());
+    REQUIRE(*new_owner == 19);
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr2", "[E]") {
-  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
-  auto shd_ptr = hld.as_shared_ptr<int>();
-  REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
-                      "Cannot disown use_count != 1 (as_unique_ptr).");
+    auto hld     = smart_holder::from_raw_ptr_take_ownership(new int(19));
+    auto shd_ptr = hld.as_shared_ptr<int>();
+    REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(), "Cannot disown use_count != 1 (as_unique_ptr).");
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr_with_deleter", "[E]") {
-  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
-  auto condense_for_macro = [](smart_holder& hld) {
-    hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
-  };
-  REQUIRE_THROWS_WITH(
-      condense_for_macro(hld),
-      "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
+    auto hld                = smart_holder::from_raw_ptr_take_ownership(new int(19));
+    auto condense_for_macro = [](smart_holder &hld) {
+        hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+    };
+    REQUIRE_THROWS_WITH(condense_for_macro(hld),
+                        "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_shared_ptr", "[S]") {
-  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
-  std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
-  REQUIRE(hld.has_pointee());
-  REQUIRE(*new_owner == 19);
+    auto hld                       = smart_holder::from_raw_ptr_take_ownership(new int(19));
+    std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
+    REQUIRE(hld.has_pointee());
+    REQUIRE(*new_owner == 19);
 }
 
 TEST_CASE("from_unique_ptr+lvalue_ref", "[S]") {
-  std::unique_ptr<int> orig_owner(new int(19));
-  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  REQUIRE(hld.lvalue_ref<int>() == 19);
+    std::unique_ptr<int> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    REQUIRE(hld.lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership1", "[S]") {
-  std::unique_ptr<int> orig_owner(new int(19));
-  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  auto new_owner =
-      std::unique_ptr<int>(hld.as_raw_ptr_release_ownership<int>());
-  REQUIRE(!hld.has_pointee());
-  REQUIRE(*new_owner == 19);
+    std::unique_ptr<int> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    auto new_owner = std::unique_ptr<int>(hld.as_raw_ptr_release_ownership<int>());
+    REQUIRE(!hld.has_pointee());
+    REQUIRE(*new_owner == 19);
 }
 
 TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership2", "[E]") {
-  std::unique_ptr<int> orig_owner(new int(19));
-  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  auto shd_ptr = hld.as_shared_ptr<int>();
-  REQUIRE_THROWS_WITH(
-      hld.as_raw_ptr_release_ownership<int>(),
-      "Cannot disown use_count != 1 (as_raw_ptr_release_ownership).");
+    std::unique_ptr<int> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    auto shd_ptr = hld.as_shared_ptr<int>();
+    REQUIRE_THROWS_WITH(hld.as_raw_ptr_release_ownership<int>(),
+                        "Cannot disown use_count != 1 (as_raw_ptr_release_ownership).");
 }
 
 TEST_CASE("from_unique_ptr+as_unique_ptr1", "[S]") {
-  std::unique_ptr<int> orig_owner(new int(19));
-  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  std::unique_ptr<int> new_owner = hld.as_unique_ptr<int>();
-  REQUIRE(!hld.has_pointee());
-  REQUIRE(*new_owner == 19);
+    std::unique_ptr<int> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    std::unique_ptr<int> new_owner = hld.as_unique_ptr<int>();
+    REQUIRE(!hld.has_pointee());
+    REQUIRE(*new_owner == 19);
 }
 
 TEST_CASE("from_unique_ptr+as_unique_ptr2", "[E]") {
-  std::unique_ptr<int> orig_owner(new int(19));
-  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  auto shd_ptr = hld.as_shared_ptr<int>();
-  REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
-                      "Cannot disown use_count != 1 (as_unique_ptr).");
+    std::unique_ptr<int> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    auto shd_ptr = hld.as_shared_ptr<int>();
+    REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(), "Cannot disown use_count != 1 (as_unique_ptr).");
 }
 
 TEST_CASE("from_unique_ptr+as_unique_ptr_with_deleter", "[E]") {
-  std::unique_ptr<int> orig_owner(new int(19));
-  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  auto condense_for_macro = [](smart_holder& hld) {
-    hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
-  };
-  REQUIRE_THROWS_WITH(
-      condense_for_macro(hld),
-      "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
+    std::unique_ptr<int> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    auto condense_for_macro = [](smart_holder &hld) {
+        hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+    };
+    REQUIRE_THROWS_WITH(condense_for_macro(hld),
+                        "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
 }
 
 TEST_CASE("from_unique_ptr+as_shared_ptr", "[S]") {
-  std::unique_ptr<int> orig_owner(new int(19));
-  auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
-  REQUIRE(hld.has_pointee());
-  REQUIRE(*new_owner == 19);
+    std::unique_ptr<int> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
+    REQUIRE(hld.has_pointee());
+    REQUIRE(*new_owner == 19);
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+lvalue_ref", "[S]") {
-  std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
-      new int(19));
-  auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  REQUIRE(hld.lvalue_ref<int>() == 19);
+    std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    REQUIRE(hld.lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+as_raw_ptr_release_ownership", "[E]") {
-  std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
-      new int(19));
-  auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  REQUIRE_THROWS_WITH(
-      hld.as_raw_ptr_release_ownership<int>(),
-      "Cannot disown custom deleter (as_raw_ptr_release_ownership).");
+    std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    REQUIRE_THROWS_WITH(hld.as_raw_ptr_release_ownership<int>(),
+                        "Cannot disown custom deleter (as_raw_ptr_release_ownership).");
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr", "[E]") {
-  std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
-      new int(19));
-  auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
-                      "Cannot disown custom deleter (as_unique_ptr).");
+    std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(), "Cannot disown custom deleter (as_unique_ptr).");
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter1", "[S]") {
-  std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
-      new int(19));
-  auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  std::unique_ptr<int, helpers::functor_builtin_delete<int>> new_owner =
-      hld.as_unique_ptr_with_deleter<int,
-                                     helpers::functor_builtin_delete<int>>();
-  REQUIRE(!hld.has_pointee());
-  REQUIRE(*new_owner == 19);
+    std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    std::unique_ptr<int, helpers::functor_builtin_delete<int>> new_owner
+        = hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+    REQUIRE(!hld.has_pointee());
+    REQUIRE(*new_owner == 19);
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter2", "[E]") {
-  std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
-      new int(19));
-  auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  auto condense_for_macro = [](smart_holder& hld) {
-    hld.as_unique_ptr_with_deleter<int, helpers::functor_other_delete<int>>();
-  };
-  REQUIRE_THROWS_WITH(
-      condense_for_macro(hld),
-      "Incompatible unique_ptr deleter (as_unique_ptr_with_deleter).");
+    std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    auto condense_for_macro = [](smart_holder &hld) {
+        hld.as_unique_ptr_with_deleter<int, helpers::functor_other_delete<int>>();
+    };
+    REQUIRE_THROWS_WITH(condense_for_macro(hld),
+                        "Incompatible unique_ptr deleter (as_unique_ptr_with_deleter).");
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+as_shared_ptr", "[S]") {
-  std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(
-      new int(19));
-  auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
-  REQUIRE(orig_owner.get() == nullptr);
-  std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
-  REQUIRE(hld.has_pointee());
-  REQUIRE(*new_owner == 19);
+    std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
+    auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
+    REQUIRE(orig_owner.get() == nullptr);
+    std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
+    REQUIRE(hld.has_pointee());
+    REQUIRE(*new_owner == 19);
 }
 
 TEST_CASE("from_shared_ptr+lvalue_ref", "[S]") {
-  std::shared_ptr<int> orig_owner(new int(19));
-  auto hld = smart_holder::from_shared_ptr(orig_owner);
-  REQUIRE(hld.lvalue_ref<int>() == 19);
+    std::shared_ptr<int> orig_owner(new int(19));
+    auto hld = smart_holder::from_shared_ptr(orig_owner);
+    REQUIRE(hld.lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_shared_ptr+as_raw_ptr_release_ownership", "[E]") {
-  std::shared_ptr<int> orig_owner(new int(19));
-  auto hld = smart_holder::from_shared_ptr(orig_owner);
-  REQUIRE_THROWS_WITH(
-      hld.as_raw_ptr_release_ownership<int>(),
-      "Cannot disown external shared_ptr (as_raw_ptr_release_ownership).");
+    std::shared_ptr<int> orig_owner(new int(19));
+    auto hld = smart_holder::from_shared_ptr(orig_owner);
+    REQUIRE_THROWS_WITH(hld.as_raw_ptr_release_ownership<int>(),
+                        "Cannot disown external shared_ptr (as_raw_ptr_release_ownership).");
 }
 
 TEST_CASE("from_shared_ptr+as_unique_ptr", "[E]") {
-  std::shared_ptr<int> orig_owner(new int(19));
-  auto hld = smart_holder::from_shared_ptr(orig_owner);
-  REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
-                      "Cannot disown external shared_ptr (as_unique_ptr).");
+    std::shared_ptr<int> orig_owner(new int(19));
+    auto hld = smart_holder::from_shared_ptr(orig_owner);
+    REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
+                        "Cannot disown external shared_ptr (as_unique_ptr).");
 }
 
 TEST_CASE("from_shared_ptr+as_unique_ptr_with_deleter", "[E]") {
-  std::shared_ptr<int> orig_owner(new int(19));
-  auto hld = smart_holder::from_shared_ptr(orig_owner);
-  auto condense_for_macro = [](smart_holder& hld) {
-    hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
-  };
-  REQUIRE_THROWS_WITH(
-      condense_for_macro(hld),
-      "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
+    std::shared_ptr<int> orig_owner(new int(19));
+    auto hld                = smart_holder::from_shared_ptr(orig_owner);
+    auto condense_for_macro = [](smart_holder &hld) {
+        hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+    };
+    REQUIRE_THROWS_WITH(condense_for_macro(hld),
+                        "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
 }
 
 TEST_CASE("from_shared_ptr+as_shared_ptr", "[S]") {
-  std::shared_ptr<int> orig_owner(new int(19));
-  auto hld = smart_holder::from_shared_ptr(orig_owner);
-  REQUIRE(*hld.as_shared_ptr<int>() == 19);
+    std::shared_ptr<int> orig_owner(new int(19));
+    auto hld = smart_holder::from_shared_ptr(orig_owner);
+    REQUIRE(*hld.as_shared_ptr<int>() == 19);
 }
 
 TEST_CASE("error_unpopulated_holder", "[E]") {
-  smart_holder hld;
-  REQUIRE_THROWS_WITH(hld.as_raw_ptr_unowned<int>(),
-                      "Unpopulated holder (as_raw_ptr_unowned).");
+    smart_holder hld;
+    REQUIRE_THROWS_WITH(hld.as_raw_ptr_unowned<int>(), "Unpopulated holder (as_raw_ptr_unowned).");
 }
 
 TEST_CASE("error_incompatible_type", "[E]") {
-  static int value = 19;
-  auto hld = smart_holder::from_raw_ptr_unowned(&value);
-  REQUIRE_THROWS_WITH(hld.as_unique_ptr<std::string>(),
-                      "Incompatible type (as_unique_ptr).");
+    static int value = 19;
+    auto hld         = smart_holder::from_raw_ptr_unowned(&value);
+    REQUIRE_THROWS_WITH(hld.as_unique_ptr<std::string>(), "Incompatible type (as_unique_ptr).");
 }
 
 TEST_CASE("error_disowned_holder", "[E]") {
-  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
-  hld.as_unique_ptr<int>();
-  REQUIRE_THROWS_WITH(hld.lvalue_ref<int>(), "Disowned holder (lvalue_ref).");
+    auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
+    hld.as_unique_ptr<int>();
+    REQUIRE_THROWS_WITH(hld.lvalue_ref<int>(), "Disowned holder (lvalue_ref).");
 }
 
 TEST_CASE("error_cannot_disown_nullptr", "[E]") {
-  auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
-  hld.as_unique_ptr<int>();
-  REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
-                      "Cannot disown nullptr (as_unique_ptr).");
+    auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
+    hld.as_unique_ptr<int>();
+    REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(), "Cannot disown nullptr (as_unique_ptr).");
 }

From b64294f0e81c76b50c8b8a55ba8a1a89a0773a88 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 12 Jan 2021 10:53:42 -0800
Subject: [PATCH 047/206] Pure `clang-format --style=file -i` change, with two
 `clang-format off` directives.

---
 tests/test_classh_wip.cpp | 105 ++++++++++++++++++++------------------
 1 file changed, 55 insertions(+), 50 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 1767af9d31..d7e99ceea4 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -8,7 +8,11 @@
 namespace pybind11_tests {
 namespace classh_wip {
 
-struct mpty { std::string mtxt; };
+struct mpty {
+    std::string mtxt;
+};
+
+// clang-format off
 
 mpty        rtrn_mpty_valu() { mpty obj; return obj; }
 mpty&&      rtrn_mpty_rref() { mpty obj; return std::move(obj); }
@@ -36,8 +40,10 @@ std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const
 std::string pass_mpty_uqmp(std::unique_ptr<mpty> obj)       { return "pass_uqmp:" + obj->mtxt; }
 std::string pass_mpty_uqcp(std::unique_ptr<mpty const> obj) { return "pass_uqcp:" + obj->mtxt; }
 
-}  // namespace classh_wip
-}  // namespace pybind11_tests
+// clang-format on
+
+} // namespace classh_wip
+} // namespace pybind11_tests
 
 namespace pybind11 {
 namespace detail {
@@ -47,15 +53,16 @@ using namespace pybind11_tests::classh_wip;
 template <typename T>
 struct smart_holder_type_caster_load {
     bool load(handle src, bool /*convert*/) {
-        if (!isinstance<T>(src)) return false;
-        auto inst = reinterpret_cast<instance *>(src.ptr());
-        auto v_h = inst->get_value_and_holder(get_type_info(typeid(T)));
+        if (!isinstance<T>(src))
+            return false;
+        auto inst  = reinterpret_cast<instance *>(src.ptr());
+        auto v_h   = inst->get_value_and_holder(get_type_info(typeid(T)));
         smhldr_ptr = &v_h.holder<pybindit::memory::smart_holder>();
         return true;
     }
 
-  protected:
-    pybindit::memory::smart_holder* smhldr_ptr = nullptr;
+protected:
+    pybindit::memory::smart_holder *smhldr_ptr = nullptr;
 };
 
 template <>
@@ -65,48 +72,41 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     // static handle cast(mpty, ...)
     // is redundant (leads to ambiguous overloads).
 
-    static handle cast(mpty&& /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
+    static handle cast(mpty && /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
         return str("cast_rref").release();
     }
 
-    static handle cast(mpty const& /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
+    static handle cast(mpty const & /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
         return str("cast_cref").release();
     }
 
-    static handle cast(mpty& /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
+    static handle cast(mpty & /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
         return str("cast_mref").release();
     }
 
-    static handle cast(mpty const* /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
+    static handle cast(mpty const * /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
         return str("cast_cptr").release();
     }
 
-    static handle cast(mpty* /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
+    static handle cast(mpty * /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
         return str("cast_mptr").release();
     }
 
     template <typename T_>
     using cast_op_type = conditional_t<
-        std::is_same<remove_reference_t<T_>, mpty const*>::value, mpty const*,
+        std::is_same<remove_reference_t<T_>, mpty const *>::value,
+        mpty const *,
         conditional_t<
-            std::is_same<remove_reference_t<T_>, mpty*>::value, mpty*,
+            std::is_same<remove_reference_t<T_>, mpty *>::value,
+            mpty *,
             conditional_t<
-                std::is_same<T_, mpty const&>::value, mpty const&,
-                conditional_t<
-                    std::is_same<T_, mpty&>::value, mpty&,
-                    conditional_t<
-                        std::is_same<T_, mpty&&>::value, mpty&&,
-                        mpty>>>>>;
+                std::is_same<T_, mpty const &>::value,
+                mpty const &,
+                conditional_t<std::is_same<T_, mpty &>::value,
+                              mpty &,
+                              conditional_t<std::is_same<T_, mpty &&>::value, mpty &&, mpty>>>>>;
+
+    // clang-format off
 
     operator mpty()        { return smhldr_ptr->lvalue_ref<mpty>(); }
     operator mpty&&() &&   { return smhldr_ptr->rvalue_ref<mpty>(); }
@@ -114,19 +114,22 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     operator mpty&()       { return smhldr_ptr->lvalue_ref<mpty>(); }
     operator mpty const*() { return smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
     operator mpty*()       { return smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
+
+    // clang-format on
 };
 
 template <>
 struct type_caster<std::shared_ptr<mpty>> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<std::shared_ptr<mpty>>();
 
-    static handle cast(const std::shared_ptr<mpty>& /*src*/,
+    static handle cast(const std::shared_ptr<mpty> & /*src*/,
                        return_value_policy /*policy*/,
                        handle /*parent*/) {
         return str("cast_shmp").release();
     }
 
-    template <typename> using cast_op_type = std::shared_ptr<mpty>;
+    template <typename>
+    using cast_op_type = std::shared_ptr<mpty>;
 
     operator std::shared_ptr<mpty>() { return smhldr_ptr->as_shared_ptr<mpty>(); }
 };
@@ -135,13 +138,14 @@ template <>
 struct type_caster<std::shared_ptr<mpty const>> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<std::shared_ptr<mpty const>>();
 
-    static handle cast(const std::shared_ptr<mpty const>& /*src*/,
+    static handle cast(const std::shared_ptr<mpty const> & /*src*/,
                        return_value_policy /*policy*/,
                        handle /*parent*/) {
         return str("cast_shcp").release();
     }
 
-    template <typename> using cast_op_type = std::shared_ptr<mpty const>;
+    template <typename>
+    using cast_op_type = std::shared_ptr<mpty const>;
 
     operator std::shared_ptr<mpty const>() { return smhldr_ptr->as_shared_ptr<mpty>(); }
 };
@@ -150,13 +154,13 @@ template <>
 struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<std::unique_ptr<mpty>>();
 
-    static handle cast(std::unique_ptr<mpty>&& /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
+    static handle
+    cast(std::unique_ptr<mpty> && /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
         return str("cast_uqmp").release();
     }
 
-    template <typename> using cast_op_type = std::unique_ptr<mpty>;
+    template <typename>
+    using cast_op_type = std::unique_ptr<mpty>;
 
     operator std::unique_ptr<mpty>() { return smhldr_ptr->as_unique_ptr<mpty>(); }
 };
@@ -165,19 +169,20 @@ template <>
 struct type_caster<std::unique_ptr<mpty const>> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<std::unique_ptr<mpty const>>();
 
-    static handle cast(std::unique_ptr<mpty const>&& /*src*/,
+    static handle cast(std::unique_ptr<mpty const> && /*src*/,
                        return_value_policy /*policy*/,
                        handle /*parent*/) {
         return str("cast_uqcp").release();
     }
 
-    template <typename> using cast_op_type = std::unique_ptr<mpty const>;
+    template <typename>
+    using cast_op_type = std::unique_ptr<mpty const>;
 
     operator std::unique_ptr<mpty const>() { return smhldr_ptr->as_unique_ptr<mpty>(); }
 };
 
-}  // namespace detail
-}  // namespace pybind11
+} // namespace detail
+} // namespace pybind11
 
 namespace pybind11_tests {
 namespace classh_wip {
@@ -185,11 +190,11 @@ namespace classh_wip {
 TEST_SUBMODULE(classh_wip, m) {
     namespace py = pybind11;
 
-    py::classh<mpty>(m, "mpty")
-        .def(py::init<>())
-        .def(py::init([](const std::string& mtxt) {
-            mpty obj; obj.mtxt = mtxt; return obj; }))
-    ;
+    py::classh<mpty>(m, "mpty").def(py::init<>()).def(py::init([](const std::string &mtxt) {
+        mpty obj;
+        obj.mtxt = mtxt;
+        return obj;
+    }));
 
     m.def("rtrn_mpty_valu", rtrn_mpty_valu);
     m.def("rtrn_mpty_rref", rtrn_mpty_rref);
@@ -218,5 +223,5 @@ TEST_SUBMODULE(classh_wip, m) {
     m.def("pass_mpty_uqcp", pass_mpty_uqcp);
 }
 
-}  // namespace classh_wip
-}  // namespace pybind11_tests
+} // namespace classh_wip
+} // namespace pybind11_tests

From f04515b45229bb485069b6b5e07ef838eb50eb90 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 12 Jan 2021 11:42:24 -0800
Subject: [PATCH 048/206] Fixing oversight (discovered by flake8).

---
 tests/test_cpp_base_py_derived.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_cpp_base_py_derived.py b/tests/test_cpp_base_py_derived.py
index 3a36c81fe9..ca30f0f981 100644
--- a/tests/test_cpp_base_py_derived.py
+++ b/tests/test_cpp_base_py_derived.py
@@ -23,7 +23,7 @@ def clone(self):
 def test_base():
   b = m.base()
   assert b.get_num() == 100
-  m.get_num(b) == 100
+  assert m.get_num(b) == 100
   bc = b.clone()
   assert bc.get_num() == 150
   assert m.clone_get_num(b) == 103157

From e24cf097e3380b96618fd2f8159a5d0e7b7815b9 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 12 Jan 2021 11:46:23 -0800
Subject: [PATCH 049/206] flake8 cleanup

---
 tests/test_cpp_base_py_derived.py             | 42 +++++++++----------
 tests/test_private_first_base.py              |  1 -
 tests/test_smart_ptr_base_derived.py          |  2 +
 tests/test_smart_ptr_private_first_base.py    |  1 -
 tests/test_type_caster_bare_interface_demo.py |  1 -
 5 files changed, 22 insertions(+), 25 deletions(-)

diff --git a/tests/test_cpp_base_py_derived.py b/tests/test_cpp_base_py_derived.py
index ca30f0f981..3d601d3729 100644
--- a/tests/test_cpp_base_py_derived.py
+++ b/tests/test_cpp_base_py_derived.py
@@ -2,37 +2,35 @@
 # pybind11 equivalent of Boost.Python test:
 # https://github.com/rwgk/rwgk_tbx/blob/6c9a6d6bc72d5c1b8609724433259c5b47178680/tst_cpp_base_py_derived.py
 # See also: https://github.com/pybind/pybind11/issues/1333 (this was the starting point)
-import pytest
 
 from pybind11_tests import cpp_base_py_derived as m
 
 
-class drvd(m.base):
+class drvd(m.base):  # noqa: N801
+    def __init__(self, _num=200):
+        super().__init__()
+        self._drvd_num = _num
 
-  def __init__(self, _num = 200):
-    super().__init__()
-    self._drvd_num = _num
+    def get_num(self):
+        return self._drvd_num
 
-  def get_num(self):
-    return self._drvd_num
-
-  def clone(self):
-    return drvd(250)
+    def clone(self):
+        return drvd(250)
 
 
 def test_base():
-  b = m.base()
-  assert b.get_num() == 100
-  assert m.get_num(b) == 100
-  bc = b.clone()
-  assert bc.get_num() == 150
-  assert m.clone_get_num(b) == 103157
+    b = m.base()
+    assert b.get_num() == 100
+    assert m.get_num(b) == 100
+    bc = b.clone()
+    assert bc.get_num() == 150
+    assert m.clone_get_num(b) == 103157
 
 
 def test_drvd():
-  d = drvd()
-  assert d.get_num() == 200
-  assert m.get_num(d) == 200
-  dc = d.clone()
-  assert dc.get_num() == 250
-  assert m.clone_get_num(d) == 203257
+    d = drvd()
+    assert d.get_num() == 200
+    assert m.get_num(d) == 200
+    dc = d.clone()
+    assert dc.get_num() == 250
+    assert m.clone_get_num(d) == 203257
diff --git a/tests/test_private_first_base.py b/tests/test_private_first_base.py
index 7004da50e4..36cc60e1e9 100644
--- a/tests/test_private_first_base.py
+++ b/tests/test_private_first_base.py
@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-import pytest
 
 from pybind11_tests import private_first_base as m
 
diff --git a/tests/test_smart_ptr_base_derived.py b/tests/test_smart_ptr_base_derived.py
index b57c364da8..534b5e5c34 100644
--- a/tests/test_smart_ptr_base_derived.py
+++ b/tests/test_smart_ptr_base_derived.py
@@ -7,6 +7,7 @@
 CDERIVED_GET_INT_RESULT = 31607978
 VDERIVED_GET_INT_RESULT = 29852452
 
+
 def test_concrete():
     m.to_cout("")
     m.to_cout("")
@@ -22,6 +23,7 @@ def test_concrete():
         m.pass_shared_cderived(cb)
     m.to_cout("")
 
+
 def test_virtual():
     m.to_cout("")
     m.to_cout("")
diff --git a/tests/test_smart_ptr_private_first_base.py b/tests/test_smart_ptr_private_first_base.py
index e085646a95..db17e787ff 100644
--- a/tests/test_smart_ptr_private_first_base.py
+++ b/tests/test_smart_ptr_private_first_base.py
@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-import pytest
 
 from pybind11_tests import smart_ptr_private_first_base as m
 
diff --git a/tests/test_type_caster_bare_interface_demo.py b/tests/test_type_caster_bare_interface_demo.py
index 35ae0ee293..6152d88a6e 100644
--- a/tests/test_type_caster_bare_interface_demo.py
+++ b/tests/test_type_caster_bare_interface_demo.py
@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-import pytest
 
 from pybind11_tests import type_caster_bare_interface_demo as m
 

From b8226c0b2239a9a184f87a22f64d4a6075d61071 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 12 Jan 2021 12:01:26 -0800
Subject: [PATCH 050/206] Systematically setting mtxt for all rtrn_mpty_*
 functions (preparation, the values are not actually used yet).

---
 tests/test_classh_wip.cpp | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index d7e99ceea4..f9dad5572b 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -14,12 +14,12 @@ struct mpty {
 
 // clang-format off
 
-mpty        rtrn_mpty_valu() { mpty obj; return obj; }
-mpty&&      rtrn_mpty_rref() { mpty obj; return std::move(obj); }
-mpty const& rtrn_mpty_cref() { static mpty obj; return obj; }
-mpty&       rtrn_mpty_mref() { static mpty obj; return obj; }
-mpty const* rtrn_mpty_cptr() { static mpty obj; return &obj; }
-mpty*       rtrn_mpty_mptr() { static mpty obj; return &obj; }
+mpty        rtrn_mpty_valu() { mpty obj{"rtrn_valu"}; return obj; }
+mpty&&      rtrn_mpty_rref() { mpty obj{"rtrn_rref"}; return std::move(obj); }
+mpty const& rtrn_mpty_cref() { static mpty obj; obj.mtxt = "rtrn_cref"; return obj; }
+mpty&       rtrn_mpty_mref() { static mpty obj; obj.mtxt = "rtrn_mref"; return obj; }
+mpty const* rtrn_mpty_cptr() { static mpty obj; obj.mtxt = "rtrn_cptr"; return &obj; }
+mpty*       rtrn_mpty_mptr() { static mpty obj; obj.mtxt = "rtrn_mptr"; return &obj; }
 
 std::string pass_mpty_valu(mpty obj)        { return "pass_valu:" + obj.mtxt; }
 std::string pass_mpty_rref(mpty&& obj)      { return "pass_rref:" + obj.mtxt; }
@@ -28,16 +28,16 @@ std::string pass_mpty_mref(mpty& obj)       { return "pass_mref:" + obj.mtxt; }
 std::string pass_mpty_cptr(mpty const* obj) { return "pass_cptr:" + obj->mtxt; }
 std::string pass_mpty_mptr(mpty* obj)       { return "pass_mptr:" + obj->mtxt; }
 
-std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty>(new mpty); }
-std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const>(new mpty); }
+std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty      >(new mpty{"rtrn_shmp"}); }
+std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const>(new mpty{"rtrn_shcp"}); }
 
-std::string pass_mpty_shmp(std::shared_ptr<mpty> obj)       { return "pass_shmp:" + obj->mtxt; }
+std::string pass_mpty_shmp(std::shared_ptr<mpty>       obj) { return "pass_shmp:" + obj->mtxt; }
 std::string pass_mpty_shcp(std::shared_ptr<mpty const> obj) { return "pass_shcp:" + obj->mtxt; }
 
-std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty>(new mpty); }
-std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty); }
+std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty      >(new mpty{"rtrn_uqmp"}); }
+std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty{"rtrn_uqmp"}); }
 
-std::string pass_mpty_uqmp(std::unique_ptr<mpty> obj)       { return "pass_uqmp:" + obj->mtxt; }
+std::string pass_mpty_uqmp(std::unique_ptr<mpty      > obj) { return "pass_uqmp:" + obj->mtxt; }
 std::string pass_mpty_uqcp(std::unique_ptr<mpty const> obj) { return "pass_uqcp:" + obj->mtxt; }
 
 // clang-format on

From 14b585ccf6ba58db2ae09ef13d89687fbfc965eb Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 12 Jan 2021 13:26:22 -0800
Subject: [PATCH 051/206] static cast handle for rtrn_cptr works by simply
 dropping in code from type_caster_base (marked with comments).

---
 tests/test_classh_wip.cpp | 68 +++++++++++++++++++++++++++++++++++++--
 tests/test_classh_wip.py  |  2 +-
 2 files changed, 67 insertions(+), 3 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index f9dad5572b..58d991bd89 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -42,6 +42,8 @@ std::string pass_mpty_uqcp(std::unique_ptr<mpty const> obj) { return "pass_uqcp:
 
 // clang-format on
 
+std::string get_mtxt(mpty const &obj) { return obj.mtxt; }
+
 } // namespace classh_wip
 } // namespace pybind11_tests
 
@@ -84,8 +86,15 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
         return str("cast_mref").release();
     }
 
-    static handle cast(mpty const * /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_cptr").release();
+    static handle cast(mpty const *src, return_value_policy policy, handle parent) {
+        // type_caster_base BEGIN
+        // clang-format off
+        auto st = src_and_type(src);
+        return type_caster_generic::cast(
+            st.first, policy, parent, st.second,
+            make_copy_constructor(src), make_move_constructor(src));
+        // clang-format on
+        // type_caster_base END
     }
 
     static handle cast(mpty * /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
@@ -116,6 +125,59 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     operator mpty*()       { return smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
 
     // clang-format on
+
+    using itype = mpty;
+
+    // type_caster_base BEGIN
+    // clang-format off
+
+    // Returns a (pointer, type_info) pair taking care of necessary type lookup for a
+    // polymorphic type (using RTTI by default, but can be overridden by specializing
+    // polymorphic_type_hook). If the instance isn't derived, returns the base version.
+    static std::pair<const void *, const type_info *> src_and_type(const itype *src) {
+        auto &cast_type = typeid(itype);
+        const std::type_info *instance_type = nullptr;
+        const void *vsrc = polymorphic_type_hook<itype>::get(src, instance_type);
+        if (instance_type && !same_type(cast_type, *instance_type)) {
+            // This is a base pointer to a derived type. If the derived type is registered
+            // with pybind11, we want to make the full derived object available.
+            // In the typical case where itype is polymorphic, we get the correct
+            // derived pointer (which may be != base pointer) by a dynamic_cast to
+            // most derived type. If itype is not polymorphic, we won't get here
+            // except via a user-provided specialization of polymorphic_type_hook,
+            // and the user has promised that no this-pointer adjustment is
+            // required in that case, so it's OK to use static_cast.
+            if (const auto *tpi = get_type_info(*instance_type))
+                return {vsrc, tpi};
+        }
+        // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer, so
+        // don't do a cast
+        return type_caster_generic::src_and_type(src, cast_type, instance_type);
+    }
+
+    using Constructor = void *(*)(const void *);
+
+    /* Only enabled when the types are {copy,move}-constructible *and* when the type
+       does not have a private operator new implementation. */
+    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
+    static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
+        return [](const void *arg) -> void * {
+            return new T(*reinterpret_cast<const T *>(arg));
+        };
+    }
+
+    template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
+    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
+        return [](const void *arg) -> void * {
+            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
+        };
+    }
+
+    static Constructor make_copy_constructor(...) { return nullptr; }
+    static Constructor make_move_constructor(...) { return nullptr; }
+
+    // clang-format on
+    // type_caster_base END
 };
 
 template <>
@@ -221,6 +283,8 @@ TEST_SUBMODULE(classh_wip, m) {
 
     m.def("pass_mpty_uqmp", pass_mpty_uqmp);
     m.def("pass_mpty_uqcp", pass_mpty_uqcp);
+
+    m.def("get_mtxt", get_mtxt); // Requires pass_mpty_cref to work properly.
 }
 
 } // namespace classh_wip
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index 4ecdee8b64..719b303a8d 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -18,7 +18,7 @@ def test_cast():
     assert m.rtrn_mpty_rref() == "cast_rref"
     assert m.rtrn_mpty_cref() == "cast_cref"
     assert m.rtrn_mpty_mref() == "cast_mref"
-    assert m.rtrn_mpty_cptr() == "cast_cptr"
+    assert m.get_mtxt(m.rtrn_mpty_cptr()) == "rtrn_cptr"
     assert m.rtrn_mpty_mptr() == "cast_mptr"
 
 

From c2137a9f440bcdd30609896d1b5b8266d41266f1 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 12 Jan 2021 13:45:48 -0800
Subject: [PATCH 052/206] static cast handle for rtrn_cref works by simply
 dropping in code from type_caster_base (marked with comments). rtrn_mref and
 rtrn_mptr work via const_cast (to add const).

---
 tests/test_classh_wip.cpp | 18 ++++++++++++------
 tests/test_classh_wip.py  |  6 +++---
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 58d991bd89..d974452da2 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -78,12 +78,18 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
         return str("cast_rref").release();
     }
 
-    static handle cast(mpty const & /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_cref").release();
+    static handle cast(mpty const &src, return_value_policy policy, handle parent) {
+        // type_caster_base BEGIN
+        // clang-format off
+        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
+            policy = return_value_policy::copy;
+        return cast(&src, policy, parent);
+        // clang-format on
+        // type_caster_base END
     }
 
-    static handle cast(mpty & /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_mref").release();
+    static handle cast(mpty &src, return_value_policy policy, handle parent) {
+        return cast(const_cast<mpty const &>(src), policy, parent); // Mtbl2Const
     }
 
     static handle cast(mpty const *src, return_value_policy policy, handle parent) {
@@ -97,8 +103,8 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
         // type_caster_base END
     }
 
-    static handle cast(mpty * /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_mptr").release();
+    static handle cast(mpty *src, return_value_policy policy, handle parent) {
+        return cast(const_cast<mpty const *>(src), policy, parent); // Mtbl2Const
     }
 
     template <typename T_>
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index 719b303a8d..10a42ae9df 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -16,10 +16,10 @@ def test_mpty_constructors():
 def test_cast():
     assert m.rtrn_mpty_valu() == "cast_rref"
     assert m.rtrn_mpty_rref() == "cast_rref"
-    assert m.rtrn_mpty_cref() == "cast_cref"
-    assert m.rtrn_mpty_mref() == "cast_mref"
+    assert m.get_mtxt(m.rtrn_mpty_cref()) == "rtrn_cref"
+    assert m.get_mtxt(m.rtrn_mpty_mref()) == "rtrn_mref"
     assert m.get_mtxt(m.rtrn_mpty_cptr()) == "rtrn_cptr"
-    assert m.rtrn_mpty_mptr() == "cast_mptr"
+    assert m.get_mtxt(m.rtrn_mpty_mptr()) == "rtrn_mptr"
 
 
 def test_load():

From 1a4b6c05cfc4fa6fa488c9ee30b3fcde624e6033 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 12 Jan 2021 14:24:31 -0800
Subject: [PATCH 053/206] static cast handle for rtrn_valu works by simply
 dropping in code from type_caster_base (marked with comments). rtrn_rref
 raises a RuntimeError, to be investigated.

---
 tests/test_classh_wip.cpp |  8 ++++++--
 tests/test_classh_wip.py  | 11 +++++++++--
 2 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index d974452da2..5fe14a6389 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -74,8 +74,12 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     // static handle cast(mpty, ...)
     // is redundant (leads to ambiguous overloads).
 
-    static handle cast(mpty && /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_rref").release();
+    static handle cast(mpty &&src, return_value_policy /*policy*/, handle parent) {
+        // type_caster_base BEGIN
+        // clang-format off
+        return cast(&src, return_value_policy::move, parent);
+        // clang-format on
+        // type_caster_base END
     }
 
     static handle cast(mpty const &src, return_value_policy policy, handle parent) {
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index 10a42ae9df..93aaae01da 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -14,14 +14,21 @@ def test_mpty_constructors():
 
 
 def test_cast():
-    assert m.rtrn_mpty_valu() == "cast_rref"
-    assert m.rtrn_mpty_rref() == "cast_rref"
+    assert m.get_mtxt(m.rtrn_mpty_valu()) == "rtrn_valu"
+    #                                         rtrn_rref exercised separately.
     assert m.get_mtxt(m.rtrn_mpty_cref()) == "rtrn_cref"
     assert m.get_mtxt(m.rtrn_mpty_mref()) == "rtrn_mref"
     assert m.get_mtxt(m.rtrn_mpty_cptr()) == "rtrn_cptr"
     assert m.get_mtxt(m.rtrn_mpty_mptr()) == "rtrn_mptr"
 
 
+def test_cast_rref():
+    e = m.rtrn_mpty_rref()
+    assert e.__class__.__name__ == "mpty"
+    with pytest.raises(RuntimeError):
+        m.get_mtxt(e)  # E.g. basic_string::_M_construct null not valid
+
+
 def test_load():
     assert m.pass_mpty_valu(m.mpty("Valu")) == "pass_valu:Valu"
     assert m.pass_mpty_rref(m.mpty("Rref")) == "pass_rref:Rref"

From 0f3a21f14b1e28b45926890b192ffdc9dc0e5d81 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 12 Jan 2021 20:01:12 -0800
Subject: [PATCH 054/206] Copying type_caster_generic::cast into
 type_caster<mpty> as-is (preparation for handling smart pointers).

---
 tests/test_classh_wip.cpp | 95 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 94 insertions(+), 1 deletion(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 5fe14a6389..e0652c0380 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -100,7 +100,7 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
         // type_caster_base BEGIN
         // clang-format off
         auto st = src_and_type(src);
-        return type_caster_generic::cast(
+        return cast( // Originally type_caster_generic::cast.
             st.first, policy, parent, st.second,
             make_copy_constructor(src), make_move_constructor(src));
         // clang-format on
@@ -188,6 +188,99 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
 
     // clang-format on
     // type_caster_base END
+
+    // Originally type_caster_generic::cast.
+    // clang-format off
+    PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
+                                         const detail::type_info *tinfo,
+                                         void *(*copy_constructor)(const void *),
+                                         void *(*move_constructor)(const void *),
+                                         const void *existing_holder = nullptr) {
+        if (!tinfo) // no type info: error will be set already
+            return handle();
+
+        void *src = const_cast<void *>(_src);
+        if (src == nullptr)
+            return none().release();
+
+        auto it_instances = get_internals().registered_instances.equal_range(src);
+        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
+            for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
+                if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
+                    return handle((PyObject *) it_i->second).inc_ref();
+            }
+        }
+
+        auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto wrapper = reinterpret_cast<instance *>(inst.ptr());
+        wrapper->owned = false;
+        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
+
+        switch (policy) {
+            case return_value_policy::automatic:
+            case return_value_policy::take_ownership:
+                valueptr = src;
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::automatic_reference:
+            case return_value_policy::reference:
+                valueptr = src;
+                wrapper->owned = false;
+                break;
+
+            case return_value_policy::copy:
+                if (copy_constructor)
+                    valueptr = copy_constructor(src);
+                else {
+#if defined(NDEBUG)
+                    throw cast_error("return_value_policy = copy, but type is "
+                                     "non-copyable! (compile in debug mode for details)");
+#else
+                    std::string type_name(tinfo->cpptype->name());
+                    detail::clean_type_id(type_name);
+                    throw cast_error("return_value_policy = copy, but type " +
+                                     type_name + " is non-copyable!");
+#endif
+                }
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::move:
+                if (move_constructor)
+                    valueptr = move_constructor(src);
+                else if (copy_constructor)
+                    valueptr = copy_constructor(src);
+                else {
+#if defined(NDEBUG)
+                    throw cast_error("return_value_policy = move, but type is neither "
+                                     "movable nor copyable! "
+                                     "(compile in debug mode for details)");
+#else
+                    std::string type_name(tinfo->cpptype->name());
+                    detail::clean_type_id(type_name);
+                    throw cast_error("return_value_policy = move, but type " +
+                                     type_name + " is neither movable nor copyable!");
+#endif
+                }
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::reference_internal:
+                valueptr = src;
+                wrapper->owned = false;
+                keep_alive_impl(inst, parent);
+                break;
+
+            default:
+                throw cast_error("unhandled return_value_policy: should not happen!");
+        }
+
+        tinfo->init_instance(wrapper, existing_holder);
+
+        return inst.release();
+    }
+    // clang-format on
 };
 
 template <>

From d4029ecde98a5868661db47ccc39b1d371f42736 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 12 Jan 2021 20:05:20 -0800
Subject: [PATCH 055/206] Pure clang-format change (applied to original
 type_caster_generic::cast).

---
 tests/test_classh_wip.cpp | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index e0652c0380..5c9fcdb9d4 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -190,8 +190,9 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     // type_caster_base END
 
     // Originally type_caster_generic::cast.
-    // clang-format off
-    PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
+    PYBIND11_NOINLINE static handle cast(const void *_src,
+                                         return_value_policy policy,
+                                         handle parent,
                                          const detail::type_info *tinfo,
                                          void *(*copy_constructor)(const void *),
                                          void *(*move_constructor)(const void *),
@@ -211,21 +212,21 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
             }
         }
 
-        auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        auto wrapper = reinterpret_cast<instance *>(inst.ptr());
-        wrapper->owned = false;
+        auto inst       = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto wrapper    = reinterpret_cast<instance *>(inst.ptr());
+        wrapper->owned  = false;
         void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
 
         switch (policy) {
             case return_value_policy::automatic:
             case return_value_policy::take_ownership:
-                valueptr = src;
+                valueptr       = src;
                 wrapper->owned = true;
                 break;
 
             case return_value_policy::automatic_reference:
             case return_value_policy::reference:
-                valueptr = src;
+                valueptr       = src;
                 wrapper->owned = false;
                 break;
 
@@ -239,8 +240,8 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
 #else
                     std::string type_name(tinfo->cpptype->name());
                     detail::clean_type_id(type_name);
-                    throw cast_error("return_value_policy = copy, but type " +
-                                     type_name + " is non-copyable!");
+                    throw cast_error("return_value_policy = copy, but type " + type_name
+                                     + " is non-copyable!");
 #endif
                 }
                 wrapper->owned = true;
@@ -259,15 +260,15 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
 #else
                     std::string type_name(tinfo->cpptype->name());
                     detail::clean_type_id(type_name);
-                    throw cast_error("return_value_policy = move, but type " +
-                                     type_name + " is neither movable nor copyable!");
+                    throw cast_error("return_value_policy = move, but type " + type_name
+                                     + " is neither movable nor copyable!");
 #endif
                 }
                 wrapper->owned = true;
                 break;
 
             case return_value_policy::reference_internal:
-                valueptr = src;
+                valueptr       = src;
                 wrapper->owned = false;
                 keep_alive_impl(inst, parent);
                 break;
@@ -280,7 +281,6 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
 
         return inst.release();
     }
-    // clang-format on
 };
 
 template <>

From 012c1604265cb28d1912d5440ecc47352ce3fbf0 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 13 Jan 2021 05:34:13 -0800
Subject: [PATCH 056/206] Adding comment re potential use_count data race.

---
 include/pybind11/smart_holder_poc.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index 0b70c719ce..3c882ee4ae 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -131,6 +131,10 @@ struct smart_holder {
             throw std::runtime_error(std::string("Cannot disown nullptr (") + context + ").");
         }
         if (vptr.use_count() != 1) {
+            // In multithreaded environments accessing use_count is racy,
+            // but in the context of Python it is a bug (elsewhere) if the
+            // Global Interpreter Lock (GIL) is not being held when this code
+            // is reached.
             throw std::runtime_error(std::string("Cannot disown use_count != 1 (") + context
                                      + ").");
         }

From 8bc154893b0db64a31b4f1d03b3662562083625f Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 13 Jan 2021 10:48:08 -0800
Subject: [PATCH 057/206] static handle cast implementations for rtrn_shmp,
 rtrn_shcp.

---
 include/pybind11/classh.h | 24 +++++------------
 tests/test_classh_wip.cpp | 55 ++++++++++++++++++++++++++++++++-------
 tests/test_classh_wip.py  |  4 +--
 3 files changed, 53 insertions(+), 30 deletions(-)

diff --git a/include/pybind11/classh.h b/include/pybind11/classh.h
index 61bc50d4b9..77a9a93281 100644
--- a/include/pybind11/classh.h
+++ b/include/pybind11/classh.h
@@ -268,30 +268,18 @@ class classh : public detail::generic_type {
 private:
     /// Initialize holder object, variant 1: object derives from enable_shared_from_this
     template <typename T>
-    static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
+    static void init_holder(detail::value_and_holder &/*v_h*/,
             const holder_type * /* unused */, const std::enable_shared_from_this<T> * /* dummy */) {
-        try {
-            auto sh = std::dynamic_pointer_cast<type>(  // Was: typename holder_type::element_type
-                    v_h.value_ptr<type>()->shared_from_this());
-            if (sh) {
-                new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(sh));
-                v_h.set_holder_constructed();
-            }
-        } catch (const std::bad_weak_ptr &) {}
-
-        if (!v_h.holder_constructed() && inst->owned) {
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
-            v_h.set_holder_constructed();
-        }
+        throw std::runtime_error("Not implemented: classh::init_holder enable_shared_from_this.");
     }
 
     /// Initialize holder object, variant 2: try to construct from existing holder object, if possible
-    static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
+    static void init_holder(detail::value_and_holder &v_h,
             const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
         if (holder_ptr) {
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(*reinterpret_cast<const holder_type *>(holder_ptr));
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*holder_ptr));
             v_h.set_holder_constructed();
-        } else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
+        } else { // Was: if (inst->owned || detail::always_construct_holder<holder_type>::value)
             new (std::addressof(v_h.holder<holder_type>())) holder_type(
                 std::move(holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<type>())));
             v_h.set_holder_constructed();
@@ -308,7 +296,7 @@ class classh : public detail::generic_type {
             register_instance(inst, v_h.value_ptr(), v_h.type);
             v_h.set_instance_registered();
         }
-        init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
+        init_holder(v_h, static_cast<const holder_type *>(holder_ptr), v_h.value_ptr<type>());
     }
 
     /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.
diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 5c9fcdb9d4..66d0ab3a41 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -93,7 +93,7 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     }
 
     static handle cast(mpty &src, return_value_policy policy, handle parent) {
-        return cast(const_cast<mpty const &>(src), policy, parent); // Mtbl2Const
+        return cast(const_cast<mpty const &>(src), policy, parent); // Mutbl2Const
     }
 
     static handle cast(mpty const *src, return_value_policy policy, handle parent) {
@@ -108,7 +108,7 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     }
 
     static handle cast(mpty *src, return_value_policy policy, handle parent) {
-        return cast(const_cast<mpty const *>(src), policy, parent); // Mtbl2Const
+        return cast(const_cast<mpty const *>(src), policy, parent); // Mutbl2Const
     }
 
     template <typename T_>
@@ -287,10 +287,43 @@ template <>
 struct type_caster<std::shared_ptr<mpty>> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<std::shared_ptr<mpty>>();
 
-    static handle cast(const std::shared_ptr<mpty> & /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
-        return str("cast_shmp").release();
+    static handle
+    cast(const std::shared_ptr<mpty> &src, return_value_policy policy, handle parent) {
+        if (policy != return_value_policy::automatic
+            && policy != return_value_policy::reference_internal) {
+            // IMPROVEABLE: Error message.
+            throw cast_error("Invalid return_value_policy for shared_ptr.");
+        }
+
+        auto src_raw_ptr = src.get();
+        auto st          = type_caster<mpty>::src_and_type(src_raw_ptr);
+        if (st.first == nullptr)
+            return none().release(); // PyErr was set already.
+
+        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
+        const detail::type_info *tinfo = st.second;
+        auto it_instances = get_internals().registered_instances.equal_range(src_raw_void_ptr);
+        // Loop copied from type_caster_generic::cast.
+        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
+            for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
+                if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
+                    // MISSING: Enforcement of consistency with existing smart_holder.
+                    // MISSING: keep_alive.
+                    return handle((PyObject *) it_i->second).inc_ref();
+            }
+        }
+
+        object inst            = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        instance *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
+        inst_raw_ptr->owned    = false; // Not actually used.
+
+        auto smhldr = pybindit::memory::smart_holder::from_shared_ptr(src);
+        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
+
+        if (policy == return_value_policy::reference_internal)
+            keep_alive_impl(inst, parent);
+
+        return inst.release();
     }
 
     template <typename>
@@ -303,10 +336,12 @@ template <>
 struct type_caster<std::shared_ptr<mpty const>> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<std::shared_ptr<mpty const>>();
 
-    static handle cast(const std::shared_ptr<mpty const> & /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
-        return str("cast_shcp").release();
+    static handle
+    cast(const std::shared_ptr<mpty const> &src, return_value_policy policy, handle parent) {
+        return type_caster<std::shared_ptr<mpty>>::cast(
+            std::const_pointer_cast<mpty>(src), // Const2Mutbl
+            policy,
+            parent);
     }
 
     template <typename>
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index 93aaae01da..148270d12c 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -39,8 +39,8 @@ def test_load():
 
 
 def test_cast_shared_ptr():
-    assert m.rtrn_mpty_shmp() == "cast_shmp"
-    assert m.rtrn_mpty_shcp() == "cast_shcp"
+    assert m.get_mtxt(m.rtrn_mpty_shmp()) == "rtrn_shmp"
+    assert m.get_mtxt(m.rtrn_mpty_shcp()) == "rtrn_shcp"
 
 
 def test_load_shared_ptr():

From 233709c51d67f709327558c6ad0daba265ce5b53 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 13 Jan 2021 11:23:50 -0800
Subject: [PATCH 058/206] Adding MISSING comments in operator
 std::unique_ptr<mpty[ const]>.

---
 tests/test_classh_wip.cpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 66d0ab3a41..bbdc3f3d37 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -362,7 +362,10 @@ struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty>
     template <typename>
     using cast_op_type = std::unique_ptr<mpty>;
 
-    operator std::unique_ptr<mpty>() { return smhldr_ptr->as_unique_ptr<mpty>(); }
+    operator std::unique_ptr<mpty>() {
+        // MISSING: value_and_holder value_ptr reset,  deregister_instance.
+        return smhldr_ptr->as_unique_ptr<mpty>();
+    }
 };
 
 template <>
@@ -378,7 +381,10 @@ struct type_caster<std::unique_ptr<mpty const>> : smart_holder_type_caster_load<
     template <typename>
     using cast_op_type = std::unique_ptr<mpty const>;
 
-    operator std::unique_ptr<mpty const>() { return smhldr_ptr->as_unique_ptr<mpty>(); }
+    operator std::unique_ptr<mpty const>() {
+        // MISSING: value_and_holder value_ptr reset,  deregister_instance.
+        return smhldr_ptr->as_unique_ptr<mpty>();
+    }
 };
 
 } // namespace detail

From 19eec17abee786618c0ad73437b021b878838cf8 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 13 Jan 2021 12:00:26 -0800
Subject: [PATCH 059/206] static handle cast implementations for rtrn_uqmp,
 rtrn_uqcp.

---
 tests/test_classh_wip.cpp | 50 ++++++++++++++++++++++++++++++++-------
 tests/test_classh_wip.py  |  4 ++--
 2 files changed, 44 insertions(+), 10 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index bbdc3f3d37..c864673d52 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -35,7 +35,7 @@ std::string pass_mpty_shmp(std::shared_ptr<mpty>       obj) { return "pass_shmp:
 std::string pass_mpty_shcp(std::shared_ptr<mpty const> obj) { return "pass_shcp:" + obj->mtxt; }
 
 std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty      >(new mpty{"rtrn_uqmp"}); }
-std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty{"rtrn_uqmp"}); }
+std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty{"rtrn_uqcp"}); }
 
 std::string pass_mpty_uqmp(std::unique_ptr<mpty      > obj) { return "pass_uqmp:" + obj->mtxt; }
 std::string pass_mpty_uqcp(std::unique_ptr<mpty const> obj) { return "pass_uqcp:" + obj->mtxt; }
@@ -354,9 +354,41 @@ template <>
 struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<std::unique_ptr<mpty>>();
 
-    static handle
-    cast(std::unique_ptr<mpty> && /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_uqmp").release();
+    static handle cast(std::unique_ptr<mpty> &&src, return_value_policy policy, handle parent) {
+        if (policy != return_value_policy::automatic
+            && policy != return_value_policy::reference_internal) {
+            // IMPROVEABLE: Error message.
+            throw cast_error("Invalid return_value_policy for unique_ptr.");
+        }
+
+        auto src_raw_ptr = src.get();
+        auto st          = type_caster<mpty>::src_and_type(src_raw_ptr);
+        if (st.first == nullptr)
+            return none().release(); // PyErr was set already.
+
+        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
+        const detail::type_info *tinfo = st.second;
+        auto it_instances = get_internals().registered_instances.equal_range(src_raw_void_ptr);
+        // Loop copied from type_caster_generic::cast.
+        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
+            for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
+                if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
+                    throw cast_error(
+                        "Invalid unique_ptr: another instance owns this pointer already.");
+            }
+        }
+
+        object inst            = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        instance *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
+        inst_raw_ptr->owned    = false; // Not actually used.
+
+        auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(src));
+        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
+
+        if (policy == return_value_policy::reference_internal)
+            keep_alive_impl(inst, parent);
+
+        return inst.release();
     }
 
     template <typename>
@@ -372,10 +404,12 @@ template <>
 struct type_caster<std::unique_ptr<mpty const>> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<std::unique_ptr<mpty const>>();
 
-    static handle cast(std::unique_ptr<mpty const> && /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
-        return str("cast_uqcp").release();
+    static handle
+    cast(std::unique_ptr<mpty const> &&src, return_value_policy policy, handle parent) {
+        return type_caster<std::unique_ptr<mpty>>::cast(
+            std::unique_ptr<mpty>(const_cast<mpty *>(src.release())), // Const2Mutbl
+            policy,
+            parent);
     }
 
     template <typename>
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index 148270d12c..f17b0aecbd 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -49,8 +49,8 @@ def test_load_shared_ptr():
 
 
 def test_cast_unique_ptr():
-    assert m.rtrn_mpty_uqmp() == "cast_uqmp"
-    assert m.rtrn_mpty_uqcp() == "cast_uqcp"
+    assert m.get_mtxt(m.rtrn_mpty_uqmp()) == "rtrn_uqmp"
+    assert m.get_mtxt(m.rtrn_mpty_uqcp()) == "rtrn_uqcp"
 
 
 def test_load_unique_ptr():

From 6c3c590d933c3382bafb0195376f227f51219080 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 14 Jan 2021 10:24:20 -0800
Subject: [PATCH 060/206] Bug fix: vptr_deleter_armed_flag_ptr has to live on
 the heap.

See new bullet point in comment section near the top.

The variable was also renamed to reflect its function more accurately.
---
 include/pybind11/smart_holder_poc.h | 69 ++++++++++++++++-------------
 1 file changed, 39 insertions(+), 30 deletions(-)

diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index 3c882ee4ae..d7145fd762 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -31,6 +31,11 @@ High-level aspects:
 * The `typename T` between `from` and `as` calls must match exactly.
   Inheritance casting needs to be handled in a different layer (similar
   to the code organization in boost/python/object/inheritance.hpp).
+
+* The smart_holder is movable but not copyable, as a consequence of using
+  unique_ptr for the vptr_deleter_armed_flag_ptr. Note that the bool for
+  the flag has to live on the heap, for the smart_holder to be movable.
+  unique_ptr is a great fit for this situation.
 */
 
 #pragma once
@@ -49,7 +54,7 @@ namespace memory {
 template <typename T>
 struct guarded_builtin_delete {
     bool *flag_ptr;
-    explicit guarded_builtin_delete(bool *guard_flag_ptr) : flag_ptr{guard_flag_ptr} {}
+    explicit guarded_builtin_delete(bool *armed_flag_ptr) : flag_ptr{armed_flag_ptr} {}
     void operator()(T *raw_ptr) {
         if (*flag_ptr)
             delete raw_ptr;
@@ -59,7 +64,7 @@ struct guarded_builtin_delete {
 template <typename T, typename D>
 struct guarded_custom_deleter {
     bool *flag_ptr;
-    explicit guarded_custom_deleter(bool *guard_flag_ptr) : flag_ptr{guard_flag_ptr} {}
+    explicit guarded_custom_deleter(bool *armed_flag_ptr) : flag_ptr{armed_flag_ptr} {}
     void operator()(T *raw_ptr) {
         if (*flag_ptr)
             D()(raw_ptr);
@@ -69,14 +74,19 @@ struct guarded_custom_deleter {
 struct smart_holder {
     const std::type_info *rtti_held;
     const std::type_info *rtti_uqp_del;
+    std::unique_ptr<bool> vptr_deleter_armed_flag_ptr;
     std::shared_ptr<void> vptr;
-    bool vptr_deleter_guard_flag;
     bool vptr_is_using_noop_deleter : 1;
     bool vptr_is_using_builtin_delete : 1;
     bool vptr_is_external_shared_ptr : 1;
 
     smart_holder()
-        : rtti_held{nullptr}, rtti_uqp_del{nullptr}, vptr_deleter_guard_flag{false},
+        : rtti_held{nullptr}, rtti_uqp_del{nullptr}, vptr_is_using_noop_deleter{false},
+          vptr_is_using_builtin_delete{false}, vptr_is_external_shared_ptr{false} {}
+
+    explicit smart_holder(bool vptr_deleter_armed_flag)
+        : rtti_held{nullptr}, rtti_uqp_del{nullptr}, vptr_deleter_armed_flag_ptr{new bool{
+                                                         vptr_deleter_armed_flag}},
           vptr_is_using_noop_deleter{false}, vptr_is_using_builtin_delete{false},
           vptr_is_external_shared_ptr{false} {}
 
@@ -130,11 +140,11 @@ struct smart_holder {
         if (vptr.get() == nullptr) {
             throw std::runtime_error(std::string("Cannot disown nullptr (") + context + ").");
         }
+        // In multithreaded environments accessing use_count can lead to
+        // race conditions, but in the context of Python it is a bug (elsewhere)
+        // if the Global Interpreter Lock (GIL) is not being held when this code
+        // is reached.
         if (vptr.use_count() != 1) {
-            // In multithreaded environments accessing use_count is racy,
-            // but in the context of Python it is a bug (elsewhere) if the
-            // Global Interpreter Lock (GIL) is not being held when this code
-            // is reached.
             throw std::runtime_error(std::string("Cannot disown use_count != 1 (") + context
                                      + ").");
         }
@@ -142,10 +152,10 @@ struct smart_holder {
 
     template <typename T>
     static smart_holder from_raw_ptr_unowned(T *raw_ptr) {
-        smart_holder hld;
-        hld.rtti_held                  = &typeid(T);
+        smart_holder hld(false);
+        hld.rtti_held = &typeid(T);
+        hld.vptr.reset(raw_ptr, guarded_builtin_delete<T>(hld.vptr_deleter_armed_flag_ptr.get()));
         hld.vptr_is_using_noop_deleter = true;
-        hld.vptr.reset(raw_ptr, guarded_builtin_delete<T>(&hld.vptr_deleter_guard_flag));
         return hld;
     }
 
@@ -174,11 +184,10 @@ struct smart_holder {
 
     template <typename T>
     static smart_holder from_raw_ptr_take_ownership(T *raw_ptr) {
-        smart_holder hld;
-        hld.rtti_held                    = &typeid(T);
-        hld.vptr_deleter_guard_flag      = true;
+        smart_holder hld(true);
+        hld.rtti_held = &typeid(T);
+        hld.vptr.reset(raw_ptr, guarded_builtin_delete<T>(hld.vptr_deleter_armed_flag_ptr.get()));
         hld.vptr_is_using_builtin_delete = true;
-        hld.vptr.reset(raw_ptr, guarded_builtin_delete<T>(&hld.vptr_deleter_guard_flag));
         return hld;
     }
 
@@ -187,20 +196,20 @@ struct smart_holder {
         ensure_compatible_rtti_held<T>(context);
         ensure_vptr_is_using_builtin_delete(context);
         ensure_use_count_1(context);
-        T *raw_ptr              = static_cast<T *>(vptr.get());
-        vptr_deleter_guard_flag = false;
+        T *raw_ptr                   = static_cast<T *>(vptr.get());
+        *vptr_deleter_armed_flag_ptr = false;
         vptr.reset();
         return raw_ptr;
     }
 
     template <typename T>
     static smart_holder from_unique_ptr(std::unique_ptr<T> &&unq_ptr) {
-        smart_holder hld;
-        hld.rtti_held                    = &typeid(T);
-        hld.vptr_deleter_guard_flag      = true;
-        hld.vptr_is_using_builtin_delete = true;
-        hld.vptr.reset(unq_ptr.get(), guarded_builtin_delete<T>(&hld.vptr_deleter_guard_flag));
+        smart_holder hld(true);
+        hld.rtti_held = &typeid(T);
+        hld.vptr.reset(unq_ptr.get(),
+                       guarded_builtin_delete<T>(hld.vptr_deleter_armed_flag_ptr.get()));
         unq_ptr.release();
+        hld.vptr_is_using_builtin_delete = true;
         return hld;
     }
 
@@ -211,11 +220,11 @@ struct smart_holder {
 
     template <typename T, typename D>
     static smart_holder from_unique_ptr_with_deleter(std::unique_ptr<T, D> &&unq_ptr) {
-        smart_holder hld;
-        hld.rtti_held               = &typeid(T);
-        hld.rtti_uqp_del            = &typeid(D);
-        hld.vptr_deleter_guard_flag = true;
-        hld.vptr.reset(unq_ptr.get(), guarded_custom_deleter<T, D>(&hld.vptr_deleter_guard_flag));
+        smart_holder hld(true);
+        hld.rtti_held    = &typeid(T);
+        hld.rtti_uqp_del = &typeid(D);
+        hld.vptr.reset(unq_ptr.get(),
+                       guarded_custom_deleter<T, D>(hld.vptr_deleter_armed_flag_ptr.get()));
         unq_ptr.release();
         return hld;
     }
@@ -226,8 +235,8 @@ struct smart_holder {
         ensure_compatible_rtti_held<T>(context);
         ensure_compatible_rtti_uqp_del<D>(context);
         ensure_use_count_1(context);
-        T *raw_ptr              = static_cast<T *>(vptr.get());
-        vptr_deleter_guard_flag = false;
+        T *raw_ptr                   = static_cast<T *>(vptr.get());
+        *vptr_deleter_armed_flag_ptr = false;
         vptr.reset();
         return std::unique_ptr<T, D>(raw_ptr);
     }
@@ -236,8 +245,8 @@ struct smart_holder {
     static smart_holder from_shared_ptr(std::shared_ptr<T> shd_ptr) {
         smart_holder hld;
         hld.rtti_held                   = &typeid(T);
-        hld.vptr_is_external_shared_ptr = true;
         hld.vptr                        = std::static_pointer_cast<void>(shd_ptr);
+        hld.vptr_is_external_shared_ptr = true;
         return hld;
     }
 

From 19dc3568e05d6f5cf49c5dc75e713adac4af0bee Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 14 Jan 2021 10:29:23 -0800
Subject: [PATCH 061/206] Fixing bugs discovered by ASAN. The code is now ASAN,
 MSAN, UBSAN clean.

---
 include/pybind11/classh.h | 32 ++++++++++++++++----------------
 tests/test_classh_wip.cpp | 14 +++++++++-----
 tests/test_classh_wip.py  |  9 +--------
 3 files changed, 26 insertions(+), 29 deletions(-)

diff --git a/include/pybind11/classh.h b/include/pybind11/classh.h
index 77a9a93281..96510077cf 100644
--- a/include/pybind11/classh.h
+++ b/include/pybind11/classh.h
@@ -266,37 +266,37 @@ class classh : public detail::generic_type {
     }
 
 private:
-    /// Initialize holder object, variant 1: object derives from enable_shared_from_this
     template <typename T>
-    static void init_holder(detail::value_and_holder &/*v_h*/,
-            const holder_type * /* unused */, const std::enable_shared_from_this<T> * /* dummy */) {
+    static void init_holder(bool /*owned*/, detail::value_and_holder &/*v_h*/,
+            holder_type * /* unused */, const std::enable_shared_from_this<T> * /* dummy */) {
         throw std::runtime_error("Not implemented: classh::init_holder enable_shared_from_this.");
     }
 
-    /// Initialize holder object, variant 2: try to construct from existing holder object, if possible
-    static void init_holder(detail::value_and_holder &v_h,
-            const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
+    static void init_holder(bool owned, detail::value_and_holder &v_h,
+            holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
         if (holder_ptr) {
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*holder_ptr));
-            v_h.set_holder_constructed();
-        } else { // Was: if (inst->owned || detail::always_construct_holder<holder_type>::value)
             new (std::addressof(v_h.holder<holder_type>())) holder_type(
-                std::move(holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<type>())));
-            v_h.set_holder_constructed();
+                std::move(*holder_ptr));
+        } else if (owned) {
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(
+                holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<type>()));
+        }
+        else {
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(
+                holder_type::from_raw_ptr_unowned(v_h.value_ptr<type>()));
         }
+        v_h.set_holder_constructed();
     }
 
-    /// Performs instance initialization including constructing a holder and registering the known
-    /// instance.  Should be called as soon as the `type` value_ptr is set for an instance.  Takes an
-    /// optional pointer to an existing holder to use; if not specified and the instance is
-    /// `.owned`, a new holder will be constructed to manage the value pointer.
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
         auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
         if (!v_h.instance_registered()) {
             register_instance(inst, v_h.value_ptr(), v_h.type);
             v_h.set_instance_registered();
         }
-        init_holder(v_h, static_cast<const holder_type *>(holder_ptr), v_h.value_ptr<type>());
+        // Need for const_cast is a consequence of the type_info::init_instance type:
+        // void (*init_instance)(instance *, const void *);
+        init_holder(inst->owned, v_h, static_cast<holder_type *>(const_cast<void *>(holder_ptr)), v_h.value_ptr<type>());
     }
 
     /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.
diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index c864673d52..860736c27c 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -15,11 +15,11 @@ struct mpty {
 // clang-format off
 
 mpty        rtrn_mpty_valu() { mpty obj{"rtrn_valu"}; return obj; }
-mpty&&      rtrn_mpty_rref() { mpty obj{"rtrn_rref"}; return std::move(obj); }
+mpty&&      rtrn_mpty_rref() { static mpty obj; obj.mtxt = "rtrn_rref"; return std::move(obj); }
 mpty const& rtrn_mpty_cref() { static mpty obj; obj.mtxt = "rtrn_cref"; return obj; }
 mpty&       rtrn_mpty_mref() { static mpty obj; obj.mtxt = "rtrn_mref"; return obj; }
-mpty const* rtrn_mpty_cptr() { static mpty obj; obj.mtxt = "rtrn_cptr"; return &obj; }
-mpty*       rtrn_mpty_mptr() { static mpty obj; obj.mtxt = "rtrn_mptr"; return &obj; }
+mpty const* rtrn_mpty_cptr() { return new mpty{"rtrn_cptr"}; }
+mpty*       rtrn_mpty_mptr() { return new mpty{"rtrn_mptr"}; }
 
 std::string pass_mpty_valu(mpty obj)        { return "pass_valu:" + obj.mtxt; }
 std::string pass_mpty_rref(mpty&& obj)      { return "pass_rref:" + obj.mtxt; }
@@ -315,7 +315,9 @@ struct type_caster<std::shared_ptr<mpty>> : smart_holder_type_caster_load<mpty>
 
         object inst            = reinterpret_steal<object>(make_new_instance(tinfo->type));
         instance *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
-        inst_raw_ptr->owned    = false; // Not actually used.
+        inst_raw_ptr->owned    = true;
+        void *&valueptr        = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+        valueptr               = src_raw_void_ptr;
 
         auto smhldr = pybindit::memory::smart_holder::from_shared_ptr(src);
         tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
@@ -380,7 +382,9 @@ struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty>
 
         object inst            = reinterpret_steal<object>(make_new_instance(tinfo->type));
         instance *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
-        inst_raw_ptr->owned    = false; // Not actually used.
+        inst_raw_ptr->owned    = true;
+        void *&valueptr        = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+        valueptr               = src_raw_void_ptr;
 
         auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(src));
         tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index f17b0aecbd..f816af06f2 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -15,20 +15,13 @@ def test_mpty_constructors():
 
 def test_cast():
     assert m.get_mtxt(m.rtrn_mpty_valu()) == "rtrn_valu"
-    #                                         rtrn_rref exercised separately.
+    assert m.get_mtxt(m.rtrn_mpty_rref()) == "rtrn_rref"
     assert m.get_mtxt(m.rtrn_mpty_cref()) == "rtrn_cref"
     assert m.get_mtxt(m.rtrn_mpty_mref()) == "rtrn_mref"
     assert m.get_mtxt(m.rtrn_mpty_cptr()) == "rtrn_cptr"
     assert m.get_mtxt(m.rtrn_mpty_mptr()) == "rtrn_mptr"
 
 
-def test_cast_rref():
-    e = m.rtrn_mpty_rref()
-    assert e.__class__.__name__ == "mpty"
-    with pytest.raises(RuntimeError):
-        m.get_mtxt(e)  # E.g. basic_string::_M_construct null not valid
-
-
 def test_load():
     assert m.pass_mpty_valu(m.mpty("Valu")) == "pass_valu:Valu"
     assert m.pass_mpty_rref(m.mpty("Rref")) == "pass_rref:Rref"

From 2b12cc922953e3cd2661f9d71f16ca34ebce2c17 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 14 Jan 2021 12:58:40 -0800
Subject: [PATCH 062/206] Making test_type_caster_bare_interface_demo.cpp
 slightly more realistic, ASAN, MSAN, UBSAN clean.

---
 .../test_type_caster_bare_interface_demo.cpp  | 116 +++++++++---------
 1 file changed, 55 insertions(+), 61 deletions(-)

diff --git a/tests/test_type_caster_bare_interface_demo.cpp b/tests/test_type_caster_bare_interface_demo.cpp
index 12e98f5d2e..ea6041a650 100644
--- a/tests/test_type_caster_bare_interface_demo.cpp
+++ b/tests/test_type_caster_bare_interface_demo.cpp
@@ -7,12 +7,14 @@ namespace type_caster_bare_interface_demo {
 
 struct mpty {};
 
+// clang-format off
+
 mpty        rtrn_mpty_valu() { mpty obj; return obj; }
-mpty&&      rtrn_mpty_rref() { mpty obj; return std::move(obj); }
+mpty&&      rtrn_mpty_rref() { static mpty obj; return std::move(obj); }
 mpty const& rtrn_mpty_cref() { static mpty obj; return obj; }
 mpty&       rtrn_mpty_mref() { static mpty obj; return obj; }
-mpty const* rtrn_mpty_cptr() { static mpty obj; return &obj; }
-mpty*       rtrn_mpty_mptr() { static mpty obj; return &obj; }
+mpty const* rtrn_mpty_cptr() { return new mpty; }
+mpty*       rtrn_mpty_mptr() { return new mpty; }
 
 const char* pass_mpty_valu(mpty)        { return "load_valu"; }
 const char* pass_mpty_rref(mpty&&)      { return "load_rref"; }
@@ -21,20 +23,22 @@ const char* pass_mpty_mref(mpty&)       { return "load_mref"; }
 const char* pass_mpty_cptr(mpty const*) { return "load_cptr"; }
 const char* pass_mpty_mptr(mpty*)       { return "load_mptr"; }
 
-std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty>(new mpty); }
+std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty      >(new mpty); }
 std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const>(new mpty); }
 
 const char* pass_mpty_shmp(std::shared_ptr<mpty>)       { return "load_shmp"; }
 const char* pass_mpty_shcp(std::shared_ptr<mpty const>) { return "load_shcp"; }
 
-std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty>(new mpty); }
+std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty      >(new mpty); }
 std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty); }
 
 const char* pass_mpty_uqmp(std::unique_ptr<mpty>)       { return "load_uqmp"; }
 const char* pass_mpty_uqcp(std::unique_ptr<mpty const>) { return "load_uqcp"; }
 
-}  // namespace type_caster_bare_interface_demo
-}  // namespace pybind11_tests
+// clang-format on
+
+} // namespace type_caster_bare_interface_demo
+} // namespace pybind11_tests
 
 namespace pybind11 {
 namespace detail {
@@ -48,139 +52,129 @@ struct type_caster<mpty> {
     // static handle cast(mpty, ...)
     // is redundant (leads to ambiguous overloads).
 
-    static handle cast(mpty&& /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
+    static handle cast(mpty && /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
         return str("cast_rref").release();
     }
 
-    static handle cast(mpty const& /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
+    static handle cast(mpty const & /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
         return str("cast_cref").release();
     }
 
-    static handle cast(mpty& /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
+    static handle cast(mpty & /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
         return str("cast_mref").release();
     }
 
-    static handle cast(mpty const* /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
+    static handle cast(mpty const *src, return_value_policy /*policy*/, handle /*parent*/) {
+        delete src;
         return str("cast_cptr").release();
     }
 
-    static handle cast(mpty* /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
+    static handle cast(mpty *src, return_value_policy /*policy*/, handle /*parent*/) {
+        delete src;
         return str("cast_mptr").release();
     }
 
     template <typename T_>
     using cast_op_type = conditional_t<
-        std::is_same<remove_reference_t<T_>, mpty const*>::value, mpty const*,
+        std::is_same<remove_reference_t<T_>, mpty const *>::value,
+        mpty const *,
         conditional_t<
-            std::is_same<remove_reference_t<T_>, mpty*>::value, mpty*,
+            std::is_same<remove_reference_t<T_>, mpty *>::value,
+            mpty *,
             conditional_t<
-                std::is_same<T_, mpty const&>::value, mpty const&,
-                conditional_t<
-                    std::is_same<T_, mpty&>::value, mpty&,
-                    conditional_t<
-                        std::is_same<T_, mpty&&>::value, mpty&&,
-                        mpty>>>>>;
+                std::is_same<T_, mpty const &>::value,
+                mpty const &,
+                conditional_t<std::is_same<T_, mpty &>::value,
+                              mpty &,
+                              conditional_t<std::is_same<T_, mpty &&>::value, mpty &&, mpty>>>>>;
+
+    // clang-format off
 
     operator mpty()        { return rtrn_mpty_valu(); }
     operator mpty&&() &&   { return rtrn_mpty_rref(); }
     operator mpty const&() { return rtrn_mpty_cref(); }
     operator mpty&()       { return rtrn_mpty_mref(); }
-    operator mpty const*() { return rtrn_mpty_cptr(); }
-    operator mpty*()       { return rtrn_mpty_mptr(); }
+    operator mpty const*() { static mpty obj; return &obj; }
+    operator mpty*()       { static mpty obj; return &obj; }
 
-    bool load(handle /*src*/, bool /*convert*/) {
-        return true;
-    }
+    // clang-format on
+
+    bool load(handle /*src*/, bool /*convert*/) { return true; }
 };
 
 template <>
 struct type_caster<std::shared_ptr<mpty>> {
     static constexpr auto name = _<std::shared_ptr<mpty>>();
 
-    static handle cast(const std::shared_ptr<mpty>& /*src*/,
+    static handle cast(const std::shared_ptr<mpty> & /*src*/,
                        return_value_policy /*policy*/,
                        handle /*parent*/) {
         return str("cast_shmp").release();
     }
 
-    template <typename> using cast_op_type = std::shared_ptr<mpty>;
+    template <typename>
+    using cast_op_type = std::shared_ptr<mpty>;
 
     operator std::shared_ptr<mpty>() { return rtrn_mpty_shmp(); }
 
-    bool load(handle /*src*/, bool /*convert*/) {
-        return true;
-    }
+    bool load(handle /*src*/, bool /*convert*/) { return true; }
 };
 
 template <>
 struct type_caster<std::shared_ptr<mpty const>> {
     static constexpr auto name = _<std::shared_ptr<mpty const>>();
 
-    static handle cast(const std::shared_ptr<mpty const>& /*src*/,
+    static handle cast(const std::shared_ptr<mpty const> & /*src*/,
                        return_value_policy /*policy*/,
                        handle /*parent*/) {
         return str("cast_shcp").release();
     }
 
-    template <typename> using cast_op_type = std::shared_ptr<mpty const>;
+    template <typename>
+    using cast_op_type = std::shared_ptr<mpty const>;
 
     operator std::shared_ptr<mpty const>() { return rtrn_mpty_shcp(); }
 
-    bool load(handle /*src*/, bool /*convert*/) {
-        return true;
-    }
+    bool load(handle /*src*/, bool /*convert*/) { return true; }
 };
 
 template <>
 struct type_caster<std::unique_ptr<mpty>> {
     static constexpr auto name = _<std::unique_ptr<mpty>>();
 
-    static handle cast(std::unique_ptr<mpty>&& /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
+    static handle
+    cast(std::unique_ptr<mpty> && /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
         return str("cast_uqmp").release();
     }
 
-    template <typename> using cast_op_type = std::unique_ptr<mpty>;
+    template <typename>
+    using cast_op_type = std::unique_ptr<mpty>;
 
     operator std::unique_ptr<mpty>() { return rtrn_mpty_uqmp(); }
 
-    bool load(handle /*src*/, bool /*convert*/) {
-        return true;
-    }
+    bool load(handle /*src*/, bool /*convert*/) { return true; }
 };
 
 template <>
 struct type_caster<std::unique_ptr<mpty const>> {
     static constexpr auto name = _<std::unique_ptr<mpty const>>();
 
-    static handle cast(std::unique_ptr<mpty const>&& /*src*/,
+    static handle cast(std::unique_ptr<mpty const> && /*src*/,
                        return_value_policy /*policy*/,
                        handle /*parent*/) {
         return str("cast_uqcp").release();
     }
 
-    template <typename> using cast_op_type = std::unique_ptr<mpty const>;
+    template <typename>
+    using cast_op_type = std::unique_ptr<mpty const>;
 
     operator std::unique_ptr<mpty const>() { return rtrn_mpty_uqcp(); }
 
-    bool load(handle /*src*/, bool /*convert*/) {
-        return true;
-    }
+    bool load(handle /*src*/, bool /*convert*/) { return true; }
 };
 
-}  // namespace detail
-}  // namespace pybind11
+} // namespace detail
+} // namespace pybind11
 
 namespace pybind11_tests {
 namespace type_caster_bare_interface_demo {
@@ -213,5 +207,5 @@ TEST_SUBMODULE(type_caster_bare_interface_demo, m) {
     m.def("pass_mpty_uqcp", pass_mpty_uqcp);
 }
 
-}  // namespace type_caster_bare_interface_demo
-}  // namespace pybind11_tests
+} // namespace type_caster_bare_interface_demo
+} // namespace pybind11_tests

From 9e03cc79767c1dcab58061e915f0c3149f818164 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 14 Jan 2021 22:23:07 -0800
Subject: [PATCH 063/206] Calling deregister_instance after disowning via
 unique_ptr.

---
 tests/test_classh_wip.cpp | 55 +++++++++++++++++++++++++--------------
 tests/test_classh_wip.py  | 12 ++++++++-
 2 files changed, 46 insertions(+), 21 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 860736c27c..8876b8a3f8 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -54,17 +54,35 @@ using namespace pybind11_tests::classh_wip;
 
 template <typename T>
 struct smart_holder_type_caster_load {
+    using holder_type = pybindit::memory::smart_holder;
+
     bool load(handle src, bool /*convert*/) {
         if (!isinstance<T>(src))
             return false;
         auto inst  = reinterpret_cast<instance *>(src.ptr());
-        auto v_h   = inst->get_value_and_holder(get_type_info(typeid(T)));
-        smhldr_ptr = &v_h.holder<pybindit::memory::smart_holder>();
+        loaded_v_h = inst->get_value_and_holder(get_type_info(typeid(T)));
+        if (!loaded_v_h.holder_constructed()) {
+            // IMPROVEABLE: Error message.
+            throw std::runtime_error("Missing value for wrapped C++ type:"
+                                     " Python instance is uninitialized or was disowned.");
+        }
+        loaded_smhldr_ptr = &loaded_v_h.holder<holder_type>();
         return true;
     }
 
+    std::unique_ptr<T> loaded_as_unique_ptr() {
+        void *value_void_ptr = loaded_v_h.value_ptr();
+        auto unq_ptr         = loaded_smhldr_ptr->as_unique_ptr<mpty>();
+        loaded_v_h.holder<holder_type>().~holder_type();
+        loaded_v_h.set_holder_constructed(false);
+        loaded_v_h.value_ptr() = nullptr;
+        deregister_instance(loaded_v_h.inst, value_void_ptr, loaded_v_h.type);
+        return unq_ptr;
+    }
+
 protected:
-    pybindit::memory::smart_holder *smhldr_ptr = nullptr;
+    value_and_holder loaded_v_h;
+    holder_type *loaded_smhldr_ptr = nullptr;
 };
 
 template <>
@@ -127,12 +145,12 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
 
     // clang-format off
 
-    operator mpty()        { return smhldr_ptr->lvalue_ref<mpty>(); }
-    operator mpty&&() &&   { return smhldr_ptr->rvalue_ref<mpty>(); }
-    operator mpty const&() { return smhldr_ptr->lvalue_ref<mpty>(); }
-    operator mpty&()       { return smhldr_ptr->lvalue_ref<mpty>(); }
-    operator mpty const*() { return smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
-    operator mpty*()       { return smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
+    operator mpty()        { return loaded_smhldr_ptr->lvalue_ref<mpty>(); }
+    operator mpty&&() &&   { return loaded_smhldr_ptr->rvalue_ref<mpty>(); }
+    operator mpty const&() { return loaded_smhldr_ptr->lvalue_ref<mpty>(); }
+    operator mpty&()       { return loaded_smhldr_ptr->lvalue_ref<mpty>(); }
+    operator mpty const*() { return loaded_smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
+    operator mpty*()       { return loaded_smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
 
     // clang-format on
 
@@ -331,7 +349,7 @@ struct type_caster<std::shared_ptr<mpty>> : smart_holder_type_caster_load<mpty>
     template <typename>
     using cast_op_type = std::shared_ptr<mpty>;
 
-    operator std::shared_ptr<mpty>() { return smhldr_ptr->as_shared_ptr<mpty>(); }
+    operator std::shared_ptr<mpty>() { return loaded_smhldr_ptr->as_shared_ptr<mpty>(); }
 };
 
 template <>
@@ -349,7 +367,7 @@ struct type_caster<std::shared_ptr<mpty const>> : smart_holder_type_caster_load<
     template <typename>
     using cast_op_type = std::shared_ptr<mpty const>;
 
-    operator std::shared_ptr<mpty const>() { return smhldr_ptr->as_shared_ptr<mpty>(); }
+    operator std::shared_ptr<mpty const>() { return loaded_smhldr_ptr->as_shared_ptr<mpty>(); }
 };
 
 template <>
@@ -398,10 +416,7 @@ struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty>
     template <typename>
     using cast_op_type = std::unique_ptr<mpty>;
 
-    operator std::unique_ptr<mpty>() {
-        // MISSING: value_and_holder value_ptr reset,  deregister_instance.
-        return smhldr_ptr->as_unique_ptr<mpty>();
-    }
+    operator std::unique_ptr<mpty>() { return loaded_as_unique_ptr(); }
 };
 
 template <>
@@ -419,10 +434,7 @@ struct type_caster<std::unique_ptr<mpty const>> : smart_holder_type_caster_load<
     template <typename>
     using cast_op_type = std::unique_ptr<mpty const>;
 
-    operator std::unique_ptr<mpty const>() {
-        // MISSING: value_and_holder value_ptr reset,  deregister_instance.
-        return smhldr_ptr->as_unique_ptr<mpty>();
-    }
+    operator std::unique_ptr<mpty const>() { return loaded_as_unique_ptr(); }
 };
 
 } // namespace detail
@@ -466,7 +478,10 @@ TEST_SUBMODULE(classh_wip, m) {
     m.def("pass_mpty_uqmp", pass_mpty_uqmp);
     m.def("pass_mpty_uqcp", pass_mpty_uqcp);
 
-    m.def("get_mtxt", get_mtxt); // Requires pass_mpty_cref to work properly.
+    // Helpers, these require selected functions above to work, as indicated:
+    m.def("get_mtxt", get_mtxt); // pass_mpty_cref
+    m.def("unique_ptr_roundtrip",
+          [](std::unique_ptr<mpty> obj) { return obj; }); // pass_mpty_uqmp, rtrn_mpty_uqmp
 }
 
 } // namespace classh_wip
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index f816af06f2..4f467b2bdb 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -63,4 +63,14 @@ def test_pass_unique_ptr_disowns(pass_mpty, argm, rtrn):
     assert pass_mpty(obj) == rtrn
     with pytest.raises(RuntimeError) as exc_info:
         m.pass_mpty_uqmp(obj)
-    assert str(exc_info.value) == "Cannot disown nullptr (as_unique_ptr)."
+    assert str(exc_info.value) == (
+        "Missing value for wrapped C++ type:"
+        " Python instance is uninitialized or was disowned."
+    )
+
+
+def test_unique_ptr_roundtrip(num_round_trips=1000):
+    recycled = m.mpty("passenger")
+    for _ in range(num_round_trips):
+        recycled = m.unique_ptr_roundtrip(recycled)
+        assert m.get_mtxt(recycled) == "passenger"

From 5223e9197b8fc13a6ebad4c5f53d18d8d571330c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 15 Jan 2021 11:00:36 -0800
Subject: [PATCH 064/206] Removing enable_shared_from_this stub, simplifying
 existing code, clang-format.

Open question, with respect to the original code:
https://github.com/pybind/pybind11/blob/76a160070b369f8d82b945c97924227e8b835c94/include/pybind11/pybind11.h#L1510
To me it looks like the exact situation marked as `std::shared_ptr<Good> gp1 = not_so_good.getptr();` here: https://en.cppreference.com/w/cpp/memory/enable_shared_from_this
The comment there is: `// undefined behavior (until C++17) and std::bad_weak_ptr thrown (since C++17)`
Does the existing code have UB pre C++17?

I'll leave handling of enable_shared_from_this for later, as the need arises.
---
 include/pybind11/classh.h | 46 +++++++++++++++++----------------------
 1 file changed, 20 insertions(+), 26 deletions(-)

diff --git a/include/pybind11/classh.h b/include/pybind11/classh.h
index 96510077cf..16b5242b7c 100644
--- a/include/pybind11/classh.h
+++ b/include/pybind11/classh.h
@@ -1,10 +1,11 @@
 #pragma once
 
-#include "smart_holder_poc.h"
 #include "pybind11.h"
+#include "smart_holder_poc.h"
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 
+// clang-format off
 template <typename type_, typename... options>
 class classh : public detail::generic_type {
     template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>;
@@ -266,38 +267,31 @@ class classh : public detail::generic_type {
     }
 
 private:
-    template <typename T>
-    static void init_holder(bool /*owned*/, detail::value_and_holder &/*v_h*/,
-            holder_type * /* unused */, const std::enable_shared_from_this<T> * /* dummy */) {
-        throw std::runtime_error("Not implemented: classh::init_holder enable_shared_from_this.");
-    }
-
-    static void init_holder(bool owned, detail::value_and_holder &v_h,
-            holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
-        if (holder_ptr) {
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(
-                std::move(*holder_ptr));
-        } else if (owned) {
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(
-                holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<type>()));
-        }
-        else {
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(
-                holder_type::from_raw_ptr_unowned(v_h.value_ptr<type>()));
-        }
-        v_h.set_holder_constructed();
-    }
+    // clang-format on
+    static void init_instance(detail::instance *inst, const void *holder_const_void_ptr) {
+        // Need for const_cast is a consequence of the type_info::init_instance type:
+        // void (*init_instance)(instance *, const void *);
+        auto holder_void_ptr = const_cast<void *>(holder_const_void_ptr);
 
-    static void init_instance(detail::instance *inst, const void *holder_ptr) {
         auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
         if (!v_h.instance_registered()) {
             register_instance(inst, v_h.value_ptr(), v_h.type);
             v_h.set_instance_registered();
         }
-        // Need for const_cast is a consequence of the type_info::init_instance type:
-        // void (*init_instance)(instance *, const void *);
-        init_holder(inst->owned, v_h, static_cast<holder_type *>(const_cast<void *>(holder_ptr)), v_h.value_ptr<type>());
+        if (holder_void_ptr) {
+            // Note: inst->owned ignored.
+            auto holder_ptr = static_cast<holder_type *>(holder_void_ptr);
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*holder_ptr));
+        } else if (inst->owned) {
+            new (std::addressof(v_h.holder<holder_type>()))
+                holder_type(holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<type>()));
+        } else {
+            new (std::addressof(v_h.holder<holder_type>()))
+                holder_type(holder_type::from_raw_ptr_unowned(v_h.value_ptr<type>()));
+        }
+        v_h.set_holder_constructed();
     }
+    // clang-format off
 
     /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.
     static void dealloc(detail::value_and_holder &v_h) {

From 7fd3d51d012096943c91b8c5a26f1f59c664b162 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 15 Jan 2021 11:44:07 -0800
Subject: [PATCH 065/206] Cosmetical change around helper functions.

---
 tests/test_classh_wip.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 8876b8a3f8..f5bf70189a 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -42,7 +42,9 @@ std::string pass_mpty_uqcp(std::unique_ptr<mpty const> obj) { return "pass_uqcp:
 
 // clang-format on
 
+// Helpers for testing.
 std::string get_mtxt(mpty const &obj) { return obj.mtxt; }
+std::unique_ptr<mpty> unique_ptr_roundtrip(std::unique_ptr<mpty> obj) { return obj; }
 
 } // namespace classh_wip
 } // namespace pybind11_tests
@@ -478,10 +480,10 @@ TEST_SUBMODULE(classh_wip, m) {
     m.def("pass_mpty_uqmp", pass_mpty_uqmp);
     m.def("pass_mpty_uqcp", pass_mpty_uqcp);
 
-    // Helpers, these require selected functions above to work, as indicated:
-    m.def("get_mtxt", get_mtxt); // pass_mpty_cref
-    m.def("unique_ptr_roundtrip",
-          [](std::unique_ptr<mpty> obj) { return obj; }); // pass_mpty_uqmp, rtrn_mpty_uqmp
+    // Helpers for testing.
+    // These require selected functions above to work first, as indicated:
+    m.def("get_mtxt", get_mtxt);                         // pass_mpty_cref
+    m.def("unique_ptr_roundtrip", unique_ptr_roundtrip); // pass_mpty_uqmp, rtrn_mpty_uqmp
 }
 
 } // namespace classh_wip

From dc0f63ec391923d21b6eceb4143a67f198925c1a Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 15 Jan 2021 12:18:18 -0800
Subject: [PATCH 066/206] Using type_caster_base<mpty>::src_and_type directly,
 removing copy. Also renaming one cast to cast_const_raw_ptr, for clarity.

---
 tests/test_classh_wip.cpp | 49 ++++++++++-----------------------------
 1 file changed, 12 insertions(+), 37 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index f5bf70189a..cb78fd8fd7 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -117,14 +117,14 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     }
 
     static handle cast(mpty const *src, return_value_policy policy, handle parent) {
-        // type_caster_base BEGIN
-        // clang-format off
-        auto st = src_and_type(src);
-        return cast( // Originally type_caster_generic::cast.
-            st.first, policy, parent, st.second,
-            make_copy_constructor(src), make_move_constructor(src));
-        // clang-format on
-        // type_caster_base END
+        auto st = type_caster_base<mpty>::src_and_type(src);
+        return cast_const_raw_ptr( // Originally type_caster_generic::cast.
+            st.first,
+            policy,
+            parent,
+            st.second,
+            make_copy_constructor(src),
+            make_move_constructor(src));
     }
 
     static handle cast(mpty *src, return_value_policy policy, handle parent) {
@@ -156,35 +156,9 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
 
     // clang-format on
 
-    using itype = mpty;
-
     // type_caster_base BEGIN
     // clang-format off
 
-    // Returns a (pointer, type_info) pair taking care of necessary type lookup for a
-    // polymorphic type (using RTTI by default, but can be overridden by specializing
-    // polymorphic_type_hook). If the instance isn't derived, returns the base version.
-    static std::pair<const void *, const type_info *> src_and_type(const itype *src) {
-        auto &cast_type = typeid(itype);
-        const std::type_info *instance_type = nullptr;
-        const void *vsrc = polymorphic_type_hook<itype>::get(src, instance_type);
-        if (instance_type && !same_type(cast_type, *instance_type)) {
-            // This is a base pointer to a derived type. If the derived type is registered
-            // with pybind11, we want to make the full derived object available.
-            // In the typical case where itype is polymorphic, we get the correct
-            // derived pointer (which may be != base pointer) by a dynamic_cast to
-            // most derived type. If itype is not polymorphic, we won't get here
-            // except via a user-provided specialization of polymorphic_type_hook,
-            // and the user has promised that no this-pointer adjustment is
-            // required in that case, so it's OK to use static_cast.
-            if (const auto *tpi = get_type_info(*instance_type))
-                return {vsrc, tpi};
-        }
-        // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer, so
-        // don't do a cast
-        return type_caster_generic::src_and_type(src, cast_type, instance_type);
-    }
-
     using Constructor = void *(*)(const void *);
 
     /* Only enabled when the types are {copy,move}-constructible *and* when the type
@@ -210,7 +184,8 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     // type_caster_base END
 
     // Originally type_caster_generic::cast.
-    PYBIND11_NOINLINE static handle cast(const void *_src,
+    PYBIND11_NOINLINE static handle cast_const_raw_ptr(
+                                         const void *_src,
                                          return_value_policy policy,
                                          handle parent,
                                          const detail::type_info *tinfo,
@@ -316,7 +291,7 @@ struct type_caster<std::shared_ptr<mpty>> : smart_holder_type_caster_load<mpty>
         }
 
         auto src_raw_ptr = src.get();
-        auto st          = type_caster<mpty>::src_and_type(src_raw_ptr);
+        auto st          = type_caster_base<mpty>::src_and_type(src_raw_ptr);
         if (st.first == nullptr)
             return none().release(); // PyErr was set already.
 
@@ -384,7 +359,7 @@ struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty>
         }
 
         auto src_raw_ptr = src.get();
-        auto st          = type_caster<mpty>::src_and_type(src_raw_ptr);
+        auto st          = type_caster_base<mpty>::src_and_type(src_raw_ptr);
         if (st.first == nullptr)
             return none().release(); // PyErr was set already.
 

From cef065f95f7fefe443347900b531aed002771514 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 15 Jan 2021 15:49:38 -0800
Subject: [PATCH 067/206] Fixing clang-format oversight.

---
 tests/test_classh_wip.cpp | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index cb78fd8fd7..b5a9274fb5 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -184,14 +184,13 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     // type_caster_base END
 
     // Originally type_caster_generic::cast.
-    PYBIND11_NOINLINE static handle cast_const_raw_ptr(
-                                         const void *_src,
-                                         return_value_policy policy,
-                                         handle parent,
-                                         const detail::type_info *tinfo,
-                                         void *(*copy_constructor)(const void *),
-                                         void *(*move_constructor)(const void *),
-                                         const void *existing_holder = nullptr) {
+    PYBIND11_NOINLINE static handle cast_const_raw_ptr(const void *_src,
+                                                       return_value_policy policy,
+                                                       handle parent,
+                                                       const detail::type_info *tinfo,
+                                                       void *(*copy_constructor)(const void *),
+                                                       void *(*move_constructor)(const void *),
+                                                       const void *existing_holder = nullptr) {
         if (!tinfo) // no type info: error will be set already
             return handle();
 

From fd11b71a79fbbb1cc36e5aa73bce1a37acbbf9d0 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 15 Jan 2021 16:22:18 -0800
Subject: [PATCH 068/206] Using factored-out make_constructor (PR #2798),
 removing duplicate code.

---
 include/pybind11/cast.h   | 915 ++++++++++++++++++++++++++++++++++++++
 tests/test_classh_wip.cpp |  31 +-
 2 files changed, 917 insertions(+), 29 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 64b4022be3..b28acb8a66 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -47,6 +47,921 @@
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 PYBIND11_NAMESPACE_BEGIN(detail)
 
+/// A life support system for temporary objects created by `type_caster::load()`.
+/// Adding a patient will keep it alive up until the enclosing function returns.
+class loader_life_support {
+public:
+    /// A new patient frame is created when a function is entered
+    loader_life_support() {
+        get_internals().loader_patient_stack.push_back(nullptr);
+    }
+
+    /// ... and destroyed after it returns
+    ~loader_life_support() {
+        auto &stack = get_internals().loader_patient_stack;
+        if (stack.empty())
+            pybind11_fail("loader_life_support: internal error");
+
+        auto ptr = stack.back();
+        stack.pop_back();
+        Py_CLEAR(ptr);
+
+        // A heuristic to reduce the stack's capacity (e.g. after long recursive calls)
+        if (stack.capacity() > 16 && !stack.empty() && stack.capacity() / stack.size() > 2)
+            stack.shrink_to_fit();
+    }
+
+    /// 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) {
+        auto &stack = get_internals().loader_patient_stack;
+        if (stack.empty())
+            throw cast_error("When called outside a bound function, py::cast() cannot "
+                             "do Python -> C++ conversions which require the creation "
+                             "of temporary values");
+
+        auto &list_ptr = stack.back();
+        if (list_ptr == nullptr) {
+            list_ptr = PyList_New(1);
+            if (!list_ptr)
+                pybind11_fail("loader_life_support: error allocating list");
+            PyList_SET_ITEM(list_ptr, 0, h.inc_ref().ptr());
+        } else {
+            auto result = PyList_Append(list_ptr, h.ptr());
+            if (result == -1)
+                pybind11_fail("loader_life_support: error adding patient");
+        }
+    }
+};
+
+// Gets the cache entry for the given type, creating it if necessary.  The return value is the pair
+// returned by emplace, i.e. an iterator for the entry and a bool set to `true` if the entry was
+// just created.
+inline std::pair<decltype(internals::registered_types_py)::iterator, bool> all_type_info_get_cache(PyTypeObject *type);
+
+// Populates a just-created cache entry.
+PYBIND11_NOINLINE inline void all_type_info_populate(PyTypeObject *t, std::vector<type_info *> &bases) {
+    std::vector<PyTypeObject *> check;
+    for (handle parent : reinterpret_borrow<tuple>(t->tp_bases))
+        check.push_back((PyTypeObject *) parent.ptr());
+
+    auto const &type_dict = get_internals().registered_types_py;
+    for (size_t i = 0; i < check.size(); i++) {
+        auto type = check[i];
+        // Ignore Python2 old-style class super type:
+        if (!PyType_Check((PyObject *) type)) continue;
+
+        // Check `type` in the current set of registered python types:
+        auto it = type_dict.find(type);
+        if (it != type_dict.end()) {
+            // We found a cache entry for it, so it's either pybind-registered or has pre-computed
+            // pybind bases, but we have to make sure we haven't already seen the type(s) before: we
+            // want to follow Python/virtual C++ rules that there should only be one instance of a
+            // common base.
+            for (auto *tinfo : it->second) {
+                // NB: Could use a second set here, rather than doing a linear search, but since
+                // having a large number of immediate pybind11-registered types seems fairly
+                // unlikely, that probably isn't worthwhile.
+                bool found = false;
+                for (auto *known : bases) {
+                    if (known == tinfo) { found = true; break; }
+                }
+                if (!found) bases.push_back(tinfo);
+            }
+        }
+        else if (type->tp_bases) {
+            // It's some python type, so keep follow its bases classes to look for one or more
+            // registered types
+            if (i + 1 == check.size()) {
+                // When we're at the end, we can pop off the current element to avoid growing
+                // `check` when adding just one base (which is typical--i.e. when there is no
+                // multiple inheritance)
+                check.pop_back();
+                i--;
+            }
+            for (handle parent : reinterpret_borrow<tuple>(type->tp_bases))
+                check.push_back((PyTypeObject *) parent.ptr());
+        }
+    }
+}
+
+/**
+ * Extracts vector of type_info pointers of pybind-registered roots of the given Python type.  Will
+ * be just 1 pybind type for the Python type of a pybind-registered class, or for any Python-side
+ * derived class that uses single inheritance.  Will contain as many types as required for a Python
+ * class that uses multiple inheritance to inherit (directly or indirectly) from multiple
+ * pybind-registered classes.  Will be empty if neither the type nor any base classes are
+ * pybind-registered.
+ *
+ * The value is cached for the lifetime of the Python type.
+ */
+inline const std::vector<detail::type_info *> &all_type_info(PyTypeObject *type) {
+    auto ins = all_type_info_get_cache(type);
+    if (ins.second)
+        // New cache entry: populate it
+        all_type_info_populate(type, ins.first->second);
+
+    return ins.first->second;
+}
+
+/**
+ * Gets a single pybind11 type info for a python type.  Returns nullptr if neither the type nor any
+ * ancestors are pybind11-registered.  Throws an exception if there are multiple bases--use
+ * `all_type_info` instead if you want to support multiple bases.
+ */
+PYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type) {
+    auto &bases = all_type_info(type);
+    if (bases.empty())
+        return nullptr;
+    if (bases.size() > 1)
+        pybind11_fail("pybind11::detail::get_type_info: type has multiple pybind11-registered bases");
+    return bases.front();
+}
+
+inline detail::type_info *get_local_type_info(const std::type_index &tp) {
+    auto &locals = registered_local_types_cpp();
+    auto it = locals.find(tp);
+    if (it != locals.end())
+        return it->second;
+    return nullptr;
+}
+
+inline detail::type_info *get_global_type_info(const std::type_index &tp) {
+    auto &types = get_internals().registered_types_cpp;
+    auto it = types.find(tp);
+    if (it != types.end())
+        return it->second;
+    return nullptr;
+}
+
+/// Return the type info for a given C++ type; on lookup failure can either throw or return nullptr.
+PYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_index &tp,
+                                                          bool throw_if_missing = false) {
+    if (auto ltype = get_local_type_info(tp))
+        return ltype;
+    if (auto gtype = get_global_type_info(tp))
+        return gtype;
+
+    if (throw_if_missing) {
+        std::string tname = tp.name();
+        detail::clean_type_id(tname);
+        pybind11_fail("pybind11::detail::get_type_info: unable to find type info for \"" + tname + "\"");
+    }
+    return nullptr;
+}
+
+PYBIND11_NOINLINE inline handle get_type_handle(const std::type_info &tp, bool throw_if_missing) {
+    detail::type_info *type_info = get_type_info(tp, throw_if_missing);
+    return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
+}
+
+// Searches the inheritance graph for a registered Python instance, using all_type_info().
+PYBIND11_NOINLINE inline handle find_registered_python_instance(void *src,
+                                                                const detail::type_info *tinfo) {
+    auto it_instances = get_internals().registered_instances.equal_range(src);
+    for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
+        for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
+            if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
+                return handle((PyObject *) it_i->second).inc_ref();
+        }
+    }
+    return handle();
+}
+
+struct value_and_holder {
+    instance *inst = nullptr;
+    size_t index = 0u;
+    const detail::type_info *type = nullptr;
+    void **vh = nullptr;
+
+    // Main constructor for a found value/holder:
+    value_and_holder(instance *i, const detail::type_info *type, size_t vpos, size_t index) :
+        inst{i}, index{index}, type{type},
+        vh{inst->simple_layout ? inst->simple_value_holder : &inst->nonsimple.values_and_holders[vpos]}
+    {}
+
+    // Default constructor (used to signal a value-and-holder not found by get_value_and_holder())
+    value_and_holder() = default;
+
+    // Used for past-the-end iterator
+    value_and_holder(size_t index) : index{index} {}
+
+    template <typename V = void> V *&value_ptr() const {
+        return reinterpret_cast<V *&>(vh[0]);
+    }
+    // True if this `value_and_holder` has a non-null value pointer
+    explicit operator bool() const { return value_ptr(); }
+
+    template <typename H> H &holder() const {
+        return reinterpret_cast<H &>(vh[1]);
+    }
+    bool holder_constructed() const {
+        return inst->simple_layout
+            ? inst->simple_holder_constructed
+            : inst->nonsimple.status[index] & instance::status_holder_constructed;
+    }
+    void set_holder_constructed(bool v = true) {
+        if (inst->simple_layout)
+            inst->simple_holder_constructed = v;
+        else if (v)
+            inst->nonsimple.status[index] |= instance::status_holder_constructed;
+        else
+            inst->nonsimple.status[index] &= (uint8_t) ~instance::status_holder_constructed;
+    }
+    bool instance_registered() const {
+        return inst->simple_layout
+            ? inst->simple_instance_registered
+            : inst->nonsimple.status[index] & instance::status_instance_registered;
+    }
+    void set_instance_registered(bool v = true) {
+        if (inst->simple_layout)
+            inst->simple_instance_registered = v;
+        else if (v)
+            inst->nonsimple.status[index] |= instance::status_instance_registered;
+        else
+            inst->nonsimple.status[index] &= (uint8_t) ~instance::status_instance_registered;
+    }
+};
+
+// Container for accessing and iterating over an instance's values/holders
+struct values_and_holders {
+private:
+    instance *inst;
+    using type_vec = std::vector<detail::type_info *>;
+    const type_vec &tinfo;
+
+public:
+    values_and_holders(instance *inst) : inst{inst}, tinfo(all_type_info(Py_TYPE(inst))) {}
+
+    struct iterator {
+    private:
+        instance *inst = nullptr;
+        const type_vec *types = nullptr;
+        value_and_holder curr;
+        friend struct values_and_holders;
+        iterator(instance *inst, const type_vec *tinfo)
+            : inst{inst}, types{tinfo},
+            curr(inst /* instance */,
+                 types->empty() ? nullptr : (*types)[0] /* type info */,
+                 0, /* vpos: (non-simple types only): the first vptr comes first */
+                 0 /* index */)
+        {}
+        // Past-the-end iterator:
+        iterator(size_t end) : curr(end) {}
+    public:
+        bool operator==(const iterator &other) const { return curr.index == other.curr.index; }
+        bool operator!=(const iterator &other) const { return curr.index != other.curr.index; }
+        iterator &operator++() {
+            if (!inst->simple_layout)
+                curr.vh += 1 + (*types)[curr.index]->holder_size_in_ptrs;
+            ++curr.index;
+            curr.type = curr.index < types->size() ? (*types)[curr.index] : nullptr;
+            return *this;
+        }
+        value_and_holder &operator*() { return curr; }
+        value_and_holder *operator->() { return &curr; }
+    };
+
+    iterator begin() { return iterator(inst, &tinfo); }
+    iterator end() { return iterator(tinfo.size()); }
+
+    iterator find(const type_info *find_type) {
+        auto it = begin(), endit = end();
+        while (it != endit && it->type != find_type) ++it;
+        return it;
+    }
+
+    size_t size() { return tinfo.size(); }
+};
+
+/**
+ * Extracts C++ value and holder pointer references from an instance (which may contain multiple
+ * values/holders for python-side multiple inheritance) that match the given type.  Throws an error
+ * if the given type (or ValueType, if omitted) is not a pybind11 base of the given instance.  If
+ * `find_type` is omitted (or explicitly specified as nullptr) the first value/holder are returned,
+ * regardless of type (and the resulting .type will be nullptr).
+ *
+ * The returned object should be short-lived: in particular, it must not outlive the called-upon
+ * instance.
+ */
+PYBIND11_NOINLINE inline value_and_holder instance::get_value_and_holder(const type_info *find_type /*= nullptr default in common.h*/, bool throw_if_missing /*= true in common.h*/) {
+    // Optimize common case:
+    if (!find_type || Py_TYPE(this) == find_type->type)
+        return value_and_holder(this, find_type, 0, 0);
+
+    detail::values_and_holders vhs(this);
+    auto it = vhs.find(find_type);
+    if (it != vhs.end())
+        return *it;
+
+    if (!throw_if_missing)
+        return value_and_holder();
+
+#if defined(NDEBUG)
+    pybind11_fail("pybind11::detail::instance::get_value_and_holder: "
+            "type is not a pybind11 base of the given instance "
+            "(compile in debug mode for type details)");
+#else
+    pybind11_fail("pybind11::detail::instance::get_value_and_holder: `" +
+            get_fully_qualified_tp_name(find_type->type) + "' is not a pybind11 base of the given `" +
+            get_fully_qualified_tp_name(Py_TYPE(this)) + "' instance");
+#endif
+}
+
+PYBIND11_NOINLINE inline void instance::allocate_layout() {
+    auto &tinfo = all_type_info(Py_TYPE(this));
+
+    const size_t n_types = tinfo.size();
+
+    if (n_types == 0)
+        pybind11_fail("instance allocation failed: new instance has no pybind11-registered base types");
+
+    simple_layout =
+        n_types == 1 && tinfo.front()->holder_size_in_ptrs <= instance_simple_holder_in_ptrs();
+
+    // Simple path: no python-side multiple inheritance, and a small-enough holder
+    if (simple_layout) {
+        simple_value_holder[0] = nullptr;
+        simple_holder_constructed = false;
+        simple_instance_registered = false;
+    }
+    else { // multiple base types or a too-large holder
+        // Allocate space to hold: [v1*][h1][v2*][h2]...[bb...] where [vN*] is a value pointer,
+        // [hN] is the (uninitialized) holder instance for value N, and [bb...] is a set of bool
+        // values that tracks whether each associated holder has been initialized.  Each [block] is
+        // padded, if necessary, to an integer multiple of sizeof(void *).
+        size_t space = 0;
+        for (auto t : tinfo) {
+            space += 1; // value pointer
+            space += t->holder_size_in_ptrs; // holder instance
+        }
+        size_t flags_at = space;
+        space += size_in_ptrs(n_types); // status bytes (holder_constructed and instance_registered)
+
+        // Allocate space for flags, values, and holders, and initialize it to 0 (flags and values,
+        // in particular, need to be 0).  Use Python's memory allocation functions: in Python 3.6
+        // they default to using pymalloc, which is designed to be efficient for small allocations
+        // like the one we're doing here; in earlier versions (and for larger allocations) they are
+        // just wrappers around malloc.
+#if PY_VERSION_HEX >= 0x03050000
+        nonsimple.values_and_holders = (void **) PyMem_Calloc(space, sizeof(void *));
+        if (!nonsimple.values_and_holders) throw std::bad_alloc();
+#else
+        nonsimple.values_and_holders = (void **) PyMem_New(void *, space);
+        if (!nonsimple.values_and_holders) throw std::bad_alloc();
+        std::memset(nonsimple.values_and_holders, 0, space * sizeof(void *));
+#endif
+        nonsimple.status = reinterpret_cast<uint8_t *>(&nonsimple.values_and_holders[flags_at]);
+    }
+    owned = true;
+}
+
+PYBIND11_NOINLINE inline void instance::deallocate_layout() {
+    if (!simple_layout)
+        PyMem_Free(nonsimple.values_and_holders);
+}
+
+PYBIND11_NOINLINE inline bool isinstance_generic(handle obj, const std::type_info &tp) {
+    handle type = detail::get_type_handle(tp, false);
+    if (!type)
+        return false;
+    return isinstance(obj, type);
+}
+
+PYBIND11_NOINLINE inline std::string error_string() {
+    if (!PyErr_Occurred()) {
+        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);
+
+#if PY_MAJOR_VERSION >= 3
+    if (scope.trace != nullptr)
+        PyException_SetTraceback(scope.value, scope.trace);
+#endif
+
+#if !defined(PYPY_VERSION)
+    if (scope.trace) {
+        auto *trace = (PyTracebackObject *) scope.trace;
+
+        /* Get the deepest trace possible */
+        while (trace->tb_next)
+            trace = trace->tb_next;
+
+        PyFrameObject *frame = trace->tb_frame;
+        errorString += "\n\nAt:\n";
+        while (frame) {
+            int lineno = PyFrame_GetLineNumber(frame);
+            errorString +=
+                "  " + handle(frame->f_code->co_filename).cast<std::string>() +
+                "(" + std::to_string(lineno) + "): " +
+                handle(frame->f_code->co_name).cast<std::string>() + "\n";
+            frame = frame->f_back;
+        }
+    }
+#endif
+
+    return errorString;
+}
+
+PYBIND11_NOINLINE inline handle get_object_handle(const void *ptr, const detail::type_info *type ) {
+    auto &instances = get_internals().registered_instances;
+    auto range = instances.equal_range(ptr);
+    for (auto it = range.first; it != range.second; ++it) {
+        for (const auto &vh : values_and_holders(it->second)) {
+            if (vh.type == type)
+                return handle((PyObject *) it->second);
+        }
+    }
+    return handle();
+}
+
+inline PyThreadState *get_thread_state_unchecked() {
+#if defined(PYPY_VERSION)
+    return PyThreadState_GET();
+#elif PY_VERSION_HEX < 0x03000000
+    return _PyThreadState_Current;
+#elif PY_VERSION_HEX < 0x03050000
+    return (PyThreadState*) _Py_atomic_load_relaxed(&_PyThreadState_Current);
+#elif PY_VERSION_HEX < 0x03050200
+    return (PyThreadState*) _PyThreadState_Current.value;
+#else
+    return _PyThreadState_UncheckedGet();
+#endif
+}
+
+// Forward declarations
+inline void keep_alive_impl(handle nurse, handle patient);
+inline PyObject *make_new_instance(PyTypeObject *type);
+
+class type_caster_generic {
+public:
+    PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info)
+        : typeinfo(get_type_info(type_info)), cpptype(&type_info) { }
+
+    type_caster_generic(const type_info *typeinfo)
+        : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { }
+
+    bool load(handle src, bool convert) {
+        return load_impl<type_caster_generic>(src, convert);
+    }
+
+    PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
+                                         const detail::type_info *tinfo,
+                                         void *(*copy_constructor)(const void *),
+                                         void *(*move_constructor)(const void *),
+                                         const void *existing_holder = nullptr) {
+        if (!tinfo) // no type info: error will be set already
+            return handle();
+
+        void *src = const_cast<void *>(_src);
+        if (src == nullptr)
+            return none().release();
+
+        if (handle registered_inst = find_registered_python_instance(src, tinfo))
+            return registered_inst;
+
+        auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto wrapper = reinterpret_cast<instance *>(inst.ptr());
+        wrapper->owned = false;
+        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
+
+        switch (policy) {
+            case return_value_policy::automatic:
+            case return_value_policy::take_ownership:
+                valueptr = src;
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::automatic_reference:
+            case return_value_policy::reference:
+                valueptr = src;
+                wrapper->owned = false;
+                break;
+
+            case return_value_policy::copy:
+                if (copy_constructor)
+                    valueptr = copy_constructor(src);
+                else {
+#if defined(NDEBUG)
+                    throw cast_error("return_value_policy = copy, but type is "
+                                     "non-copyable! (compile in debug mode for details)");
+#else
+                    std::string type_name(tinfo->cpptype->name());
+                    detail::clean_type_id(type_name);
+                    throw cast_error("return_value_policy = copy, but type " +
+                                     type_name + " is non-copyable!");
+#endif
+                }
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::move:
+                if (move_constructor)
+                    valueptr = move_constructor(src);
+                else if (copy_constructor)
+                    valueptr = copy_constructor(src);
+                else {
+#if defined(NDEBUG)
+                    throw cast_error("return_value_policy = move, but type is neither "
+                                     "movable nor copyable! "
+                                     "(compile in debug mode for details)");
+#else
+                    std::string type_name(tinfo->cpptype->name());
+                    detail::clean_type_id(type_name);
+                    throw cast_error("return_value_policy = move, but type " +
+                                     type_name + " is neither movable nor copyable!");
+#endif
+                }
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::reference_internal:
+                valueptr = src;
+                wrapper->owned = false;
+                keep_alive_impl(inst, parent);
+                break;
+
+            default:
+                throw cast_error("unhandled return_value_policy: should not happen!");
+        }
+
+        tinfo->init_instance(wrapper, existing_holder);
+
+        return inst.release();
+    }
+
+    // Base methods for generic caster; there are overridden in copyable_holder_caster
+    void load_value(value_and_holder &&v_h) {
+        auto *&vptr = v_h.value_ptr();
+        // Lazy allocation for unallocated values:
+        if (vptr == nullptr) {
+            auto *type = v_h.type ? v_h.type : typeinfo;
+            if (type->operator_new) {
+                vptr = type->operator_new(type->type_size);
+            } else {
+                #if defined(__cpp_aligned_new) && (!defined(_MSC_VER) || _MSC_VER >= 1912)
+                    if (type->type_align > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
+                        vptr = ::operator new(type->type_size,
+                                              std::align_val_t(type->type_align));
+                    else
+                #endif
+                vptr = ::operator new(type->type_size);
+            }
+        }
+        value = vptr;
+    }
+    bool try_implicit_casts(handle src, bool convert) {
+        for (auto &cast : typeinfo->implicit_casts) {
+            type_caster_generic sub_caster(*cast.first);
+            if (sub_caster.load(src, convert)) {
+                value = cast.second(sub_caster.value);
+                return true;
+            }
+        }
+        return false;
+    }
+    bool try_direct_conversions(handle src) {
+        for (auto &converter : *typeinfo->direct_conversions) {
+            if (converter(src.ptr(), value))
+                return true;
+        }
+        return false;
+    }
+    void check_holder_compat() {}
+
+    PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
+        auto caster = type_caster_generic(ti);
+        if (caster.load(src, false))
+            return caster.value;
+        return nullptr;
+    }
+
+    /// Try to load with foreign typeinfo, if available. Used when there is no
+    /// native typeinfo, or when the native one wasn't able to produce a value.
+    PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) {
+        constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
+        const auto pytype = type::handle_of(src);
+        if (!hasattr(pytype, local_key))
+            return false;
+
+        type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key));
+        // Only consider this foreign loader if actually foreign and is a loader of the correct cpp type
+        if (foreign_typeinfo->module_local_load == &local_load
+            || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype)))
+            return false;
+
+        if (auto result = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo)) {
+            value = result;
+            return true;
+        }
+        return false;
+    }
+
+    // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
+    // bits of code between here and copyable_holder_caster where the two classes need different
+    // logic (without having to resort to virtual inheritance).
+    template <typename ThisT>
+    PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
+        if (!src) return false;
+        if (!typeinfo) return try_load_foreign_module_local(src);
+        if (src.is_none()) {
+            // Defer accepting None to other overloads (if we aren't in convert mode):
+            if (!convert) return false;
+            value = nullptr;
+            return true;
+        }
+
+        auto &this_ = static_cast<ThisT &>(*this);
+        this_.check_holder_compat();
+
+        PyTypeObject *srctype = Py_TYPE(src.ptr());
+
+        // Case 1: If src is an exact type match for the target type then we can reinterpret_cast
+        // the instance's value pointer to the target type:
+        if (srctype == typeinfo->type) {
+            this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
+            return true;
+        }
+        // Case 2: We have a derived class
+        else if (PyType_IsSubtype(srctype, typeinfo->type)) {
+            auto &bases = all_type_info(srctype);
+            bool no_cpp_mi = typeinfo->simple_type;
+
+            // Case 2a: the python type is a Python-inherited derived class that inherits from just
+            // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of
+            // the right type and we can use reinterpret_cast.
+            // (This is essentially the same as case 2b, but because not using multiple inheritance
+            // is extremely common, we handle it specially to avoid the loop iterator and type
+            // pointer lookup overhead)
+            if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
+                this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
+                return true;
+            }
+            // Case 2b: the python type inherits from multiple C++ bases.  Check the bases to see if
+            // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we
+            // can safely reinterpret_cast to the relevant pointer.
+            else if (bases.size() > 1) {
+                for (auto base : bases) {
+                    if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
+                        this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
+                        return true;
+                    }
+                }
+            }
+
+            // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match
+            // in the registered bases, above, so try implicit casting (needed for proper C++ casting
+            // when MI is involved).
+            if (this_.try_implicit_casts(src, convert))
+                return true;
+        }
+
+        // Perform an implicit conversion
+        if (convert) {
+            for (auto &converter : typeinfo->implicit_conversions) {
+                auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
+                if (load_impl<ThisT>(temp, false)) {
+                    loader_life_support::add_patient(temp);
+                    return true;
+                }
+            }
+            if (this_.try_direct_conversions(src))
+                return true;
+        }
+
+        // Failed to match local typeinfo. Try again with global.
+        if (typeinfo->module_local) {
+            if (auto gtype = get_global_type_info(*typeinfo->cpptype)) {
+                typeinfo = gtype;
+                return load(src, false);
+            }
+        }
+
+        // Global typeinfo has precedence over foreign module_local
+        return try_load_foreign_module_local(src);
+    }
+
+
+    // Called to do type lookup and wrap the pointer and type in a pair when a dynamic_cast
+    // isn't needed or can't be used.  If the type is unknown, sets the error and returns a pair
+    // with .second = nullptr.  (p.first = nullptr is not an error: it becomes None).
+    PYBIND11_NOINLINE static std::pair<const void *, const type_info *> src_and_type(
+            const void *src, const std::type_info &cast_type, const std::type_info *rtti_type = nullptr) {
+        if (auto *tpi = get_type_info(cast_type))
+            return {src, const_cast<const type_info *>(tpi)};
+
+        // Not found, set error:
+        std::string tname = rtti_type ? rtti_type->name() : cast_type.name();
+        detail::clean_type_id(tname);
+        std::string msg = "Unregistered type : " + tname;
+        PyErr_SetString(PyExc_TypeError, msg.c_str());
+        return {nullptr, nullptr};
+    }
+
+    const type_info *typeinfo = nullptr;
+    const std::type_info *cpptype = nullptr;
+    void *value = nullptr;
+};
+
+/**
+ * Determine suitable casting operator for pointer-or-lvalue-casting type casters.  The type caster
+ * needs to provide `operator T*()` and `operator T&()` operators.
+ *
+ * If the type supports moving the value away via an `operator T&&() &&` method, it should use
+ * `movable_cast_op_type` instead.
+ */
+template <typename T>
+using cast_op_type =
+    conditional_t<std::is_pointer<remove_reference_t<T>>::value,
+        typename std::add_pointer<intrinsic_t<T>>::type,
+        typename std::add_lvalue_reference<intrinsic_t<T>>::type>;
+
+/**
+ * Determine suitable casting operator for a type caster with a movable value.  Such a type caster
+ * needs to provide `operator T*()`, `operator T&()`, and `operator T&&() &&`.  The latter will be
+ * called in appropriate contexts where the value can be moved rather than copied.
+ *
+ * These operator are automatically provided when using the PYBIND11_TYPE_CASTER macro.
+ */
+template <typename T>
+using movable_cast_op_type =
+    conditional_t<std::is_pointer<typename std::remove_reference<T>::type>::value,
+        typename std::add_pointer<intrinsic_t<T>>::type,
+    conditional_t<std::is_rvalue_reference<T>::value,
+        typename std::add_rvalue_reference<intrinsic_t<T>>::type,
+        typename std::add_lvalue_reference<intrinsic_t<T>>::type>>;
+
+// std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when
+// T is non-copyable, but code containing such a copy constructor fails to actually compile.
+template <typename T, typename SFINAE = void> struct is_copy_constructible : std::is_copy_constructible<T> {};
+
+// Specialization for types that appear to be copy constructible but also look like stl containers
+// (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
+// so, copy constructability depends on whether the value_type is copy constructible.
+template <typename Container> struct is_copy_constructible<Container, enable_if_t<all_of<
+        std::is_copy_constructible<Container>,
+        std::is_same<typename Container::value_type &, typename Container::reference>,
+        // Avoid infinite recursion
+        negation<std::is_same<Container, typename Container::value_type>>
+    >::value>> : is_copy_constructible<typename Container::value_type> {};
+
+// Likewise for std::pair
+// (after C++17 it is mandatory that the copy constructor not exist when the two types aren't themselves
+// copy constructible, but this can not be relied upon when T1 or T2 are themselves containers).
+template <typename T1, typename T2> struct is_copy_constructible<std::pair<T1, T2>>
+    : all_of<is_copy_constructible<T1>, is_copy_constructible<T2>> {};
+
+// The same problems arise with std::is_copy_assignable, so we use the same workaround.
+template <typename T, typename SFINAE = void> struct is_copy_assignable : std::is_copy_assignable<T> {};
+template <typename Container> struct is_copy_assignable<Container, enable_if_t<all_of<
+        std::is_copy_assignable<Container>,
+        std::is_same<typename Container::value_type &, typename Container::reference>
+    >::value>> : is_copy_assignable<typename Container::value_type> {};
+template <typename T1, typename T2> struct is_copy_assignable<std::pair<T1, T2>>
+    : all_of<is_copy_assignable<T1>, is_copy_assignable<T2>> {};
+
+// Helper for type_caster_base.
+struct make_constructor {
+    using Constructor = void *(*)(const void *);
+
+    /* Only enabled when the types are {copy,move}-constructible *and* when the type
+       does not have a private operator new implementation. */
+    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
+    static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
+        return [](const void *arg) -> void * {
+            return new T(*reinterpret_cast<const T *>(arg));
+        };
+    }
+
+    template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
+    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
+        return [](const void *arg) -> void * {
+            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
+        };
+    }
+
+    static Constructor make_copy_constructor(...) { return nullptr; }
+    static Constructor make_move_constructor(...) { return nullptr; }
+};
+
+PYBIND11_NAMESPACE_END(detail)
+
+// polymorphic_type_hook<itype>::get(src, tinfo) determines whether the object pointed
+// to by `src` actually is an instance of some class derived from `itype`.
+// If so, it sets `tinfo` to point to the std::type_info representing that derived
+// type, and returns a pointer to the start of the most-derived object of that type
+// (in which `src` is a subobject; this will be the same address as `src` in most
+// single inheritance cases). If not, or if `src` is nullptr, it simply returns `src`
+// and leaves `tinfo` at its default value of nullptr.
+//
+// The default polymorphic_type_hook just returns src. A specialization for polymorphic
+// types determines the runtime type of the passed object and adjusts the this-pointer
+// appropriately via dynamic_cast<void*>. This is what enables a C++ Animal* to appear
+// to Python as a Dog (if Dog inherits from Animal, Animal is polymorphic, Dog is
+// registered with pybind11, and this Animal is in fact a Dog).
+//
+// You may specialize polymorphic_type_hook yourself for types that want to appear
+// polymorphic to Python but do not use C++ RTTI. (This is a not uncommon pattern
+// in performance-sensitive applications, used most notably in LLVM.)
+//
+// polymorphic_type_hook_base allows users to specialize polymorphic_type_hook with
+// std::enable_if. User provided specializations will always have higher priority than
+// the default implementation and specialization provided in polymorphic_type_hook_base.
+template <typename itype, typename SFINAE = void>
+struct polymorphic_type_hook_base
+{
+    static const void *get(const itype *src, const std::type_info*&) { return src; }
+};
+template <typename itype>
+struct polymorphic_type_hook_base<itype, detail::enable_if_t<std::is_polymorphic<itype>::value>>
+{
+    static const void *get(const itype *src, const std::type_info*& type) {
+        type = src ? &typeid(*src) : nullptr;
+        return dynamic_cast<const void*>(src);
+    }
+};
+template <typename itype, typename SFINAE = void>
+struct polymorphic_type_hook : public polymorphic_type_hook_base<itype> {};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+/// Generic type caster for objects stored on the heap
+template <typename type> class type_caster_base : public type_caster_generic,
+                                                  protected make_constructor {
+    using itype = intrinsic_t<type>;
+
+public:
+    static constexpr auto name = _<type>();
+
+    type_caster_base() : type_caster_base(typeid(type)) { }
+    explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) { }
+
+    static handle cast(const itype &src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
+            policy = return_value_policy::copy;
+        return cast(&src, policy, parent);
+    }
+
+    static handle cast(itype &&src, return_value_policy, handle parent) {
+        return cast(&src, return_value_policy::move, parent);
+    }
+
+    // Returns a (pointer, type_info) pair taking care of necessary type lookup for a
+    // polymorphic type (using RTTI by default, but can be overridden by specializing
+    // polymorphic_type_hook). If the instance isn't derived, returns the base version.
+    static std::pair<const void *, const type_info *> src_and_type(const itype *src) {
+        auto &cast_type = typeid(itype);
+        const std::type_info *instance_type = nullptr;
+        const void *vsrc = polymorphic_type_hook<itype>::get(src, instance_type);
+        if (instance_type && !same_type(cast_type, *instance_type)) {
+            // This is a base pointer to a derived type. If the derived type is registered
+            // with pybind11, we want to make the full derived object available.
+            // In the typical case where itype is polymorphic, we get the correct
+            // derived pointer (which may be != base pointer) by a dynamic_cast to
+            // most derived type. If itype is not polymorphic, we won't get here
+            // except via a user-provided specialization of polymorphic_type_hook,
+            // and the user has promised that no this-pointer adjustment is
+            // required in that case, so it's OK to use static_cast.
+            if (const auto *tpi = get_type_info(*instance_type))
+                return {vsrc, tpi};
+        }
+        // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer, so
+        // don't do a cast
+        return type_caster_generic::src_and_type(src, cast_type, instance_type);
+    }
+
+    static handle cast(const itype *src, return_value_policy policy, handle parent) {
+        auto st = src_and_type(src);
+        return type_caster_generic::cast(
+            st.first, policy, parent, st.second,
+            make_copy_constructor(src), make_move_constructor(src));
+    }
+
+    static handle cast_holder(const itype *src, const void *holder) {
+        auto st = src_and_type(src);
+        return type_caster_generic::cast(
+            st.first, return_value_policy::take_ownership, {}, st.second,
+            nullptr, nullptr, holder);
+    }
+
+    template <typename T> using cast_op_type = detail::cast_op_type<T>;
+
+    operator itype*() { return (type *) value; }
+    operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
+};
+
 template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
 template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
 
diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index b5a9274fb5..e663df0558 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -123,8 +123,8 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
             policy,
             parent,
             st.second,
-            make_copy_constructor(src),
-            make_move_constructor(src));
+            make_constructor::make_copy_constructor(src),
+            make_constructor::make_move_constructor(src));
     }
 
     static handle cast(mpty *src, return_value_policy policy, handle parent) {
@@ -156,33 +156,6 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
 
     // clang-format on
 
-    // type_caster_base BEGIN
-    // clang-format off
-
-    using Constructor = void *(*)(const void *);
-
-    /* Only enabled when the types are {copy,move}-constructible *and* when the type
-       does not have a private operator new implementation. */
-    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
-    static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
-        return [](const void *arg) -> void * {
-            return new T(*reinterpret_cast<const T *>(arg));
-        };
-    }
-
-    template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
-    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
-        return [](const void *arg) -> void * {
-            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
-        };
-    }
-
-    static Constructor make_copy_constructor(...) { return nullptr; }
-    static Constructor make_move_constructor(...) { return nullptr; }
-
-    // clang-format on
-    // type_caster_base END
-
     // Originally type_caster_generic::cast.
     PYBIND11_NOINLINE static handle cast_const_raw_ptr(const void *_src,
                                                        return_value_policy policy,

From 47b0352d0519b32f4be70ccc4bfdf91faa8b26e1 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 15 Jan 2021 16:47:47 -0800
Subject: [PATCH 069/206] Inserting additional assert to ensure a returned
 unique_ptr is always a new Python instance.

---
 tests/test_classh_wip.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index 4f467b2bdb..172e1d6ffa 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -70,7 +70,13 @@ def test_pass_unique_ptr_disowns(pass_mpty, argm, rtrn):
 
 
 def test_unique_ptr_roundtrip(num_round_trips=1000):
+    # Multiple roundtrips to stress-test instance registration/deregistration.
     recycled = m.mpty("passenger")
     for _ in range(num_round_trips):
+        id_orig = id(recycled)
         recycled = m.unique_ptr_roundtrip(recycled)
         assert m.get_mtxt(recycled) == "passenger"
+        id_rtrn = id(recycled)
+        # Ensure the returned object is a different Python instance.
+        assert id_rtrn != id_orig
+        id_orig = id_rtrn

From d189fa3be36efc01852f15e62f6a0da664a0fab2 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 15 Jan 2021 16:52:09 -0800
Subject: [PATCH 070/206] Adding minor comment (change to internals needed to
 distinguish uninitialized/disowned in error message).

---
 tests/test_classh_wip.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index e663df0558..e905f7b863 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -64,7 +64,8 @@ struct smart_holder_type_caster_load {
         auto inst  = reinterpret_cast<instance *>(src.ptr());
         loaded_v_h = inst->get_value_and_holder(get_type_info(typeid(T)));
         if (!loaded_v_h.holder_constructed()) {
-            // IMPROVEABLE: Error message.
+            // IMPROVEABLE: Error message. A change to the existing internals is
+            // needed to cleanly distinguish between uninitialized or disowned.
             throw std::runtime_error("Missing value for wrapped C++ type:"
                                      " Python instance is uninitialized or was disowned.");
         }

From 5cbc40027dcd8b3b58f3fe2d3400564c635c15a5 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 16 Jan 2021 17:38:58 -0800
Subject: [PATCH 071/206] Factoring out find_existing_python_instance().

---
 tests/test_classh_wip.cpp | 51 +++++++++++++++++++--------------------
 1 file changed, 25 insertions(+), 26 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index e905f7b863..14913dca0a 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -54,6 +54,20 @@ namespace detail {
 
 using namespace pybind11_tests::classh_wip;
 
+inline std::pair<bool, handle> find_existing_python_instance(void *src_void_ptr,
+                                                             const detail::type_info *tinfo) {
+    // Loop copied from type_caster_generic::cast.
+    // IMPROVEABLE: Factor out of type_caster_generic::cast.
+    auto it_instances = get_internals().registered_instances.equal_range(src_void_ptr);
+    for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
+        for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
+            if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
+                return std::make_pair(true, handle((PyObject *) it_i->second).inc_ref());
+        }
+    }
+    return std::make_pair(false, handle());
+}
+
 template <typename T>
 struct smart_holder_type_caster_load {
     using holder_type = pybindit::memory::smart_holder;
@@ -172,13 +186,9 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
         if (src == nullptr)
             return none().release();
 
-        auto it_instances = get_internals().registered_instances.equal_range(src);
-        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
-            for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
-                if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
-                    return handle((PyObject *) it_i->second).inc_ref();
-            }
-        }
+        auto existing_inst = find_existing_python_instance(src, tinfo);
+        if (existing_inst.first)
+            return existing_inst.second;
 
         auto inst       = reinterpret_steal<object>(make_new_instance(tinfo->type));
         auto wrapper    = reinterpret_cast<instance *>(inst.ptr());
@@ -270,16 +280,11 @@ struct type_caster<std::shared_ptr<mpty>> : smart_holder_type_caster_load<mpty>
 
         void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
         const detail::type_info *tinfo = st.second;
-        auto it_instances = get_internals().registered_instances.equal_range(src_raw_void_ptr);
-        // Loop copied from type_caster_generic::cast.
-        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
-            for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
-                if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
-                    // MISSING: Enforcement of consistency with existing smart_holder.
-                    // MISSING: keep_alive.
-                    return handle((PyObject *) it_i->second).inc_ref();
-            }
-        }
+        auto existing_inst             = find_existing_python_instance(src_raw_void_ptr, tinfo);
+        if (existing_inst.first)
+            // MISSING: Enforcement of consistency with existing smart_holder.
+            // MISSING: keep_alive.
+            return existing_inst.second;
 
         object inst            = reinterpret_steal<object>(make_new_instance(tinfo->type));
         instance *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
@@ -338,15 +343,9 @@ struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty>
 
         void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
         const detail::type_info *tinfo = st.second;
-        auto it_instances = get_internals().registered_instances.equal_range(src_raw_void_ptr);
-        // Loop copied from type_caster_generic::cast.
-        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
-            for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
-                if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
-                    throw cast_error(
-                        "Invalid unique_ptr: another instance owns this pointer already.");
-            }
-        }
+        auto existing_inst             = find_existing_python_instance(src_raw_void_ptr, tinfo);
+        if (existing_inst.first)
+            throw cast_error("Invalid unique_ptr: another instance owns this pointer already.");
 
         object inst            = reinterpret_steal<object>(make_new_instance(tinfo->type));
         instance *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());

From 0d6bceb6d40f0a85a59ed499fb5c68c5a2adc6fa Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 17 Jan 2021 10:29:56 -0800
Subject: [PATCH 072/206] Moving factored-out make_constructor to
 test_classh_wip.cpp, restoring previous version of cast.h. This is currently
 the most practical approach. See PR #2798 for background.

---
 include/pybind11/cast.h   | 49 ++++++++++++++++++---------------------
 tests/test_classh_wip.cpp | 28 ++++++++++++++++++++++
 2 files changed, 51 insertions(+), 26 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index b28acb8a66..8fe3ad7abc 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -832,30 +832,6 @@ template <typename Container> struct is_copy_assignable<Container, enable_if_t<a
 template <typename T1, typename T2> struct is_copy_assignable<std::pair<T1, T2>>
     : all_of<is_copy_assignable<T1>, is_copy_assignable<T2>> {};
 
-// Helper for type_caster_base.
-struct make_constructor {
-    using Constructor = void *(*)(const void *);
-
-    /* Only enabled when the types are {copy,move}-constructible *and* when the type
-       does not have a private operator new implementation. */
-    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
-    static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
-        return [](const void *arg) -> void * {
-            return new T(*reinterpret_cast<const T *>(arg));
-        };
-    }
-
-    template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
-    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
-        return [](const void *arg) -> void * {
-            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
-        };
-    }
-
-    static Constructor make_copy_constructor(...) { return nullptr; }
-    static Constructor make_move_constructor(...) { return nullptr; }
-};
-
 PYBIND11_NAMESPACE_END(detail)
 
 // polymorphic_type_hook<itype>::get(src, tinfo) determines whether the object pointed
@@ -898,8 +874,7 @@ struct polymorphic_type_hook : public polymorphic_type_hook_base<itype> {};
 PYBIND11_NAMESPACE_BEGIN(detail)
 
 /// Generic type caster for objects stored on the heap
-template <typename type> class type_caster_base : public type_caster_generic,
-                                                  protected make_constructor {
+template <typename type> class type_caster_base : public type_caster_generic {
     using itype = intrinsic_t<type>;
 
 public:
@@ -960,6 +935,28 @@ template <typename type> class type_caster_base : public type_caster_generic,
 
     operator itype*() { return (type *) value; }
     operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
+
+protected:
+    using Constructor = void *(*)(const void *);
+
+    /* Only enabled when the types are {copy,move}-constructible *and* when the type
+       does not have a private operator new implementation. */
+    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
+    static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
+        return [](const void *arg) -> void * {
+            return new T(*reinterpret_cast<const T *>(arg));
+        };
+    }
+
+    template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
+    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
+        return [](const void *arg) -> void * {
+            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
+        };
+    }
+
+    static Constructor make_copy_constructor(...) { return nullptr; }
+    static Constructor make_move_constructor(...) { return nullptr; }
 };
 
 template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 14913dca0a..62e0b5d953 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -102,6 +102,34 @@ struct smart_holder_type_caster_load {
     holder_type *loaded_smhldr_ptr = nullptr;
 };
 
+// type_caster_base BEGIN
+// clang-format off
+// Helper factored out of type_caster_base.
+struct make_constructor {
+    using Constructor = void *(*)(const void *);
+
+    /* Only enabled when the types are {copy,move}-constructible *and* when the type
+       does not have a private operator new implementation. */
+    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
+    static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
+        return [](const void *arg) -> void * {
+            return new T(*reinterpret_cast<const T *>(arg));
+        };
+    }
+
+    template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
+    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
+        return [](const void *arg) -> void * {
+            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
+        };
+    }
+
+    static Constructor make_copy_constructor(...) { return nullptr; }
+    static Constructor make_move_constructor(...) { return nullptr; }
+};
+// clang-format on
+// type_caster_base END
+
 template <>
 struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     static constexpr auto name = _<mpty>();

From bd0c8fa96093676dd6d7d90fbd234d5b3ca36920 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 17 Jan 2021 12:11:59 -0800
Subject: [PATCH 073/206] Copying classh type_casters from test_classh_wip.cpp
 UNMODIFIED, as a baseline for generalizing the code.

---
 include/pybind11/detail/classh_type_casters.h | 367 ++++++++++++++++++
 1 file changed, 367 insertions(+)
 create mode 100644 include/pybind11/detail/classh_type_casters.h

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
new file mode 100644
index 0000000000..d26e0f1003
--- /dev/null
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -0,0 +1,367 @@
+namespace pybind11 {
+namespace detail {
+
+using namespace pybind11_tests::classh_wip;
+
+inline std::pair<bool, handle> find_existing_python_instance(void *src_void_ptr,
+                                                             const detail::type_info *tinfo) {
+    // Loop copied from type_caster_generic::cast.
+    // IMPROVEABLE: Factor out of type_caster_generic::cast.
+    auto it_instances = get_internals().registered_instances.equal_range(src_void_ptr);
+    for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
+        for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
+            if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
+                return std::make_pair(true, handle((PyObject *) it_i->second).inc_ref());
+        }
+    }
+    return std::make_pair(false, handle());
+}
+
+template <typename T>
+struct smart_holder_type_caster_load {
+    using holder_type = pybindit::memory::smart_holder;
+
+    bool load(handle src, bool /*convert*/) {
+        if (!isinstance<T>(src))
+            return false;
+        auto inst  = reinterpret_cast<instance *>(src.ptr());
+        loaded_v_h = inst->get_value_and_holder(get_type_info(typeid(T)));
+        if (!loaded_v_h.holder_constructed()) {
+            // IMPROVEABLE: Error message. A change to the existing internals is
+            // needed to cleanly distinguish between uninitialized or disowned.
+            throw std::runtime_error("Missing value for wrapped C++ type:"
+                                     " Python instance is uninitialized or was disowned.");
+        }
+        loaded_smhldr_ptr = &loaded_v_h.holder<holder_type>();
+        return true;
+    }
+
+    std::unique_ptr<T> loaded_as_unique_ptr() {
+        void *value_void_ptr = loaded_v_h.value_ptr();
+        auto unq_ptr         = loaded_smhldr_ptr->as_unique_ptr<mpty>();
+        loaded_v_h.holder<holder_type>().~holder_type();
+        loaded_v_h.set_holder_constructed(false);
+        loaded_v_h.value_ptr() = nullptr;
+        deregister_instance(loaded_v_h.inst, value_void_ptr, loaded_v_h.type);
+        return unq_ptr;
+    }
+
+protected:
+    value_and_holder loaded_v_h;
+    holder_type *loaded_smhldr_ptr = nullptr;
+};
+
+// type_caster_base BEGIN
+// clang-format off
+// Helper factored out of type_caster_base.
+struct make_constructor {
+    using Constructor = void *(*)(const void *);
+
+    /* Only enabled when the types are {copy,move}-constructible *and* when the type
+       does not have a private operator new implementation. */
+    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
+    static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
+        return [](const void *arg) -> void * {
+            return new T(*reinterpret_cast<const T *>(arg));
+        };
+    }
+
+    template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
+    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
+        return [](const void *arg) -> void * {
+            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
+        };
+    }
+
+    static Constructor make_copy_constructor(...) { return nullptr; }
+    static Constructor make_move_constructor(...) { return nullptr; }
+};
+// clang-format on
+// type_caster_base END
+
+template <>
+struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
+    static constexpr auto name = _<mpty>();
+
+    // static handle cast(mpty, ...)
+    // is redundant (leads to ambiguous overloads).
+
+    static handle cast(mpty &&src, return_value_policy /*policy*/, handle parent) {
+        // type_caster_base BEGIN
+        // clang-format off
+        return cast(&src, return_value_policy::move, parent);
+        // clang-format on
+        // type_caster_base END
+    }
+
+    static handle cast(mpty const &src, return_value_policy policy, handle parent) {
+        // type_caster_base BEGIN
+        // clang-format off
+        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
+            policy = return_value_policy::copy;
+        return cast(&src, policy, parent);
+        // clang-format on
+        // type_caster_base END
+    }
+
+    static handle cast(mpty &src, return_value_policy policy, handle parent) {
+        return cast(const_cast<mpty const &>(src), policy, parent); // Mutbl2Const
+    }
+
+    static handle cast(mpty const *src, return_value_policy policy, handle parent) {
+        auto st = type_caster_base<mpty>::src_and_type(src);
+        return cast_const_raw_ptr( // Originally type_caster_generic::cast.
+            st.first,
+            policy,
+            parent,
+            st.second,
+            make_constructor::make_copy_constructor(src),
+            make_constructor::make_move_constructor(src));
+    }
+
+    static handle cast(mpty *src, return_value_policy policy, handle parent) {
+        return cast(const_cast<mpty const *>(src), policy, parent); // Mutbl2Const
+    }
+
+    template <typename T_>
+    using cast_op_type = conditional_t<
+        std::is_same<remove_reference_t<T_>, mpty const *>::value,
+        mpty const *,
+        conditional_t<
+            std::is_same<remove_reference_t<T_>, mpty *>::value,
+            mpty *,
+            conditional_t<
+                std::is_same<T_, mpty const &>::value,
+                mpty const &,
+                conditional_t<std::is_same<T_, mpty &>::value,
+                              mpty &,
+                              conditional_t<std::is_same<T_, mpty &&>::value, mpty &&, mpty>>>>>;
+
+    // clang-format off
+
+    operator mpty()        { return loaded_smhldr_ptr->lvalue_ref<mpty>(); }
+    operator mpty&&() &&   { return loaded_smhldr_ptr->rvalue_ref<mpty>(); }
+    operator mpty const&() { return loaded_smhldr_ptr->lvalue_ref<mpty>(); }
+    operator mpty&()       { return loaded_smhldr_ptr->lvalue_ref<mpty>(); }
+    operator mpty const*() { return loaded_smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
+    operator mpty*()       { return loaded_smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
+
+    // clang-format on
+
+    // Originally type_caster_generic::cast.
+    PYBIND11_NOINLINE static handle cast_const_raw_ptr(const void *_src,
+                                                       return_value_policy policy,
+                                                       handle parent,
+                                                       const detail::type_info *tinfo,
+                                                       void *(*copy_constructor)(const void *),
+                                                       void *(*move_constructor)(const void *),
+                                                       const void *existing_holder = nullptr) {
+        if (!tinfo) // no type info: error will be set already
+            return handle();
+
+        void *src = const_cast<void *>(_src);
+        if (src == nullptr)
+            return none().release();
+
+        auto existing_inst = find_existing_python_instance(src, tinfo);
+        if (existing_inst.first)
+            return existing_inst.second;
+
+        auto inst       = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto wrapper    = reinterpret_cast<instance *>(inst.ptr());
+        wrapper->owned  = false;
+        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
+
+        switch (policy) {
+            case return_value_policy::automatic:
+            case return_value_policy::take_ownership:
+                valueptr       = src;
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::automatic_reference:
+            case return_value_policy::reference:
+                valueptr       = src;
+                wrapper->owned = false;
+                break;
+
+            case return_value_policy::copy:
+                if (copy_constructor)
+                    valueptr = copy_constructor(src);
+                else {
+#if defined(NDEBUG)
+                    throw cast_error("return_value_policy = copy, but type is "
+                                     "non-copyable! (compile in debug mode for details)");
+#else
+                    std::string type_name(tinfo->cpptype->name());
+                    detail::clean_type_id(type_name);
+                    throw cast_error("return_value_policy = copy, but type " + type_name
+                                     + " is non-copyable!");
+#endif
+                }
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::move:
+                if (move_constructor)
+                    valueptr = move_constructor(src);
+                else if (copy_constructor)
+                    valueptr = copy_constructor(src);
+                else {
+#if defined(NDEBUG)
+                    throw cast_error("return_value_policy = move, but type is neither "
+                                     "movable nor copyable! "
+                                     "(compile in debug mode for details)");
+#else
+                    std::string type_name(tinfo->cpptype->name());
+                    detail::clean_type_id(type_name);
+                    throw cast_error("return_value_policy = move, but type " + type_name
+                                     + " is neither movable nor copyable!");
+#endif
+                }
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::reference_internal:
+                valueptr       = src;
+                wrapper->owned = false;
+                keep_alive_impl(inst, parent);
+                break;
+
+            default:
+                throw cast_error("unhandled return_value_policy: should not happen!");
+        }
+
+        tinfo->init_instance(wrapper, existing_holder);
+
+        return inst.release();
+    }
+};
+
+template <>
+struct type_caster<std::shared_ptr<mpty>> : smart_holder_type_caster_load<mpty> {
+    static constexpr auto name = _<std::shared_ptr<mpty>>();
+
+    static handle
+    cast(const std::shared_ptr<mpty> &src, return_value_policy policy, handle parent) {
+        if (policy != return_value_policy::automatic
+            && policy != return_value_policy::reference_internal) {
+            // IMPROVEABLE: Error message.
+            throw cast_error("Invalid return_value_policy for shared_ptr.");
+        }
+
+        auto src_raw_ptr = src.get();
+        auto st          = type_caster_base<mpty>::src_and_type(src_raw_ptr);
+        if (st.first == nullptr)
+            return none().release(); // PyErr was set already.
+
+        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
+        const detail::type_info *tinfo = st.second;
+        auto existing_inst             = find_existing_python_instance(src_raw_void_ptr, tinfo);
+        if (existing_inst.first)
+            // MISSING: Enforcement of consistency with existing smart_holder.
+            // MISSING: keep_alive.
+            return existing_inst.second;
+
+        object inst            = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        instance *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
+        inst_raw_ptr->owned    = true;
+        void *&valueptr        = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+        valueptr               = src_raw_void_ptr;
+
+        auto smhldr = pybindit::memory::smart_holder::from_shared_ptr(src);
+        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
+
+        if (policy == return_value_policy::reference_internal)
+            keep_alive_impl(inst, parent);
+
+        return inst.release();
+    }
+
+    template <typename>
+    using cast_op_type = std::shared_ptr<mpty>;
+
+    operator std::shared_ptr<mpty>() { return loaded_smhldr_ptr->as_shared_ptr<mpty>(); }
+};
+
+template <>
+struct type_caster<std::shared_ptr<mpty const>> : smart_holder_type_caster_load<mpty> {
+    static constexpr auto name = _<std::shared_ptr<mpty const>>();
+
+    static handle
+    cast(const std::shared_ptr<mpty const> &src, return_value_policy policy, handle parent) {
+        return type_caster<std::shared_ptr<mpty>>::cast(
+            std::const_pointer_cast<mpty>(src), // Const2Mutbl
+            policy,
+            parent);
+    }
+
+    template <typename>
+    using cast_op_type = std::shared_ptr<mpty const>;
+
+    operator std::shared_ptr<mpty const>() { return loaded_smhldr_ptr->as_shared_ptr<mpty>(); }
+};
+
+template <>
+struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty> {
+    static constexpr auto name = _<std::unique_ptr<mpty>>();
+
+    static handle cast(std::unique_ptr<mpty> &&src, return_value_policy policy, handle parent) {
+        if (policy != return_value_policy::automatic
+            && policy != return_value_policy::reference_internal) {
+            // IMPROVEABLE: Error message.
+            throw cast_error("Invalid return_value_policy for unique_ptr.");
+        }
+
+        auto src_raw_ptr = src.get();
+        auto st          = type_caster_base<mpty>::src_and_type(src_raw_ptr);
+        if (st.first == nullptr)
+            return none().release(); // PyErr was set already.
+
+        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
+        const detail::type_info *tinfo = st.second;
+        auto existing_inst             = find_existing_python_instance(src_raw_void_ptr, tinfo);
+        if (existing_inst.first)
+            throw cast_error("Invalid unique_ptr: another instance owns this pointer already.");
+
+        object inst            = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        instance *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
+        inst_raw_ptr->owned    = true;
+        void *&valueptr        = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+        valueptr               = src_raw_void_ptr;
+
+        auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(src));
+        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
+
+        if (policy == return_value_policy::reference_internal)
+            keep_alive_impl(inst, parent);
+
+        return inst.release();
+    }
+
+    template <typename>
+    using cast_op_type = std::unique_ptr<mpty>;
+
+    operator std::unique_ptr<mpty>() { return loaded_as_unique_ptr(); }
+};
+
+template <>
+struct type_caster<std::unique_ptr<mpty const>> : smart_holder_type_caster_load<mpty> {
+    static constexpr auto name = _<std::unique_ptr<mpty const>>();
+
+    static handle
+    cast(std::unique_ptr<mpty const> &&src, return_value_policy policy, handle parent) {
+        return type_caster<std::unique_ptr<mpty>>::cast(
+            std::unique_ptr<mpty>(const_cast<mpty *>(src.release())), // Const2Mutbl
+            policy,
+            parent);
+    }
+
+    template <typename>
+    using cast_op_type = std::unique_ptr<mpty const>;
+
+    operator std::unique_ptr<mpty const>() { return loaded_as_unique_ptr(); }
+};
+
+} // namespace detail
+} // namespace pybind11

From 6dae732b92221f20d711f56bf3f4d41932dc1575 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 17 Jan 2021 13:19:48 -0800
Subject: [PATCH 074/206] Using pybind11/detail/classh_type_casters.h from
 test_classh_wip.cpp.

---
 include/pybind11/classh.h                     |   1 +
 include/pybind11/detail/classh_type_casters.h | 137 ++++---
 tests/test_classh_wip.cpp                     | 363 +-----------------
 3 files changed, 83 insertions(+), 418 deletions(-)

diff --git a/include/pybind11/classh.h b/include/pybind11/classh.h
index 16b5242b7c..a23468f6f4 100644
--- a/include/pybind11/classh.h
+++ b/include/pybind11/classh.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "detail/classh_type_casters.h"
 #include "pybind11.h"
 #include "smart_holder_poc.h"
 
diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index d26e0f1003..a3708ab30c 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -1,8 +1,20 @@
+#pragma once
+
+#include "../pytypes.h"
+#include "../smart_holder_poc.h"
+#include "common.h"
+#include "descr.h"
+#include "internals.h"
+
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+
 namespace pybind11 {
 namespace detail {
 
-using namespace pybind11_tests::classh_wip;
-
 inline std::pair<bool, handle> find_existing_python_instance(void *src_void_ptr,
                                                              const detail::type_info *tinfo) {
     // Loop copied from type_caster_generic::cast.
@@ -38,7 +50,7 @@ struct smart_holder_type_caster_load {
 
     std::unique_ptr<T> loaded_as_unique_ptr() {
         void *value_void_ptr = loaded_v_h.value_ptr();
-        auto unq_ptr         = loaded_smhldr_ptr->as_unique_ptr<mpty>();
+        auto unq_ptr         = loaded_smhldr_ptr->as_unique_ptr<T>();
         loaded_v_h.holder<holder_type>().~holder_type();
         loaded_v_h.set_holder_constructed(false);
         loaded_v_h.value_ptr() = nullptr;
@@ -79,14 +91,14 @@ struct make_constructor {
 // clang-format on
 // type_caster_base END
 
-template <>
-struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
-    static constexpr auto name = _<mpty>();
+template <typename T>
+struct classh_type_caster : smart_holder_type_caster_load<T> {
+    static constexpr auto name = _<T>();
 
-    // static handle cast(mpty, ...)
+    // static handle cast(T, ...)
     // is redundant (leads to ambiguous overloads).
 
-    static handle cast(mpty &&src, return_value_policy /*policy*/, handle parent) {
+    static handle cast(T &&src, return_value_policy /*policy*/, handle parent) {
         // type_caster_base BEGIN
         // clang-format off
         return cast(&src, return_value_policy::move, parent);
@@ -94,7 +106,7 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
         // type_caster_base END
     }
 
-    static handle cast(mpty const &src, return_value_policy policy, handle parent) {
+    static handle cast(T const &src, return_value_policy policy, handle parent) {
         // type_caster_base BEGIN
         // clang-format off
         if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
@@ -104,12 +116,12 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
         // type_caster_base END
     }
 
-    static handle cast(mpty &src, return_value_policy policy, handle parent) {
-        return cast(const_cast<mpty const &>(src), policy, parent); // Mutbl2Const
+    static handle cast(T &src, return_value_policy policy, handle parent) {
+        return cast(const_cast<T const &>(src), policy, parent); // Mutbl2Const
     }
 
-    static handle cast(mpty const *src, return_value_policy policy, handle parent) {
-        auto st = type_caster_base<mpty>::src_and_type(src);
+    static handle cast(T const *src, return_value_policy policy, handle parent) {
+        auto st = type_caster_base<T>::src_and_type(src);
         return cast_const_raw_ptr( // Originally type_caster_generic::cast.
             st.first,
             policy,
@@ -119,32 +131,31 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
             make_constructor::make_move_constructor(src));
     }
 
-    static handle cast(mpty *src, return_value_policy policy, handle parent) {
-        return cast(const_cast<mpty const *>(src), policy, parent); // Mutbl2Const
+    static handle cast(T *src, return_value_policy policy, handle parent) {
+        return cast(const_cast<T const *>(src), policy, parent); // Mutbl2Const
     }
 
     template <typename T_>
     using cast_op_type = conditional_t<
-        std::is_same<remove_reference_t<T_>, mpty const *>::value,
-        mpty const *,
+        std::is_same<remove_reference_t<T_>, T const *>::value,
+        T const *,
         conditional_t<
-            std::is_same<remove_reference_t<T_>, mpty *>::value,
-            mpty *,
-            conditional_t<
-                std::is_same<T_, mpty const &>::value,
-                mpty const &,
-                conditional_t<std::is_same<T_, mpty &>::value,
-                              mpty &,
-                              conditional_t<std::is_same<T_, mpty &&>::value, mpty &&, mpty>>>>>;
+            std::is_same<remove_reference_t<T_>, T *>::value,
+            T *,
+            conditional_t<std::is_same<T_, T const &>::value,
+                          T const &,
+                          conditional_t<std::is_same<T_, T &>::value,
+                                        T &,
+                                        conditional_t<std::is_same<T_, T &&>::value, T &&, T>>>>>;
 
     // clang-format off
 
-    operator mpty()        { return loaded_smhldr_ptr->lvalue_ref<mpty>(); }
-    operator mpty&&() &&   { return loaded_smhldr_ptr->rvalue_ref<mpty>(); }
-    operator mpty const&() { return loaded_smhldr_ptr->lvalue_ref<mpty>(); }
-    operator mpty&()       { return loaded_smhldr_ptr->lvalue_ref<mpty>(); }
-    operator mpty const*() { return loaded_smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
-    operator mpty*()       { return loaded_smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
+    operator T()        { return this->loaded_smhldr_ptr->template lvalue_ref<T>(); }
+    operator T&&() &&   { return this->loaded_smhldr_ptr->template rvalue_ref<T>(); }
+    operator T const&() { return this->loaded_smhldr_ptr->template lvalue_ref<T>(); }
+    operator T&()       { return this->loaded_smhldr_ptr->template lvalue_ref<T>(); }
+    operator T const*() { return this->loaded_smhldr_ptr->template as_raw_ptr_unowned<T>(); }
+    operator T*()       { return this->loaded_smhldr_ptr->template as_raw_ptr_unowned<T>(); }
 
     // clang-format on
 
@@ -238,12 +249,11 @@ struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
     }
 };
 
-template <>
-struct type_caster<std::shared_ptr<mpty>> : smart_holder_type_caster_load<mpty> {
-    static constexpr auto name = _<std::shared_ptr<mpty>>();
+template <typename T>
+struct classh_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_load<T> {
+    static constexpr auto name = _<std::shared_ptr<T>>();
 
-    static handle
-    cast(const std::shared_ptr<mpty> &src, return_value_policy policy, handle parent) {
+    static handle cast(const std::shared_ptr<T> &src, return_value_policy policy, handle parent) {
         if (policy != return_value_policy::automatic
             && policy != return_value_policy::reference_internal) {
             // IMPROVEABLE: Error message.
@@ -251,7 +261,7 @@ struct type_caster<std::shared_ptr<mpty>> : smart_holder_type_caster_load<mpty>
         }
 
         auto src_raw_ptr = src.get();
-        auto st          = type_caster_base<mpty>::src_and_type(src_raw_ptr);
+        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
         if (st.first == nullptr)
             return none().release(); // PyErr was set already.
 
@@ -279,34 +289,36 @@ struct type_caster<std::shared_ptr<mpty>> : smart_holder_type_caster_load<mpty>
     }
 
     template <typename>
-    using cast_op_type = std::shared_ptr<mpty>;
+    using cast_op_type = std::shared_ptr<T>;
 
-    operator std::shared_ptr<mpty>() { return loaded_smhldr_ptr->as_shared_ptr<mpty>(); }
+    operator std::shared_ptr<T>() { return this->loaded_smhldr_ptr->template as_shared_ptr<T>(); }
 };
 
-template <>
-struct type_caster<std::shared_ptr<mpty const>> : smart_holder_type_caster_load<mpty> {
-    static constexpr auto name = _<std::shared_ptr<mpty const>>();
+template <typename T>
+struct classh_type_caster<std::shared_ptr<T const>> : smart_holder_type_caster_load<T> {
+    static constexpr auto name = _<std::shared_ptr<T const>>();
 
     static handle
-    cast(const std::shared_ptr<mpty const> &src, return_value_policy policy, handle parent) {
-        return type_caster<std::shared_ptr<mpty>>::cast(
-            std::const_pointer_cast<mpty>(src), // Const2Mutbl
+    cast(const std::shared_ptr<T const> &src, return_value_policy policy, handle parent) {
+        return type_caster<std::shared_ptr<T>>::cast(
+            std::const_pointer_cast<T>(src), // Const2Mutbl
             policy,
             parent);
     }
 
     template <typename>
-    using cast_op_type = std::shared_ptr<mpty const>;
+    using cast_op_type = std::shared_ptr<T const>;
 
-    operator std::shared_ptr<mpty const>() { return loaded_smhldr_ptr->as_shared_ptr<mpty>(); }
+    operator std::shared_ptr<T const>() {
+        return this->loaded_smhldr_ptr->template as_shared_ptr<T>();
+    }
 };
 
-template <>
-struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty> {
-    static constexpr auto name = _<std::unique_ptr<mpty>>();
+template <typename T>
+struct classh_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_load<T> {
+    static constexpr auto name = _<std::unique_ptr<T>>();
 
-    static handle cast(std::unique_ptr<mpty> &&src, return_value_policy policy, handle parent) {
+    static handle cast(std::unique_ptr<T> &&src, return_value_policy policy, handle parent) {
         if (policy != return_value_policy::automatic
             && policy != return_value_policy::reference_internal) {
             // IMPROVEABLE: Error message.
@@ -314,7 +326,7 @@ struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty>
         }
 
         auto src_raw_ptr = src.get();
-        auto st          = type_caster_base<mpty>::src_and_type(src_raw_ptr);
+        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
         if (st.first == nullptr)
             return none().release(); // PyErr was set already.
 
@@ -340,27 +352,26 @@ struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty>
     }
 
     template <typename>
-    using cast_op_type = std::unique_ptr<mpty>;
+    using cast_op_type = std::unique_ptr<T>;
 
-    operator std::unique_ptr<mpty>() { return loaded_as_unique_ptr(); }
+    operator std::unique_ptr<T>() { return this->loaded_as_unique_ptr(); }
 };
 
-template <>
-struct type_caster<std::unique_ptr<mpty const>> : smart_holder_type_caster_load<mpty> {
-    static constexpr auto name = _<std::unique_ptr<mpty const>>();
+template <typename T>
+struct classh_type_caster<std::unique_ptr<T const>> : smart_holder_type_caster_load<T> {
+    static constexpr auto name = _<std::unique_ptr<T const>>();
 
-    static handle
-    cast(std::unique_ptr<mpty const> &&src, return_value_policy policy, handle parent) {
-        return type_caster<std::unique_ptr<mpty>>::cast(
-            std::unique_ptr<mpty>(const_cast<mpty *>(src.release())), // Const2Mutbl
+    static handle cast(std::unique_ptr<T const> &&src, return_value_policy policy, handle parent) {
+        return type_caster<std::unique_ptr<T>>::cast(
+            std::unique_ptr<T>(const_cast<T *>(src.release())), // Const2Mutbl
             policy,
             parent);
     }
 
     template <typename>
-    using cast_op_type = std::unique_ptr<mpty const>;
+    using cast_op_type = std::unique_ptr<T const>;
 
-    operator std::unique_ptr<mpty const>() { return loaded_as_unique_ptr(); }
+    operator std::unique_ptr<T const>() { return this->loaded_as_unique_ptr(); }
 };
 
 } // namespace detail
diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 62e0b5d953..7bf976fcab 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -52,367 +52,20 @@ std::unique_ptr<mpty> unique_ptr_roundtrip(std::unique_ptr<mpty> obj) { return o
 namespace pybind11 {
 namespace detail {
 
-using namespace pybind11_tests::classh_wip;
-
-inline std::pair<bool, handle> find_existing_python_instance(void *src_void_ptr,
-                                                             const detail::type_info *tinfo) {
-    // Loop copied from type_caster_generic::cast.
-    // IMPROVEABLE: Factor out of type_caster_generic::cast.
-    auto it_instances = get_internals().registered_instances.equal_range(src_void_ptr);
-    for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
-        for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
-            if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
-                return std::make_pair(true, handle((PyObject *) it_i->second).inc_ref());
-        }
-    }
-    return std::make_pair(false, handle());
-}
-
-template <typename T>
-struct smart_holder_type_caster_load {
-    using holder_type = pybindit::memory::smart_holder;
-
-    bool load(handle src, bool /*convert*/) {
-        if (!isinstance<T>(src))
-            return false;
-        auto inst  = reinterpret_cast<instance *>(src.ptr());
-        loaded_v_h = inst->get_value_and_holder(get_type_info(typeid(T)));
-        if (!loaded_v_h.holder_constructed()) {
-            // IMPROVEABLE: Error message. A change to the existing internals is
-            // needed to cleanly distinguish between uninitialized or disowned.
-            throw std::runtime_error("Missing value for wrapped C++ type:"
-                                     " Python instance is uninitialized or was disowned.");
-        }
-        loaded_smhldr_ptr = &loaded_v_h.holder<holder_type>();
-        return true;
-    }
-
-    std::unique_ptr<T> loaded_as_unique_ptr() {
-        void *value_void_ptr = loaded_v_h.value_ptr();
-        auto unq_ptr         = loaded_smhldr_ptr->as_unique_ptr<mpty>();
-        loaded_v_h.holder<holder_type>().~holder_type();
-        loaded_v_h.set_holder_constructed(false);
-        loaded_v_h.value_ptr() = nullptr;
-        deregister_instance(loaded_v_h.inst, value_void_ptr, loaded_v_h.type);
-        return unq_ptr;
-    }
-
-protected:
-    value_and_holder loaded_v_h;
-    holder_type *loaded_smhldr_ptr = nullptr;
-};
-
-// type_caster_base BEGIN
-// clang-format off
-// Helper factored out of type_caster_base.
-struct make_constructor {
-    using Constructor = void *(*)(const void *);
-
-    /* Only enabled when the types are {copy,move}-constructible *and* when the type
-       does not have a private operator new implementation. */
-    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
-    static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
-        return [](const void *arg) -> void * {
-            return new T(*reinterpret_cast<const T *>(arg));
-        };
-    }
-
-    template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
-    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
-        return [](const void *arg) -> void * {
-            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
-        };
-    }
-
-    static Constructor make_copy_constructor(...) { return nullptr; }
-    static Constructor make_move_constructor(...) { return nullptr; }
-};
-// clang-format on
-// type_caster_base END
+using mpty = pybind11_tests::classh_wip::mpty;
 
 template <>
-struct type_caster<mpty> : smart_holder_type_caster_load<mpty> {
-    static constexpr auto name = _<mpty>();
-
-    // static handle cast(mpty, ...)
-    // is redundant (leads to ambiguous overloads).
-
-    static handle cast(mpty &&src, return_value_policy /*policy*/, handle parent) {
-        // type_caster_base BEGIN
-        // clang-format off
-        return cast(&src, return_value_policy::move, parent);
-        // clang-format on
-        // type_caster_base END
-    }
-
-    static handle cast(mpty const &src, return_value_policy policy, handle parent) {
-        // type_caster_base BEGIN
-        // clang-format off
-        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
-            policy = return_value_policy::copy;
-        return cast(&src, policy, parent);
-        // clang-format on
-        // type_caster_base END
-    }
-
-    static handle cast(mpty &src, return_value_policy policy, handle parent) {
-        return cast(const_cast<mpty const &>(src), policy, parent); // Mutbl2Const
-    }
-
-    static handle cast(mpty const *src, return_value_policy policy, handle parent) {
-        auto st = type_caster_base<mpty>::src_and_type(src);
-        return cast_const_raw_ptr( // Originally type_caster_generic::cast.
-            st.first,
-            policy,
-            parent,
-            st.second,
-            make_constructor::make_copy_constructor(src),
-            make_constructor::make_move_constructor(src));
-    }
-
-    static handle cast(mpty *src, return_value_policy policy, handle parent) {
-        return cast(const_cast<mpty const *>(src), policy, parent); // Mutbl2Const
-    }
-
-    template <typename T_>
-    using cast_op_type = conditional_t<
-        std::is_same<remove_reference_t<T_>, mpty const *>::value,
-        mpty const *,
-        conditional_t<
-            std::is_same<remove_reference_t<T_>, mpty *>::value,
-            mpty *,
-            conditional_t<
-                std::is_same<T_, mpty const &>::value,
-                mpty const &,
-                conditional_t<std::is_same<T_, mpty &>::value,
-                              mpty &,
-                              conditional_t<std::is_same<T_, mpty &&>::value, mpty &&, mpty>>>>>;
-
-    // clang-format off
-
-    operator mpty()        { return loaded_smhldr_ptr->lvalue_ref<mpty>(); }
-    operator mpty&&() &&   { return loaded_smhldr_ptr->rvalue_ref<mpty>(); }
-    operator mpty const&() { return loaded_smhldr_ptr->lvalue_ref<mpty>(); }
-    operator mpty&()       { return loaded_smhldr_ptr->lvalue_ref<mpty>(); }
-    operator mpty const*() { return loaded_smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
-    operator mpty*()       { return loaded_smhldr_ptr->as_raw_ptr_unowned<mpty>(); }
-
-    // clang-format on
-
-    // Originally type_caster_generic::cast.
-    PYBIND11_NOINLINE static handle cast_const_raw_ptr(const void *_src,
-                                                       return_value_policy policy,
-                                                       handle parent,
-                                                       const detail::type_info *tinfo,
-                                                       void *(*copy_constructor)(const void *),
-                                                       void *(*move_constructor)(const void *),
-                                                       const void *existing_holder = nullptr) {
-        if (!tinfo) // no type info: error will be set already
-            return handle();
-
-        void *src = const_cast<void *>(_src);
-        if (src == nullptr)
-            return none().release();
-
-        auto existing_inst = find_existing_python_instance(src, tinfo);
-        if (existing_inst.first)
-            return existing_inst.second;
-
-        auto inst       = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        auto wrapper    = reinterpret_cast<instance *>(inst.ptr());
-        wrapper->owned  = false;
-        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
-
-        switch (policy) {
-            case return_value_policy::automatic:
-            case return_value_policy::take_ownership:
-                valueptr       = src;
-                wrapper->owned = true;
-                break;
-
-            case return_value_policy::automatic_reference:
-            case return_value_policy::reference:
-                valueptr       = src;
-                wrapper->owned = false;
-                break;
-
-            case return_value_policy::copy:
-                if (copy_constructor)
-                    valueptr = copy_constructor(src);
-                else {
-#if defined(NDEBUG)
-                    throw cast_error("return_value_policy = copy, but type is "
-                                     "non-copyable! (compile in debug mode for details)");
-#else
-                    std::string type_name(tinfo->cpptype->name());
-                    detail::clean_type_id(type_name);
-                    throw cast_error("return_value_policy = copy, but type " + type_name
-                                     + " is non-copyable!");
-#endif
-                }
-                wrapper->owned = true;
-                break;
-
-            case return_value_policy::move:
-                if (move_constructor)
-                    valueptr = move_constructor(src);
-                else if (copy_constructor)
-                    valueptr = copy_constructor(src);
-                else {
-#if defined(NDEBUG)
-                    throw cast_error("return_value_policy = move, but type is neither "
-                                     "movable nor copyable! "
-                                     "(compile in debug mode for details)");
-#else
-                    std::string type_name(tinfo->cpptype->name());
-                    detail::clean_type_id(type_name);
-                    throw cast_error("return_value_policy = move, but type " + type_name
-                                     + " is neither movable nor copyable!");
-#endif
-                }
-                wrapper->owned = true;
-                break;
-
-            case return_value_policy::reference_internal:
-                valueptr       = src;
-                wrapper->owned = false;
-                keep_alive_impl(inst, parent);
-                break;
-
-            default:
-                throw cast_error("unhandled return_value_policy: should not happen!");
-        }
-
-        tinfo->init_instance(wrapper, existing_holder);
-
-        return inst.release();
-    }
-};
-
+class type_caster<mpty> : public classh_type_caster<mpty> {};
 template <>
-struct type_caster<std::shared_ptr<mpty>> : smart_holder_type_caster_load<mpty> {
-    static constexpr auto name = _<std::shared_ptr<mpty>>();
-
-    static handle
-    cast(const std::shared_ptr<mpty> &src, return_value_policy policy, handle parent) {
-        if (policy != return_value_policy::automatic
-            && policy != return_value_policy::reference_internal) {
-            // IMPROVEABLE: Error message.
-            throw cast_error("Invalid return_value_policy for shared_ptr.");
-        }
-
-        auto src_raw_ptr = src.get();
-        auto st          = type_caster_base<mpty>::src_and_type(src_raw_ptr);
-        if (st.first == nullptr)
-            return none().release(); // PyErr was set already.
-
-        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
-        const detail::type_info *tinfo = st.second;
-        auto existing_inst             = find_existing_python_instance(src_raw_void_ptr, tinfo);
-        if (existing_inst.first)
-            // MISSING: Enforcement of consistency with existing smart_holder.
-            // MISSING: keep_alive.
-            return existing_inst.second;
-
-        object inst            = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        instance *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
-        inst_raw_ptr->owned    = true;
-        void *&valueptr        = values_and_holders(inst_raw_ptr).begin()->value_ptr();
-        valueptr               = src_raw_void_ptr;
-
-        auto smhldr = pybindit::memory::smart_holder::from_shared_ptr(src);
-        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
-
-        if (policy == return_value_policy::reference_internal)
-            keep_alive_impl(inst, parent);
-
-        return inst.release();
-    }
-
-    template <typename>
-    using cast_op_type = std::shared_ptr<mpty>;
-
-    operator std::shared_ptr<mpty>() { return loaded_smhldr_ptr->as_shared_ptr<mpty>(); }
-};
-
+class type_caster<std::shared_ptr<mpty>> : public classh_type_caster<std::shared_ptr<mpty>> {};
 template <>
-struct type_caster<std::shared_ptr<mpty const>> : smart_holder_type_caster_load<mpty> {
-    static constexpr auto name = _<std::shared_ptr<mpty const>>();
-
-    static handle
-    cast(const std::shared_ptr<mpty const> &src, return_value_policy policy, handle parent) {
-        return type_caster<std::shared_ptr<mpty>>::cast(
-            std::const_pointer_cast<mpty>(src), // Const2Mutbl
-            policy,
-            parent);
-    }
-
-    template <typename>
-    using cast_op_type = std::shared_ptr<mpty const>;
-
-    operator std::shared_ptr<mpty const>() { return loaded_smhldr_ptr->as_shared_ptr<mpty>(); }
-};
-
+class type_caster<std::shared_ptr<mpty const>>
+    : public classh_type_caster<std::shared_ptr<mpty const>> {};
 template <>
-struct type_caster<std::unique_ptr<mpty>> : smart_holder_type_caster_load<mpty> {
-    static constexpr auto name = _<std::unique_ptr<mpty>>();
-
-    static handle cast(std::unique_ptr<mpty> &&src, return_value_policy policy, handle parent) {
-        if (policy != return_value_policy::automatic
-            && policy != return_value_policy::reference_internal) {
-            // IMPROVEABLE: Error message.
-            throw cast_error("Invalid return_value_policy for unique_ptr.");
-        }
-
-        auto src_raw_ptr = src.get();
-        auto st          = type_caster_base<mpty>::src_and_type(src_raw_ptr);
-        if (st.first == nullptr)
-            return none().release(); // PyErr was set already.
-
-        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
-        const detail::type_info *tinfo = st.second;
-        auto existing_inst             = find_existing_python_instance(src_raw_void_ptr, tinfo);
-        if (existing_inst.first)
-            throw cast_error("Invalid unique_ptr: another instance owns this pointer already.");
-
-        object inst            = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        instance *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
-        inst_raw_ptr->owned    = true;
-        void *&valueptr        = values_and_holders(inst_raw_ptr).begin()->value_ptr();
-        valueptr               = src_raw_void_ptr;
-
-        auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(src));
-        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
-
-        if (policy == return_value_policy::reference_internal)
-            keep_alive_impl(inst, parent);
-
-        return inst.release();
-    }
-
-    template <typename>
-    using cast_op_type = std::unique_ptr<mpty>;
-
-    operator std::unique_ptr<mpty>() { return loaded_as_unique_ptr(); }
-};
-
+class type_caster<std::unique_ptr<mpty>> : public classh_type_caster<std::unique_ptr<mpty>> {};
 template <>
-struct type_caster<std::unique_ptr<mpty const>> : smart_holder_type_caster_load<mpty> {
-    static constexpr auto name = _<std::unique_ptr<mpty const>>();
-
-    static handle
-    cast(std::unique_ptr<mpty const> &&src, return_value_policy policy, handle parent) {
-        return type_caster<std::unique_ptr<mpty>>::cast(
-            std::unique_ptr<mpty>(const_cast<mpty *>(src.release())), // Const2Mutbl
-            policy,
-            parent);
-    }
-
-    template <typename>
-    using cast_op_type = std::unique_ptr<mpty const>;
-
-    operator std::unique_ptr<mpty const>() { return loaded_as_unique_ptr(); }
-};
+class type_caster<std::unique_ptr<mpty const>>
+    : public classh_type_caster<std::unique_ptr<mpty const>> {};
 
 } // namespace detail
 } // namespace pybind11

From a2400b423dd8de18ccd7946e7a4cf99e7c7736d2 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 17 Jan 2021 13:32:50 -0800
Subject: [PATCH 075/206] Adding & using PYBIND11_CLASSH_TYPE_CASTERS define.

---
 include/pybind11/detail/classh_type_casters.h | 18 ++++++++++++++++
 tests/test_classh_wip.cpp                     | 21 +------------------
 2 files changed, 19 insertions(+), 20 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index a3708ab30c..661a9fbfd7 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -374,5 +374,23 @@ struct classh_type_caster<std::unique_ptr<T const>> : smart_holder_type_caster_l
     operator std::unique_ptr<T const>() { return this->loaded_as_unique_ptr(); }
 };
 
+#define PYBIND11_CLASSH_TYPE_CASTERS(T)                                                           \
+    namespace pybind11 {                                                                          \
+    namespace detail {                                                                            \
+    template <>                                                                                   \
+    class type_caster<T> : public classh_type_caster<T> {};                                       \
+    template <>                                                                                   \
+    class type_caster<std::shared_ptr<T>> : public classh_type_caster<std::shared_ptr<T>> {};     \
+    template <>                                                                                   \
+    class type_caster<std::shared_ptr<T const>>                                                   \
+        : public classh_type_caster<std::shared_ptr<T const>> {};                                 \
+    template <>                                                                                   \
+    class type_caster<std::unique_ptr<T>> : public classh_type_caster<std::unique_ptr<T>> {};     \
+    template <>                                                                                   \
+    class type_caster<std::unique_ptr<T const>>                                                   \
+        : public classh_type_caster<std::unique_ptr<T const>> {};                                 \
+    }                                                                                             \
+    }
+
 } // namespace detail
 } // namespace pybind11
diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 7bf976fcab..79821f330f 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -49,26 +49,7 @@ std::unique_ptr<mpty> unique_ptr_roundtrip(std::unique_ptr<mpty> obj) { return o
 } // namespace classh_wip
 } // namespace pybind11_tests
 
-namespace pybind11 {
-namespace detail {
-
-using mpty = pybind11_tests::classh_wip::mpty;
-
-template <>
-class type_caster<mpty> : public classh_type_caster<mpty> {};
-template <>
-class type_caster<std::shared_ptr<mpty>> : public classh_type_caster<std::shared_ptr<mpty>> {};
-template <>
-class type_caster<std::shared_ptr<mpty const>>
-    : public classh_type_caster<std::shared_ptr<mpty const>> {};
-template <>
-class type_caster<std::unique_ptr<mpty>> : public classh_type_caster<std::unique_ptr<mpty>> {};
-template <>
-class type_caster<std::unique_ptr<mpty const>>
-    : public classh_type_caster<std::unique_ptr<mpty const>> {};
-
-} // namespace detail
-} // namespace pybind11
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_wip::mpty)
 
 namespace pybind11_tests {
 namespace classh_wip {

From a7b074559844683cbd51b611ecbdb04988c1b034 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 18 Jan 2021 05:45:07 -0800
Subject: [PATCH 076/206] Adding test_classh_inheritance, currently failing
 (passes with class_).

---
 tests/test_classh_inheritance.cpp | 45 +++++++++++++++++++++++++++++++
 tests/test_classh_inheritance.py  | 17 ++++++++++++
 2 files changed, 62 insertions(+)
 create mode 100644 tests/test_classh_inheritance.cpp
 create mode 100644 tests/test_classh_inheritance.py

diff --git a/tests/test_classh_inheritance.cpp b/tests/test_classh_inheritance.cpp
new file mode 100644
index 0000000000..6dd1de59b0
--- /dev/null
+++ b/tests/test_classh_inheritance.cpp
@@ -0,0 +1,45 @@
+#include "pybind11_tests.h"
+
+#include <pybind11/classh.h>
+
+namespace pybind11_tests {
+namespace classh_inheritance {
+
+struct base {
+    base() : base_id(100) {}
+    virtual ~base() = default;
+    virtual int id() const { return base_id; }
+    int base_id;
+};
+
+struct drvd : base {
+    int id() const override { return 2 * base_id; }
+};
+
+inline drvd *make_drvd() { return new drvd; }
+inline base *make_drvd_up_cast() { return new drvd; }
+
+inline int pass_base(const base *b) { return b->id(); }
+inline int pass_drvd(const drvd *d) { return d->id(); }
+
+} // namespace classh_inheritance
+} // namespace pybind11_tests
+
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_inheritance::base)
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_inheritance::drvd)
+
+namespace pybind11_tests {
+namespace classh_inheritance {
+
+TEST_SUBMODULE(classh_inheritance, m) {
+    py::classh<base>(m, "base");
+    py::classh<drvd, base>(m, "drvd");
+
+    m.def("make_drvd", make_drvd, py::return_value_policy::take_ownership);
+    m.def("make_drvd_up_cast", make_drvd_up_cast, py::return_value_policy::take_ownership);
+    m.def("pass_base", pass_base);
+    m.def("pass_drvd", pass_drvd);
+}
+
+} // namespace classh_inheritance
+} // namespace pybind11_tests
diff --git a/tests/test_classh_inheritance.py b/tests/test_classh_inheritance.py
new file mode 100644
index 0000000000..7784dd90f9
--- /dev/null
+++ b/tests/test_classh_inheritance.py
@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+from pybind11_tests import classh_inheritance as m
+
+
+def test_make_drvd_pass_base():
+    d = m.make_drvd()
+    i = m.pass_base(d)
+    assert i == 200
+
+
+def test_make_drvd_up_cast_pass_drvd():
+    b = m.make_drvd_up_cast()
+    # the base return is down-cast immediately.
+    assert b.__class__.__name__ == "drvd"
+    i = m.pass_drvd(b)
+    assert i == 200

From 689e253ec96deb9db4a5ae4de9b48a26b9a798fe Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 19 Jan 2021 20:39:03 -0800
Subject: [PATCH 077/206] Removing .clang-format before git rebase master
 (where the file was added).

---
 .clang-format | 21 ---------------------
 1 file changed, 21 deletions(-)
 delete mode 100644 .clang-format

diff --git a/.clang-format b/.clang-format
deleted file mode 100644
index 8700fca84d..0000000000
--- a/.clang-format
+++ /dev/null
@@ -1,21 +0,0 @@
----
-# See all possible options and defaults with:
-# clang-format --style=llvm --dump-config
-BasedOnStyle: LLVM
-AccessModifierOffset: -4
-AlignConsecutiveAssignments: true
-AlwaysBreakTemplateDeclarations: Yes
-BinPackArguments: false
-BinPackParameters: false
-BreakBeforeBinaryOperators: All
-BreakConstructorInitializers: BeforeColon
-ColumnLimit: 99
-IndentCaseLabels: true
-IndentPPDirectives: AfterHash
-IndentWidth: 4
-Language: Cpp
-SpaceAfterCStyleCast: true
-# SpaceInEmptyBlock: true # too new
-Standard: Cpp11
-TabWidth: 4
-...

From c87145c403abe546ac112e4d9c4a5bd1dbe901c3 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 19 Jan 2021 21:22:39 -0800
Subject: [PATCH 078/206] Bringing back .clang-format, the previous rm was a
 bad idea.

---
 .clang-format | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 .clang-format

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000000..8700fca84d
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,21 @@
+---
+# See all possible options and defaults with:
+# clang-format --style=llvm --dump-config
+BasedOnStyle: LLVM
+AccessModifierOffset: -4
+AlignConsecutiveAssignments: true
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBinaryOperators: All
+BreakConstructorInitializers: BeforeColon
+ColumnLimit: 99
+IndentCaseLabels: true
+IndentPPDirectives: AfterHash
+IndentWidth: 4
+Language: Cpp
+SpaceAfterCStyleCast: true
+# SpaceInEmptyBlock: true # too new
+Standard: Cpp11
+TabWidth: 4
+...

From cc50eaa9b7132802d9bb1a41a25eeaa4e1adc56c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 19 Jan 2021 21:25:07 -0800
Subject: [PATCH 079/206] Folding in modified_type_caster_generic_load_impl,
 just enough to pass test_class_wip. test_classh_inheritance is still failing,
 but with a different error: [RuntimeError: Incompatible type
 (as_raw_ptr_unowned).]

---
 include/pybind11/detail/classh_type_casters.h | 178 +++++++++++++++++-
 1 file changed, 170 insertions(+), 8 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index 661a9fbfd7..3907267bbb 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -29,21 +29,183 @@ inline std::pair<bool, handle> find_existing_python_instance(void *src_void_ptr,
     return std::make_pair(false, handle());
 }
 
-template <typename T>
-struct smart_holder_type_caster_load {
-    using holder_type = pybindit::memory::smart_holder;
+// clang-format off
+class modified_type_caster_generic_load_impl {
+public:
+    PYBIND11_NOINLINE modified_type_caster_generic_load_impl(const std::type_info &type_info)
+        : typeinfo(get_type_info(type_info)), cpptype(&type_info) { }
 
-    bool load(handle src, bool /*convert*/) {
-        if (!isinstance<T>(src))
-            return false;
-        auto inst  = reinterpret_cast<instance *>(src.ptr());
-        loaded_v_h = inst->get_value_and_holder(get_type_info(typeid(T)));
+    modified_type_caster_generic_load_impl(const type_info *typeinfo)
+        : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { }
+
+    bool load(handle src, bool convert) {
+        return load_impl<modified_type_caster_generic_load_impl>(src, convert);
+    }
+
+    // Base methods for generic caster; there are overridden in copyable_holder_caster
+    void load_value_and_holder(value_and_holder &&v_h) {
+        loaded_v_h = std::move(v_h);
         if (!loaded_v_h.holder_constructed()) {
             // IMPROVEABLE: Error message. A change to the existing internals is
             // needed to cleanly distinguish between uninitialized or disowned.
             throw std::runtime_error("Missing value for wrapped C++ type:"
                                      " Python instance is uninitialized or was disowned.");
         }
+        if (v_h.value_ptr() == nullptr) {
+            pybind11_fail("Unexpected v_h.value_ptr() nullptr.");
+        }
+        loaded_v_h.type = typeinfo;
+    }
+
+    bool try_implicit_casts(handle src, bool convert) {
+        for (auto &cast : typeinfo->implicit_casts) {
+            modified_type_caster_generic_load_impl sub_caster(*cast.first);
+            if (sub_caster.load(src, convert)) {
+                pybind11_fail("Not Implemented: classh try_implicit_casts.");
+                // value = cast.second(sub_caster.value); TODO:value_and_holder
+                return true;
+            }
+        }
+        return false;
+    }
+
+    bool try_direct_conversions(handle src) {
+        for (auto &converter : *typeinfo->direct_conversions) {
+            if (converter(src.ptr(), loaded_v_h.value_ptr()))
+                return true;
+        }
+        return false;
+    }
+
+    PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
+        auto caster = modified_type_caster_generic_load_impl(ti);
+        if (caster.load(src, false))
+            pybind11_fail("Not Implemented: classh local_load.");
+            // return caster.value; TODO:value_and_holder
+        return nullptr;
+    }
+
+    /// Try to load with foreign typeinfo, if available. Used when there is no
+    /// native typeinfo, or when the native one wasn't able to produce a value.
+    PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) {
+        constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
+        const auto pytype = type::handle_of(src);
+        if (!hasattr(pytype, local_key))
+            return false;
+
+        type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key));
+        // Only consider this foreign loader if actually foreign and is a loader of the correct cpp type
+        if (foreign_typeinfo->module_local_load == &local_load
+            || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype)))
+            return false;
+
+        if (auto result = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo)) {
+            pybind11_fail("Not Implemented: classh try_load_foreign_module_local.");
+            // value = result; TODO:value_and_holder
+            return true;
+        }
+        return false;
+    }
+
+    // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
+    // bits of code between here and copyable_holder_caster where the two classes need different
+    // logic (without having to resort to virtual inheritance).
+    template <typename ThisT>
+    PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
+        if (!src) return false;
+        if (!typeinfo) return try_load_foreign_module_local(src);
+        if (src.is_none()) {
+            // Defer accepting None to other overloads (if we aren't in convert mode):
+            if (!convert) return false;
+            loaded_v_h = value_and_holder();
+            return true;
+        }
+
+        auto &this_ = static_cast<ThisT &>(*this);
+
+        PyTypeObject *srctype = Py_TYPE(src.ptr());
+
+        // Case 1: If src is an exact type match for the target type then we can reinterpret_cast
+        // the instance's value pointer to the target type:
+        if (srctype == typeinfo->type) {
+            this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
+            return true;
+        }
+        // Case 2: We have a derived class
+        else if (PyType_IsSubtype(srctype, typeinfo->type)) {
+            auto &bases = all_type_info(srctype);
+            bool no_cpp_mi = typeinfo->simple_type;
+
+            // Case 2a: the python type is a Python-inherited derived class that inherits from just
+            // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of
+            // the right type and we can use reinterpret_cast.
+            // (This is essentially the same as case 2b, but because not using multiple inheritance
+            // is extremely common, we handle it specially to avoid the loop iterator and type
+            // pointer lookup overhead)
+            if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
+                this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
+                return true;
+            }
+            // Case 2b: the python type inherits from multiple C++ bases.  Check the bases to see if
+            // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we
+            // can safely reinterpret_cast to the relevant pointer.
+            else if (bases.size() > 1) {
+                for (auto base : bases) {
+                    if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
+                        this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
+                        return true;
+                    }
+                }
+            }
+
+            // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match
+            // in the registered bases, above, so try implicit casting (needed for proper C++ casting
+            // when MI is involved).
+            if (this_.try_implicit_casts(src, convert))
+                return true;
+        }
+
+        // Perform an implicit conversion
+        if (convert) {
+            for (auto &converter : typeinfo->implicit_conversions) {
+                auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
+                if (load_impl<ThisT>(temp, false)) {
+                    loader_life_support::add_patient(temp);
+                    return true;
+                }
+            }
+            if (this_.try_direct_conversions(src))
+                return true;
+        }
+
+        // Failed to match local typeinfo. Try again with global.
+        if (typeinfo->module_local) {
+            if (auto gtype = get_global_type_info(*typeinfo->cpptype)) {
+                typeinfo = gtype;
+                return load(src, false);
+            }
+        }
+
+        // Global typeinfo has precedence over foreign module_local
+        return try_load_foreign_module_local(src);
+    }
+
+    const type_info *typeinfo = nullptr;
+    const std::type_info *cpptype = nullptr;
+    value_and_holder loaded_v_h;
+};
+// clang-format on
+
+template <typename T>
+struct smart_holder_type_caster_load {
+    using holder_type = pybindit::memory::smart_holder;
+
+    bool load(handle src, bool convert) {
+        if (!isinstance<T>(src))
+            return false;
+        modified_type_caster_generic_load_impl tcgli(typeid(T));
+        tcgli.load(src, convert);
+        loaded_v_h        = tcgli.loaded_v_h;
         loaded_smhldr_ptr = &loaded_v_h.holder<holder_type>();
         return true;
     }

From acb2c3315d7646a44cc8dfb50f6a1e50b8d98647 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 20 Jan 2021 13:27:35 -0800
Subject: [PATCH 080/206] Minimal changes needed to pass
 test_classh_inheritance.

---
 include/pybind11/detail/classh_type_casters.h | 44 ++++++++++++-------
 1 file changed, 29 insertions(+), 15 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index 3907267bbb..e52f693432 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -35,7 +35,7 @@ class modified_type_caster_generic_load_impl {
     PYBIND11_NOINLINE modified_type_caster_generic_load_impl(const std::type_info &type_info)
         : typeinfo(get_type_info(type_info)), cpptype(&type_info) { }
 
-    modified_type_caster_generic_load_impl(const type_info *typeinfo)
+    explicit modified_type_caster_generic_load_impl(const type_info *typeinfo = nullptr)
         : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { }
 
     bool load(handle src, bool convert) {
@@ -133,7 +133,7 @@ class modified_type_caster_generic_load_impl {
         }
         // Case 2: We have a derived class
         else if (PyType_IsSubtype(srctype, typeinfo->type)) {
-            auto &bases = all_type_info(srctype);
+            auto &bases = all_type_info(srctype); // subtype bases
             bool no_cpp_mi = typeinfo->simple_type;
 
             // Case 2a: the python type is a Python-inherited derived class that inherits from just
@@ -144,6 +144,8 @@ class modified_type_caster_generic_load_impl {
             // pointer lookup overhead)
             if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
                 this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
+                subtype_typeinfo = bases.front();
+                reinterpret_cast_ok = true;
                 return true;
             }
             // Case 2b: the python type inherits from multiple C++ bases.  Check the bases to see if
@@ -153,6 +155,8 @@ class modified_type_caster_generic_load_impl {
                 for (auto base : bases) {
                     if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
                         this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
+                        subtype_typeinfo = base;
+                        reinterpret_cast_ok = true;
                         return true;
                     }
                 }
@@ -161,8 +165,9 @@ class modified_type_caster_generic_load_impl {
             // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match
             // in the registered bases, above, so try implicit casting (needed for proper C++ casting
             // when MI is involved).
-            if (this_.try_implicit_casts(src, convert))
+            if (this_.try_implicit_casts(src, convert)) {
                 return true;
+            }
         }
 
         // Perform an implicit conversion
@@ -192,7 +197,9 @@ class modified_type_caster_generic_load_impl {
 
     const type_info *typeinfo = nullptr;
     const std::type_info *cpptype = nullptr;
+    const type_info *subtype_typeinfo = nullptr;
     value_and_holder loaded_v_h;
+    bool reinterpret_cast_ok = false;
 };
 // clang-format on
 
@@ -203,25 +210,32 @@ struct smart_holder_type_caster_load {
     bool load(handle src, bool convert) {
         if (!isinstance<T>(src))
             return false;
-        modified_type_caster_generic_load_impl tcgli(typeid(T));
-        tcgli.load(src, convert);
-        loaded_v_h        = tcgli.loaded_v_h;
-        loaded_smhldr_ptr = &loaded_v_h.holder<holder_type>();
+        load_impl = modified_type_caster_generic_load_impl(typeid(T));
+        if (!load_impl.load(src, convert))
+            return false;
+        loaded_smhldr_ptr = &load_impl.loaded_v_h.holder<holder_type>();
         return true;
     }
 
+    T *as_raw_ptr_unowned() {
+        if (load_impl.subtype_typeinfo != nullptr && load_impl.reinterpret_cast_ok) {
+            return reinterpret_cast<T *>(loaded_smhldr_ptr->vptr.get());
+        }
+        return loaded_smhldr_ptr->as_raw_ptr_unowned<T>();
+    }
+
     std::unique_ptr<T> loaded_as_unique_ptr() {
-        void *value_void_ptr = loaded_v_h.value_ptr();
+        void *value_void_ptr = load_impl.loaded_v_h.value_ptr();
         auto unq_ptr         = loaded_smhldr_ptr->as_unique_ptr<T>();
-        loaded_v_h.holder<holder_type>().~holder_type();
-        loaded_v_h.set_holder_constructed(false);
-        loaded_v_h.value_ptr() = nullptr;
-        deregister_instance(loaded_v_h.inst, value_void_ptr, loaded_v_h.type);
+        load_impl.loaded_v_h.holder<holder_type>().~holder_type();
+        load_impl.loaded_v_h.set_holder_constructed(false);
+        load_impl.loaded_v_h.value_ptr() = nullptr;
+        deregister_instance(load_impl.loaded_v_h.inst, value_void_ptr, load_impl.loaded_v_h.type);
         return unq_ptr;
     }
 
 protected:
-    value_and_holder loaded_v_h;
+    modified_type_caster_generic_load_impl load_impl;
     holder_type *loaded_smhldr_ptr = nullptr;
 };
 
@@ -316,8 +330,8 @@ struct classh_type_caster : smart_holder_type_caster_load<T> {
     operator T&&() &&   { return this->loaded_smhldr_ptr->template rvalue_ref<T>(); }
     operator T const&() { return this->loaded_smhldr_ptr->template lvalue_ref<T>(); }
     operator T&()       { return this->loaded_smhldr_ptr->template lvalue_ref<T>(); }
-    operator T const*() { return this->loaded_smhldr_ptr->template as_raw_ptr_unowned<T>(); }
-    operator T*()       { return this->loaded_smhldr_ptr->template as_raw_ptr_unowned<T>(); }
+    operator T const*() { return this->as_raw_ptr_unowned(); }
+    operator T*()       { return this->as_raw_ptr_unowned(); }
 
     // clang-format on
 

From a11dfba2a5b3139e86256dac452e13cc6dc88704 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 20 Jan 2021 15:55:38 -0800
Subject: [PATCH 081/206] First pass adjusting try_implicit_casts and
 try_load_foreign_module_local to capture loaded_v_h, but untested and guarded
 with pybind11_failure("Untested"). This was done mainly to determine general
 feasibility. Note the TODO in pybind11.h, where
 type_caster_generic::local_load is currently hard-coded. test_classh_wip and
 test_classh_inheritance still pass, as before.

---
 include/pybind11/detail/classh_type_casters.h | 48 +++++++++++++------
 include/pybind11/pybind11.h                   |  2 +-
 2 files changed, 35 insertions(+), 15 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index e52f693432..b6b7e6ff39 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -52,17 +52,23 @@ class modified_type_caster_generic_load_impl {
                                      " Python instance is uninitialized or was disowned.");
         }
         if (v_h.value_ptr() == nullptr) {
-            pybind11_fail("Unexpected v_h.value_ptr() nullptr.");
+            pybind11_fail("classh_type_casters: Unexpected v_h.value_ptr() nullptr.");
         }
         loaded_v_h.type = typeinfo;
     }
 
     bool try_implicit_casts(handle src, bool convert) {
+        pybind11_fail("classh_type_casters: try_implicit_casts UNTESTED.");
         for (auto &cast : typeinfo->implicit_casts) {
             modified_type_caster_generic_load_impl sub_caster(*cast.first);
             if (sub_caster.load(src, convert)) {
-                pybind11_fail("Not Implemented: classh try_implicit_casts.");
-                // value = cast.second(sub_caster.value); TODO:value_and_holder
+                if (loaded_v_h_cpptype != nullptr) {
+                    pybind11_fail("classh_type_casters: try_implicit_casts failure.");
+                }
+                loaded_v_h = sub_caster.loaded_v_h;
+                loaded_v_h_cpptype = cast.first;
+                implicit_cast = cast.second;
+                reinterpret_cast_ok = sub_caster.reinterpret_cast_ok;
                 return true;
             }
         }
@@ -78,10 +84,14 @@ class modified_type_caster_generic_load_impl {
     }
 
     PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
-        auto caster = modified_type_caster_generic_load_impl(ti);
-        if (caster.load(src, false))
-            pybind11_fail("Not Implemented: classh local_load.");
-            // return caster.value; TODO:value_and_holder
+        pybind11_fail("classh_type_casters: local_load UNTESTED.");
+        // Not thread safe. But the GIL needs to be held anyway in the context of this code.
+        static modified_type_caster_generic_load_impl caster;
+        caster = modified_type_caster_generic_load_impl(ti);
+        if (caster.load(src, false)) {
+            // Trick to work with the existing pybind11 internals.
+            return &caster; // Any pointer except nullptr;
+        }
         return nullptr;
     }
 
@@ -99,9 +109,17 @@ class modified_type_caster_generic_load_impl {
             || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype)))
             return false;
 
-        if (auto result = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo)) {
-            pybind11_fail("Not Implemented: classh try_load_foreign_module_local.");
-            // value = result; TODO:value_and_holder
+        void* void_ptr = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo);
+        if (void_ptr != nullptr) {
+            pybind11_fail("classh_type_casters: try_load_foreign_module_local UNTESTED.");
+            auto foreign_load_impl = static_cast<modified_type_caster_generic_load_impl *>(void_ptr);
+            if (loaded_v_h_cpptype != nullptr) {
+                pybind11_fail("classh_type_casters: try_load_foreign_module_local failure.");
+            }
+            loaded_v_h = foreign_load_impl->loaded_v_h;
+            loaded_v_h_cpptype = foreign_load_impl->loaded_v_h_cpptype;
+            implicit_cast = foreign_load_impl->implicit_cast;
+            reinterpret_cast_ok = foreign_load_impl->reinterpret_cast_ok;
             return true;
         }
         return false;
@@ -144,7 +162,7 @@ class modified_type_caster_generic_load_impl {
             // pointer lookup overhead)
             if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
                 this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
-                subtype_typeinfo = bases.front();
+                loaded_v_h_cpptype = bases.front()->cpptype;
                 reinterpret_cast_ok = true;
                 return true;
             }
@@ -152,10 +170,11 @@ class modified_type_caster_generic_load_impl {
             // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we
             // can safely reinterpret_cast to the relevant pointer.
             else if (bases.size() > 1) {
+                pybind11_fail("classh_type_casters: Case 2b UNTESTED.");
                 for (auto base : bases) {
                     if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
                         this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
-                        subtype_typeinfo = base;
+                        loaded_v_h_cpptype = base->cpptype;
                         reinterpret_cast_ok = true;
                         return true;
                     }
@@ -197,7 +216,8 @@ class modified_type_caster_generic_load_impl {
 
     const type_info *typeinfo = nullptr;
     const std::type_info *cpptype = nullptr;
-    const type_info *subtype_typeinfo = nullptr;
+    const std::type_info *loaded_v_h_cpptype = nullptr;
+    void *(*implicit_cast)(void *) = nullptr;
     value_and_holder loaded_v_h;
     bool reinterpret_cast_ok = false;
 };
@@ -218,7 +238,7 @@ struct smart_holder_type_caster_load {
     }
 
     T *as_raw_ptr_unowned() {
-        if (load_impl.subtype_typeinfo != nullptr && load_impl.reinterpret_cast_ok) {
+        if (load_impl.loaded_v_h_cpptype != nullptr && load_impl.reinterpret_cast_ok) {
             return reinterpret_cast<T *>(loaded_smhldr_ptr->vptr.get());
         }
         return loaded_smhldr_ptr->as_raw_ptr_unowned<T>();
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index f9c92df12b..c96a57293e 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1129,7 +1129,7 @@ class generic_type : public object {
 
         if (rec.module_local) {
             // Stash the local typeinfo and loader so that external modules can access it.
-            tinfo->module_local_load = &type_caster_generic::local_load;
+            tinfo->module_local_load = &type_caster_generic::local_load; // TODO classh_type_casters local_load
             setattr(m_ptr, PYBIND11_MODULE_LOCAL_ID, capsule(tinfo));
         }
     }

From d0c351bac61f606ff812cb4f329f7d9c29a20808 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 20 Jan 2021 19:11:10 -0800
Subject: [PATCH 082/206] Decoupling generic_type from type_caster_generic.

---
 include/pybind11/classh.h   | 2 +-
 include/pybind11/pybind11.h | 7 ++++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/include/pybind11/classh.h b/include/pybind11/classh.h
index a23468f6f4..15b6e8ab97 100644
--- a/include/pybind11/classh.h
+++ b/include/pybind11/classh.h
@@ -60,7 +60,7 @@ class classh : public detail::generic_type {
         /* Process optional arguments, if any */
         process_attributes<Extra...>::init(extra..., &record);
 
-        generic_type::initialize(record);
+        generic_type::initialize(record, &modified_type_caster_generic_load_impl::local_load);
 
         if (has_alias) {
             auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index c96a57293e..b7afb001f0 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1083,7 +1083,8 @@ class generic_type : public object {
 public:
     PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check)
 protected:
-    void initialize(const type_record &rec) {
+    void initialize(const type_record &rec,
+                    void *(*type_caster_module_local_load)(PyObject *, const type_info *)) {
         if (rec.scope && hasattr(rec.scope, "__dict__") && rec.scope.attr("__dict__").contains(rec.name))
             pybind11_fail("generic_type: cannot initialize type \"" + std::string(rec.name) +
                           "\": an object with that name is already defined");
@@ -1129,7 +1130,7 @@ class generic_type : public object {
 
         if (rec.module_local) {
             // Stash the local typeinfo and loader so that external modules can access it.
-            tinfo->module_local_load = &type_caster_generic::local_load; // TODO classh_type_casters local_load
+            tinfo->module_local_load = type_caster_module_local_load;
             setattr(m_ptr, PYBIND11_MODULE_LOCAL_ID, capsule(tinfo));
         }
     }
@@ -1296,7 +1297,7 @@ class class_ : public detail::generic_type {
         /* Process optional arguments, if any */
         process_attributes<Extra...>::init(extra..., &record);
 
-        generic_type::initialize(record);
+        generic_type::initialize(record, &type_caster_generic::local_load);
 
         if (has_alias) {
             auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;

From ed01faef9378e49604265ef293626050910fbf30 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 21 Jan 2021 21:17:15 -0800
Subject: [PATCH 083/206] Changes and tests covering classh_type_casters
 try_implicit_casts.

---
 include/pybind11/detail/classh_type_casters.h | 19 ++++---
 tests/test_classh_inheritance.cpp             | 50 ++++++++++++++++---
 tests/test_classh_inheritance.py              | 25 ++++++++--
 3 files changed, 77 insertions(+), 17 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index b6b7e6ff39..aa28859861 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -58,7 +58,6 @@ class modified_type_caster_generic_load_impl {
     }
 
     bool try_implicit_casts(handle src, bool convert) {
-        pybind11_fail("classh_type_casters: try_implicit_casts UNTESTED.");
         for (auto &cast : typeinfo->implicit_casts) {
             modified_type_caster_generic_load_impl sub_caster(*cast.first);
             if (sub_caster.load(src, convert)) {
@@ -68,7 +67,6 @@ class modified_type_caster_generic_load_impl {
                 loaded_v_h = sub_caster.loaded_v_h;
                 loaded_v_h_cpptype = cast.first;
                 implicit_cast = cast.second;
-                reinterpret_cast_ok = sub_caster.reinterpret_cast_ok;
                 return true;
             }
         }
@@ -119,7 +117,6 @@ class modified_type_caster_generic_load_impl {
             loaded_v_h = foreign_load_impl->loaded_v_h;
             loaded_v_h_cpptype = foreign_load_impl->loaded_v_h_cpptype;
             implicit_cast = foreign_load_impl->implicit_cast;
-            reinterpret_cast_ok = foreign_load_impl->reinterpret_cast_ok;
             return true;
         }
         return false;
@@ -163,7 +160,7 @@ class modified_type_caster_generic_load_impl {
             if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
                 this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
                 loaded_v_h_cpptype = bases.front()->cpptype;
-                reinterpret_cast_ok = true;
+                reinterpret_cast_deemed_ok = true;
                 return true;
             }
             // Case 2b: the python type inherits from multiple C++ bases.  Check the bases to see if
@@ -175,7 +172,7 @@ class modified_type_caster_generic_load_impl {
                     if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
                         this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
                         loaded_v_h_cpptype = base->cpptype;
-                        reinterpret_cast_ok = true;
+                        reinterpret_cast_deemed_ok = true;
                         return true;
                     }
                 }
@@ -219,7 +216,7 @@ class modified_type_caster_generic_load_impl {
     const std::type_info *loaded_v_h_cpptype = nullptr;
     void *(*implicit_cast)(void *) = nullptr;
     value_and_holder loaded_v_h;
-    bool reinterpret_cast_ok = false;
+    bool reinterpret_cast_deemed_ok = false;
 };
 // clang-format on
 
@@ -238,8 +235,14 @@ struct smart_holder_type_caster_load {
     }
 
     T *as_raw_ptr_unowned() {
-        if (load_impl.loaded_v_h_cpptype != nullptr && load_impl.reinterpret_cast_ok) {
-            return reinterpret_cast<T *>(loaded_smhldr_ptr->vptr.get());
+        if (load_impl.loaded_v_h_cpptype != nullptr) {
+            if (load_impl.reinterpret_cast_deemed_ok) {
+                return static_cast<T *>(loaded_smhldr_ptr->vptr.get());
+            }
+            if (load_impl.implicit_cast != nullptr) {
+                void *implicit_casted = load_impl.implicit_cast(loaded_smhldr_ptr->vptr.get());
+                return static_cast<T *>(implicit_casted);
+            }
         }
         return loaded_smhldr_ptr->as_raw_ptr_unowned<T>();
     }
diff --git a/tests/test_classh_inheritance.cpp b/tests/test_classh_inheritance.cpp
index 6dd1de59b0..0e3314ecc4 100644
--- a/tests/test_classh_inheritance.cpp
+++ b/tests/test_classh_inheritance.cpp
@@ -5,22 +5,45 @@
 namespace pybind11_tests {
 namespace classh_inheritance {
 
-struct base {
-    base() : base_id(100) {}
-    virtual ~base() = default;
+template <int Id>
+struct base_template {
+    base_template() : base_id(Id) {}
+    virtual ~base_template() = default;
     virtual int id() const { return base_id; }
     int base_id;
 };
 
+using base = base_template<100>;
+
 struct drvd : base {
     int id() const override { return 2 * base_id; }
 };
 
-inline drvd *make_drvd() { return new drvd; }
+// clang-format off
+inline drvd *make_drvd()         { return new drvd; }
 inline base *make_drvd_up_cast() { return new drvd; }
 
-inline int pass_base(const base *b) { return b->id(); }
-inline int pass_drvd(const drvd *d) { return d->id(); }
+inline int pass_base(const base *b) { return b->id() + 11; }
+inline int pass_drvd(const drvd *d) { return d->id() + 12; }
+// clang-format on
+
+using base1 = base_template<110>;
+using base2 = base_template<120>;
+
+// Not reusing base here because it would interfere with the single-inheritance test.
+struct drvd2 : base1, base2 {
+    int id() const override { return 3 * base1::base_id + 4 * base2::base_id; }
+};
+
+// clang-format off
+inline drvd2 *make_drvd2()          { return new drvd2; }
+inline base1 *make_drvd2_up_cast1() { return new drvd2; }
+inline base2 *make_drvd2_up_cast2() { return new drvd2; }
+
+inline int pass_base1(const base1 *b) { return b->id() + 21; }
+inline int pass_base2(const base2 *b) { return b->id() + 22; }
+inline int pass_drvd2(const drvd2 *d) { return d->id() + 23; }
+// clang-format on
 
 } // namespace classh_inheritance
 } // namespace pybind11_tests
@@ -28,6 +51,10 @@ inline int pass_drvd(const drvd *d) { return d->id(); }
 PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_inheritance::base)
 PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_inheritance::drvd)
 
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_inheritance::base1)
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_inheritance::base2)
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_inheritance::drvd2)
+
 namespace pybind11_tests {
 namespace classh_inheritance {
 
@@ -39,6 +66,17 @@ TEST_SUBMODULE(classh_inheritance, m) {
     m.def("make_drvd_up_cast", make_drvd_up_cast, py::return_value_policy::take_ownership);
     m.def("pass_base", pass_base);
     m.def("pass_drvd", pass_drvd);
+
+    py::classh<base1>(m, "base1");
+    py::classh<base2>(m, "base2");
+    py::classh<drvd2, base1, base2>(m, "drvd2");
+
+    m.def("make_drvd2", make_drvd2, py::return_value_policy::take_ownership);
+    m.def("make_drvd2_up_cast1", make_drvd2_up_cast1, py::return_value_policy::take_ownership);
+    m.def("make_drvd2_up_cast2", make_drvd2_up_cast2, py::return_value_policy::take_ownership);
+    m.def("pass_base1", pass_base1);
+    m.def("pass_base2", pass_base2);
+    m.def("pass_drvd2", pass_drvd2);
 }
 
 } // namespace classh_inheritance
diff --git a/tests/test_classh_inheritance.py b/tests/test_classh_inheritance.py
index 7784dd90f9..7af68f80cc 100644
--- a/tests/test_classh_inheritance.py
+++ b/tests/test_classh_inheritance.py
@@ -5,8 +5,8 @@
 
 def test_make_drvd_pass_base():
     d = m.make_drvd()
-    i = m.pass_base(d)
-    assert i == 200
+    i = m.pass_base(d)  # load_impl Case 2a
+    assert i == 2 * 100 + 11
 
 
 def test_make_drvd_up_cast_pass_drvd():
@@ -14,4 +14,23 @@ def test_make_drvd_up_cast_pass_drvd():
     # the base return is down-cast immediately.
     assert b.__class__.__name__ == "drvd"
     i = m.pass_drvd(b)
-    assert i == 200
+    assert i == 2 * 100 + 12
+
+
+def test_make_drvd2_pass_bases():
+    d = m.make_drvd2()
+    i1 = m.pass_base1(d)  # load_impl Case 2c
+    assert i1 == 3 * 110 + 4 * 120 + 21
+    i2 = m.pass_base2(d)
+    assert i2 == 3 * 110 + 4 * 120 + 22
+
+
+def test_make_drvd2_up_casts_pass_drvd2():
+    b1 = m.make_drvd2_up_cast1()
+    assert b1.__class__.__name__ == "drvd2"
+    i1 = m.pass_drvd2(b1)
+    assert i1 == 3 * 110 + 4 * 120 + 23
+    b2 = m.make_drvd2_up_cast2()
+    assert b2.__class__.__name__ == "drvd2"
+    i2 = m.pass_drvd2(b2)
+    assert i2 == 3 * 110 + 4 * 120 + 23

From d3ef4a959a7c7bb93aadc642c97ea30712cbd00b Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 22 Jan 2021 13:17:27 -0800
Subject: [PATCH 084/206] Minimal test covering classh_type_casters load_impl
 Case 2b.

---
 include/pybind11/detail/classh_type_casters.h |  1 -
 tests/test_classh_inheritance.cpp             |  4 ++--
 tests/test_classh_inheritance.py              | 13 +++++++++++++
 3 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index aa28859861..d00543e5dd 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -167,7 +167,6 @@ class modified_type_caster_generic_load_impl {
             // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we
             // can safely reinterpret_cast to the relevant pointer.
             else if (bases.size() > 1) {
-                pybind11_fail("classh_type_casters: Case 2b UNTESTED.");
                 for (auto base : bases) {
                     if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
                         this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
diff --git a/tests/test_classh_inheritance.cpp b/tests/test_classh_inheritance.cpp
index 0e3314ecc4..ed801fc65f 100644
--- a/tests/test_classh_inheritance.cpp
+++ b/tests/test_classh_inheritance.cpp
@@ -67,8 +67,8 @@ TEST_SUBMODULE(classh_inheritance, m) {
     m.def("pass_base", pass_base);
     m.def("pass_drvd", pass_drvd);
 
-    py::classh<base1>(m, "base1");
-    py::classh<base2>(m, "base2");
+    py::classh<base1>(m, "base1").def(py::init<>()); // __init__ needed for Python inheritance.
+    py::classh<base2>(m, "base2").def(py::init<>());
     py::classh<drvd2, base1, base2>(m, "drvd2");
 
     m.def("make_drvd2", make_drvd2, py::return_value_policy::take_ownership);
diff --git a/tests/test_classh_inheritance.py b/tests/test_classh_inheritance.py
index 7af68f80cc..9af0bc3ed9 100644
--- a/tests/test_classh_inheritance.py
+++ b/tests/test_classh_inheritance.py
@@ -34,3 +34,16 @@ def test_make_drvd2_up_casts_pass_drvd2():
     assert b2.__class__.__name__ == "drvd2"
     i2 = m.pass_drvd2(b2)
     assert i2 == 3 * 110 + 4 * 120 + 23
+
+
+def test_python_drvd2():
+    class Drvd2(m.base1, m.base2):
+        def __init__(self):
+            m.base1.__init__(self)
+            m.base2.__init__(self)
+
+    d = Drvd2()
+    i1 = m.pass_base1(d)  # load_impl Case 2b
+    assert i1 == 110 + 21
+    i2 = m.pass_base2(d)
+    assert i2 == 120 + 22

From 299bba429f92f75b8ee39b0662c5bb8afb930070 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 22 Jan 2021 19:19:55 -0800
Subject: [PATCH 085/206] Removing stray isinstance<T>(src): it interferes with
 the py::module_local feature. Adding missing #includes.

---
 include/pybind11/detail/classh_type_casters.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index d00543e5dd..3c5033e53f 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -1,7 +1,9 @@
 #pragma once
 
+#include "../cast.h"
 #include "../pytypes.h"
 #include "../smart_holder_poc.h"
+#include "class.h"
 #include "common.h"
 #include "descr.h"
 #include "internals.h"
@@ -224,8 +226,6 @@ struct smart_holder_type_caster_load {
     using holder_type = pybindit::memory::smart_holder;
 
     bool load(handle src, bool convert) {
-        if (!isinstance<T>(src))
-            return false;
         load_impl = modified_type_caster_generic_load_impl(typeid(T));
         if (!load_impl.load(src, convert))
             return false;

From ce626e09f55678278a8e359621f8d97b3bc5991e Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 22 Jan 2021 20:05:22 -0800
Subject: [PATCH 086/206] Tests for classh py::module_local() feature.

---
 include/pybind11/detail/classh_type_casters.h |  2 --
 tests/classh_module_local_0.cpp               | 27 +++++++++++++++
 tests/classh_module_local_1.cpp               | 33 +++++++++++++++++++
 tests/classh_module_local_2.cpp               | 33 +++++++++++++++++++
 tests/test_classh_module_local.py             | 27 +++++++++++++++
 5 files changed, 120 insertions(+), 2 deletions(-)
 create mode 100644 tests/classh_module_local_0.cpp
 create mode 100644 tests/classh_module_local_1.cpp
 create mode 100644 tests/classh_module_local_2.cpp
 create mode 100644 tests/test_classh_module_local.py

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index 3c5033e53f..267d46c010 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -84,7 +84,6 @@ class modified_type_caster_generic_load_impl {
     }
 
     PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
-        pybind11_fail("classh_type_casters: local_load UNTESTED.");
         // Not thread safe. But the GIL needs to be held anyway in the context of this code.
         static modified_type_caster_generic_load_impl caster;
         caster = modified_type_caster_generic_load_impl(ti);
@@ -111,7 +110,6 @@ class modified_type_caster_generic_load_impl {
 
         void* void_ptr = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo);
         if (void_ptr != nullptr) {
-            pybind11_fail("classh_type_casters: try_load_foreign_module_local UNTESTED.");
             auto foreign_load_impl = static_cast<modified_type_caster_generic_load_impl *>(void_ptr);
             if (loaded_v_h_cpptype != nullptr) {
                 pybind11_fail("classh_type_casters: try_load_foreign_module_local failure.");
diff --git a/tests/classh_module_local_0.cpp b/tests/classh_module_local_0.cpp
new file mode 100644
index 0000000000..1e543c824e
--- /dev/null
+++ b/tests/classh_module_local_0.cpp
@@ -0,0 +1,27 @@
+#include <pybind11/classh.h>
+
+#include <string>
+
+namespace pybind11_tests {
+namespace classh_module_local {
+
+struct bottle {
+    std::string msg;
+};
+
+std::string get_msg(const bottle &b) { return b.msg; }
+
+bottle make_bottle() { return bottle(); }
+
+} // namespace classh_module_local
+} // namespace pybind11_tests
+
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_module_local::bottle)
+
+PYBIND11_MODULE(classh_module_local_0, m) {
+    using namespace pybind11_tests::classh_module_local;
+
+    m.def("get_msg", get_msg);
+
+    m.def("make_bottle", make_bottle);
+}
diff --git a/tests/classh_module_local_1.cpp b/tests/classh_module_local_1.cpp
new file mode 100644
index 0000000000..456c863c1c
--- /dev/null
+++ b/tests/classh_module_local_1.cpp
@@ -0,0 +1,33 @@
+// Identical to classh_module_local_2.cpp, except 2 replaced with 1.
+#include <pybind11/classh.h>
+
+#include <string>
+
+namespace pybind11_tests {
+namespace classh_module_local {
+
+struct bottle {
+    std::string msg;
+};
+
+std::string get_msg(const bottle &b) { return b.msg; }
+
+} // namespace classh_module_local
+} // namespace pybind11_tests
+
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_module_local::bottle)
+
+PYBIND11_MODULE(classh_module_local_1, m) {
+    namespace py = pybind11;
+    using namespace pybind11_tests::classh_module_local;
+
+    py::classh<bottle>(m, "bottle", py::module_local())
+        .def(py::init([](const std::string &msg) {
+            bottle obj;
+            obj.msg = msg;
+            return obj;
+        }))
+        .def("tag", [](const bottle &) { return 1; });
+
+    m.def("get_msg", get_msg);
+}
diff --git a/tests/classh_module_local_2.cpp b/tests/classh_module_local_2.cpp
new file mode 100644
index 0000000000..f9837e889d
--- /dev/null
+++ b/tests/classh_module_local_2.cpp
@@ -0,0 +1,33 @@
+// Identical to classh_module_local_1.cpp, except 1 replaced with 2.
+#include <pybind11/classh.h>
+
+#include <string>
+
+namespace pybind11_tests {
+namespace classh_module_local {
+
+struct bottle {
+    std::string msg;
+};
+
+std::string get_msg(const bottle &b) { return b.msg; }
+
+} // namespace classh_module_local
+} // namespace pybind11_tests
+
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_module_local::bottle)
+
+PYBIND11_MODULE(classh_module_local_2, m) {
+    namespace py = pybind11;
+    using namespace pybind11_tests::classh_module_local;
+
+    py::classh<bottle>(m, "bottle", py::module_local())
+        .def(py::init([](const std::string &msg) {
+            bottle obj;
+            obj.msg = msg;
+            return obj;
+        }))
+        .def("tag", [](const bottle &) { return 2; });
+
+    m.def("get_msg", get_msg);
+}
diff --git a/tests/test_classh_module_local.py b/tests/test_classh_module_local.py
new file mode 100644
index 0000000000..b9e6b414c5
--- /dev/null
+++ b/tests/test_classh_module_local.py
@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+import classh_module_local_0 as m0
+import classh_module_local_1 as m1
+import classh_module_local_2 as m2
+
+
+def test_cross_module_get_msg():
+    b1 = m1.bottle("A")
+    assert b1.tag() == 1
+    b2 = m2.bottle("B")
+    assert b2.tag() == 2
+    assert m1.get_msg(b1) == "A"
+    assert m2.get_msg(b2) == "B"
+    assert m1.get_msg(b2) == "B"
+    assert m2.get_msg(b1) == "A"
+    assert m0.get_msg(b1) == "A"
+    assert m0.get_msg(b2) == "B"
+
+
+def test_m0_make_bottle():
+    with pytest.raises(TypeError) as exc_info:
+        m0.make_bottle()
+    assert str(exc_info.value).startswith(
+        "Unable to convert function return value to a Python type!"
+    )

From f646967746e945e1a3e37b70c8df845889bf4650 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 08:27:03 -0800
Subject: [PATCH 087/206] Pure renaming of function names in
 test_classh_inheritance, similar to the systematic approach used in
 test_class_wip. NO functional changes.

---
 tests/test_classh_inheritance.cpp | 45 +++++++++++++++++--------------
 tests/test_classh_inheritance.py  | 34 +++++++++++------------
 2 files changed, 42 insertions(+), 37 deletions(-)

diff --git a/tests/test_classh_inheritance.cpp b/tests/test_classh_inheritance.cpp
index ed801fc65f..fa7f9aadd7 100644
--- a/tests/test_classh_inheritance.cpp
+++ b/tests/test_classh_inheritance.cpp
@@ -20,11 +20,11 @@ struct drvd : base {
 };
 
 // clang-format off
-inline drvd *make_drvd()         { return new drvd; }
-inline base *make_drvd_up_cast() { return new drvd; }
+inline drvd *rtrn_mptr_drvd()         { return new drvd; }
+inline base *rtrn_mptr_drvd_up_cast() { return new drvd; }
 
-inline int pass_base(const base *b) { return b->id() + 11; }
-inline int pass_drvd(const drvd *d) { return d->id() + 12; }
+inline int pass_cptr_base(const base *b) { return b->id() + 11; }
+inline int pass_cptr_drvd(const drvd *d) { return d->id() + 12; }
 // clang-format on
 
 using base1 = base_template<110>;
@@ -36,13 +36,13 @@ struct drvd2 : base1, base2 {
 };
 
 // clang-format off
-inline drvd2 *make_drvd2()          { return new drvd2; }
-inline base1 *make_drvd2_up_cast1() { return new drvd2; }
-inline base2 *make_drvd2_up_cast2() { return new drvd2; }
+inline drvd2 *rtrn_mptr_drvd2()          { return new drvd2; }
+inline base1 *rtrn_mptr_drvd2_up_cast1() { return new drvd2; }
+inline base2 *rtrn_mptr_drvd2_up_cast2() { return new drvd2; }
 
-inline int pass_base1(const base1 *b) { return b->id() + 21; }
-inline int pass_base2(const base2 *b) { return b->id() + 22; }
-inline int pass_drvd2(const drvd2 *d) { return d->id() + 23; }
+inline int pass_cptr_base1(const base1 *b) { return b->id() + 21; }
+inline int pass_cptr_base2(const base2 *b) { return b->id() + 22; }
+inline int pass_cptr_drvd2(const drvd2 *d) { return d->id() + 23; }
 // clang-format on
 
 } // namespace classh_inheritance
@@ -62,21 +62,26 @@ TEST_SUBMODULE(classh_inheritance, m) {
     py::classh<base>(m, "base");
     py::classh<drvd, base>(m, "drvd");
 
-    m.def("make_drvd", make_drvd, py::return_value_policy::take_ownership);
-    m.def("make_drvd_up_cast", make_drvd_up_cast, py::return_value_policy::take_ownership);
-    m.def("pass_base", pass_base);
-    m.def("pass_drvd", pass_drvd);
+    m.def("rtrn_mptr_drvd", rtrn_mptr_drvd, py::return_value_policy::take_ownership);
+    m.def(
+        "rtrn_mptr_drvd_up_cast", rtrn_mptr_drvd_up_cast, py::return_value_policy::take_ownership);
+    m.def("pass_cptr_base", pass_cptr_base);
+    m.def("pass_cptr_drvd", pass_cptr_drvd);
 
     py::classh<base1>(m, "base1").def(py::init<>()); // __init__ needed for Python inheritance.
     py::classh<base2>(m, "base2").def(py::init<>());
     py::classh<drvd2, base1, base2>(m, "drvd2");
 
-    m.def("make_drvd2", make_drvd2, py::return_value_policy::take_ownership);
-    m.def("make_drvd2_up_cast1", make_drvd2_up_cast1, py::return_value_policy::take_ownership);
-    m.def("make_drvd2_up_cast2", make_drvd2_up_cast2, py::return_value_policy::take_ownership);
-    m.def("pass_base1", pass_base1);
-    m.def("pass_base2", pass_base2);
-    m.def("pass_drvd2", pass_drvd2);
+    m.def("rtrn_mptr_drvd2", rtrn_mptr_drvd2, py::return_value_policy::take_ownership);
+    m.def("rtrn_mptr_drvd2_up_cast1",
+          rtrn_mptr_drvd2_up_cast1,
+          py::return_value_policy::take_ownership);
+    m.def("rtrn_mptr_drvd2_up_cast2",
+          rtrn_mptr_drvd2_up_cast2,
+          py::return_value_policy::take_ownership);
+    m.def("pass_cptr_base1", pass_cptr_base1);
+    m.def("pass_cptr_base2", pass_cptr_base2);
+    m.def("pass_cptr_drvd2", pass_cptr_drvd2);
 }
 
 } // namespace classh_inheritance
diff --git a/tests/test_classh_inheritance.py b/tests/test_classh_inheritance.py
index 9af0bc3ed9..8421bc3047 100644
--- a/tests/test_classh_inheritance.py
+++ b/tests/test_classh_inheritance.py
@@ -3,36 +3,36 @@
 from pybind11_tests import classh_inheritance as m
 
 
-def test_make_drvd_pass_base():
-    d = m.make_drvd()
-    i = m.pass_base(d)  # load_impl Case 2a
+def test_rtrn_mptr_drvd_pass_cptr_base():
+    d = m.rtrn_mptr_drvd()
+    i = m.pass_cptr_base(d)  # load_impl Case 2a
     assert i == 2 * 100 + 11
 
 
-def test_make_drvd_up_cast_pass_drvd():
-    b = m.make_drvd_up_cast()
+def test_rtrn_mptr_drvd_up_cast_pass_cptr_drvd():
+    b = m.rtrn_mptr_drvd_up_cast()
     # the base return is down-cast immediately.
     assert b.__class__.__name__ == "drvd"
-    i = m.pass_drvd(b)
+    i = m.pass_cptr_drvd(b)
     assert i == 2 * 100 + 12
 
 
-def test_make_drvd2_pass_bases():
-    d = m.make_drvd2()
-    i1 = m.pass_base1(d)  # load_impl Case 2c
+def test_rtrn_mptr_drvd2_pass_cptr_bases():
+    d = m.rtrn_mptr_drvd2()
+    i1 = m.pass_cptr_base1(d)  # load_impl Case 2c
     assert i1 == 3 * 110 + 4 * 120 + 21
-    i2 = m.pass_base2(d)
+    i2 = m.pass_cptr_base2(d)
     assert i2 == 3 * 110 + 4 * 120 + 22
 
 
-def test_make_drvd2_up_casts_pass_drvd2():
-    b1 = m.make_drvd2_up_cast1()
+def test_rtrn_mptr_drvd2_up_casts_pass_cptr_drvd2():
+    b1 = m.rtrn_mptr_drvd2_up_cast1()
     assert b1.__class__.__name__ == "drvd2"
-    i1 = m.pass_drvd2(b1)
+    i1 = m.pass_cptr_drvd2(b1)
     assert i1 == 3 * 110 + 4 * 120 + 23
-    b2 = m.make_drvd2_up_cast2()
+    b2 = m.rtrn_mptr_drvd2_up_cast2()
     assert b2.__class__.__name__ == "drvd2"
-    i2 = m.pass_drvd2(b2)
+    i2 = m.pass_cptr_drvd2(b2)
     assert i2 == 3 * 110 + 4 * 120 + 23
 
 
@@ -43,7 +43,7 @@ def __init__(self):
             m.base2.__init__(self)
 
     d = Drvd2()
-    i1 = m.pass_base1(d)  # load_impl Case 2b
+    i1 = m.pass_cptr_base1(d)  # load_impl Case 2b
     assert i1 == 110 + 21
-    i2 = m.pass_base2(d)
+    i2 = m.pass_cptr_base2(d)
     assert i2 == 120 + 22

From 678ecb9b18c77039f20d4fa89f2a20423cf980a6 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 08:39:26 -0800
Subject: [PATCH 088/206] Pure renaming of function and variable names, for
 better generalization when convoluting with inheritance. NO functional
 changes.

---
 tests/test_classh_wip.cpp | 96 +++++++++++++++++++--------------------
 tests/test_classh_wip.py  | 70 ++++++++++++++--------------
 2 files changed, 83 insertions(+), 83 deletions(-)

diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 79821f330f..17e5a1014a 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -8,48 +8,48 @@
 namespace pybind11_tests {
 namespace classh_wip {
 
-struct mpty {
+struct atyp { // Short for "any type".
     std::string mtxt;
 };
 
 // clang-format off
 
-mpty        rtrn_mpty_valu() { mpty obj{"rtrn_valu"}; return obj; }
-mpty&&      rtrn_mpty_rref() { static mpty obj; obj.mtxt = "rtrn_rref"; return std::move(obj); }
-mpty const& rtrn_mpty_cref() { static mpty obj; obj.mtxt = "rtrn_cref"; return obj; }
-mpty&       rtrn_mpty_mref() { static mpty obj; obj.mtxt = "rtrn_mref"; return obj; }
-mpty const* rtrn_mpty_cptr() { return new mpty{"rtrn_cptr"}; }
-mpty*       rtrn_mpty_mptr() { return new mpty{"rtrn_mptr"}; }
+atyp        rtrn_valu_atyp() { atyp obj{"rtrn_valu"}; return obj; }
+atyp&&      rtrn_rref_atyp() { static atyp obj; obj.mtxt = "rtrn_rref"; return std::move(obj); }
+atyp const& rtrn_cref_atyp() { static atyp obj; obj.mtxt = "rtrn_cref"; return obj; }
+atyp&       rtrn_mref_atyp() { static atyp obj; obj.mtxt = "rtrn_mref"; return obj; }
+atyp const* rtrn_cptr_atyp() { return new atyp{"rtrn_cptr"}; }
+atyp*       rtrn_mptr_atyp() { return new atyp{"rtrn_mptr"}; }
 
-std::string pass_mpty_valu(mpty obj)        { return "pass_valu:" + obj.mtxt; }
-std::string pass_mpty_rref(mpty&& obj)      { return "pass_rref:" + obj.mtxt; }
-std::string pass_mpty_cref(mpty const& obj) { return "pass_cref:" + obj.mtxt; }
-std::string pass_mpty_mref(mpty& obj)       { return "pass_mref:" + obj.mtxt; }
-std::string pass_mpty_cptr(mpty const* obj) { return "pass_cptr:" + obj->mtxt; }
-std::string pass_mpty_mptr(mpty* obj)       { return "pass_mptr:" + obj->mtxt; }
+std::string pass_valu_atyp(atyp obj)        { return "pass_valu:" + obj.mtxt; }
+std::string pass_rref_atyp(atyp&& obj)      { return "pass_rref:" + obj.mtxt; }
+std::string pass_cref_atyp(atyp const& obj) { return "pass_cref:" + obj.mtxt; }
+std::string pass_mref_atyp(atyp& obj)       { return "pass_mref:" + obj.mtxt; }
+std::string pass_cptr_atyp(atyp const* obj) { return "pass_cptr:" + obj->mtxt; }
+std::string pass_mptr_atyp(atyp* obj)       { return "pass_mptr:" + obj->mtxt; }
 
-std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty      >(new mpty{"rtrn_shmp"}); }
-std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const>(new mpty{"rtrn_shcp"}); }
+std::shared_ptr<atyp>       rtrn_shmp_atyp() { return std::shared_ptr<atyp      >(new atyp{"rtrn_shmp"}); }
+std::shared_ptr<atyp const> rtrn_shcp_atyp() { return std::shared_ptr<atyp const>(new atyp{"rtrn_shcp"}); }
 
-std::string pass_mpty_shmp(std::shared_ptr<mpty>       obj) { return "pass_shmp:" + obj->mtxt; }
-std::string pass_mpty_shcp(std::shared_ptr<mpty const> obj) { return "pass_shcp:" + obj->mtxt; }
+std::string pass_shmp_atyp(std::shared_ptr<atyp>       obj) { return "pass_shmp:" + obj->mtxt; }
+std::string pass_shcp_atyp(std::shared_ptr<atyp const> obj) { return "pass_shcp:" + obj->mtxt; }
 
-std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty      >(new mpty{"rtrn_uqmp"}); }
-std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty{"rtrn_uqcp"}); }
+std::unique_ptr<atyp>       rtrn_uqmp_atyp() { return std::unique_ptr<atyp      >(new atyp{"rtrn_uqmp"}); }
+std::unique_ptr<atyp const> rtrn_uqcp_atyp() { return std::unique_ptr<atyp const>(new atyp{"rtrn_uqcp"}); }
 
-std::string pass_mpty_uqmp(std::unique_ptr<mpty      > obj) { return "pass_uqmp:" + obj->mtxt; }
-std::string pass_mpty_uqcp(std::unique_ptr<mpty const> obj) { return "pass_uqcp:" + obj->mtxt; }
+std::string pass_uqmp_atyp(std::unique_ptr<atyp      > obj) { return "pass_uqmp:" + obj->mtxt; }
+std::string pass_uqcp_atyp(std::unique_ptr<atyp const> obj) { return "pass_uqcp:" + obj->mtxt; }
 
 // clang-format on
 
 // Helpers for testing.
-std::string get_mtxt(mpty const &obj) { return obj.mtxt; }
-std::unique_ptr<mpty> unique_ptr_roundtrip(std::unique_ptr<mpty> obj) { return obj; }
+std::string get_mtxt(atyp const &obj) { return obj.mtxt; }
+std::unique_ptr<atyp> unique_ptr_roundtrip(std::unique_ptr<atyp> obj) { return obj; }
 
 } // namespace classh_wip
 } // namespace pybind11_tests
 
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_wip::mpty)
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_wip::atyp)
 
 namespace pybind11_tests {
 namespace classh_wip {
@@ -57,42 +57,42 @@ namespace classh_wip {
 TEST_SUBMODULE(classh_wip, m) {
     namespace py = pybind11;
 
-    py::classh<mpty>(m, "mpty").def(py::init<>()).def(py::init([](const std::string &mtxt) {
-        mpty obj;
+    py::classh<atyp>(m, "atyp").def(py::init<>()).def(py::init([](const std::string &mtxt) {
+        atyp obj;
         obj.mtxt = mtxt;
         return obj;
     }));
 
-    m.def("rtrn_mpty_valu", rtrn_mpty_valu);
-    m.def("rtrn_mpty_rref", rtrn_mpty_rref);
-    m.def("rtrn_mpty_cref", rtrn_mpty_cref);
-    m.def("rtrn_mpty_mref", rtrn_mpty_mref);
-    m.def("rtrn_mpty_cptr", rtrn_mpty_cptr);
-    m.def("rtrn_mpty_mptr", rtrn_mpty_mptr);
+    m.def("rtrn_valu_atyp", rtrn_valu_atyp);
+    m.def("rtrn_rref_atyp", rtrn_rref_atyp);
+    m.def("rtrn_cref_atyp", rtrn_cref_atyp);
+    m.def("rtrn_mref_atyp", rtrn_mref_atyp);
+    m.def("rtrn_cptr_atyp", rtrn_cptr_atyp);
+    m.def("rtrn_mptr_atyp", rtrn_mptr_atyp);
 
-    m.def("pass_mpty_valu", pass_mpty_valu);
-    m.def("pass_mpty_rref", pass_mpty_rref);
-    m.def("pass_mpty_cref", pass_mpty_cref);
-    m.def("pass_mpty_mref", pass_mpty_mref);
-    m.def("pass_mpty_cptr", pass_mpty_cptr);
-    m.def("pass_mpty_mptr", pass_mpty_mptr);
+    m.def("pass_valu_atyp", pass_valu_atyp);
+    m.def("pass_rref_atyp", pass_rref_atyp);
+    m.def("pass_cref_atyp", pass_cref_atyp);
+    m.def("pass_mref_atyp", pass_mref_atyp);
+    m.def("pass_cptr_atyp", pass_cptr_atyp);
+    m.def("pass_mptr_atyp", pass_mptr_atyp);
 
-    m.def("rtrn_mpty_shmp", rtrn_mpty_shmp);
-    m.def("rtrn_mpty_shcp", rtrn_mpty_shcp);
+    m.def("rtrn_shmp_atyp", rtrn_shmp_atyp);
+    m.def("rtrn_shcp_atyp", rtrn_shcp_atyp);
 
-    m.def("pass_mpty_shmp", pass_mpty_shmp);
-    m.def("pass_mpty_shcp", pass_mpty_shcp);
+    m.def("pass_shmp_atyp", pass_shmp_atyp);
+    m.def("pass_shcp_atyp", pass_shcp_atyp);
 
-    m.def("rtrn_mpty_uqmp", rtrn_mpty_uqmp);
-    m.def("rtrn_mpty_uqcp", rtrn_mpty_uqcp);
+    m.def("rtrn_uqmp_atyp", rtrn_uqmp_atyp);
+    m.def("rtrn_uqcp_atyp", rtrn_uqcp_atyp);
 
-    m.def("pass_mpty_uqmp", pass_mpty_uqmp);
-    m.def("pass_mpty_uqcp", pass_mpty_uqcp);
+    m.def("pass_uqmp_atyp", pass_uqmp_atyp);
+    m.def("pass_uqcp_atyp", pass_uqcp_atyp);
 
     // Helpers for testing.
     // These require selected functions above to work first, as indicated:
-    m.def("get_mtxt", get_mtxt);                         // pass_mpty_cref
-    m.def("unique_ptr_roundtrip", unique_ptr_roundtrip); // pass_mpty_uqmp, rtrn_mpty_uqmp
+    m.def("get_mtxt", get_mtxt);                         // pass_cref_atyp
+    m.def("unique_ptr_roundtrip", unique_ptr_roundtrip); // pass_uqmp_atyp, rtrn_uqmp_atyp
 }
 
 } // namespace classh_wip
diff --git a/tests/test_classh_wip.py b/tests/test_classh_wip.py
index 172e1d6ffa..b6f86d2bfb 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_classh_wip.py
@@ -4,65 +4,65 @@
 from pybind11_tests import classh_wip as m
 
 
-def test_mpty_constructors():
-    e = m.mpty()
-    assert e.__class__.__name__ == "mpty"
-    e = m.mpty("")
-    assert e.__class__.__name__ == "mpty"
-    e = m.mpty("txtm")
-    assert e.__class__.__name__ == "mpty"
+def test_atyp_constructors():
+    e = m.atyp()
+    assert e.__class__.__name__ == "atyp"
+    e = m.atyp("")
+    assert e.__class__.__name__ == "atyp"
+    e = m.atyp("txtm")
+    assert e.__class__.__name__ == "atyp"
 
 
 def test_cast():
-    assert m.get_mtxt(m.rtrn_mpty_valu()) == "rtrn_valu"
-    assert m.get_mtxt(m.rtrn_mpty_rref()) == "rtrn_rref"
-    assert m.get_mtxt(m.rtrn_mpty_cref()) == "rtrn_cref"
-    assert m.get_mtxt(m.rtrn_mpty_mref()) == "rtrn_mref"
-    assert m.get_mtxt(m.rtrn_mpty_cptr()) == "rtrn_cptr"
-    assert m.get_mtxt(m.rtrn_mpty_mptr()) == "rtrn_mptr"
+    assert m.get_mtxt(m.rtrn_valu_atyp()) == "rtrn_valu"
+    assert m.get_mtxt(m.rtrn_rref_atyp()) == "rtrn_rref"
+    assert m.get_mtxt(m.rtrn_cref_atyp()) == "rtrn_cref"
+    assert m.get_mtxt(m.rtrn_mref_atyp()) == "rtrn_mref"
+    assert m.get_mtxt(m.rtrn_cptr_atyp()) == "rtrn_cptr"
+    assert m.get_mtxt(m.rtrn_mptr_atyp()) == "rtrn_mptr"
 
 
 def test_load():
-    assert m.pass_mpty_valu(m.mpty("Valu")) == "pass_valu:Valu"
-    assert m.pass_mpty_rref(m.mpty("Rref")) == "pass_rref:Rref"
-    assert m.pass_mpty_cref(m.mpty("Cref")) == "pass_cref:Cref"
-    assert m.pass_mpty_mref(m.mpty("Mref")) == "pass_mref:Mref"
-    assert m.pass_mpty_cptr(m.mpty("Cptr")) == "pass_cptr:Cptr"
-    assert m.pass_mpty_mptr(m.mpty("Mptr")) == "pass_mptr:Mptr"
+    assert m.pass_valu_atyp(m.atyp("Valu")) == "pass_valu:Valu"
+    assert m.pass_rref_atyp(m.atyp("Rref")) == "pass_rref:Rref"
+    assert m.pass_cref_atyp(m.atyp("Cref")) == "pass_cref:Cref"
+    assert m.pass_mref_atyp(m.atyp("Mref")) == "pass_mref:Mref"
+    assert m.pass_cptr_atyp(m.atyp("Cptr")) == "pass_cptr:Cptr"
+    assert m.pass_mptr_atyp(m.atyp("Mptr")) == "pass_mptr:Mptr"
 
 
 def test_cast_shared_ptr():
-    assert m.get_mtxt(m.rtrn_mpty_shmp()) == "rtrn_shmp"
-    assert m.get_mtxt(m.rtrn_mpty_shcp()) == "rtrn_shcp"
+    assert m.get_mtxt(m.rtrn_shmp_atyp()) == "rtrn_shmp"
+    assert m.get_mtxt(m.rtrn_shcp_atyp()) == "rtrn_shcp"
 
 
 def test_load_shared_ptr():
-    assert m.pass_mpty_shmp(m.mpty("Shmp")) == "pass_shmp:Shmp"
-    assert m.pass_mpty_shcp(m.mpty("Shcp")) == "pass_shcp:Shcp"
+    assert m.pass_shmp_atyp(m.atyp("Shmp")) == "pass_shmp:Shmp"
+    assert m.pass_shcp_atyp(m.atyp("Shcp")) == "pass_shcp:Shcp"
 
 
 def test_cast_unique_ptr():
-    assert m.get_mtxt(m.rtrn_mpty_uqmp()) == "rtrn_uqmp"
-    assert m.get_mtxt(m.rtrn_mpty_uqcp()) == "rtrn_uqcp"
+    assert m.get_mtxt(m.rtrn_uqmp_atyp()) == "rtrn_uqmp"
+    assert m.get_mtxt(m.rtrn_uqcp_atyp()) == "rtrn_uqcp"
 
 
 def test_load_unique_ptr():
-    assert m.pass_mpty_uqmp(m.mpty("Uqmp")) == "pass_uqmp:Uqmp"
-    assert m.pass_mpty_uqcp(m.mpty("Uqcp")) == "pass_uqcp:Uqcp"
+    assert m.pass_uqmp_atyp(m.atyp("Uqmp")) == "pass_uqmp:Uqmp"
+    assert m.pass_uqcp_atyp(m.atyp("Uqcp")) == "pass_uqcp:Uqcp"
 
 
 @pytest.mark.parametrize(
-    "pass_mpty, argm, rtrn",
+    "pass_atyp, argm, rtrn",
     [
-        (m.pass_mpty_uqmp, "Uqmp", "pass_uqmp:Uqmp"),
-        (m.pass_mpty_uqcp, "Uqcp", "pass_uqcp:Uqcp"),
+        (m.pass_uqmp_atyp, "Uqmp", "pass_uqmp:Uqmp"),
+        (m.pass_uqcp_atyp, "Uqcp", "pass_uqcp:Uqcp"),
     ],
 )
-def test_pass_unique_ptr_disowns(pass_mpty, argm, rtrn):
-    obj = m.mpty(argm)
-    assert pass_mpty(obj) == rtrn
+def test_pass_unique_ptr_disowns(pass_atyp, argm, rtrn):
+    obj = m.atyp(argm)
+    assert pass_atyp(obj) == rtrn
     with pytest.raises(RuntimeError) as exc_info:
-        m.pass_mpty_uqmp(obj)
+        m.pass_uqmp_atyp(obj)
     assert str(exc_info.value) == (
         "Missing value for wrapped C++ type:"
         " Python instance is uninitialized or was disowned."
@@ -71,7 +71,7 @@ def test_pass_unique_ptr_disowns(pass_mpty, argm, rtrn):
 
 def test_unique_ptr_roundtrip(num_round_trips=1000):
     # Multiple roundtrips to stress-test instance registration/deregistration.
-    recycled = m.mpty("passenger")
+    recycled = m.atyp("passenger")
     for _ in range(num_round_trips):
         id_orig = id(recycled)
         recycled = m.unique_ptr_roundtrip(recycled)

From 6e825d33408022d991225edf4aa9d969fc25665f Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 08:49:48 -0800
Subject: [PATCH 089/206] Adopting systematic naming scheme from
 test_classh_wip. NO functional changes.

---
 tests/classh_module_local_0.cpp   | 14 +++++++-------
 tests/classh_module_local_1.cpp   | 20 ++++++++++----------
 tests/classh_module_local_2.cpp   | 20 ++++++++++----------
 tests/test_classh_module_local.py | 26 +++++++++++++-------------
 4 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/tests/classh_module_local_0.cpp b/tests/classh_module_local_0.cpp
index 1e543c824e..39c391c953 100644
--- a/tests/classh_module_local_0.cpp
+++ b/tests/classh_module_local_0.cpp
@@ -5,23 +5,23 @@
 namespace pybind11_tests {
 namespace classh_module_local {
 
-struct bottle {
-    std::string msg;
+struct atyp { // Short for "any type".
+    std::string mtxt;
 };
 
-std::string get_msg(const bottle &b) { return b.msg; }
+std::string get_mtxt(const atyp &obj) { return obj.mtxt; }
 
-bottle make_bottle() { return bottle(); }
+atyp rtrn_valu_atyp() { return atyp(); }
 
 } // namespace classh_module_local
 } // namespace pybind11_tests
 
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_module_local::bottle)
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_module_local::atyp)
 
 PYBIND11_MODULE(classh_module_local_0, m) {
     using namespace pybind11_tests::classh_module_local;
 
-    m.def("get_msg", get_msg);
+    m.def("get_mtxt", get_mtxt);
 
-    m.def("make_bottle", make_bottle);
+    m.def("rtrn_valu_atyp", rtrn_valu_atyp);
 }
diff --git a/tests/classh_module_local_1.cpp b/tests/classh_module_local_1.cpp
index 456c863c1c..04e21cf087 100644
--- a/tests/classh_module_local_1.cpp
+++ b/tests/classh_module_local_1.cpp
@@ -6,28 +6,28 @@
 namespace pybind11_tests {
 namespace classh_module_local {
 
-struct bottle {
-    std::string msg;
+struct atyp { // Short for "any type".
+    std::string mtxt;
 };
 
-std::string get_msg(const bottle &b) { return b.msg; }
+std::string get_mtxt(const atyp &obj) { return obj.mtxt; }
 
 } // namespace classh_module_local
 } // namespace pybind11_tests
 
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_module_local::bottle)
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_module_local::atyp)
 
 PYBIND11_MODULE(classh_module_local_1, m) {
     namespace py = pybind11;
     using namespace pybind11_tests::classh_module_local;
 
-    py::classh<bottle>(m, "bottle", py::module_local())
-        .def(py::init([](const std::string &msg) {
-            bottle obj;
-            obj.msg = msg;
+    py::classh<atyp>(m, "atyp", py::module_local())
+        .def(py::init([](const std::string &mtxt) {
+            atyp obj;
+            obj.mtxt = mtxt;
             return obj;
         }))
-        .def("tag", [](const bottle &) { return 1; });
+        .def("tag", [](const atyp &) { return 1; });
 
-    m.def("get_msg", get_msg);
+    m.def("get_mtxt", get_mtxt);
 }
diff --git a/tests/classh_module_local_2.cpp b/tests/classh_module_local_2.cpp
index f9837e889d..596e6626d7 100644
--- a/tests/classh_module_local_2.cpp
+++ b/tests/classh_module_local_2.cpp
@@ -6,28 +6,28 @@
 namespace pybind11_tests {
 namespace classh_module_local {
 
-struct bottle {
-    std::string msg;
+struct atyp { // Short for "any type".
+    std::string mtxt;
 };
 
-std::string get_msg(const bottle &b) { return b.msg; }
+std::string get_mtxt(const atyp &obj) { return obj.mtxt; }
 
 } // namespace classh_module_local
 } // namespace pybind11_tests
 
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_module_local::bottle)
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_module_local::atyp)
 
 PYBIND11_MODULE(classh_module_local_2, m) {
     namespace py = pybind11;
     using namespace pybind11_tests::classh_module_local;
 
-    py::classh<bottle>(m, "bottle", py::module_local())
-        .def(py::init([](const std::string &msg) {
-            bottle obj;
-            obj.msg = msg;
+    py::classh<atyp>(m, "atyp", py::module_local())
+        .def(py::init([](const std::string &mtxt) {
+            atyp obj;
+            obj.mtxt = mtxt;
             return obj;
         }))
-        .def("tag", [](const bottle &) { return 2; });
+        .def("tag", [](const atyp &) { return 2; });
 
-    m.def("get_msg", get_msg);
+    m.def("get_mtxt", get_mtxt);
 }
diff --git a/tests/test_classh_module_local.py b/tests/test_classh_module_local.py
index b9e6b414c5..f7113efe57 100644
--- a/tests/test_classh_module_local.py
+++ b/tests/test_classh_module_local.py
@@ -6,22 +6,22 @@
 import classh_module_local_2 as m2
 
 
-def test_cross_module_get_msg():
-    b1 = m1.bottle("A")
-    assert b1.tag() == 1
-    b2 = m2.bottle("B")
-    assert b2.tag() == 2
-    assert m1.get_msg(b1) == "A"
-    assert m2.get_msg(b2) == "B"
-    assert m1.get_msg(b2) == "B"
-    assert m2.get_msg(b1) == "A"
-    assert m0.get_msg(b1) == "A"
-    assert m0.get_msg(b2) == "B"
+def test_cross_module_get_mtxt():
+    obj1 = m1.atyp("A")
+    assert obj1.tag() == 1
+    obj2 = m2.atyp("B")
+    assert obj2.tag() == 2
+    assert m1.get_mtxt(obj1) == "A"
+    assert m2.get_mtxt(obj2) == "B"
+    assert m1.get_mtxt(obj2) == "B"
+    assert m2.get_mtxt(obj1) == "A"
+    assert m0.get_mtxt(obj1) == "A"
+    assert m0.get_mtxt(obj2) == "B"
 
 
-def test_m0_make_bottle():
+def test_m0_rtrn_valu_atyp():
     with pytest.raises(TypeError) as exc_info:
-        m0.make_bottle()
+        m0.rtrn_valu_atyp()
     assert str(exc_info.value).startswith(
         "Unable to convert function return value to a Python type!"
     )

From 4bd7394e2d17c57d87827b6c749ba0c6ea0aadc1 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 09:13:45 -0800
Subject: [PATCH 090/206] Moving const after type name, for functions that
 cover a systematic scheme. NO functional changes.

---
 tests/test_classh_inheritance.cpp | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/tests/test_classh_inheritance.cpp b/tests/test_classh_inheritance.cpp
index fa7f9aadd7..ed944e521b 100644
--- a/tests/test_classh_inheritance.cpp
+++ b/tests/test_classh_inheritance.cpp
@@ -23,8 +23,8 @@ struct drvd : base {
 inline drvd *rtrn_mptr_drvd()         { return new drvd; }
 inline base *rtrn_mptr_drvd_up_cast() { return new drvd; }
 
-inline int pass_cptr_base(const base *b) { return b->id() + 11; }
-inline int pass_cptr_drvd(const drvd *d) { return d->id() + 12; }
+inline int pass_cptr_base(base const *b) { return b->id() + 11; }
+inline int pass_cptr_drvd(drvd const *d) { return d->id() + 12; }
 // clang-format on
 
 using base1 = base_template<110>;
@@ -40,9 +40,9 @@ inline drvd2 *rtrn_mptr_drvd2()          { return new drvd2; }
 inline base1 *rtrn_mptr_drvd2_up_cast1() { return new drvd2; }
 inline base2 *rtrn_mptr_drvd2_up_cast2() { return new drvd2; }
 
-inline int pass_cptr_base1(const base1 *b) { return b->id() + 21; }
-inline int pass_cptr_base2(const base2 *b) { return b->id() + 22; }
-inline int pass_cptr_drvd2(const drvd2 *d) { return d->id() + 23; }
+inline int pass_cptr_base1(base1 const *b) { return b->id() + 21; }
+inline int pass_cptr_base2(base2 const *b) { return b->id() + 22; }
+inline int pass_cptr_drvd2(drvd2 const *d) { return d->id() + 23; }
 // clang-format on
 
 } // namespace classh_inheritance
@@ -62,9 +62,10 @@ TEST_SUBMODULE(classh_inheritance, m) {
     py::classh<base>(m, "base");
     py::classh<drvd, base>(m, "drvd");
 
-    m.def("rtrn_mptr_drvd", rtrn_mptr_drvd, py::return_value_policy::take_ownership);
-    m.def(
-        "rtrn_mptr_drvd_up_cast", rtrn_mptr_drvd_up_cast, py::return_value_policy::take_ownership);
+    auto rvto = py::return_value_policy::take_ownership;
+
+    m.def("rtrn_mptr_drvd", rtrn_mptr_drvd, rvto);
+    m.def("rtrn_mptr_drvd_up_cast", rtrn_mptr_drvd_up_cast, rvto);
     m.def("pass_cptr_base", pass_cptr_base);
     m.def("pass_cptr_drvd", pass_cptr_drvd);
 
@@ -72,13 +73,9 @@ TEST_SUBMODULE(classh_inheritance, m) {
     py::classh<base2>(m, "base2").def(py::init<>());
     py::classh<drvd2, base1, base2>(m, "drvd2");
 
-    m.def("rtrn_mptr_drvd2", rtrn_mptr_drvd2, py::return_value_policy::take_ownership);
-    m.def("rtrn_mptr_drvd2_up_cast1",
-          rtrn_mptr_drvd2_up_cast1,
-          py::return_value_policy::take_ownership);
-    m.def("rtrn_mptr_drvd2_up_cast2",
-          rtrn_mptr_drvd2_up_cast2,
-          py::return_value_policy::take_ownership);
+    m.def("rtrn_mptr_drvd2", rtrn_mptr_drvd2, rvto);
+    m.def("rtrn_mptr_drvd2_up_cast1", rtrn_mptr_drvd2_up_cast1, rvto);
+    m.def("rtrn_mptr_drvd2_up_cast2", rtrn_mptr_drvd2_up_cast2, rvto);
     m.def("pass_cptr_base1", pass_cptr_base1);
     m.def("pass_cptr_base2", pass_cptr_base2);
     m.def("pass_cptr_drvd2", pass_cptr_drvd2);

From 45dfd26f269f4815271a36eb1dc1b54ec4d0d8eb Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 10:09:20 -0800
Subject: [PATCH 091/206] Adding
 smart_holder_type_caster_load::loaded_as_shared_ptr, currently bypassing
 smart_holder shared_ptr tracking completely, but the tests pass and are
 sanitizer clean.

---
 include/pybind11/detail/classh_type_casters.h | 21 ++++++++++++-------
 tests/test_classh_inheritance.cpp             | 13 ++++++++++++
 tests/test_classh_inheritance.py              | 14 +++++++++++++
 3 files changed, 40 insertions(+), 8 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index 267d46c010..033a5ead15 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -231,7 +231,8 @@ struct smart_holder_type_caster_load {
         return true;
     }
 
-    T *as_raw_ptr_unowned() {
+    T *loaded_as_raw_ptr_unowned() {
+        // BYPASSES smart_holder type checking completely.
         if (load_impl.loaded_v_h_cpptype != nullptr) {
             if (load_impl.reinterpret_cast_deemed_ok) {
                 return static_cast<T *>(loaded_smhldr_ptr->vptr.get());
@@ -241,7 +242,13 @@ struct smart_holder_type_caster_load {
                 return static_cast<T *>(implicit_casted);
             }
         }
-        return loaded_smhldr_ptr->as_raw_ptr_unowned<T>();
+        return static_cast<T *>(loaded_smhldr_ptr->vptr.get());
+    }
+
+    std::shared_ptr<T> loaded_as_shared_ptr() {
+        T *raw_ptr = loaded_as_raw_ptr_unowned();
+        // BYPASSES smart_holder shared_ptr tracking completely.
+        return std::shared_ptr<T>(loaded_smhldr_ptr->vptr, raw_ptr);
     }
 
     std::unique_ptr<T> loaded_as_unique_ptr() {
@@ -350,8 +357,8 @@ struct classh_type_caster : smart_holder_type_caster_load<T> {
     operator T&&() &&   { return this->loaded_smhldr_ptr->template rvalue_ref<T>(); }
     operator T const&() { return this->loaded_smhldr_ptr->template lvalue_ref<T>(); }
     operator T&()       { return this->loaded_smhldr_ptr->template lvalue_ref<T>(); }
-    operator T const*() { return this->as_raw_ptr_unowned(); }
-    operator T*()       { return this->as_raw_ptr_unowned(); }
+    operator T const*() { return this->loaded_as_raw_ptr_unowned(); }
+    operator T*()       { return this->loaded_as_raw_ptr_unowned(); }
 
     // clang-format on
 
@@ -487,7 +494,7 @@ struct classh_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_load<T>
     template <typename>
     using cast_op_type = std::shared_ptr<T>;
 
-    operator std::shared_ptr<T>() { return this->loaded_smhldr_ptr->template as_shared_ptr<T>(); }
+    operator std::shared_ptr<T>() { return this->loaded_as_shared_ptr(); }
 };
 
 template <typename T>
@@ -505,9 +512,7 @@ struct classh_type_caster<std::shared_ptr<T const>> : smart_holder_type_caster_l
     template <typename>
     using cast_op_type = std::shared_ptr<T const>;
 
-    operator std::shared_ptr<T const>() {
-        return this->loaded_smhldr_ptr->template as_shared_ptr<T>();
-    }
+    operator std::shared_ptr<T const>() { return this->loaded_as_shared_ptr(); } // Mutbl2Const
 };
 
 template <typename T>
diff --git a/tests/test_classh_inheritance.cpp b/tests/test_classh_inheritance.cpp
index ed944e521b..2694d051fd 100644
--- a/tests/test_classh_inheritance.cpp
+++ b/tests/test_classh_inheritance.cpp
@@ -2,6 +2,8 @@
 
 #include <pybind11/classh.h>
 
+#include <memory>
+
 namespace pybind11_tests {
 namespace classh_inheritance {
 
@@ -25,6 +27,12 @@ inline base *rtrn_mptr_drvd_up_cast() { return new drvd; }
 
 inline int pass_cptr_base(base const *b) { return b->id() + 11; }
 inline int pass_cptr_drvd(drvd const *d) { return d->id() + 12; }
+
+inline std::shared_ptr<drvd> rtrn_shmp_drvd()         { return std::shared_ptr<drvd>(new drvd); }
+inline std::shared_ptr<base> rtrn_shmp_drvd_up_cast() { return std::shared_ptr<drvd>(new drvd); }
+
+inline int pass_shcp_base(std::shared_ptr<base const> b) { return b->id() + 21; }
+inline int pass_shcp_drvd(std::shared_ptr<drvd const> d) { return d->id() + 22; }
 // clang-format on
 
 using base1 = base_template<110>;
@@ -69,6 +77,11 @@ TEST_SUBMODULE(classh_inheritance, m) {
     m.def("pass_cptr_base", pass_cptr_base);
     m.def("pass_cptr_drvd", pass_cptr_drvd);
 
+    m.def("rtrn_shmp_drvd", rtrn_shmp_drvd);
+    m.def("rtrn_shmp_drvd_up_cast", rtrn_shmp_drvd_up_cast);
+    m.def("pass_shcp_base", pass_shcp_base);
+    m.def("pass_shcp_drvd", pass_shcp_drvd);
+
     py::classh<base1>(m, "base1").def(py::init<>()); // __init__ needed for Python inheritance.
     py::classh<base2>(m, "base2").def(py::init<>());
     py::classh<drvd2, base1, base2>(m, "drvd2");
diff --git a/tests/test_classh_inheritance.py b/tests/test_classh_inheritance.py
index 8421bc3047..cf72c5bc4a 100644
--- a/tests/test_classh_inheritance.py
+++ b/tests/test_classh_inheritance.py
@@ -9,6 +9,12 @@ def test_rtrn_mptr_drvd_pass_cptr_base():
     assert i == 2 * 100 + 11
 
 
+def test_rtrn_shmp_drvd_pass_shcp_base():
+    d = m.rtrn_shmp_drvd()
+    i = m.pass_shcp_base(d)  # load_impl Case 2a
+    assert i == 2 * 100 + 21
+
+
 def test_rtrn_mptr_drvd_up_cast_pass_cptr_drvd():
     b = m.rtrn_mptr_drvd_up_cast()
     # the base return is down-cast immediately.
@@ -17,6 +23,14 @@ def test_rtrn_mptr_drvd_up_cast_pass_cptr_drvd():
     assert i == 2 * 100 + 12
 
 
+def test_rtrn_shmp_drvd_up_cast_pass_shcp_drvd():
+    b = m.rtrn_shmp_drvd_up_cast()
+    # the base return is down-cast immediately.
+    assert b.__class__.__name__ == "drvd"
+    i = m.pass_shcp_drvd(b)
+    assert i == 2 * 100 + 22
+
+
 def test_rtrn_mptr_drvd2_pass_cptr_bases():
     d = m.rtrn_mptr_drvd2()
     i1 = m.pass_cptr_base1(d)  # load_impl Case 2c

From 49bf91f954d54921ed6c98c44a64b8ee226b8d61 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 11:10:01 -0800
Subject: [PATCH 092/206] Removing rtti_held from smart_holder. See updated
 comment.

---
 include/pybind11/detail/classh_type_casters.h |  8 +--
 include/pybind11/smart_holder_poc.h           | 69 ++++++++-----------
 tests/core/smart_holder_poc_test.cpp          | 34 ++++-----
 3 files changed, 48 insertions(+), 63 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index 033a5ead15..56790744db 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -353,10 +353,10 @@ struct classh_type_caster : smart_holder_type_caster_load<T> {
 
     // clang-format off
 
-    operator T()        { return this->loaded_smhldr_ptr->template lvalue_ref<T>(); }
-    operator T&&() &&   { return this->loaded_smhldr_ptr->template rvalue_ref<T>(); }
-    operator T const&() { return this->loaded_smhldr_ptr->template lvalue_ref<T>(); }
-    operator T&()       { return this->loaded_smhldr_ptr->template lvalue_ref<T>(); }
+    operator T()        { return this->loaded_smhldr_ptr->template as_lvalue_ref<T>(); }
+    operator T&&() &&   { return this->loaded_smhldr_ptr->template as_rvalue_ref<T>(); }
+    operator T const&() { return this->loaded_smhldr_ptr->template as_lvalue_ref<T>(); }
+    operator T&()       { return this->loaded_smhldr_ptr->template as_lvalue_ref<T>(); }
     operator T const*() { return this->loaded_as_raw_ptr_unowned(); }
     operator T*()       { return this->loaded_as_raw_ptr_unowned(); }
 
diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index d7145fd762..58e4bd5877 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -12,7 +12,13 @@ High-level aspects:
   C++ Undefined Behavior, especially from Python.
 
 * Support a system design with clean runtime inheritance casting. From this
-  it follows that the `smart_holder` needs to be type-erased (`void*`, RTTI).
+  it follows that the `smart_holder` needs to be type-erased (`void*`).
+
+* Handling of RTTI for the type-erased held pointer is NOT implemented here.
+  It is the responsibility of the caller to ensure that `static_cast<T *>`
+  is well-formed when calling `as_*` member functions. Inheritance casting
+  needs to be handled in a different layer (similar to the code organization
+  in boost/python/object/inheritance.hpp).
 
 Details:
 
@@ -28,10 +34,6 @@ High-level aspects:
 * If created from an external `shared_ptr`, or a `unique_ptr` with a custom
   deleter, including life-time management for external objects is infeasible.
 
-* The `typename T` between `from` and `as` calls must match exactly.
-  Inheritance casting needs to be handled in a different layer (similar
-  to the code organization in boost/python/object/inheritance.hpp).
-
 * The smart_holder is movable but not copyable, as a consequence of using
   unique_ptr for the vptr_deleter_armed_flag_ptr. Note that the bool for
   the flag has to live on the heap, for the smart_holder to be movable.
@@ -72,35 +74,30 @@ struct guarded_custom_deleter {
 };
 
 struct smart_holder {
-    const std::type_info *rtti_held;
     const std::type_info *rtti_uqp_del;
     std::unique_ptr<bool> vptr_deleter_armed_flag_ptr;
     std::shared_ptr<void> vptr;
     bool vptr_is_using_noop_deleter : 1;
     bool vptr_is_using_builtin_delete : 1;
     bool vptr_is_external_shared_ptr : 1;
+    bool is_populated : 1;
 
     smart_holder()
-        : rtti_held{nullptr}, rtti_uqp_del{nullptr}, vptr_is_using_noop_deleter{false},
-          vptr_is_using_builtin_delete{false}, vptr_is_external_shared_ptr{false} {}
+        : rtti_uqp_del{nullptr}, vptr_is_using_noop_deleter{false},
+          vptr_is_using_builtin_delete{false}, vptr_is_external_shared_ptr{false}, is_populated{
+                                                                                       false} {}
 
     explicit smart_holder(bool vptr_deleter_armed_flag)
-        : rtti_held{nullptr}, rtti_uqp_del{nullptr}, vptr_deleter_armed_flag_ptr{new bool{
-                                                         vptr_deleter_armed_flag}},
+        : rtti_uqp_del{nullptr}, vptr_deleter_armed_flag_ptr{new bool{vptr_deleter_armed_flag}},
           vptr_is_using_noop_deleter{false}, vptr_is_using_builtin_delete{false},
-          vptr_is_external_shared_ptr{false} {}
+          vptr_is_external_shared_ptr{false}, is_populated{false} {}
 
     bool has_pointee() const { return vptr.get() != nullptr; }
 
-    template <typename T>
-    void ensure_compatible_rtti_held(const char *context) const {
-        if (!rtti_held) {
+    void ensure_is_populated(const char *context) const {
+        if (!is_populated) {
             throw std::runtime_error(std::string("Unpopulated holder (") + context + ").");
         }
-        const std::type_info *rtti_requested = &typeid(T);
-        if (!(*rtti_requested == *rtti_held)) {
-            throw std::runtime_error(std::string("Incompatible type (") + context + ").");
-        }
     }
 
     template <typename D>
@@ -153,50 +150,47 @@ struct smart_holder {
     template <typename T>
     static smart_holder from_raw_ptr_unowned(T *raw_ptr) {
         smart_holder hld(false);
-        hld.rtti_held = &typeid(T);
         hld.vptr.reset(raw_ptr, guarded_builtin_delete<T>(hld.vptr_deleter_armed_flag_ptr.get()));
         hld.vptr_is_using_noop_deleter = true;
+        hld.is_populated               = true;
         return hld;
     }
 
     template <typename T>
     T *as_raw_ptr_unowned() const {
-        static const char *context = "as_raw_ptr_unowned";
-        ensure_compatible_rtti_held<T>(context);
         return static_cast<T *>(vptr.get());
     }
 
     template <typename T>
-    T &lvalue_ref() const {
-        static const char *context = "lvalue_ref";
-        ensure_compatible_rtti_held<T>(context);
+    T &as_lvalue_ref() const {
+        static const char *context = "as_lvalue_ref";
+        ensure_is_populated(context);
         ensure_has_pointee(context);
-        return *static_cast<T *>(vptr.get());
+        return *as_raw_ptr_unowned<T>();
     }
 
     template <typename T>
-    T &&rvalue_ref() const {
-        static const char *context = "rvalue_ref";
-        ensure_compatible_rtti_held<T>(context);
+    T &&as_rvalue_ref() const {
+        static const char *context = "as_rvalue_ref";
+        ensure_is_populated(context);
         ensure_has_pointee(context);
-        return std::move(*static_cast<T *>(vptr.get()));
+        return std::move(*as_raw_ptr_unowned<T>());
     }
 
     template <typename T>
     static smart_holder from_raw_ptr_take_ownership(T *raw_ptr) {
         smart_holder hld(true);
-        hld.rtti_held = &typeid(T);
         hld.vptr.reset(raw_ptr, guarded_builtin_delete<T>(hld.vptr_deleter_armed_flag_ptr.get()));
         hld.vptr_is_using_builtin_delete = true;
+        hld.is_populated                 = true;
         return hld;
     }
 
     template <typename T>
     T *as_raw_ptr_release_ownership(const char *context = "as_raw_ptr_release_ownership") {
-        ensure_compatible_rtti_held<T>(context);
         ensure_vptr_is_using_builtin_delete(context);
         ensure_use_count_1(context);
-        T *raw_ptr                   = static_cast<T *>(vptr.get());
+        T *raw_ptr                   = as_raw_ptr_unowned<T>();
         *vptr_deleter_armed_flag_ptr = false;
         vptr.reset();
         return raw_ptr;
@@ -205,11 +199,11 @@ struct smart_holder {
     template <typename T>
     static smart_holder from_unique_ptr(std::unique_ptr<T> &&unq_ptr) {
         smart_holder hld(true);
-        hld.rtti_held = &typeid(T);
         hld.vptr.reset(unq_ptr.get(),
                        guarded_builtin_delete<T>(hld.vptr_deleter_armed_flag_ptr.get()));
         unq_ptr.release();
         hld.vptr_is_using_builtin_delete = true;
+        hld.is_populated                 = true;
         return hld;
     }
 
@@ -221,21 +215,20 @@ struct smart_holder {
     template <typename T, typename D>
     static smart_holder from_unique_ptr_with_deleter(std::unique_ptr<T, D> &&unq_ptr) {
         smart_holder hld(true);
-        hld.rtti_held    = &typeid(T);
         hld.rtti_uqp_del = &typeid(D);
         hld.vptr.reset(unq_ptr.get(),
                        guarded_custom_deleter<T, D>(hld.vptr_deleter_armed_flag_ptr.get()));
         unq_ptr.release();
+        hld.is_populated = true;
         return hld;
     }
 
     template <typename T, typename D>
     std::unique_ptr<T, D> as_unique_ptr_with_deleter() {
         static const char *context = "as_unique_ptr_with_deleter";
-        ensure_compatible_rtti_held<T>(context);
         ensure_compatible_rtti_uqp_del<D>(context);
         ensure_use_count_1(context);
-        T *raw_ptr                   = static_cast<T *>(vptr.get());
+        T *raw_ptr                   = as_raw_ptr_unowned<T>();
         *vptr_deleter_armed_flag_ptr = false;
         vptr.reset();
         return std::unique_ptr<T, D>(raw_ptr);
@@ -244,16 +237,14 @@ struct smart_holder {
     template <typename T>
     static smart_holder from_shared_ptr(std::shared_ptr<T> shd_ptr) {
         smart_holder hld;
-        hld.rtti_held                   = &typeid(T);
         hld.vptr                        = std::static_pointer_cast<void>(shd_ptr);
         hld.vptr_is_external_shared_ptr = true;
+        hld.is_populated                = true;
         return hld;
     }
 
     template <typename T>
     std::shared_ptr<T> as_shared_ptr() const {
-        static const char *context = "as_shared_ptr";
-        ensure_compatible_rtti_held<T>(context);
         return std::static_pointer_cast<T>(vptr);
     }
 };
diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/core/smart_holder_poc_test.cpp
index e97cadbc9d..a4123b9157 100644
--- a/tests/core/smart_holder_poc_test.cpp
+++ b/tests/core/smart_holder_poc_test.cpp
@@ -32,17 +32,17 @@ TEST_CASE("from_raw_ptr_unowned+as_raw_ptr_unowned", "[S]") {
     REQUIRE(*hld.as_raw_ptr_unowned<int>() == 19);
 }
 
-TEST_CASE("from_raw_ptr_unowned+lvalue_ref", "[S]") {
+TEST_CASE("from_raw_ptr_unowned+as_lvalue_ref", "[S]") {
     static int value = 19;
     auto hld         = smart_holder::from_raw_ptr_unowned(&value);
-    REQUIRE(hld.lvalue_ref<int>() == 19);
+    REQUIRE(hld.as_lvalue_ref<int>() == 19);
 }
 
-TEST_CASE("from_raw_ptr_unowned+rvalue_ref", "[S]") {
+TEST_CASE("from_raw_ptr_unowned+as_rvalue_ref", "[S]") {
     helpers::movable_int orig(19);
     {
         auto hld = smart_holder::from_raw_ptr_unowned(&orig);
-        helpers::movable_int othr(hld.rvalue_ref<helpers::movable_int>());
+        helpers::movable_int othr(hld.as_rvalue_ref<helpers::movable_int>());
         REQUIRE(othr.valu == 19);
         REQUIRE(orig.valu == 91);
     }
@@ -78,10 +78,10 @@ TEST_CASE("from_raw_ptr_unowned+as_shared_ptr", "[S]") {
     REQUIRE(*hld.as_shared_ptr<int>() == 19);
 }
 
-TEST_CASE("from_raw_ptr_take_ownership+lvalue_ref", "[S]") {
+TEST_CASE("from_raw_ptr_take_ownership+as_lvalue_ref", "[S]") {
     auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
     REQUIRE(hld.has_pointee());
-    REQUIRE(hld.lvalue_ref<int>() == 19);
+    REQUIRE(hld.as_lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_raw_ptr_release_ownership1", "[S]") {
@@ -127,11 +127,11 @@ TEST_CASE("from_raw_ptr_take_ownership+as_shared_ptr", "[S]") {
     REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_unique_ptr+lvalue_ref", "[S]") {
+TEST_CASE("from_unique_ptr+as_lvalue_ref", "[S]") {
     std::unique_ptr<int> orig_owner(new int(19));
     auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
     REQUIRE(orig_owner.get() == nullptr);
-    REQUIRE(hld.lvalue_ref<int>() == 19);
+    REQUIRE(hld.as_lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_unique_ptr+as_raw_ptr_release_ownership1", "[S]") {
@@ -189,11 +189,11 @@ TEST_CASE("from_unique_ptr+as_shared_ptr", "[S]") {
     REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_unique_ptr_with_deleter+lvalue_ref", "[S]") {
+TEST_CASE("from_unique_ptr_with_deleter+as_lvalue_ref", "[S]") {
     std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
     auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
     REQUIRE(orig_owner.get() == nullptr);
-    REQUIRE(hld.lvalue_ref<int>() == 19);
+    REQUIRE(hld.as_lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+as_raw_ptr_release_ownership", "[E]") {
@@ -241,10 +241,10 @@ TEST_CASE("from_unique_ptr_with_deleter+as_shared_ptr", "[S]") {
     REQUIRE(*new_owner == 19);
 }
 
-TEST_CASE("from_shared_ptr+lvalue_ref", "[S]") {
+TEST_CASE("from_shared_ptr+as_lvalue_ref", "[S]") {
     std::shared_ptr<int> orig_owner(new int(19));
     auto hld = smart_holder::from_shared_ptr(orig_owner);
-    REQUIRE(hld.lvalue_ref<int>() == 19);
+    REQUIRE(hld.as_lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_shared_ptr+as_raw_ptr_release_ownership", "[E]") {
@@ -279,19 +279,13 @@ TEST_CASE("from_shared_ptr+as_shared_ptr", "[S]") {
 
 TEST_CASE("error_unpopulated_holder", "[E]") {
     smart_holder hld;
-    REQUIRE_THROWS_WITH(hld.as_raw_ptr_unowned<int>(), "Unpopulated holder (as_raw_ptr_unowned).");
-}
-
-TEST_CASE("error_incompatible_type", "[E]") {
-    static int value = 19;
-    auto hld         = smart_holder::from_raw_ptr_unowned(&value);
-    REQUIRE_THROWS_WITH(hld.as_unique_ptr<std::string>(), "Incompatible type (as_unique_ptr).");
+    REQUIRE_THROWS_WITH(hld.as_lvalue_ref<int>(), "Unpopulated holder (as_lvalue_ref).");
 }
 
 TEST_CASE("error_disowned_holder", "[E]") {
     auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
     hld.as_unique_ptr<int>();
-    REQUIRE_THROWS_WITH(hld.lvalue_ref<int>(), "Disowned holder (lvalue_ref).");
+    REQUIRE_THROWS_WITH(hld.as_lvalue_ref<int>(), "Disowned holder (as_lvalue_ref).");
 }
 
 TEST_CASE("error_cannot_disown_nullptr", "[E]") {

From f7ce7306219285ee68e5abb90ff6e8ac0613a765 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 11:46:14 -0800
Subject: [PATCH 093/206] Cleaning up loaded_as_raw_ptr_unowned,
 loaded_as_shared_ptr.

---
 include/pybind11/detail/classh_type_casters.h | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index 56790744db..b6a0cca143 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -232,23 +232,18 @@ struct smart_holder_type_caster_load {
     }
 
     T *loaded_as_raw_ptr_unowned() {
-        // BYPASSES smart_holder type checking completely.
-        if (load_impl.loaded_v_h_cpptype != nullptr) {
-            if (load_impl.reinterpret_cast_deemed_ok) {
-                return static_cast<T *>(loaded_smhldr_ptr->vptr.get());
-            }
-            if (load_impl.implicit_cast != nullptr) {
-                void *implicit_casted = load_impl.implicit_cast(loaded_smhldr_ptr->vptr.get());
-                return static_cast<T *>(implicit_casted);
-            }
+        void *void_ptr = loaded_smhldr_ptr->as_raw_ptr_unowned<void>();
+        if (load_impl.loaded_v_h_cpptype == nullptr || load_impl.reinterpret_cast_deemed_ok
+            || load_impl.implicit_cast == nullptr) {
+            return static_cast<T *>(void_ptr);
         }
-        return static_cast<T *>(loaded_smhldr_ptr->vptr.get());
+        void *implicit_casted = load_impl.implicit_cast(void_ptr);
+        return static_cast<T *>(implicit_casted);
     }
 
     std::shared_ptr<T> loaded_as_shared_ptr() {
         T *raw_ptr = loaded_as_raw_ptr_unowned();
-        // BYPASSES smart_holder shared_ptr tracking completely.
-        return std::shared_ptr<T>(loaded_smhldr_ptr->vptr, raw_ptr);
+        return std::shared_ptr<T>(loaded_smhldr_ptr->as_shared_ptr<void>(), raw_ptr);
     }
 
     std::unique_ptr<T> loaded_as_unique_ptr() {

From 877218b735214d2b47dc2e31c4454b9a41a977dd Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 13:35:13 -0800
Subject: [PATCH 094/206] Factoring out convert_type and folding into
 loaded_as_unique_ptr.

---
 include/pybind11/detail/classh_type_casters.h | 37 +++++++++++++------
 include/pybind11/smart_holder_poc.h           | 15 ++++++--
 2 files changed, 37 insertions(+), 15 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index b6a0cca143..5d838c3b14 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -231,29 +231,42 @@ struct smart_holder_type_caster_load {
         return true;
     }
 
-    T *loaded_as_raw_ptr_unowned() {
-        void *void_ptr = loaded_smhldr_ptr->as_raw_ptr_unowned<void>();
-        if (load_impl.loaded_v_h_cpptype == nullptr || load_impl.reinterpret_cast_deemed_ok
-            || load_impl.implicit_cast == nullptr) {
-            return static_cast<T *>(void_ptr);
+    T *convert_type(void *void_ptr) {
+        if (void_ptr != nullptr && load_impl.loaded_v_h_cpptype != nullptr
+            && !load_impl.reinterpret_cast_deemed_ok && load_impl.implicit_cast != nullptr) {
+            void_ptr = load_impl.implicit_cast(void_ptr);
         }
-        void *implicit_casted = load_impl.implicit_cast(void_ptr);
-        return static_cast<T *>(implicit_casted);
+        return static_cast<T *>(void_ptr);
+    }
+
+    T *loaded_as_raw_ptr_unowned() {
+        return convert_type(loaded_smhldr_ptr->as_raw_ptr_unowned<void>());
     }
 
     std::shared_ptr<T> loaded_as_shared_ptr() {
-        T *raw_ptr = loaded_as_raw_ptr_unowned();
-        return std::shared_ptr<T>(loaded_smhldr_ptr->as_shared_ptr<void>(), raw_ptr);
+        std::shared_ptr<void> void_ptr = loaded_smhldr_ptr->as_shared_ptr<void>();
+        return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
     }
 
     std::unique_ptr<T> loaded_as_unique_ptr() {
-        void *value_void_ptr = load_impl.loaded_v_h.value_ptr();
-        auto unq_ptr         = loaded_smhldr_ptr->as_unique_ptr<T>();
+        loaded_smhldr_ptr->ensure_can_release_ownership();
+        auto raw_void_ptr = loaded_smhldr_ptr->as_raw_ptr_unowned<void>();
+        // MISSING: Safety checks for type conversions
+        // (T must be polymorphic or meet certain other conditions).
+        T *raw_type_ptr = convert_type(raw_void_ptr);
+
+        // Critical transfer-of-ownership section. This must stay together.
+        loaded_smhldr_ptr->release_ownership();
+        auto result = std::unique_ptr<T>(raw_type_ptr);
+
+        void *value_void_ptr
+            = load_impl.loaded_v_h.value_ptr(); // Expected to be identical to raw_void_ptr.
         load_impl.loaded_v_h.holder<holder_type>().~holder_type();
         load_impl.loaded_v_h.set_holder_constructed(false);
         load_impl.loaded_v_h.value_ptr() = nullptr;
         deregister_instance(load_impl.loaded_v_h.inst, value_void_ptr, load_impl.loaded_v_h.type);
-        return unq_ptr;
+
+        return result;
     }
 
 protected:
diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/smart_holder_poc.h
index 58e4bd5877..d0a8ce368e 100644
--- a/include/pybind11/smart_holder_poc.h
+++ b/include/pybind11/smart_holder_poc.h
@@ -186,13 +186,22 @@ struct smart_holder {
         return hld;
     }
 
-    template <typename T>
-    T *as_raw_ptr_release_ownership(const char *context = "as_raw_ptr_release_ownership") {
+    void ensure_can_release_ownership(const char *context = "ensure_can_release_ownership") {
         ensure_vptr_is_using_builtin_delete(context);
         ensure_use_count_1(context);
-        T *raw_ptr                   = as_raw_ptr_unowned<T>();
+    }
+
+    // Caller is responsible for calling ensure_can_release_ownership().
+    void release_ownership() {
         *vptr_deleter_armed_flag_ptr = false;
         vptr.reset();
+    }
+
+    template <typename T>
+    T *as_raw_ptr_release_ownership(const char *context = "as_raw_ptr_release_ownership") {
+        ensure_can_release_ownership(context);
+        T *raw_ptr = as_raw_ptr_unowned<T>();
+        release_ownership();
         return raw_ptr;
     }
 

From be411c837b0bf3fc20620cf37157ff2cf9f6bb22 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 14:10:11 -0800
Subject: [PATCH 095/206] Folding convert_type into lvalue_ref and rvalue_ref
 paths. Some smart_holder_type_caster_load cleanup.

---
 include/pybind11/detail/classh_type_casters.h | 52 ++++++++++++-------
 1 file changed, 33 insertions(+), 19 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index 5d838c3b14..66bad20bc5 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -227,36 +227,41 @@ struct smart_holder_type_caster_load {
         load_impl = modified_type_caster_generic_load_impl(typeid(T));
         if (!load_impl.load(src, convert))
             return false;
-        loaded_smhldr_ptr = &load_impl.loaded_v_h.holder<holder_type>();
         return true;
     }
 
-    T *convert_type(void *void_ptr) {
-        if (void_ptr != nullptr && load_impl.loaded_v_h_cpptype != nullptr
-            && !load_impl.reinterpret_cast_deemed_ok && load_impl.implicit_cast != nullptr) {
-            void_ptr = load_impl.implicit_cast(void_ptr);
-        }
-        return static_cast<T *>(void_ptr);
+    T *loaded_as_raw_ptr_unowned() const {
+        return convert_type(holder().template as_raw_ptr_unowned<void>());
+    }
+
+    T &loaded_as_lvalue_ref() const {
+        static const char *context = "loaded_as_lvalue_ref";
+        holder().ensure_is_populated(context);
+        holder().ensure_has_pointee(context);
+        return *loaded_as_raw_ptr_unowned();
     }
 
-    T *loaded_as_raw_ptr_unowned() {
-        return convert_type(loaded_smhldr_ptr->as_raw_ptr_unowned<void>());
+    T &&loaded_as_rvalue_ref() const {
+        static const char *context = "loaded_as_rvalue_ref";
+        holder().ensure_is_populated(context);
+        holder().ensure_has_pointee(context);
+        return std::move(*loaded_as_raw_ptr_unowned());
     }
 
     std::shared_ptr<T> loaded_as_shared_ptr() {
-        std::shared_ptr<void> void_ptr = loaded_smhldr_ptr->as_shared_ptr<void>();
+        std::shared_ptr<void> void_ptr = holder().template as_shared_ptr<void>();
         return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
     }
 
     std::unique_ptr<T> loaded_as_unique_ptr() {
-        loaded_smhldr_ptr->ensure_can_release_ownership();
-        auto raw_void_ptr = loaded_smhldr_ptr->as_raw_ptr_unowned<void>();
+        holder().ensure_can_release_ownership();
+        auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
         // MISSING: Safety checks for type conversions
         // (T must be polymorphic or meet certain other conditions).
         T *raw_type_ptr = convert_type(raw_void_ptr);
 
         // Critical transfer-of-ownership section. This must stay together.
-        loaded_smhldr_ptr->release_ownership();
+        holder().release_ownership();
         auto result = std::unique_ptr<T>(raw_type_ptr);
 
         void *value_void_ptr
@@ -269,9 +274,18 @@ struct smart_holder_type_caster_load {
         return result;
     }
 
-protected:
+private:
     modified_type_caster_generic_load_impl load_impl;
-    holder_type *loaded_smhldr_ptr = nullptr;
+
+    holder_type &holder() const { return load_impl.loaded_v_h.holder<holder_type>(); }
+
+    T *convert_type(void *void_ptr) const {
+        if (void_ptr != nullptr && load_impl.loaded_v_h_cpptype != nullptr
+            && !load_impl.reinterpret_cast_deemed_ok && load_impl.implicit_cast != nullptr) {
+            void_ptr = load_impl.implicit_cast(void_ptr);
+        }
+        return static_cast<T *>(void_ptr);
+    }
 };
 
 // type_caster_base BEGIN
@@ -361,10 +375,10 @@ struct classh_type_caster : smart_holder_type_caster_load<T> {
 
     // clang-format off
 
-    operator T()        { return this->loaded_smhldr_ptr->template as_lvalue_ref<T>(); }
-    operator T&&() &&   { return this->loaded_smhldr_ptr->template as_rvalue_ref<T>(); }
-    operator T const&() { return this->loaded_smhldr_ptr->template as_lvalue_ref<T>(); }
-    operator T&()       { return this->loaded_smhldr_ptr->template as_lvalue_ref<T>(); }
+    operator T()        { return this->loaded_as_lvalue_ref(); }
+    operator T&&() &&   { return this->loaded_as_rvalue_ref(); }
+    operator T const&() { return this->loaded_as_lvalue_ref(); }
+    operator T&()       { return this->loaded_as_lvalue_ref(); }
     operator T const*() { return this->loaded_as_raw_ptr_unowned(); }
     operator T*()       { return this->loaded_as_raw_ptr_unowned(); }
 

From 73cb257e1bbaedd769abc3ce63f59ad5f9c846df Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 22:01:00 -0800
Subject: [PATCH 096/206] Using unique_ptr in local_load to replace static
 variable. Also adding local_load_safety_guard.

---
 include/pybind11/detail/classh_type_casters.h | 38 +++++++++++++------
 1 file changed, 27 insertions(+), 11 deletions(-)

diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index 66bad20bc5..99afcdffd4 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -31,6 +31,9 @@ inline std::pair<bool, handle> find_existing_python_instance(void *src_void_ptr,
     return std::make_pair(false, handle());
 }
 
+// The modified_type_caster_generic_load_impl could replace type_caster_generic::load_impl but not
+// vice versa. The main difference is that the original code only propagates a reference to the
+// held value, while the modified implementation propagates value_and_holder.
 // clang-format off
 class modified_type_caster_generic_load_impl {
 public:
@@ -84,12 +87,14 @@ class modified_type_caster_generic_load_impl {
     }
 
     PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
-        // Not thread safe. But the GIL needs to be held anyway in the context of this code.
-        static modified_type_caster_generic_load_impl caster;
-        caster = modified_type_caster_generic_load_impl(ti);
-        if (caster.load(src, false)) {
+        std::unique_ptr<modified_type_caster_generic_load_impl> loader(
+            new modified_type_caster_generic_load_impl(ti));
+        if (loader->load(src, false)) {
             // Trick to work with the existing pybind11 internals.
-            return &caster; // Any pointer except nullptr;
+            // The void pointer is immediately captured in a new unique_ptr in
+            // try_load_foreign_module_local. If this assumption is violated sanitizers
+            // will most likely flag a leak (verified to be the case with ASAN).
+            return static_cast<void *>(loader.release());
         }
         return nullptr;
     }
@@ -108,15 +113,23 @@ class modified_type_caster_generic_load_impl {
             || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype)))
             return false;
 
-        void* void_ptr = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo);
-        if (void_ptr != nullptr) {
-            auto foreign_load_impl = static_cast<modified_type_caster_generic_load_impl *>(void_ptr);
+        void* foreign_loader_void_ptr =
+            foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo);
+        if (foreign_loader_void_ptr != nullptr) {
+            auto foreign_loader = std::unique_ptr<modified_type_caster_generic_load_impl>(
+                static_cast<modified_type_caster_generic_load_impl *>(foreign_loader_void_ptr));
+            // Magic number intentionally hard-coded for simplicity and maximum robustness.
+            if (foreign_loader->local_load_safety_guard != 37726257887406645) {
+                pybind11_fail(
+                    "Unexpected local_load_safety_guard,"
+                    " possibly due to py::class_ vs py::classh mixup.");
+            }
             if (loaded_v_h_cpptype != nullptr) {
                 pybind11_fail("classh_type_casters: try_load_foreign_module_local failure.");
             }
-            loaded_v_h = foreign_load_impl->loaded_v_h;
-            loaded_v_h_cpptype = foreign_load_impl->loaded_v_h_cpptype;
-            implicit_cast = foreign_load_impl->implicit_cast;
+            loaded_v_h = foreign_loader->loaded_v_h;
+            loaded_v_h_cpptype = foreign_loader->loaded_v_h_cpptype;
+            implicit_cast = foreign_loader->implicit_cast;
             return true;
         }
         return false;
@@ -216,6 +229,9 @@ class modified_type_caster_generic_load_impl {
     void *(*implicit_cast)(void *) = nullptr;
     value_and_holder loaded_v_h;
     bool reinterpret_cast_deemed_ok = false;
+    // Magic number intentionally hard-coded, to guard against class_ vs classh mixups.
+    // Ideally type_caster_generic would have a similar guard, but this requires a change there.
+    std::size_t local_load_safety_guard = 37726257887406645;
 };
 // clang-format on
 

From 149be46060a9576b9fbf1510ef45d1ca8ea72aa0 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 22:47:53 -0800
Subject: [PATCH 097/206] Converting test_unique_ptr_member to using classh:
 fully working, ASAN, MSAN, UBSAN clean.

---
 tests/test_unique_ptr_member.cpp | 87 +++++---------------------------
 tests/test_unique_ptr_member.py  | 31 ++++--------
 2 files changed, 24 insertions(+), 94 deletions(-)

diff --git a/tests/test_unique_ptr_member.cpp b/tests/test_unique_ptr_member.cpp
index ebe5e09ee8..415fb636f5 100644
--- a/tests/test_unique_ptr_member.cpp
+++ b/tests/test_unique_ptr_member.cpp
@@ -1,30 +1,21 @@
 #include "pybind11_tests.h"
 
-#include <pybind11/vptr_holder.h>
+#include <pybind11/classh.h>
 
-#include <iostream>
 #include <memory>
 
 namespace pybind11_tests {
 namespace unique_ptr_member {
 
-inline void to_cout(std::string text) { std::cout << text << std::endl; }
-
 class pointee { // NOT copyable.
-  public:
+public:
     pointee() = default;
 
-    int get_int() const {
-        to_cout("pointee::get_int()");
-        //TRIGGER_SEGSEV
-        return 213;
-    }
-
-    ~pointee() { to_cout("~pointee()"); }
+    int get_int() const { return 213; }
 
-  private:
+private:
     pointee(const pointee &) = delete;
-    pointee(pointee &&) = delete;
+    pointee(pointee &&)      = delete;
     pointee &operator=(const pointee &) = delete;
     pointee &operator=(pointee &&) = delete;
 };
@@ -34,88 +25,36 @@ inline std::unique_ptr<pointee> make_unique_pointee() {
 }
 
 class ptr_owner {
-  public:
+public:
     explicit ptr_owner(std::unique_ptr<pointee> ptr) : ptr_(std::move(ptr)) {}
 
     bool is_owner() const { return bool(ptr_); }
 
-    std::unique_ptr<pointee> give_up_ownership_via_unique_ptr() {
-        return std::move(ptr_);
-    }
-    std::shared_ptr<pointee> give_up_ownership_via_shared_ptr() {
-        return std::move(ptr_);
-    }
+    std::unique_ptr<pointee> give_up_ownership_via_unique_ptr() { return std::move(ptr_); }
+    std::shared_ptr<pointee> give_up_ownership_via_shared_ptr() { return std::move(ptr_); }
 
-  private:
+private:
     std::unique_ptr<pointee> ptr_;
 };
 
-// Just to have a minimal example of a typical C++ pattern.
-inline int cpp_pattern() {
-    auto obj = make_unique_pointee();
-    int result = (obj ? 1 : 8);
-    obj->get_int();
-    ptr_owner owner(std::move(obj));
-    result = result * 10 + (obj ? 8 : 1);
-    result = result * 10 + (owner.is_owner() ? 1 : 8);
-    to_cout("before give up");
-    auto reclaimed = owner.give_up_ownership_via_shared_ptr();
-    to_cout("after give up");
-    result = result * 10 + (owner.is_owner() ? 8 : 1);
-    result = result * 10 + (reclaimed ? 1 : 8);
-    reclaimed.reset();
-    to_cout("after del");
-    result = result * 10 + (reclaimed ? 8 : 1);
-    return result;
-}
-
 } // namespace unique_ptr_member
 } // namespace pybind11_tests
 
-namespace pybind11 {
-namespace detail {
-template <>
-struct type_caster<
-    std::unique_ptr<pybind11_tests::unique_ptr_member::pointee>> {
-  public:
-    PYBIND11_TYPE_CASTER(
-        std::unique_ptr<pybind11_tests::unique_ptr_member::pointee>,
-        _("std::unique_ptr<pybind11_tests::unique_ptr_member::pointee>"));
-
-    bool load(handle /* src */, bool) {
-        throw std::runtime_error("Not implemented: load");
-    }
-
-    static handle
-    cast(std::unique_ptr<pybind11_tests::unique_ptr_member::pointee> /* src */,
-         return_value_policy /* policy */, handle /* parent */) {
-        throw std::runtime_error("Not implemented: cast");
-    }
-};
-} // namespace detail
-} // namespace pybind11
+PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::unique_ptr_member::pointee)
 
 namespace pybind11_tests {
 namespace unique_ptr_member {
 
 TEST_SUBMODULE(unique_ptr_member, m) {
-    m.def("to_cout", to_cout);
-
-    py::class_<pointee, py::vptr_holder<pointee>>(m, "pointee")
-        .def(py::init<>())
-        .def("get_int", &pointee::get_int);
+    py::classh<pointee>(m, "pointee").def(py::init<>()).def("get_int", &pointee::get_int);
 
     m.def("make_unique_pointee", make_unique_pointee);
 
     py::class_<ptr_owner>(m, "ptr_owner")
         .def(py::init<std::unique_ptr<pointee>>(), py::arg("ptr"))
         .def("is_owner", &ptr_owner::is_owner)
-        .def("give_up_ownership_via_unique_ptr",
-             &ptr_owner::give_up_ownership_via_unique_ptr)
-        .def("give_up_ownership_via_shared_ptr",
-             &ptr_owner::give_up_ownership_via_shared_ptr);
-
-    m.def("cpp_pattern", cpp_pattern);
+        .def("give_up_ownership_via_unique_ptr", &ptr_owner::give_up_ownership_via_unique_ptr)
+        .def("give_up_ownership_via_shared_ptr", &ptr_owner::give_up_ownership_via_shared_ptr);
 }
 
 } // namespace unique_ptr_member
diff --git a/tests/test_unique_ptr_member.py b/tests/test_unique_ptr_member.py
index 85b07f6099..5ced1b3aed 100644
--- a/tests/test_unique_ptr_member.py
+++ b/tests/test_unique_ptr_member.py
@@ -5,34 +5,25 @@
 
 
 def test_make_unique_pointee():
-    m.to_cout("")
     obj = m.make_unique_pointee()
     assert obj.get_int() == 213
-    m.to_cout("")
 
 
-def test_pointee_and_ptr_owner():
-    m.to_cout("")
+@pytest.mark.parametrize(
+    "give_up_ownership_via",
+    ["give_up_ownership_via_unique_ptr", "give_up_ownership_via_shared_ptr"],
+)
+def test_pointee_and_ptr_owner(give_up_ownership_via):
     obj = m.pointee()
     assert obj.get_int() == 213
     owner = m.ptr_owner(obj)
     with pytest.raises(RuntimeError) as exc_info:
         obj.get_int()
-    assert str(exc_info.value) == "Invalid object instance"
+    assert (
+        str(exc_info.value)
+        == "Missing value for wrapped C++ type: Python instance is uninitialized or was disowned."
+    )
     assert owner.is_owner()
-    m.to_cout("before give up")
-    reclaimed = owner.give_up_ownership_via_shared_ptr()
-    m.to_cout("after give up")
+    reclaimed = getattr(owner, give_up_ownership_via)()
     assert not owner.is_owner()
-    # assert reclaimed.get_int() == 213
-    del reclaimed
-    m.to_cout("after del")
-    m.to_cout("3")
-    m.to_cout("")
-
-
-def test_cpp_pattern():
-    m.to_cout("")
-    res = m.cpp_pattern()
-    assert res == 111111
-    m.to_cout("")
+    assert reclaimed.get_int() == 213

From 60dc8f35ace973094d17d9bce393ce1495cc1b9f Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 23:16:51 -0800
Subject: [PATCH 098/206] Removing debugging comments (GET_STACK,
 GET_INT_STACK). cast.h is identical to current master again, pybind11.h only
 has the generic_type::initialize(..., &type_caster_generic::local_load)
 change.

---
 include/pybind11/cast.h     |  4 ++--
 include/pybind11/pybind11.h | 18 ++++++++----------
 2 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 8fe3ad7abc..df08b16e3e 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -2045,7 +2045,7 @@ class argument_loader {
 
     template <typename Return, typename Guard, typename Func>
     enable_if_t<!std::is_void<Return>::value, Return> call(Func &&f) && {
-        return std::move(*this).template call_impl<Return>(std::forward<Func>(f), indices{}, Guard{});  // GET_INT_STACK -3
+        return std::move(*this).template call_impl<Return>(std::forward<Func>(f), indices{}, Guard{});
     }
 
     template <typename Return, typename Guard, typename Func>
@@ -2073,7 +2073,7 @@ class argument_loader {
 
     template <typename Return, typename Func, size_t... Is, typename Guard>
     Return call_impl(Func &&f, index_sequence<Is...>, Guard &&) && {
-        return std::forward<Func>(f)(cast_op<Args>(std::move(std::get<Is>(argcasters)))...);  // GET_INT_STACK -2
+        return std::forward<Func>(f)(cast_op<Args>(std::move(std::get<Is>(argcasters)))...);
     }
 
     std::tuple<make_caster<Args>...> argcasters;
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index b7afb001f0..62b92ff357 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -57,8 +57,6 @@
 #  include <cxxabi.h>
 #endif
 
-#define TRIGGER_SEGSEV { unsigned long *bad = nullptr; *bad = -1; }
-
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 
 /// Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object
@@ -100,7 +98,7 @@ class cpp_function : public function {
     /// Construct a cpp_function from a class method (const, no ref-qualifier)
     template <typename Return, typename Class, typename... Arg, typename... Extra>
     cpp_function(Return (Class::*f)(Arg...) const, const Extra&... extra) {
-        initialize([f](const Class *c, Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },  // GET_INT_STACK -1
+        initialize([f](const Class *c, Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
                    (Return (*)(const Class *, Arg ...)) nullptr, extra...);
     }
 
@@ -170,7 +168,7 @@ class cpp_function : public function {
                       "The number of argument annotations does not match the number of function arguments");
 
         /* Dispatch code which converts function arguments and performs the actual function call */
-        rec->impl = [](function_call &call) -> handle {  // GET_INT_STACK -5
+        rec->impl = [](function_call &call) -> handle {
             cast_in args_converter;
 
             /* Try to cast the function arguments into the C++ domain */
@@ -193,7 +191,7 @@ class cpp_function : public function {
 
             /* Perform the function call */
             handle result = cast_out::cast(
-                std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);  // GET_INT_STACK -4
+                std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
 
             /* Invoke call policy post-call hook */
             process_attributes<Extra...>::postcall(call, result);
@@ -555,7 +553,7 @@ class cpp_function : public function {
         handle parent = n_args_in > 0 ? PyTuple_GET_ITEM(args_in, 0) : nullptr,
                result = PYBIND11_TRY_NEXT_OVERLOAD;
 
-        auto self_value_and_holder = value_and_holder(); // cast.h
+        auto self_value_and_holder = value_and_holder();
         if (overloads->is_constructor) {
             if (!PyObject_TypeCheck(parent.ptr(), (PyTypeObject *) overloads->scope.ptr())) {
                 PyErr_SetString(PyExc_TypeError, "__init__(self, ...) called with invalid `self` argument");
@@ -767,7 +765,7 @@ class cpp_function : public function {
                 // 6. Call the function.
                 try {
                     loader_life_support guard{};
-                    result = func.impl(call);  // GET_INT_STACK -6
+                    result = func.impl(call);
                 } catch (reference_cast_error &) {
                     result = PYBIND11_TRY_NEXT_OVERLOAD;
                 }
@@ -933,7 +931,7 @@ class cpp_function : public function {
         } else {
             if (overloads->is_constructor && !self_value_and_holder.holder_constructed()) {
                 auto *pi = reinterpret_cast<instance *>(parent.ptr());
-                self_value_and_holder.type->init_instance(pi, nullptr);  // GET_STACK -4
+                self_value_and_holder.type->init_instance(pi, nullptr);
             }
             return result.ptr();
         }
@@ -1540,7 +1538,7 @@ class class_ : public detail::generic_type {
             init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
             v_h.set_holder_constructed();
         } else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());  // GET_STACK -2
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
             v_h.set_holder_constructed();
         }
     }
@@ -1555,7 +1553,7 @@ class class_ : public detail::generic_type {
             register_instance(inst, v_h.value_ptr(), v_h.type);
             v_h.set_instance_registered();
         }
-        init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());  // GET_STACK -3
+        init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
     }
 
     /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.

From b93c240ad18d0e55858e597e6e5124dea93c8d64 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 23 Jan 2021 23:25:19 -0800
Subject: [PATCH 099/206] Purging obsolete pybind11/vptr_holder.h and
 associated test.

---
 include/pybind11/vptr_holder.h       | 77 ----------------------------
 tests/test_variant_unique_shared.cpp | 54 -------------------
 tests/test_variant_unique_shared.py  | 61 ----------------------
 3 files changed, 192 deletions(-)
 delete mode 100644 include/pybind11/vptr_holder.h
 delete mode 100644 tests/test_variant_unique_shared.cpp
 delete mode 100644 tests/test_variant_unique_shared.py

diff --git a/include/pybind11/vptr_holder.h b/include/pybind11/vptr_holder.h
deleted file mode 100644
index 1de37adc8f..0000000000
--- a/include/pybind11/vptr_holder.h
+++ /dev/null
@@ -1,77 +0,0 @@
-#pragma once
-
-#include <pybind11/pybind11.h>
-
-#include <iostream>
-#include <memory>
-#include <variant>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-// Could this be a holder for a `class_`-like `vclass`?
-// To enable passing of unique_ptr as in pure C++.
-template <typename T> class vptr {
-  public:
-    explicit vptr(T *ptr = nullptr) : vptr_{std::unique_ptr<T>(ptr)} {
-        std::cout << std::endl << "explicit vptr(T *ptr = nullptr)" << std::endl;
-        //TRIGGER_SEGSEV
-    }
-    explicit vptr(std::unique_ptr<T> u) : vptr_{std::move(u)} { std::cout << std::endl << "explicit vptr(std::unique_ptr<T> u)" << std::endl; }
-    explicit vptr(std::shared_ptr<T> s) : vptr_{s} { std::cout << std::endl << "explicit vptr(std::shared_ptr<T> s)" << std::endl; }
-
-    int ownership_type() const {
-        if (std::get_if<0>(&vptr_)) {
-            return 0;
-        }
-        if (std::get_if<1>(&vptr_)) {
-            return 1;
-        }
-        return -1;
-    }
-
-    T *get() {
-        std::cout << std::endl << "vptr::get" << std::endl;
-        auto u = std::get_if<0>(&vptr_);
-        if (u) {
-            return u->get();
-        }
-        auto s = std::get_if<1>(&vptr_);
-        if (s) {
-            return s->get();
-        }
-        return nullptr;
-    }
-
-    std::unique_ptr<T> get_unique() {
-        auto u = std::get_if<0>(&vptr_);
-        if (u) {
-            return std::move(*u);
-        }
-        throw std::runtime_error("get_unique failure.");
-    }
-
-    std::shared_ptr<T> get_shared() {
-        auto s = std::get_if<1>(&vptr_);
-        if (s) {
-            return *s;
-        }
-        auto u = std::get_if<0>(&vptr_);
-        if (u) {
-            auto result = std::shared_ptr<T>(std::move(*u));
-            vptr_ = result;
-            return result;
-        }
-        throw std::runtime_error("get_shared failure.");
-    }
-
-  private:
-    std::variant<std::unique_ptr<T>, std::shared_ptr<T>> vptr_;
-};
-
-template <typename T> class vptr_holder : public vptr<T> {
-    using vptr<T>::vptr;  // GET_STACK -1
-};
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
-
-PYBIND11_DECLARE_HOLDER_TYPE(T, pybind11::vptr_holder<T>);
diff --git a/tests/test_variant_unique_shared.cpp b/tests/test_variant_unique_shared.cpp
deleted file mode 100644
index 9f083dafbd..0000000000
--- a/tests/test_variant_unique_shared.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "pybind11_tests.h"
-
-#include <pybind11/vptr_holder.h>
-
-#include <memory>
-#include <variant>
-
-namespace pybind11_tests {
-
-using pybind11::vptr;
-
-vptr<double> from_raw() { return vptr<double>{new double{3}}; }
-
-vptr<double> from_unique() {
-    return vptr<double>{std::unique_ptr<double>(new double{5})};
-}
-
-vptr<double> from_shared() {
-    return vptr<double>{std::shared_ptr<double>(new double{7})};
-}
-
-TEST_SUBMODULE(variant_unique_shared, m) {
-
-    m.def("from_raw", from_raw);
-    m.def("from_unique", from_unique);
-    m.def("from_shared", from_shared);
-
-    py::class_<vptr<double>>(m, "vptr_double")
-        .def(py::init<>())
-        .def("ownership_type", &vptr<double>::ownership_type)
-        .def("get_value",
-             [](vptr<double> &v) {
-                 auto p = v.get();
-                 if (p)
-                     return *p;
-                 return -1.;
-             })
-        .def("get_unique",
-             [](vptr<double> &v) {
-                 v.get_unique();
-                 return;
-             })
-        .def("get_shared",
-             [](vptr<double> &v) {
-                 v.get_shared();
-                 return;
-             })
-        .def("disown_unique", [](vptr<double> &v) {
-            v.get_unique().reset();
-            return;
-        });
-}
-
-} // namespace pybind11_tests
diff --git a/tests/test_variant_unique_shared.py b/tests/test_variant_unique_shared.py
deleted file mode 100644
index 2ef0e40a7b..0000000000
--- a/tests/test_variant_unique_shared.py
+++ /dev/null
@@ -1,61 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-from pybind11_tests import variant_unique_shared as m
-
-
-def test_default_constructed():
-    v = m.vptr_double()
-    assert v.ownership_type() == 0
-    assert v.get_value() == -1
-
-
-def test_from_raw():
-    v = m.from_raw()
-    assert v.ownership_type() == 0
-    assert v.get_value() == 3
-
-
-def test_from_unique():
-    v = m.from_unique()
-    assert v.ownership_type() == 0
-    assert v.get_value() == 5
-
-
-def test_from_shared():
-    v = m.from_shared()
-    assert v.ownership_type() == 1
-    assert v.get_value() == 7
-
-
-def test_promotion_to_shared():
-    v = m.from_raw()
-    v.get_unique()
-    assert v.ownership_type() == 0
-    v.get_shared()  # Promotion to shared_ptr.
-    assert v.ownership_type() == 1
-    v.get_shared()  # Existing shared_ptr.
-    with pytest.raises(RuntimeError) as exc_info:
-        v.get_unique()
-    assert str(exc_info.value) == "get_unique failure."
-    v.get_shared()  # Still works.
-
-
-def test_shared_from_birth():
-    v = m.from_shared()
-    assert v.ownership_type() == 1
-    with pytest.raises(RuntimeError) as exc_info:
-        v.get_unique()
-    assert str(exc_info.value) == "get_unique failure."
-    v.get_shared()  # Still works.
-
-
-def test_promotion_of_disowned_to_shared():
-    v = m.from_unique()
-    assert v.get_value() == 5
-    v.disown_unique()
-    assert v.ownership_type() == 0
-    assert v.get_value() == -1
-    v.get_shared()  # Promotion of disowned to shared_ptr.
-    assert v.ownership_type() == 1
-    assert v.get_value() == -1

From a0cf20c8e8b5ac5cf4e7325dcf86b0bdb6dc717c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 24 Jan 2021 10:11:32 -0800
Subject: [PATCH 100/206] Moving several tests to
 github.com/rwgk/rwgk_tbx/tree/main/pybind11_tests

https://github.com/rwgk/rwgk_tbx/commit/a2c2f88174a30f5de80d7d26e0f77c7b60f5fb85

These tests are from experimenting, and for demonstrating UB in pybind11 multiple inheritance handling ("first_base"), to be fixed later.
---
 tests/test_cpp_base_py_derived.cpp          |  57 -------
 tests/test_cpp_base_py_derived.py           |  36 -----
 tests/test_holder_shared_ptr.cpp            |  69 ---------
 tests/test_holder_shared_ptr.py             |  56 -------
 tests/test_holder_unique_ptr.cpp            |  69 ---------
 tests/test_holder_unique_ptr.py             |  56 -------
 tests/test_private_first_base.cpp           |  63 --------
 tests/test_private_first_base.py            |  17 ---
 tests/test_smart_ptr_base_derived.cpp       | 160 --------------------
 tests/test_smart_ptr_base_derived.py        |  42 -----
 tests/test_smart_ptr_private_first_base.cpp |  58 -------
 tests/test_smart_ptr_private_first_base.py  |  17 ---
 12 files changed, 700 deletions(-)
 delete mode 100644 tests/test_cpp_base_py_derived.cpp
 delete mode 100644 tests/test_cpp_base_py_derived.py
 delete mode 100644 tests/test_holder_shared_ptr.cpp
 delete mode 100644 tests/test_holder_shared_ptr.py
 delete mode 100644 tests/test_holder_unique_ptr.cpp
 delete mode 100644 tests/test_holder_unique_ptr.py
 delete mode 100644 tests/test_private_first_base.cpp
 delete mode 100644 tests/test_private_first_base.py
 delete mode 100644 tests/test_smart_ptr_base_derived.cpp
 delete mode 100644 tests/test_smart_ptr_base_derived.py
 delete mode 100644 tests/test_smart_ptr_private_first_base.cpp
 delete mode 100644 tests/test_smart_ptr_private_first_base.py

diff --git a/tests/test_cpp_base_py_derived.cpp b/tests/test_cpp_base_py_derived.cpp
deleted file mode 100644
index cbc117f44a..0000000000
--- a/tests/test_cpp_base_py_derived.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-// pybind11 equivalent of Boost.Python test:
-// https://github.com/rwgk/rwgk_tbx/blob/6c9a6d6bc72d5c1b8609724433259c5b47178680/cpp_base_py_derived_ext.cpp
-// See also: https://github.com/pybind/pybind11/issues/1333 (this was the starting point)
-
-#include "pybind11_tests.h"
-
-namespace pybind11_tests {
-namespace cpp_base_py_derived {
-
-struct base {
-  base() : base_num(100) {}
-
-  virtual int get_num() const { return base_num; }
-
-  virtual std::shared_ptr<base> clone() const {
-    return std::shared_ptr<base>(new base(150));
-  }
-
-  virtual ~base() = default;
-
- private:
-  explicit base(int num) : base_num(num) {}
-  int base_num;
-};
-
-inline int get_num(std::shared_ptr<base> b) { return b->get_num(); }
-
-inline int clone_get_num(std::shared_ptr<base> b) {
-  std::shared_ptr<base> c = b->clone();
-  return (b->get_num() + 3) * 1000 + (c->get_num() + 7);
-}
-
-struct base_trampoline : public base {
-  using base::base;
-
-  int get_num() const override {
-    PYBIND11_OVERRIDE(int, base, get_num);
-  }
-
-  std::shared_ptr<base> clone() const override {
-    PYBIND11_OVERRIDE(std::shared_ptr<base>, base, clone);
-  }
-};
-
-TEST_SUBMODULE(cpp_base_py_derived, m) {
-  py::class_<base, base_trampoline, std::shared_ptr<base>>(m, "base")
-    .def(py::init<>())
-    .def("get_num", &base::get_num)
-    .def("clone", &base::clone)
-  ;
-
-  m.def("get_num", get_num);
-  m.def("clone_get_num", clone_get_num);
-}
-
-}  // namespace cpp_base_py_derived
-}  // namespace pybind11_tests
diff --git a/tests/test_cpp_base_py_derived.py b/tests/test_cpp_base_py_derived.py
deleted file mode 100644
index 3d601d3729..0000000000
--- a/tests/test_cpp_base_py_derived.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# -*- coding: utf-8 -*-
-# pybind11 equivalent of Boost.Python test:
-# https://github.com/rwgk/rwgk_tbx/blob/6c9a6d6bc72d5c1b8609724433259c5b47178680/tst_cpp_base_py_derived.py
-# See also: https://github.com/pybind/pybind11/issues/1333 (this was the starting point)
-
-from pybind11_tests import cpp_base_py_derived as m
-
-
-class drvd(m.base):  # noqa: N801
-    def __init__(self, _num=200):
-        super().__init__()
-        self._drvd_num = _num
-
-    def get_num(self):
-        return self._drvd_num
-
-    def clone(self):
-        return drvd(250)
-
-
-def test_base():
-    b = m.base()
-    assert b.get_num() == 100
-    assert m.get_num(b) == 100
-    bc = b.clone()
-    assert bc.get_num() == 150
-    assert m.clone_get_num(b) == 103157
-
-
-def test_drvd():
-    d = drvd()
-    assert d.get_num() == 200
-    assert m.get_num(d) == 200
-    dc = d.clone()
-    assert dc.get_num() == 250
-    assert m.clone_get_num(d) == 203257
diff --git a/tests/test_holder_shared_ptr.cpp b/tests/test_holder_shared_ptr.cpp
deleted file mode 100644
index ff248310e4..0000000000
--- a/tests/test_holder_shared_ptr.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// KEEP IN SYNC WITH test_holder_unique_ptr.cpp
-
-#include "pybind11_tests.h"
-
-#include <iostream>
-#include <memory>
-
-namespace pybind11_tests {
-namespace holder_shared_ptr {
-
-inline void to_cout(std::string text) { std::cout << text << std::endl; }
-
-class pointee { // NOT copyable.
-  public:
-    pointee() { to_cout("pointee::pointee()"); }
-
-    int get_int() const {
-        to_cout("pointee::get_int()");
-        return 213;
-    }
-
-    ~pointee() { to_cout("~pointee()"); }
-
-  private:
-    pointee(const pointee &) = delete;
-    pointee(pointee &&) = delete;
-    pointee &operator=(const pointee &) = delete;
-    pointee &operator=(pointee &&) = delete;
-};
-
-inline std::unique_ptr<pointee> make_unique_pointee() {
-    return std::unique_ptr<pointee>(new pointee);
-}
-
-inline std::shared_ptr<pointee> make_shared_pointee() {
-    return std::unique_ptr<pointee>(new pointee);
-}
-
-inline int pass_unique_pointee(std::unique_ptr<pointee> ptr) {
-    return 4000 + ptr->get_int();
-}
-
-inline int pass_shared_pointee(std::shared_ptr<pointee> ptr) {
-    return 5000 + ptr->get_int();
-}
-
-inline pointee* get_static_pointee() {
-  static pointee cpp_instance;
-  return &cpp_instance;
-}
-
-TEST_SUBMODULE(holder_shared_ptr, m) {
-    m.def("to_cout", to_cout);
-
-    py::class_<pointee, std::shared_ptr<pointee>>(m, "pointee")
-        .def(py::init<>())
-        .def("get_int", &pointee::get_int);
-
-    m.def("make_unique_pointee", make_unique_pointee);
-    m.def("make_shared_pointee", make_shared_pointee);
-    // m.def("pass_unique_pointee", pass_unique_pointee);
-    m.def("pass_shared_pointee", pass_shared_pointee);
-
-    m.def("get_static_pointee",
-          get_static_pointee, py::return_value_policy::reference);
-}
-
-} // namespace holder_shared_ptr
-} // namespace pybind11_tests
diff --git a/tests/test_holder_shared_ptr.py b/tests/test_holder_shared_ptr.py
deleted file mode 100644
index 78aa2d1a58..0000000000
--- a/tests/test_holder_shared_ptr.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-# KEEP IN SYNC WITH test_holder_unique_ptr.py
-import pytest
-
-from pybind11_tests import holder_shared_ptr as m
-
-
-def test_make_unique_pointee():
-    m.to_cout("")
-    m.to_cout("")
-    m.to_cout("make_unique_pointee")
-    obj = m.make_unique_pointee()
-    assert obj.get_int() == 213
-    m.to_cout("")
-
-
-def test_make_shared_pointee():
-    m.to_cout("")
-    m.to_cout("")
-    m.to_cout("make_shared_pointee")
-    obj = m.make_shared_pointee()
-    assert obj.get_int() == 213
-    m.to_cout("")
-
-
-def test_pass_unique_pointee():
-    m.to_cout("")
-    m.to_cout("")
-    m.to_cout("pass_unique_pointee")
-    obj = m.make_shared_pointee()
-    assert obj.get_int() == 213
-    i = m.pass_unique_pointee(obj)
-    assert i == 4213
-    m.to_cout("")
-
-
-def test_pass_shared_pointee():
-    m.to_cout("")
-    m.to_cout("")
-    m.to_cout("pass_shared_pointee")
-    obj = m.make_shared_pointee()
-    assert obj.get_int() == 213
-    i = m.pass_shared_pointee(obj)
-    assert i == 5213
-    m.to_cout("")
-
-
-def test_get_static_pointee():
-    m.to_cout("")
-    m.to_cout("")
-    m.to_cout("get_static_pointee")
-    obj = m.get_static_pointee()
-    assert obj.get_int() == 213
-    with pytest.raises(RuntimeError) as excinfo:
-        m.pass_shared_pointee(obj)
-    assert "Unable to cast from non-held to held instance" in str(excinfo.value)
diff --git a/tests/test_holder_unique_ptr.cpp b/tests/test_holder_unique_ptr.cpp
deleted file mode 100644
index d59066416a..0000000000
--- a/tests/test_holder_unique_ptr.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// KEEP IN SYNC WITH test_holder_shared_ptr.cpp
-
-#include "pybind11_tests.h"
-
-#include <iostream>
-#include <memory>
-
-namespace pybind11_tests {
-namespace holder_unique_ptr {
-
-inline void to_cout(std::string text) { std::cout << text << std::endl; }
-
-class pointee { // NOT copyable.
-  public:
-    pointee() { to_cout("pointee::pointee()"); }
-
-    int get_int() const {
-        to_cout("pointee::get_int()");
-        return 213;
-    }
-
-    ~pointee() { to_cout("~pointee()"); }
-
-  private:
-    pointee(const pointee &) = delete;
-    pointee(pointee &&) = delete;
-    pointee &operator=(const pointee &) = delete;
-    pointee &operator=(pointee &&) = delete;
-};
-
-inline std::unique_ptr<pointee> make_unique_pointee() {
-    return std::unique_ptr<pointee>(new pointee);
-}
-
-inline std::shared_ptr<pointee> make_shared_pointee() {
-    return std::unique_ptr<pointee>(new pointee);
-}
-
-inline int pass_unique_pointee(std::unique_ptr<pointee> ptr) {
-    return 4000 + ptr->get_int();
-}
-
-inline int pass_shared_pointee(std::shared_ptr<pointee> ptr) {
-    return 5000 + ptr->get_int();
-}
-
-inline pointee* get_static_pointee() {
-  static pointee cpp_instance;
-  return &cpp_instance;
-}
-
-TEST_SUBMODULE(holder_unique_ptr, m) {
-    m.def("to_cout", to_cout);
-
-    py::class_<pointee>(m, "pointee")
-        .def(py::init<>())
-        .def("get_int", &pointee::get_int);
-
-    m.def("make_unique_pointee", make_unique_pointee);
-    m.def("make_shared_pointee", make_shared_pointee);
-    // m.def("pass_unique_pointee", pass_unique_pointee);
-    m.def("pass_shared_pointee", pass_shared_pointee);
-
-    m.def("get_static_pointee",
-          get_static_pointee, py::return_value_policy::reference);
-}
-
-} // namespace holder_unique_ptr
-} // namespace pybind11_tests
diff --git a/tests/test_holder_unique_ptr.py b/tests/test_holder_unique_ptr.py
deleted file mode 100644
index a82c3fda2c..0000000000
--- a/tests/test_holder_unique_ptr.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-# KEEP IN SYNC WITH test_holder_shared_ptr.py
-import pytest
-
-from pybind11_tests import holder_unique_ptr as m
-
-
-def test_make_unique_pointee():
-    m.to_cout("")
-    m.to_cout("")
-    m.to_cout("make_unique_pointee")
-    obj = m.make_unique_pointee()
-    assert obj.get_int() == 213
-    m.to_cout("")
-
-
-def test_make_shared_pointee():
-    m.to_cout("")
-    m.to_cout("")
-    m.to_cout("make_shared_pointee")
-    obj = m.make_shared_pointee()
-    assert obj.get_int() == 213
-    m.to_cout("")
-
-
-def test_pass_unique_pointee():
-    m.to_cout("")
-    m.to_cout("")
-    m.to_cout("pass_unique_pointee")
-    obj = m.make_unique_pointee()
-    assert obj.get_int() == 213
-    i = m.pass_unique_pointee(obj)
-    assert i == 4213
-    m.to_cout("")
-
-
-def test_pass_shared_pointee():
-    m.to_cout("")
-    m.to_cout("")
-    m.to_cout("pass_shared_pointee")
-    obj = m.make_unique_pointee()
-    assert obj.get_int() == 213
-    i = m.pass_shared_pointee(obj)
-    assert i == 5213
-    m.to_cout("")
-
-
-def test_get_static_pointee():
-    m.to_cout("")
-    m.to_cout("")
-    m.to_cout("get_static_pointee")
-    obj = m.get_static_pointee()
-    assert obj.get_int() == 213
-    with pytest.raises(RuntimeError) as excinfo:
-        m.pass_unique_pointee(obj)
-    assert "Unable to cast from non-held to held instance" in str(excinfo.value)
diff --git a/tests/test_private_first_base.cpp b/tests/test_private_first_base.cpp
deleted file mode 100644
index 16aa8c361a..0000000000
--- a/tests/test_private_first_base.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-// Demonstration of UB (Undefined Behavior) in handling of polymorphic pointers,
-// specifically:
-// https://github.com/pybind/pybind11/blob/30eb39ed79d1e2eeff15219ac00773034300a5e6/include/pybind11/cast.h#L229
-//     `return reinterpret_cast<V *&>(vh[0]);`
-// casts a `void` pointer to a `base`. The `void` pointer is obtained through
-// a `dynamic_cast` here:
-// https://github.com/pybind/pybind11/blob/30eb39ed79d1e2eeff15219ac00773034300a5e6/include/pybind11/cast.h#L852
-//     `return dynamic_cast<const void*>(src);`
-// The `dynamic_cast` is well-defined:
-// https://en.cppreference.com/w/cpp/language/dynamic_cast
-//     4) If expression is a pointer to a polymorphic type, and new-type
-//        is a pointer to void, the result is a pointer to the most derived
-//        object pointed or referenced by expression.
-// But the `reinterpret_cast` above is UB: `test_make_drvd_pass_base` in
-// `test_private_first_base.py` fails with a Segmentation Fault (Linux,
-// clang++ -std=c++17).
-// The only well-defined cast is back to a `drvd` pointer (`static_cast` can be
-// used), which can then safely be cast up to a `base` pointer. Note that
-// `test_make_drvd_up_cast_pass_drvd` passes because the `void` pointer is cast
-// to `drvd` pointer in this situation.
-
-#include "pybind11_tests.h"
-
-namespace pybind11_tests {
-namespace private_first_base {
-
-struct base {
-  base() : base_id(100) {}
-  virtual ~base() = default;
-  virtual int id() const { return base_id; }
-  base(const base&) = delete;
-  int base_id;
-};
-
-struct private_first_base {  // Any class with a virtual function will do.
-  virtual void some_other_virtual_function() const {}
-  virtual ~private_first_base() = default;
-};
-
-struct drvd : private private_first_base, public base {
-  int id() const override { return 2 * base_id; }
-};
-
-inline drvd* make_drvd() { return new drvd; }
-inline base* make_drvd_up_cast() { return new drvd; }
-
-inline int pass_base(const base* b) { return b->id(); }
-inline int pass_drvd(const drvd* d) { return d->id(); }
-
-TEST_SUBMODULE(private_first_base, m) {
-  py::class_<base>(m, "base");
-  py::class_<drvd, base>(m, "drvd");
-
-  m.def("make_drvd", make_drvd,
-        py::return_value_policy::take_ownership);
-  m.def("make_drvd_up_cast", make_drvd_up_cast,
-        py::return_value_policy::take_ownership);
-  m.def("pass_base", pass_base);
-  m.def("pass_drvd", pass_drvd);
-}
-
-}  // namespace private_first_base
-}  // namespace pybind11_tests
diff --git a/tests/test_private_first_base.py b/tests/test_private_first_base.py
deleted file mode 100644
index 36cc60e1e9..0000000000
--- a/tests/test_private_first_base.py
+++ /dev/null
@@ -1,17 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from pybind11_tests import private_first_base as m
-
-
-def test_make_drvd_pass_base():
-    d = m.make_drvd()
-    i = m.pass_base(d)
-    assert i == 200
-
-
-def test_make_drvd_up_cast_pass_drvd():
-    b = m.make_drvd_up_cast()
-    # the base return is down-cast immediately.
-    assert b.__class__.__name__ == "drvd"
-    i = m.pass_drvd(b)
-    assert i == 200
diff --git a/tests/test_smart_ptr_base_derived.cpp b/tests/test_smart_ptr_base_derived.cpp
deleted file mode 100644
index 844bbd0517..0000000000
--- a/tests/test_smart_ptr_base_derived.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-#include "pybind11_tests.h"
-
-#include <iostream>
-#include <memory>
-
-namespace pybind11_tests {
-namespace smart_ptr_base_derived {
-
-inline void to_cout(std::string text) { std::cout << text << std::endl; }
-
-class cbase {
- public:
-  int get_int() const { return 90146438; }
-};
-
-class cderived : public cbase {
- public:
-  // Printing from constructor & destructor for simple external validation.
-  cderived() {
-    std::cout << std::endl << "cderived+" << std::endl;
-  }
-  ~cderived() {
-    std::cout << std::endl << "cderived-" << std::endl;
-  }
-  int get_int() const { return 31607978; }
-  int base_get_int(const cbase& base) { return get_int() + base.get_int(); }
-};
-
-class vbase {
- public:
-  virtual ~vbase() {}
-  virtual int get_int() const = 0;
-};
-
-class vderived : public vbase {
- public:
-  // Printing from constructor & destructor for simple external validation.
-  vderived() {
-    std::cout << std::endl << "vderived+" << std::endl;
-  }
-  ~vderived() {
-    std::cout << std::endl << "vderived-" << std::endl;
-  }
-  int get_int() const override { return 29852452; }
-  int base_get_int(const vbase& base) { return get_int() + base.get_int(); }
-};
-
-class vrederived : public vderived {};
-
-inline std::unique_ptr<cbase>
-make_unique_cderived_up_cast() {
-  // Undefined Behavior (pure C++ problem, NOT a pybind11 problem):
-  // cderived destructor does not run.
-  return std::unique_ptr<cderived>(new cderived);
-}
-
-inline std::shared_ptr<cderived>
-make_shared_cderived(bool use_custom_deleter = false) {
-  if (use_custom_deleter) {
-    return std::shared_ptr<cderived>(
-        new cderived, [](cderived *p) { delete p; });
-  }
-  return std::shared_ptr<cderived>(new cderived);
-}
-
-inline std::shared_ptr<cbase>
-make_shared_cderived_up_cast(bool use_custom_deleter = false) {
-  return make_shared_cderived(use_custom_deleter);
-}
-
-inline int pass_unique_cbase(std::unique_ptr<cbase> cb) {
-  return cb->get_int();
-}
-
-inline int pass_shared_cbase(std::shared_ptr<cbase> cb) {
-  return cb->get_int();
-}
-
-inline int pass_shared_cderived(std::shared_ptr<cderived> cd) {
-  return cd->get_int();
-}
-
-inline std::unique_ptr<vbase>
-make_unique_vderived_up_cast() {
-  // Well-defined behavior because vderived has a virtual destructor.
-  return std::unique_ptr<vderived>(new vderived);
-}
-
-inline std::shared_ptr<vderived>
-make_shared_vderived(bool use_custom_deleter = false) {
-  if (use_custom_deleter) {
-    return std::shared_ptr<vderived>(
-        new vderived, [](vderived *p) { delete p; });
-  }
-  return std::shared_ptr<vderived>(new vderived);
-}
-
-inline std::shared_ptr<vbase>
-make_shared_vderived_up_cast(bool use_custom_deleter = false) {
-  return make_shared_vderived(use_custom_deleter);
-}
-
-inline int pass_unique_vbase(std::unique_ptr<vbase> vb) {
-  return vb->get_int();
-}
-
-inline int pass_shared_vbase(std::shared_ptr<vbase> vb) {
-  return vb->get_int();
-}
-
-inline int pass_shared_vderived(std::shared_ptr<vderived> vd) {
-  return vd->get_int();
-}
-
-inline int pass_shared_vrederived(std::shared_ptr<vrederived> vr) {
-  return vr->get_int();
-}
-
-TEST_SUBMODULE(smart_ptr_base_derived, m) {
-    m.def("to_cout", to_cout);
-
-    py::class_<cbase, std::shared_ptr<cbase>>(m, "cbase")
-        .def(py::init<>())
-        .def("get_int", &cbase::get_int);
-
-    py::class_<cderived, cbase, std::shared_ptr<cderived>>(m, "cderived")
-        .def(py::init<>())
-        .def("get_int", &cderived::get_int);
-
-    py::class_<vbase, std::shared_ptr<vbase>>(m, "vbase")
-        .def("get_int", &vbase::get_int);
-
-    py::class_<vderived, vbase, std::shared_ptr<vderived>>(m, "vderived")
-        .def(py::init<>());
-
-    py::class_<vrederived, vderived, std::shared_ptr<vrederived>>(m, "vrederived")
-        .def(py::init<>());
-
-    m.def("make_shared_cderived",
-          make_shared_cderived,
-          py::arg("use_custom_deleter") = false);
-    m.def("make_shared_cderived_up_cast",
-          make_shared_cderived_up_cast,
-          py::arg("use_custom_deleter") = false);
-    m.def("pass_shared_cbase", pass_shared_cbase);
-    m.def("pass_shared_cderived", pass_shared_cderived);
-
-    m.def("make_shared_vderived",
-          make_shared_vderived,
-          py::arg("use_custom_deleter") = false);
-    m.def("make_shared_vderived_up_cast",
-          make_shared_vderived_up_cast,
-          py::arg("use_custom_deleter") = false);
-    m.def("pass_shared_vbase", pass_shared_vbase);
-    m.def("pass_shared_vderived", pass_shared_vderived);
-    m.def("pass_shared_vrederived", pass_shared_vrederived);
-}
-
-}  // namespace smart_ptr_base_derived
-}  // namespace pybind11_tests
diff --git a/tests/test_smart_ptr_base_derived.py b/tests/test_smart_ptr_base_derived.py
deleted file mode 100644
index 534b5e5c34..0000000000
--- a/tests/test_smart_ptr_base_derived.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-from pybind11_tests import smart_ptr_base_derived as m
-
-CBASE_GET_INT_RESULT = 90146438
-CDERIVED_GET_INT_RESULT = 31607978
-VDERIVED_GET_INT_RESULT = 29852452
-
-
-def test_concrete():
-    m.to_cout("")
-    m.to_cout("")
-    m.to_cout("make_shared_cderived")
-    cd = m.make_shared_cderived()
-    assert cd.get_int() == CDERIVED_GET_INT_RESULT
-    m.pass_shared_cderived(cd)
-    m.pass_shared_cbase(cd)
-    cb = m.make_shared_cderived_up_cast()
-    assert cb.get_int() == CBASE_GET_INT_RESULT
-    m.pass_shared_cbase(cb)
-    with pytest.raises(TypeError):
-        m.pass_shared_cderived(cb)
-    m.to_cout("")
-
-
-def test_virtual():
-    m.to_cout("")
-    m.to_cout("")
-    m.to_cout("make_shared_vderived")
-    vd = m.make_shared_vderived()
-    assert vd.get_int() == VDERIVED_GET_INT_RESULT
-    m.pass_shared_vderived(vd)
-    m.pass_shared_vbase(vd)
-    vd_uc = m.make_shared_vderived_up_cast()
-    assert vd_uc.get_int() == VDERIVED_GET_INT_RESULT
-    assert isinstance(vd_uc, m.vderived)  # pybind11 un-did upcast.
-    m.pass_shared_vbase(vd_uc)
-    m.pass_shared_vderived(vd_uc)
-    with pytest.raises(TypeError):
-        m.pass_shared_vrederived(vd_uc)
-    m.to_cout("")
diff --git a/tests/test_smart_ptr_private_first_base.cpp b/tests/test_smart_ptr_private_first_base.cpp
deleted file mode 100644
index 9ccc5edea0..0000000000
--- a/tests/test_smart_ptr_private_first_base.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-// Demonstration of Undefined Behavior in handling of shared_ptr holder,
-// specifically:
-// https://github.com/pybind/pybind11/blob/30eb39ed79d1e2eeff15219ac00773034300a5e6/include/pybind11/cast.h#L235
-//     `return reinterpret_cast<H &>(vh[1]);`
-// indirectly casts a `shared_ptr<drvd>` reference to a `shared_ptr<base>`.
-// Similarly:
-// https://github.com/pybind/pybind11/blob/30eb39ed79d1e2eeff15219ac00773034300a5e6/include/pybind11/pybind11.h#L1505
-//     `init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());`
-// explictly casts a `shared_ptr<base>` reference to a `shared_ptr<drvd>`.
-// Both tests in `test_smart_ptr_private_first_base.py` fail with a
-// Segmentation Fault (Linux, clang++ -std=c++17).
-
-#include <memory>
-
-#include "pybind11_tests.h"
-
-namespace pybind11_tests {
-namespace smart_ptr_private_first_base {
-
-struct base {
-  base() : base_id(100) {}
-  virtual ~base() = default;
-  virtual int id() const { return base_id; }
-  int base_id;
-};
-
-struct private_first_base {  // Any class with a virtual function will do.
-  virtual void some_other_virtual_function() const {}
-  virtual ~private_first_base() = default;
-};
-
-struct drvd : private private_first_base, public base {
-  int id() const override { return 2 * base_id; }
-};
-
-inline std::shared_ptr<drvd> make_shared_drvd() {
-  return std::shared_ptr<drvd>(new drvd);
-}
-
-inline std::shared_ptr<base> make_shared_drvd_up_cast() {
-  return std::shared_ptr<base>(new drvd);
-}
-
-inline int pass_shared_base(std::shared_ptr<base> b) { return b->id(); }
-inline int pass_shared_drvd(std::shared_ptr<drvd> d) { return d->id(); }
-
-TEST_SUBMODULE(smart_ptr_private_first_base, m) {
-  py::class_<base, std::shared_ptr<base>>(m, "base");
-  py::class_<drvd, base, std::shared_ptr<drvd>>(m, "drvd");
-
-  m.def("make_shared_drvd", make_shared_drvd);
-  m.def("make_shared_drvd_up_cast", make_shared_drvd_up_cast);
-  m.def("pass_shared_base", pass_shared_base);
-  m.def("pass_shared_drvd", pass_shared_drvd);
-}
-
-}  // namespace smart_ptr_private_first_base
-}  // namespace pybind11_tests
diff --git a/tests/test_smart_ptr_private_first_base.py b/tests/test_smart_ptr_private_first_base.py
deleted file mode 100644
index db17e787ff..0000000000
--- a/tests/test_smart_ptr_private_first_base.py
+++ /dev/null
@@ -1,17 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from pybind11_tests import smart_ptr_private_first_base as m
-
-
-def test_make_drvd_pass_base():
-    d = m.make_shared_drvd()
-    i = m.pass_shared_base(d)
-    assert i == 200
-
-
-def test_make_drvd_up_cast_pass_drvd():
-    b = m.make_shared_drvd_up_cast()
-    # the base return is down-cast immediately.
-    assert b.__class__.__name__ == "drvd"
-    i = m.pass_shared_drvd(b)
-    assert i == 200

From 8e5ca010e4733e4a4329f57141f102edc74efe0b Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 24 Jan 2021 15:27:32 -0800
Subject: [PATCH 101/206] Adding py::smart_holder support to py::class_,
 purging py::classh completely.

---
 include/pybind11/cast.h                       |   4 +-
 include/pybind11/classh.h                     | 318 +-----------------
 include/pybind11/detail/classh_type_casters.h |  36 ++
 include/pybind11/pybind11.h                   |  18 +-
 tests/classh_module_local_0.cpp               |   1 +
 tests/classh_module_local_1.cpp               |   3 +-
 tests/classh_module_local_2.cpp               |   3 +-
 tests/test_classh_inheritance.cpp             |  11 +-
 tests/test_classh_wip.cpp                     |  12 +-
 tests/test_unique_ptr_member.cpp              |   4 +-
 10 files changed, 78 insertions(+), 332 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index df08b16e3e..7a32d67406 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1636,6 +1636,7 @@ using type_caster_holder = conditional_t<is_copy_constructible<holder_type>::val
                                          copyable_holder_caster<type, holder_type>,
                                          move_only_holder_caster<type, holder_type>>;
 
+template <typename T, bool Value = false> struct is_smart_holder { static constexpr bool value = Value; };
 template <typename T, bool Value = false> struct always_construct_holder { static constexpr bool value = Value; };
 
 /// Create a specialization for custom holder types (silently ignores std::shared_ptr)
@@ -1650,7 +1651,8 @@ template <typename T, bool Value = false> struct always_construct_holder { stati
 
 // PYBIND11_DECLARE_HOLDER_TYPE holder types:
 template <typename base, typename holder> struct is_holder_type :
-    std::is_base_of<detail::type_caster_holder<base, holder>, detail::type_caster<holder>> {};
+    detail::any_of<std::is_base_of<detail::type_caster_holder<base, holder>, detail::type_caster<holder>>,
+                   detail::is_smart_holder<holder>> {};
 // Specialization for always-supported unique_ptr holders:
 template <typename base, typename deleter> struct is_holder_type<base, std::unique_ptr<base, deleter>> :
     std::true_type {};
diff --git a/include/pybind11/classh.h b/include/pybind11/classh.h
index 15b6e8ab97..a4c5509f63 100644
--- a/include/pybind11/classh.h
+++ b/include/pybind11/classh.h
@@ -1,326 +1,10 @@
 #pragma once
 
 #include "detail/classh_type_casters.h"
-#include "pybind11.h"
 #include "smart_holder_poc.h"
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 
-// clang-format off
-template <typename type_, typename... options>
-class classh : public detail::generic_type {
-    template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>;
-    template <typename T> using is_base = detail::is_strict_base_of<T, type_>;
-    // struct instead of using here to help MSVC:
-    template <typename T> struct is_valid_class_option :
-        detail::any_of<is_subtype<T>, is_base<T>> {};
-
-public:
-    using type = type_;
-    using type_alias = detail::exactly_one_t<is_subtype, void, options...>;
-    constexpr static bool has_alias = !std::is_void<type_alias>::value;
-    using holder_type = pybindit::memory::smart_holder;
-
-    static_assert(detail::all_of<is_valid_class_option<options>...>::value,
-            "Unknown/invalid classh template parameters provided");
-
-    static_assert(!has_alias || std::is_polymorphic<type>::value,
-            "Cannot use an alias class with a non-polymorphic type");
-
-    PYBIND11_OBJECT(classh, generic_type, PyType_Check)
-
-    template <typename... Extra>
-    classh(handle scope, const char *name, const Extra &... extra) {
-        using namespace detail;
-
-        // MI can only be specified via classh template options, not constructor parameters
-        static_assert(
-            none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
-            (   constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
-                constexpr_sum(is_base<options>::value...)   == 0 && // no template option bases
-                none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
-            "Error: multiple inheritance bases must be specified via classh template options");
-
-        type_record record;
-        record.scope = scope;
-        record.name = name;
-        record.type = &typeid(type);
-        record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
-        record.type_align = alignof(conditional_t<has_alias, type_alias, type>&);
-        record.holder_size = sizeof(holder_type);
-        record.init_instance = init_instance;
-        record.dealloc = dealloc;
-        record.default_holder = false;
-
-        set_operator_new<type>(&record);
-
-        /* Register base classes specified via template arguments to classh, if any */
-        PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
-
-        /* Process optional arguments, if any */
-        process_attributes<Extra...>::init(extra..., &record);
-
-        generic_type::initialize(record, &modified_type_caster_generic_load_impl::local_load);
-
-        if (has_alias) {
-            auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
-            instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
-        }
-    }
-
-    template <typename Base, detail::enable_if_t<is_base<Base>::value, int> = 0>
-    static void add_base(detail::type_record &rec) {
-        rec.add_base(typeid(Base), [](void *src) -> void * {
-            return static_cast<Base *>(reinterpret_cast<type *>(src));
-        });
-    }
-
-    template <typename Base, detail::enable_if_t<!is_base<Base>::value, int> = 0>
-    static void add_base(detail::type_record &) { }
-
-    template <typename Func, typename... Extra>
-    classh &def(const char *name_, Func&& f, const Extra&... extra) {
-        cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
-                        sibling(getattr(*this, name_, none())), extra...);
-        add_class_method(*this, name_, cf);
-        return *this;
-    }
-
-    template <typename Func, typename... Extra> classh &
-    def_static(const char *name_, Func &&f, const Extra&... extra) {
-        static_assert(!std::is_member_function_pointer<Func>::value,
-                "def_static(...) called with a non-static member function pointer");
-        cpp_function cf(std::forward<Func>(f), name(name_), scope(*this),
-                        sibling(getattr(*this, name_, none())), extra...);
-        attr(cf.name()) = staticmethod(cf);
-        return *this;
-    }
-
-    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
-    classh &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
-        op.execute(*this, extra...);
-        return *this;
-    }
-
-    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
-    classh & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
-        op.execute_cast(*this, extra...);
-        return *this;
-    }
-
-    template <typename... Args, typename... Extra>
-    classh &def(const detail::initimpl::constructor<Args...> &init, const Extra&... extra) {
-        init.execute(*this, extra...);
-        return *this;
-    }
-
-    template <typename... Args, typename... Extra>
-    classh &def(const detail::initimpl::alias_constructor<Args...> &init, const Extra&... extra) {
-        init.execute(*this, extra...);
-        return *this;
-    }
-
-    template <typename... Args, typename... Extra>
-    classh &def(detail::initimpl::factory<Args...> &&init, const Extra&... extra) {
-        std::move(init).execute(*this, extra...);
-        return *this;
-    }
-
-    template <typename... Args, typename... Extra>
-    classh &def(detail::initimpl::pickle_factory<Args...> &&pf, const Extra &...extra) {
-        std::move(pf).execute(*this, extra...);
-        return *this;
-    }
-
-    template <typename Func>
-    classh& def_buffer(Func &&func) {
-        struct capture { Func func; };
-        auto *ptr = new capture { std::forward<Func>(func) };
-        install_buffer_funcs([](PyObject *obj, void *ptr) -> buffer_info* {
-            detail::make_caster<type> caster;
-            if (!caster.load(obj, false))
-                return nullptr;
-            return new buffer_info(((capture *) ptr)->func(caster));
-        }, ptr);
-        weakref(m_ptr, cpp_function([ptr](handle wr) {
-            delete ptr;
-            wr.dec_ref();
-        })).release();
-        return *this;
-    }
-
-    template <typename Return, typename Class, typename... Args>
-    classh &def_buffer(Return (Class::*func)(Args...)) {
-        return def_buffer([func] (type &obj) { return (obj.*func)(); });
-    }
-
-    template <typename Return, typename Class, typename... Args>
-    classh &def_buffer(Return (Class::*func)(Args...) const) {
-        return def_buffer([func] (const type &obj) { return (obj.*func)(); });
-    }
-
-    template <typename C, typename D, typename... Extra>
-    classh &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
-        static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readwrite() requires a class member (or base class member)");
-        cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this)),
-                     fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
-        def_property(name, fget, fset, return_value_policy::reference_internal, extra...);
-        return *this;
-    }
-
-    template <typename C, typename D, typename... Extra>
-    classh &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
-        static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readonly() requires a class member (or base class member)");
-        cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this));
-        def_property_readonly(name, fget, return_value_policy::reference_internal, extra...);
-        return *this;
-    }
-
-    template <typename D, typename... Extra>
-    classh &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
-        cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this)),
-                     fset([pm](object, const D &value) { *pm = value; }, scope(*this));
-        def_property_static(name, fget, fset, return_value_policy::reference, extra...);
-        return *this;
-    }
-
-    template <typename D, typename... Extra>
-    classh &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
-        cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this));
-        def_property_readonly_static(name, fget, return_value_policy::reference, extra...);
-        return *this;
-    }
-
-    /// Uses return_value_policy::reference_internal by default
-    template <typename Getter, typename... Extra>
-    classh &def_property_readonly(const char *name, const Getter &fget, const Extra& ...extra) {
-        return def_property_readonly(name, cpp_function(method_adaptor<type>(fget)),
-                                     return_value_policy::reference_internal, extra...);
-    }
-
-    /// Uses cpp_function's return_value_policy by default
-    template <typename... Extra>
-    classh &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
-        return def_property(name, fget, nullptr, extra...);
-    }
-
-    /// Uses return_value_policy::reference by default
-    template <typename Getter, typename... Extra>
-    classh &def_property_readonly_static(const char *name, const Getter &fget, const Extra& ...extra) {
-        return def_property_readonly_static(name, cpp_function(fget), return_value_policy::reference, extra...);
-    }
-
-    /// Uses cpp_function's return_value_policy by default
-    template <typename... Extra>
-    classh &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
-        return def_property_static(name, fget, nullptr, extra...);
-    }
-
-    /// Uses return_value_policy::reference_internal by default
-    template <typename Getter, typename Setter, typename... Extra>
-    classh &def_property(const char *name, const Getter &fget, const Setter &fset, const Extra& ...extra) {
-        return def_property(name, fget, cpp_function(method_adaptor<type>(fset)), extra...);
-    }
-    template <typename Getter, typename... Extra>
-    classh &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
-        return def_property(name, cpp_function(method_adaptor<type>(fget)), fset,
-                            return_value_policy::reference_internal, extra...);
-    }
-
-    /// Uses cpp_function's return_value_policy by default
-    template <typename... Extra>
-    classh &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
-        return def_property_static(name, fget, fset, is_method(*this), extra...);
-    }
-
-    /// Uses return_value_policy::reference by default
-    template <typename Getter, typename... Extra>
-    classh &def_property_static(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
-        return def_property_static(name, cpp_function(fget), fset, return_value_policy::reference, extra...);
-    }
-
-    /// Uses cpp_function's return_value_policy by default
-    template <typename... Extra>
-    classh &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
-        static_assert( 0 == detail::constexpr_sum(std::is_base_of<arg, Extra>::value...),
-                      "Argument annotations are not allowed for properties");
-        auto rec_fget = get_function_record(fget), rec_fset = get_function_record(fset);
-        auto *rec_active = rec_fget;
-        if (rec_fget) {
-           char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific documentation string */
-           detail::process_attributes<Extra...>::init(extra..., rec_fget);
-           if (rec_fget->doc && rec_fget->doc != doc_prev) {
-              free(doc_prev);
-              rec_fget->doc = strdup(rec_fget->doc);
-           }
-        }
-        if (rec_fset) {
-            char *doc_prev = rec_fset->doc;
-            detail::process_attributes<Extra...>::init(extra..., rec_fset);
-            if (rec_fset->doc && rec_fset->doc != doc_prev) {
-                free(doc_prev);
-                rec_fset->doc = strdup(rec_fset->doc);
-            }
-            if (! rec_active) rec_active = rec_fset;
-        }
-        def_property_static_impl(name, fget, fset, rec_active);
-        return *this;
-    }
-
-private:
-    // clang-format on
-    static void init_instance(detail::instance *inst, const void *holder_const_void_ptr) {
-        // Need for const_cast is a consequence of the type_info::init_instance type:
-        // void (*init_instance)(instance *, const void *);
-        auto holder_void_ptr = const_cast<void *>(holder_const_void_ptr);
-
-        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
-        if (!v_h.instance_registered()) {
-            register_instance(inst, v_h.value_ptr(), v_h.type);
-            v_h.set_instance_registered();
-        }
-        if (holder_void_ptr) {
-            // Note: inst->owned ignored.
-            auto holder_ptr = static_cast<holder_type *>(holder_void_ptr);
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*holder_ptr));
-        } else if (inst->owned) {
-            new (std::addressof(v_h.holder<holder_type>()))
-                holder_type(holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<type>()));
-        } else {
-            new (std::addressof(v_h.holder<holder_type>()))
-                holder_type(holder_type::from_raw_ptr_unowned(v_h.value_ptr<type>()));
-        }
-        v_h.set_holder_constructed();
-    }
-    // clang-format off
-
-    /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.
-    static void dealloc(detail::value_and_holder &v_h) {
-        // We could be deallocating because we are cleaning up after a Python exception.
-        // If so, the Python error indicator will be set. We need to clear that before
-        // running the destructor, in case the destructor code calls more Python.
-        // If we don't, the Python API will exit with an exception, and pybind11 will
-        // throw error_already_set from the C++ destructor which is forbidden and triggers
-        // std::terminate().
-        error_scope scope;
-        if (v_h.holder_constructed()) {
-            v_h.holder<holder_type>().~holder_type();
-            v_h.set_holder_constructed(false);
-        }
-        else {
-            detail::call_operator_delete(v_h.value_ptr<type>(),
-                v_h.type->type_size,
-                v_h.type->type_align
-            );
-        }
-        v_h.value_ptr() = nullptr;
-    }
-
-    static detail::function_record *get_function_record(handle h) {
-        h = detail::get_function(h);
-        return h ? (detail::function_record *) reinterpret_borrow<capsule>(PyCFunction_GET_SELF(h.ptr()))
-                 : nullptr;
-    }
-};
+using pybindit::memory::smart_holder;
 
 PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/classh_type_casters.h
index 99afcdffd4..dd746021aa 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/classh_type_casters.h
@@ -631,5 +631,41 @@ struct classh_type_caster<std::unique_ptr<T const>> : smart_holder_type_caster_l
     }                                                                                             \
     }
 
+template <>
+struct is_smart_holder<pybindit::memory::smart_holder>
+    : is_smart_holder<pybindit::memory::smart_holder, true> {
+
+    static decltype(&modified_type_caster_generic_load_impl::local_load)
+    get_type_caster_local_load_function_ptr() {
+        return &modified_type_caster_generic_load_impl::local_load;
+    }
+
+    template <typename T>
+    static void init_instance_for_type(detail::instance *inst, const void *holder_const_void_ptr) {
+        // Need for const_cast is a consequence of the type_info::init_instance type:
+        // void (*init_instance)(instance *, const void *);
+        auto holder_void_ptr = const_cast<void *>(holder_const_void_ptr);
+
+        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(T)));
+        if (!v_h.instance_registered()) {
+            register_instance(inst, v_h.value_ptr(), v_h.type);
+            v_h.set_instance_registered();
+        }
+        using holder_type = pybindit::memory::smart_holder;
+        if (holder_void_ptr) {
+            // Note: inst->owned ignored.
+            auto holder_ptr = static_cast<holder_type *>(holder_void_ptr);
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*holder_ptr));
+        } else if (inst->owned) {
+            new (std::addressof(v_h.holder<holder_type>()))
+                holder_type(holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<T>()));
+        } else {
+            new (std::addressof(v_h.holder<holder_type>()))
+                holder_type(holder_type::from_raw_ptr_unowned(v_h.value_ptr<T>()));
+        }
+        v_h.set_holder_constructed();
+    }
+};
+
 } // namespace detail
 } // namespace pybind11
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 62b92ff357..78376e47f9 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1295,7 +1295,7 @@ class class_ : public detail::generic_type {
         /* Process optional arguments, if any */
         process_attributes<Extra...>::init(extra..., &record);
 
-        generic_type::initialize(record, &type_caster_generic::local_load);
+        generic_type_initialize(record);
 
         if (has_alias) {
             auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
@@ -1503,6 +1503,16 @@ class class_ : public detail::generic_type {
     }
 
 private:
+    template <typename H = holder_type, detail::enable_if_t<!detail::is_smart_holder<H>::value, int> = 0>
+    void generic_type_initialize(const detail::type_record &record) {
+        generic_type::initialize(record, &detail::type_caster_generic::local_load);
+    }
+
+    template <typename H = holder_type, detail::enable_if_t<detail::is_smart_holder<H>::value, int> = 0>
+    void generic_type_initialize(const detail::type_record &record) {
+        generic_type::initialize(record, detail::is_smart_holder<H>::get_type_caster_local_load_function_ptr());
+    }
+
     /// Initialize holder object, variant 1: object derives from enable_shared_from_this
     template <typename T>
     static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
@@ -1547,6 +1557,7 @@ class class_ : public detail::generic_type {
     /// instance.  Should be called as soon as the `type` value_ptr is set for an instance.  Takes an
     /// optional pointer to an existing holder to use; if not specified and the instance is
     /// `.owned`, a new holder will be constructed to manage the value pointer.
+    template <typename H = holder_type, detail::enable_if_t<!detail::is_smart_holder<H>::value, int> = 0>
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
         auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
         if (!v_h.instance_registered()) {
@@ -1556,6 +1567,11 @@ class class_ : public detail::generic_type {
         init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
     }
 
+    template <typename H = holder_type, detail::enable_if_t<detail::is_smart_holder<H>::value, int> = 0>
+    static void init_instance(detail::instance *inst, const void *holder_ptr) {
+        detail::is_smart_holder<H>::template init_instance_for_type<type>(inst, holder_ptr);
+    }
+
     /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.
     static void dealloc(detail::value_and_holder &v_h) {
         // We could be deallocating because we are cleaning up after a Python exception.
diff --git a/tests/classh_module_local_0.cpp b/tests/classh_module_local_0.cpp
index 39c391c953..8a80711ed0 100644
--- a/tests/classh_module_local_0.cpp
+++ b/tests/classh_module_local_0.cpp
@@ -1,4 +1,5 @@
 #include <pybind11/classh.h>
+#include <pybind11/pybind11.h>
 
 #include <string>
 
diff --git a/tests/classh_module_local_1.cpp b/tests/classh_module_local_1.cpp
index 04e21cf087..3c5948a824 100644
--- a/tests/classh_module_local_1.cpp
+++ b/tests/classh_module_local_1.cpp
@@ -1,5 +1,6 @@
 // Identical to classh_module_local_2.cpp, except 2 replaced with 1.
 #include <pybind11/classh.h>
+#include <pybind11/pybind11.h>
 
 #include <string>
 
@@ -21,7 +22,7 @@ PYBIND11_MODULE(classh_module_local_1, m) {
     namespace py = pybind11;
     using namespace pybind11_tests::classh_module_local;
 
-    py::classh<atyp>(m, "atyp", py::module_local())
+    py::class_<atyp, py::smart_holder>(m, "atyp", py::module_local())
         .def(py::init([](const std::string &mtxt) {
             atyp obj;
             obj.mtxt = mtxt;
diff --git a/tests/classh_module_local_2.cpp b/tests/classh_module_local_2.cpp
index 596e6626d7..7316f3eeb3 100644
--- a/tests/classh_module_local_2.cpp
+++ b/tests/classh_module_local_2.cpp
@@ -1,5 +1,6 @@
 // Identical to classh_module_local_1.cpp, except 1 replaced with 2.
 #include <pybind11/classh.h>
+#include <pybind11/pybind11.h>
 
 #include <string>
 
@@ -21,7 +22,7 @@ PYBIND11_MODULE(classh_module_local_2, m) {
     namespace py = pybind11;
     using namespace pybind11_tests::classh_module_local;
 
-    py::classh<atyp>(m, "atyp", py::module_local())
+    py::class_<atyp, py::smart_holder>(m, "atyp", py::module_local())
         .def(py::init([](const std::string &mtxt) {
             atyp obj;
             obj.mtxt = mtxt;
diff --git a/tests/test_classh_inheritance.cpp b/tests/test_classh_inheritance.cpp
index 2694d051fd..6f84202f65 100644
--- a/tests/test_classh_inheritance.cpp
+++ b/tests/test_classh_inheritance.cpp
@@ -67,8 +67,8 @@ namespace pybind11_tests {
 namespace classh_inheritance {
 
 TEST_SUBMODULE(classh_inheritance, m) {
-    py::classh<base>(m, "base");
-    py::classh<drvd, base>(m, "drvd");
+    py::class_<base, py::smart_holder>(m, "base");
+    py::class_<drvd, base, py::smart_holder>(m, "drvd");
 
     auto rvto = py::return_value_policy::take_ownership;
 
@@ -82,9 +82,10 @@ TEST_SUBMODULE(classh_inheritance, m) {
     m.def("pass_shcp_base", pass_shcp_base);
     m.def("pass_shcp_drvd", pass_shcp_drvd);
 
-    py::classh<base1>(m, "base1").def(py::init<>()); // __init__ needed for Python inheritance.
-    py::classh<base2>(m, "base2").def(py::init<>());
-    py::classh<drvd2, base1, base2>(m, "drvd2");
+    // __init__ needed for Python inheritance.
+    py::class_<base1, py::smart_holder>(m, "base1").def(py::init<>());
+    py::class_<base2, py::smart_holder>(m, "base2").def(py::init<>());
+    py::class_<drvd2, base1, base2, py::smart_holder>(m, "drvd2");
 
     m.def("rtrn_mptr_drvd2", rtrn_mptr_drvd2, rvto);
     m.def("rtrn_mptr_drvd2_up_cast1", rtrn_mptr_drvd2_up_cast1, rvto);
diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 17e5a1014a..2b0a9bbcf0 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -57,11 +57,13 @@ namespace classh_wip {
 TEST_SUBMODULE(classh_wip, m) {
     namespace py = pybind11;
 
-    py::classh<atyp>(m, "atyp").def(py::init<>()).def(py::init([](const std::string &mtxt) {
-        atyp obj;
-        obj.mtxt = mtxt;
-        return obj;
-    }));
+    py::class_<atyp, py::smart_holder>(m, "atyp")
+        .def(py::init<>())
+        .def(py::init([](const std::string &mtxt) {
+            atyp obj;
+            obj.mtxt = mtxt;
+            return obj;
+        }));
 
     m.def("rtrn_valu_atyp", rtrn_valu_atyp);
     m.def("rtrn_rref_atyp", rtrn_rref_atyp);
diff --git a/tests/test_unique_ptr_member.cpp b/tests/test_unique_ptr_member.cpp
index 415fb636f5..0712417018 100644
--- a/tests/test_unique_ptr_member.cpp
+++ b/tests/test_unique_ptr_member.cpp
@@ -46,7 +46,9 @@ namespace pybind11_tests {
 namespace unique_ptr_member {
 
 TEST_SUBMODULE(unique_ptr_member, m) {
-    py::classh<pointee>(m, "pointee").def(py::init<>()).def("get_int", &pointee::get_int);
+    py::class_<pointee, py::smart_holder>(m, "pointee")
+        .def(py::init<>())
+        .def("get_int", &pointee::get_int);
 
     m.def("make_unique_pointee", make_unique_pointee);
 

From 173032c32ef96d45649abaaefcd01b67ff15ea4f Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 24 Jan 2021 22:15:58 -0800
Subject: [PATCH 102/206] Renaming files in include directory, creating
 pybind11/smart_holder.h.

---
 include/pybind11/classh.h                              | 10 ----------
 include/pybind11/{ => detail}/smart_holder_poc.h       |  0
 ...assh_type_casters.h => smart_holder_type_casters.h} |  5 ++++-
 include/pybind11/smart_holder.h                        |  3 +++
 tests/classh_module_local_0.cpp                        |  2 +-
 tests/classh_module_local_1.cpp                        |  2 +-
 tests/classh_module_local_2.cpp                        |  2 +-
 tests/core/smart_holder_poc_test.cpp                   |  2 +-
 tests/test_classh_inheritance.cpp                      |  2 +-
 tests/test_classh_wip.cpp                              |  2 +-
 tests/test_unique_ptr_member.cpp                       |  2 +-
 11 files changed, 14 insertions(+), 18 deletions(-)
 delete mode 100644 include/pybind11/classh.h
 rename include/pybind11/{ => detail}/smart_holder_poc.h (100%)
 rename include/pybind11/detail/{classh_type_casters.h => smart_holder_type_casters.h} (99%)
 create mode 100644 include/pybind11/smart_holder.h

diff --git a/include/pybind11/classh.h b/include/pybind11/classh.h
deleted file mode 100644
index a4c5509f63..0000000000
--- a/include/pybind11/classh.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-#include "detail/classh_type_casters.h"
-#include "smart_holder_poc.h"
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-using pybindit::memory::smart_holder;
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/include/pybind11/smart_holder_poc.h b/include/pybind11/detail/smart_holder_poc.h
similarity index 100%
rename from include/pybind11/smart_holder_poc.h
rename to include/pybind11/detail/smart_holder_poc.h
diff --git a/include/pybind11/detail/classh_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
similarity index 99%
rename from include/pybind11/detail/classh_type_casters.h
rename to include/pybind11/detail/smart_holder_type_casters.h
index dd746021aa..cd2e19efb9 100644
--- a/include/pybind11/detail/classh_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -2,11 +2,11 @@
 
 #include "../cast.h"
 #include "../pytypes.h"
-#include "../smart_holder_poc.h"
 #include "class.h"
 #include "common.h"
 #include "descr.h"
 #include "internals.h"
+#include "smart_holder_poc.h"
 
 #include <memory>
 #include <stdexcept>
@@ -15,6 +15,9 @@
 #include <utility>
 
 namespace pybind11 {
+
+using pybindit::memory::smart_holder;
+
 namespace detail {
 
 inline std::pair<bool, handle> find_existing_python_instance(void *src_void_ptr,
diff --git a/include/pybind11/smart_holder.h b/include/pybind11/smart_holder.h
new file mode 100644
index 0000000000..fccc45ff19
--- /dev/null
+++ b/include/pybind11/smart_holder.h
@@ -0,0 +1,3 @@
+#pragma once
+
+#include "detail/smart_holder_type_casters.h"
diff --git a/tests/classh_module_local_0.cpp b/tests/classh_module_local_0.cpp
index 8a80711ed0..fecf850cce 100644
--- a/tests/classh_module_local_0.cpp
+++ b/tests/classh_module_local_0.cpp
@@ -1,5 +1,5 @@
-#include <pybind11/classh.h>
 #include <pybind11/pybind11.h>
+#include <pybind11/smart_holder.h>
 
 #include <string>
 
diff --git a/tests/classh_module_local_1.cpp b/tests/classh_module_local_1.cpp
index 3c5948a824..c385771783 100644
--- a/tests/classh_module_local_1.cpp
+++ b/tests/classh_module_local_1.cpp
@@ -1,6 +1,6 @@
 // Identical to classh_module_local_2.cpp, except 2 replaced with 1.
-#include <pybind11/classh.h>
 #include <pybind11/pybind11.h>
+#include <pybind11/smart_holder.h>
 
 #include <string>
 
diff --git a/tests/classh_module_local_2.cpp b/tests/classh_module_local_2.cpp
index 7316f3eeb3..2d33b04a0d 100644
--- a/tests/classh_module_local_2.cpp
+++ b/tests/classh_module_local_2.cpp
@@ -1,6 +1,6 @@
 // Identical to classh_module_local_1.cpp, except 1 replaced with 2.
-#include <pybind11/classh.h>
 #include <pybind11/pybind11.h>
+#include <pybind11/smart_holder.h>
 
 #include <string>
 
diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/core/smart_holder_poc_test.cpp
index a4123b9157..dab47bded0 100644
--- a/tests/core/smart_holder_poc_test.cpp
+++ b/tests/core/smart_holder_poc_test.cpp
@@ -1,4 +1,4 @@
-#include "pybind11/smart_holder_poc.h"
+#include "pybind11/detail/smart_holder_poc.h"
 
 #define CATCH_CONFIG_MAIN
 #include "catch.hpp"
diff --git a/tests/test_classh_inheritance.cpp b/tests/test_classh_inheritance.cpp
index 6f84202f65..ddaaefd517 100644
--- a/tests/test_classh_inheritance.cpp
+++ b/tests/test_classh_inheritance.cpp
@@ -1,6 +1,6 @@
 #include "pybind11_tests.h"
 
-#include <pybind11/classh.h>
+#include <pybind11/smart_holder.h>
 
 #include <memory>
 
diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 2b0a9bbcf0..8a504f2440 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -1,6 +1,6 @@
 #include "pybind11_tests.h"
 
-#include <pybind11/classh.h>
+#include <pybind11/smart_holder.h>
 
 #include <memory>
 #include <string>
diff --git a/tests/test_unique_ptr_member.cpp b/tests/test_unique_ptr_member.cpp
index 0712417018..89ff00a304 100644
--- a/tests/test_unique_ptr_member.cpp
+++ b/tests/test_unique_ptr_member.cpp
@@ -1,6 +1,6 @@
 #include "pybind11_tests.h"
 
-#include <pybind11/classh.h>
+#include <pybind11/smart_holder.h>
 
 #include <memory>
 

From 6e460b81557cee7a501df3999662837758159f79 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 24 Jan 2021 22:35:18 -0800
Subject: [PATCH 103/206] Renaming all "classh" to "smart_holder" in
 pybind11/detail/smart_holder_type_casters.h.

The user-facing macro is now PYBIND11_SMART_HOLDER_TYPE_CASTERS.
---
 .../detail/smart_holder_type_casters.h        | 36 ++++++++++---------
 tests/classh_module_local_0.cpp               |  2 +-
 tests/classh_module_local_1.cpp               |  2 +-
 tests/classh_module_local_2.cpp               |  2 +-
 tests/test_classh_inheritance.cpp             | 10 +++---
 tests/test_classh_wip.cpp                     |  2 +-
 tests/test_unique_ptr_member.cpp              |  2 +-
 7 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index cd2e19efb9..77297c454a 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -60,7 +60,7 @@ class modified_type_caster_generic_load_impl {
                                      " Python instance is uninitialized or was disowned.");
         }
         if (v_h.value_ptr() == nullptr) {
-            pybind11_fail("classh_type_casters: Unexpected v_h.value_ptr() nullptr.");
+            pybind11_fail("smart_holder_type_casters: Unexpected v_h.value_ptr() nullptr.");
         }
         loaded_v_h.type = typeinfo;
     }
@@ -70,7 +70,7 @@ class modified_type_caster_generic_load_impl {
             modified_type_caster_generic_load_impl sub_caster(*cast.first);
             if (sub_caster.load(src, convert)) {
                 if (loaded_v_h_cpptype != nullptr) {
-                    pybind11_fail("classh_type_casters: try_implicit_casts failure.");
+                    pybind11_fail("smart_holder_type_casters: try_implicit_casts failure.");
                 }
                 loaded_v_h = sub_caster.loaded_v_h;
                 loaded_v_h_cpptype = cast.first;
@@ -124,11 +124,11 @@ class modified_type_caster_generic_load_impl {
             // Magic number intentionally hard-coded for simplicity and maximum robustness.
             if (foreign_loader->local_load_safety_guard != 37726257887406645) {
                 pybind11_fail(
-                    "Unexpected local_load_safety_guard,"
-                    " possibly due to py::class_ vs py::classh mixup.");
+                    "smart_holder_type_casters: Unexpected local_load_safety_guard,"
+                    " possibly due to py::class_ holder mixup.");
             }
             if (loaded_v_h_cpptype != nullptr) {
-                pybind11_fail("classh_type_casters: try_load_foreign_module_local failure.");
+                pybind11_fail("smart_holder_type_casters: try_load_foreign_module_local failure.");
             }
             loaded_v_h = foreign_loader->loaded_v_h;
             loaded_v_h_cpptype = foreign_loader->loaded_v_h_cpptype;
@@ -232,7 +232,7 @@ class modified_type_caster_generic_load_impl {
     void *(*implicit_cast)(void *) = nullptr;
     value_and_holder loaded_v_h;
     bool reinterpret_cast_deemed_ok = false;
-    // Magic number intentionally hard-coded, to guard against class_ vs classh mixups.
+    // Magic number intentionally hard-coded, to guard against class_ holder mixups.
     // Ideally type_caster_generic would have a similar guard, but this requires a change there.
     std::size_t local_load_safety_guard = 37726257887406645;
 };
@@ -336,7 +336,7 @@ struct make_constructor {
 // type_caster_base END
 
 template <typename T>
-struct classh_type_caster : smart_holder_type_caster_load<T> {
+struct smart_holder_type_caster : smart_holder_type_caster_load<T> {
     static constexpr auto name = _<T>();
 
     // static handle cast(T, ...)
@@ -494,7 +494,7 @@ struct classh_type_caster : smart_holder_type_caster_load<T> {
 };
 
 template <typename T>
-struct classh_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_load<T> {
+struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_load<T> {
     static constexpr auto name = _<std::shared_ptr<T>>();
 
     static handle cast(const std::shared_ptr<T> &src, return_value_policy policy, handle parent) {
@@ -539,7 +539,7 @@ struct classh_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_load<T>
 };
 
 template <typename T>
-struct classh_type_caster<std::shared_ptr<T const>> : smart_holder_type_caster_load<T> {
+struct smart_holder_type_caster<std::shared_ptr<T const>> : smart_holder_type_caster_load<T> {
     static constexpr auto name = _<std::shared_ptr<T const>>();
 
     static handle
@@ -557,7 +557,7 @@ struct classh_type_caster<std::shared_ptr<T const>> : smart_holder_type_caster_l
 };
 
 template <typename T>
-struct classh_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_load<T> {
+struct smart_holder_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_load<T> {
     static constexpr auto name = _<std::unique_ptr<T>>();
 
     static handle cast(std::unique_ptr<T> &&src, return_value_policy policy, handle parent) {
@@ -600,7 +600,7 @@ struct classh_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_load<T>
 };
 
 template <typename T>
-struct classh_type_caster<std::unique_ptr<T const>> : smart_holder_type_caster_load<T> {
+struct smart_holder_type_caster<std::unique_ptr<T const>> : smart_holder_type_caster_load<T> {
     static constexpr auto name = _<std::unique_ptr<T const>>();
 
     static handle cast(std::unique_ptr<T const> &&src, return_value_policy policy, handle parent) {
@@ -616,21 +616,23 @@ struct classh_type_caster<std::unique_ptr<T const>> : smart_holder_type_caster_l
     operator std::unique_ptr<T const>() { return this->loaded_as_unique_ptr(); }
 };
 
-#define PYBIND11_CLASSH_TYPE_CASTERS(T)                                                           \
+#define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                     \
     namespace pybind11 {                                                                          \
     namespace detail {                                                                            \
     template <>                                                                                   \
-    class type_caster<T> : public classh_type_caster<T> {};                                       \
+    class type_caster<T> : public smart_holder_type_caster<T> {};                                 \
     template <>                                                                                   \
-    class type_caster<std::shared_ptr<T>> : public classh_type_caster<std::shared_ptr<T>> {};     \
+    class type_caster<std::shared_ptr<T>> : public smart_holder_type_caster<std::shared_ptr<T>> { \
+    };                                                                                            \
     template <>                                                                                   \
     class type_caster<std::shared_ptr<T const>>                                                   \
-        : public classh_type_caster<std::shared_ptr<T const>> {};                                 \
+        : public smart_holder_type_caster<std::shared_ptr<T const>> {};                           \
     template <>                                                                                   \
-    class type_caster<std::unique_ptr<T>> : public classh_type_caster<std::unique_ptr<T>> {};     \
+    class type_caster<std::unique_ptr<T>> : public smart_holder_type_caster<std::unique_ptr<T>> { \
+    };                                                                                            \
     template <>                                                                                   \
     class type_caster<std::unique_ptr<T const>>                                                   \
-        : public classh_type_caster<std::unique_ptr<T const>> {};                                 \
+        : public smart_holder_type_caster<std::unique_ptr<T const>> {};                           \
     }                                                                                             \
     }
 
diff --git a/tests/classh_module_local_0.cpp b/tests/classh_module_local_0.cpp
index fecf850cce..c52cce8ab1 100644
--- a/tests/classh_module_local_0.cpp
+++ b/tests/classh_module_local_0.cpp
@@ -17,7 +17,7 @@ atyp rtrn_valu_atyp() { return atyp(); }
 } // namespace classh_module_local
 } // namespace pybind11_tests
 
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_module_local::atyp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_module_local::atyp)
 
 PYBIND11_MODULE(classh_module_local_0, m) {
     using namespace pybind11_tests::classh_module_local;
diff --git a/tests/classh_module_local_1.cpp b/tests/classh_module_local_1.cpp
index c385771783..8efa4a87a3 100644
--- a/tests/classh_module_local_1.cpp
+++ b/tests/classh_module_local_1.cpp
@@ -16,7 +16,7 @@ std::string get_mtxt(const atyp &obj) { return obj.mtxt; }
 } // namespace classh_module_local
 } // namespace pybind11_tests
 
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_module_local::atyp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_module_local::atyp)
 
 PYBIND11_MODULE(classh_module_local_1, m) {
     namespace py = pybind11;
diff --git a/tests/classh_module_local_2.cpp b/tests/classh_module_local_2.cpp
index 2d33b04a0d..a6531ef41b 100644
--- a/tests/classh_module_local_2.cpp
+++ b/tests/classh_module_local_2.cpp
@@ -16,7 +16,7 @@ std::string get_mtxt(const atyp &obj) { return obj.mtxt; }
 } // namespace classh_module_local
 } // namespace pybind11_tests
 
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_module_local::atyp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_module_local::atyp)
 
 PYBIND11_MODULE(classh_module_local_2, m) {
     namespace py = pybind11;
diff --git a/tests/test_classh_inheritance.cpp b/tests/test_classh_inheritance.cpp
index ddaaefd517..b6d7fc0b02 100644
--- a/tests/test_classh_inheritance.cpp
+++ b/tests/test_classh_inheritance.cpp
@@ -56,12 +56,12 @@ inline int pass_cptr_drvd2(drvd2 const *d) { return d->id() + 23; }
 } // namespace classh_inheritance
 } // namespace pybind11_tests
 
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_inheritance::base)
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_inheritance::drvd)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_inheritance::base)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_inheritance::drvd)
 
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_inheritance::base1)
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_inheritance::base2)
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_inheritance::drvd2)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_inheritance::base1)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_inheritance::base2)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_inheritance::drvd2)
 
 namespace pybind11_tests {
 namespace classh_inheritance {
diff --git a/tests/test_classh_wip.cpp b/tests/test_classh_wip.cpp
index 8a504f2440..ae4a6f06b0 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_classh_wip.cpp
@@ -49,7 +49,7 @@ std::unique_ptr<atyp> unique_ptr_roundtrip(std::unique_ptr<atyp> obj) { return o
 } // namespace classh_wip
 } // namespace pybind11_tests
 
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::classh_wip::atyp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_wip::atyp)
 
 namespace pybind11_tests {
 namespace classh_wip {
diff --git a/tests/test_unique_ptr_member.cpp b/tests/test_unique_ptr_member.cpp
index 89ff00a304..a9484c0fce 100644
--- a/tests/test_unique_ptr_member.cpp
+++ b/tests/test_unique_ptr_member.cpp
@@ -40,7 +40,7 @@ class ptr_owner {
 } // namespace unique_ptr_member
 } // namespace pybind11_tests
 
-PYBIND11_CLASSH_TYPE_CASTERS(pybind11_tests::unique_ptr_member::pointee)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::unique_ptr_member::pointee)
 
 namespace pybind11_tests {
 namespace unique_ptr_member {

From b71f6ff3b209c4c41850e0fb9f1019a3c9e0bfc4 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 24 Jan 2021 23:06:33 -0800
Subject: [PATCH 104/206] Systematically renaming tests to use "class_sh" in
 the name.

---
 ...ocal_0.cpp => class_sh_module_local_0.cpp} | 10 +++++-----
 ...ocal_1.cpp => class_sh_module_local_1.cpp} | 12 +++++------
 ...ocal_2.cpp => class_sh_module_local_2.cpp} | 12 +++++------
 ...classh_wip.cpp => test_class_sh_basic.cpp} | 12 +++++------
 ...t_classh_wip.py => test_class_sh_basic.py} |  2 +-
 ...ance.cpp => test_class_sh_inheritance.cpp} | 20 +++++++++----------
 ...itance.py => test_class_sh_inheritance.py} |  2 +-
 ...local.py => test_class_sh_module_local.py} |  6 +++---
 ...pp => test_class_sh_unique_ptr_member.cpp} | 12 +++++------
 ....py => test_class_sh_unique_ptr_member.py} |  2 +-
 10 files changed, 45 insertions(+), 45 deletions(-)
 rename tests/{classh_module_local_0.cpp => class_sh_module_local_0.cpp} (60%)
 rename tests/{classh_module_local_1.cpp => class_sh_module_local_1.cpp} (64%)
 rename tests/{classh_module_local_2.cpp => class_sh_module_local_2.cpp} (64%)
 rename tests/{test_classh_wip.cpp => test_class_sh_basic.cpp} (94%)
 rename tests/{test_classh_wip.py => test_class_sh_basic.py} (98%)
 rename tests/{test_classh_inheritance.cpp => test_class_sh_inheritance.cpp} (83%)
 rename tests/{test_classh_inheritance.py => test_class_sh_inheritance.py} (96%)
 rename tests/{test_classh_module_local.py => test_class_sh_module_local.py} (84%)
 rename tests/{test_unique_ptr_member.cpp => test_class_sh_unique_ptr_member.cpp} (83%)
 rename tests/{test_unique_ptr_member.py => test_class_sh_unique_ptr_member.py} (93%)

diff --git a/tests/classh_module_local_0.cpp b/tests/class_sh_module_local_0.cpp
similarity index 60%
rename from tests/classh_module_local_0.cpp
rename to tests/class_sh_module_local_0.cpp
index c52cce8ab1..8e007fd0e3 100644
--- a/tests/classh_module_local_0.cpp
+++ b/tests/class_sh_module_local_0.cpp
@@ -4,7 +4,7 @@
 #include <string>
 
 namespace pybind11_tests {
-namespace classh_module_local {
+namespace class_sh_module_local {
 
 struct atyp { // Short for "any type".
     std::string mtxt;
@@ -14,13 +14,13 @@ std::string get_mtxt(const atyp &obj) { return obj.mtxt; }
 
 atyp rtrn_valu_atyp() { return atyp(); }
 
-} // namespace classh_module_local
+} // namespace class_sh_module_local
 } // namespace pybind11_tests
 
-PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_module_local::atyp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_module_local::atyp)
 
-PYBIND11_MODULE(classh_module_local_0, m) {
-    using namespace pybind11_tests::classh_module_local;
+PYBIND11_MODULE(class_sh_module_local_0, m) {
+    using namespace pybind11_tests::class_sh_module_local;
 
     m.def("get_mtxt", get_mtxt);
 
diff --git a/tests/classh_module_local_1.cpp b/tests/class_sh_module_local_1.cpp
similarity index 64%
rename from tests/classh_module_local_1.cpp
rename to tests/class_sh_module_local_1.cpp
index 8efa4a87a3..22adb733da 100644
--- a/tests/classh_module_local_1.cpp
+++ b/tests/class_sh_module_local_1.cpp
@@ -1,11 +1,11 @@
-// Identical to classh_module_local_2.cpp, except 2 replaced with 1.
+// Identical to class_sh_module_local_2.cpp, except 2 replaced with 1.
 #include <pybind11/pybind11.h>
 #include <pybind11/smart_holder.h>
 
 #include <string>
 
 namespace pybind11_tests {
-namespace classh_module_local {
+namespace class_sh_module_local {
 
 struct atyp { // Short for "any type".
     std::string mtxt;
@@ -13,14 +13,14 @@ struct atyp { // Short for "any type".
 
 std::string get_mtxt(const atyp &obj) { return obj.mtxt; }
 
-} // namespace classh_module_local
+} // namespace class_sh_module_local
 } // namespace pybind11_tests
 
-PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_module_local::atyp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_module_local::atyp)
 
-PYBIND11_MODULE(classh_module_local_1, m) {
+PYBIND11_MODULE(class_sh_module_local_1, m) {
     namespace py = pybind11;
-    using namespace pybind11_tests::classh_module_local;
+    using namespace pybind11_tests::class_sh_module_local;
 
     py::class_<atyp, py::smart_holder>(m, "atyp", py::module_local())
         .def(py::init([](const std::string &mtxt) {
diff --git a/tests/classh_module_local_2.cpp b/tests/class_sh_module_local_2.cpp
similarity index 64%
rename from tests/classh_module_local_2.cpp
rename to tests/class_sh_module_local_2.cpp
index a6531ef41b..e6f866267c 100644
--- a/tests/classh_module_local_2.cpp
+++ b/tests/class_sh_module_local_2.cpp
@@ -1,11 +1,11 @@
-// Identical to classh_module_local_1.cpp, except 1 replaced with 2.
+// Identical to class_sh_module_local_1.cpp, except 1 replaced with 2.
 #include <pybind11/pybind11.h>
 #include <pybind11/smart_holder.h>
 
 #include <string>
 
 namespace pybind11_tests {
-namespace classh_module_local {
+namespace class_sh_module_local {
 
 struct atyp { // Short for "any type".
     std::string mtxt;
@@ -13,14 +13,14 @@ struct atyp { // Short for "any type".
 
 std::string get_mtxt(const atyp &obj) { return obj.mtxt; }
 
-} // namespace classh_module_local
+} // namespace class_sh_module_local
 } // namespace pybind11_tests
 
-PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_module_local::atyp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_module_local::atyp)
 
-PYBIND11_MODULE(classh_module_local_2, m) {
+PYBIND11_MODULE(class_sh_module_local_2, m) {
     namespace py = pybind11;
-    using namespace pybind11_tests::classh_module_local;
+    using namespace pybind11_tests::class_sh_module_local;
 
     py::class_<atyp, py::smart_holder>(m, "atyp", py::module_local())
         .def(py::init([](const std::string &mtxt) {
diff --git a/tests/test_classh_wip.cpp b/tests/test_class_sh_basic.cpp
similarity index 94%
rename from tests/test_classh_wip.cpp
rename to tests/test_class_sh_basic.cpp
index ae4a6f06b0..488b033fc7 100644
--- a/tests/test_classh_wip.cpp
+++ b/tests/test_class_sh_basic.cpp
@@ -6,7 +6,7 @@
 #include <string>
 
 namespace pybind11_tests {
-namespace classh_wip {
+namespace class_sh_basic {
 
 struct atyp { // Short for "any type".
     std::string mtxt;
@@ -46,15 +46,15 @@ std::string pass_uqcp_atyp(std::unique_ptr<atyp const> obj) { return "pass_uqcp:
 std::string get_mtxt(atyp const &obj) { return obj.mtxt; }
 std::unique_ptr<atyp> unique_ptr_roundtrip(std::unique_ptr<atyp> obj) { return obj; }
 
-} // namespace classh_wip
+} // namespace class_sh_basic
 } // namespace pybind11_tests
 
-PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_wip::atyp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_basic::atyp)
 
 namespace pybind11_tests {
-namespace classh_wip {
+namespace class_sh_basic {
 
-TEST_SUBMODULE(classh_wip, m) {
+TEST_SUBMODULE(class_sh_basic, m) {
     namespace py = pybind11;
 
     py::class_<atyp, py::smart_holder>(m, "atyp")
@@ -97,5 +97,5 @@ TEST_SUBMODULE(classh_wip, m) {
     m.def("unique_ptr_roundtrip", unique_ptr_roundtrip); // pass_uqmp_atyp, rtrn_uqmp_atyp
 }
 
-} // namespace classh_wip
+} // namespace class_sh_basic
 } // namespace pybind11_tests
diff --git a/tests/test_classh_wip.py b/tests/test_class_sh_basic.py
similarity index 98%
rename from tests/test_classh_wip.py
rename to tests/test_class_sh_basic.py
index b6f86d2bfb..21a93b5dc1 100644
--- a/tests/test_classh_wip.py
+++ b/tests/test_class_sh_basic.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 import pytest
 
-from pybind11_tests import classh_wip as m
+from pybind11_tests import class_sh_basic as m
 
 
 def test_atyp_constructors():
diff --git a/tests/test_classh_inheritance.cpp b/tests/test_class_sh_inheritance.cpp
similarity index 83%
rename from tests/test_classh_inheritance.cpp
rename to tests/test_class_sh_inheritance.cpp
index b6d7fc0b02..81049061fa 100644
--- a/tests/test_classh_inheritance.cpp
+++ b/tests/test_class_sh_inheritance.cpp
@@ -5,7 +5,7 @@
 #include <memory>
 
 namespace pybind11_tests {
-namespace classh_inheritance {
+namespace class_sh_inheritance {
 
 template <int Id>
 struct base_template {
@@ -53,20 +53,20 @@ inline int pass_cptr_base2(base2 const *b) { return b->id() + 22; }
 inline int pass_cptr_drvd2(drvd2 const *d) { return d->id() + 23; }
 // clang-format on
 
-} // namespace classh_inheritance
+} // namespace class_sh_inheritance
 } // namespace pybind11_tests
 
-PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_inheritance::base)
-PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_inheritance::drvd)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_inheritance::base)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_inheritance::drvd)
 
-PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_inheritance::base1)
-PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_inheritance::base2)
-PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::classh_inheritance::drvd2)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_inheritance::base1)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_inheritance::base2)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_inheritance::drvd2)
 
 namespace pybind11_tests {
-namespace classh_inheritance {
+namespace class_sh_inheritance {
 
-TEST_SUBMODULE(classh_inheritance, m) {
+TEST_SUBMODULE(class_sh_inheritance, m) {
     py::class_<base, py::smart_holder>(m, "base");
     py::class_<drvd, base, py::smart_holder>(m, "drvd");
 
@@ -95,5 +95,5 @@ TEST_SUBMODULE(classh_inheritance, m) {
     m.def("pass_cptr_drvd2", pass_cptr_drvd2);
 }
 
-} // namespace classh_inheritance
+} // namespace class_sh_inheritance
 } // namespace pybind11_tests
diff --git a/tests/test_classh_inheritance.py b/tests/test_class_sh_inheritance.py
similarity index 96%
rename from tests/test_classh_inheritance.py
rename to tests/test_class_sh_inheritance.py
index cf72c5bc4a..69f9131d70 100644
--- a/tests/test_classh_inheritance.py
+++ b/tests/test_class_sh_inheritance.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-from pybind11_tests import classh_inheritance as m
+from pybind11_tests import class_sh_inheritance as m
 
 
 def test_rtrn_mptr_drvd_pass_cptr_base():
diff --git a/tests/test_classh_module_local.py b/tests/test_class_sh_module_local.py
similarity index 84%
rename from tests/test_classh_module_local.py
rename to tests/test_class_sh_module_local.py
index f7113efe57..aa4d1f3c5d 100644
--- a/tests/test_classh_module_local.py
+++ b/tests/test_class_sh_module_local.py
@@ -1,9 +1,9 @@
 # -*- coding: utf-8 -*-
 import pytest
 
-import classh_module_local_0 as m0
-import classh_module_local_1 as m1
-import classh_module_local_2 as m2
+import class_sh_module_local_0 as m0
+import class_sh_module_local_1 as m1
+import class_sh_module_local_2 as m2
 
 
 def test_cross_module_get_mtxt():
diff --git a/tests/test_unique_ptr_member.cpp b/tests/test_class_sh_unique_ptr_member.cpp
similarity index 83%
rename from tests/test_unique_ptr_member.cpp
rename to tests/test_class_sh_unique_ptr_member.cpp
index a9484c0fce..0da05f4e3e 100644
--- a/tests/test_unique_ptr_member.cpp
+++ b/tests/test_class_sh_unique_ptr_member.cpp
@@ -5,7 +5,7 @@
 #include <memory>
 
 namespace pybind11_tests {
-namespace unique_ptr_member {
+namespace class_sh_unique_ptr_member {
 
 class pointee { // NOT copyable.
 public:
@@ -37,15 +37,15 @@ class ptr_owner {
     std::unique_ptr<pointee> ptr_;
 };
 
-} // namespace unique_ptr_member
+} // namespace class_sh_unique_ptr_member
 } // namespace pybind11_tests
 
-PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::unique_ptr_member::pointee)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_unique_ptr_member::pointee)
 
 namespace pybind11_tests {
-namespace unique_ptr_member {
+namespace class_sh_unique_ptr_member {
 
-TEST_SUBMODULE(unique_ptr_member, m) {
+TEST_SUBMODULE(class_sh_unique_ptr_member, m) {
     py::class_<pointee, py::smart_holder>(m, "pointee")
         .def(py::init<>())
         .def("get_int", &pointee::get_int);
@@ -59,5 +59,5 @@ TEST_SUBMODULE(unique_ptr_member, m) {
         .def("give_up_ownership_via_shared_ptr", &ptr_owner::give_up_ownership_via_shared_ptr);
 }
 
-} // namespace unique_ptr_member
+} // namespace class_sh_unique_ptr_member
 } // namespace pybind11_tests
diff --git a/tests/test_unique_ptr_member.py b/tests/test_class_sh_unique_ptr_member.py
similarity index 93%
rename from tests/test_unique_ptr_member.py
rename to tests/test_class_sh_unique_ptr_member.py
index 5ced1b3aed..5537ac7a98 100644
--- a/tests/test_unique_ptr_member.py
+++ b/tests/test_class_sh_unique_ptr_member.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 import pytest
 
-from pybind11_tests import unique_ptr_member as m
+from pybind11_tests import class_sh_unique_ptr_member as m
 
 
 def test_make_unique_pointee():

From 16132685628d47d4f6165323641292b35ea38108 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 24 Jan 2021 23:16:46 -0800
Subject: [PATCH 105/206] Renaming test_type_caster_bare_interface_demo to
 test_type_caster_bare_interface.

---
 ..._demo.cpp => test_type_caster_bare_interface.cpp} | 12 ++++++------
 ...ce_demo.py => test_type_caster_bare_interface.py} |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)
 rename tests/{test_type_caster_bare_interface_demo.cpp => test_type_caster_bare_interface.cpp} (95%)
 rename tests/{test_type_caster_bare_interface_demo.py => test_type_caster_bare_interface.py} (94%)

diff --git a/tests/test_type_caster_bare_interface_demo.cpp b/tests/test_type_caster_bare_interface.cpp
similarity index 95%
rename from tests/test_type_caster_bare_interface_demo.cpp
rename to tests/test_type_caster_bare_interface.cpp
index ea6041a650..02b6281c2e 100644
--- a/tests/test_type_caster_bare_interface_demo.cpp
+++ b/tests/test_type_caster_bare_interface.cpp
@@ -3,7 +3,7 @@
 #include <memory>
 
 namespace pybind11_tests {
-namespace type_caster_bare_interface_demo {
+namespace type_caster_bare_interface {
 
 struct mpty {};
 
@@ -37,13 +37,13 @@ const char* pass_mpty_uqcp(std::unique_ptr<mpty const>) { return "load_uqcp"; }
 
 // clang-format on
 
-} // namespace type_caster_bare_interface_demo
+} // namespace type_caster_bare_interface
 } // namespace pybind11_tests
 
 namespace pybind11 {
 namespace detail {
 
-using namespace pybind11_tests::type_caster_bare_interface_demo;
+using namespace pybind11_tests::type_caster_bare_interface;
 
 template <>
 struct type_caster<mpty> {
@@ -177,9 +177,9 @@ struct type_caster<std::unique_ptr<mpty const>> {
 } // namespace pybind11
 
 namespace pybind11_tests {
-namespace type_caster_bare_interface_demo {
+namespace type_caster_bare_interface {
 
-TEST_SUBMODULE(type_caster_bare_interface_demo, m) {
+TEST_SUBMODULE(type_caster_bare_interface, m) {
     m.def("rtrn_mpty_valu", rtrn_mpty_valu);
     m.def("rtrn_mpty_rref", rtrn_mpty_rref);
     m.def("rtrn_mpty_cref", rtrn_mpty_cref);
@@ -207,5 +207,5 @@ TEST_SUBMODULE(type_caster_bare_interface_demo, m) {
     m.def("pass_mpty_uqcp", pass_mpty_uqcp);
 }
 
-} // namespace type_caster_bare_interface_demo
+} // namespace type_caster_bare_interface
 } // namespace pybind11_tests
diff --git a/tests/test_type_caster_bare_interface_demo.py b/tests/test_type_caster_bare_interface.py
similarity index 94%
rename from tests/test_type_caster_bare_interface_demo.py
rename to tests/test_type_caster_bare_interface.py
index 6152d88a6e..5a19e1abcf 100644
--- a/tests/test_type_caster_bare_interface_demo.py
+++ b/tests/test_type_caster_bare_interface.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-from pybind11_tests import type_caster_bare_interface_demo as m
+from pybind11_tests import type_caster_bare_interface as m
 
 
 def test_cast():

From 9ef2cce72f465eb9c015734ad0c0bbaea66b3723 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 24 Jan 2021 23:22:43 -0800
Subject: [PATCH 106/206] Renaming new tests/core subdirectory to
 tests/pure_cpp.

---
 tests/{core => pure_cpp}/smart_holder_poc_test.cpp | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename tests/{core => pure_cpp}/smart_holder_poc_test.cpp (100%)

diff --git a/tests/core/smart_holder_poc_test.cpp b/tests/pure_cpp/smart_holder_poc_test.cpp
similarity index 100%
rename from tests/core/smart_holder_poc_test.cpp
rename to tests/pure_cpp/smart_holder_poc_test.cpp

From 6ab0a02e3f130ada98af67555faebd5e485d5624 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 25 Jan 2021 00:30:17 -0800
Subject: [PATCH 107/206] Adding new tests to CMake config, resetting CI
 config.

---
 .appveyor.yml                   |  3 ---
 .github/workflows/ci.yml        |  2 +-
 .github/workflows/configure.yml |  2 +-
 .github/workflows/format.yml    |  2 +-
 .github/workflows/pip.yml       |  2 +-
 CMakeLists.txt                  |  4 +++-
 tests/CMakeLists.txt            | 16 ++++++++++++++++
 7 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/.appveyor.yml b/.appveyor.yml
index 9a1d69a6af..85445d41a2 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -1,9 +1,6 @@
 version: 1.0.{build}
 image:
 - Visual Studio 2015
-branches:
-  only:
-    - will_never_exist
 test: off
 skip_branch_with_pr: true
 build:
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index aed9bfb3d5..a1bdec7bd7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,7 +2,7 @@ name: CI
 
 on:
   workflow_dispatch:
-  # pull_request:
+  pull_request:
   push:
     branches:
       - master
diff --git a/.github/workflows/configure.yml b/.github/workflows/configure.yml
index 1b9336052f..0f3117be99 100644
--- a/.github/workflows/configure.yml
+++ b/.github/workflows/configure.yml
@@ -2,7 +2,7 @@ name: Config
 
 on:
   workflow_dispatch:
-  # pull_request:
+  pull_request:
   push:
     branches:
       - master
diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
index 5e8792ee03..5cebed17da 100644
--- a/.github/workflows/format.yml
+++ b/.github/workflows/format.yml
@@ -5,7 +5,7 @@ name: Format
 
 on:
   workflow_dispatch:
-  # pull_request:
+  pull_request:
   push:
     branches:
     - master
diff --git a/.github/workflows/pip.yml b/.github/workflows/pip.yml
index 0bed204a2c..5547a5e285 100644
--- a/.github/workflows/pip.yml
+++ b/.github/workflows/pip.yml
@@ -2,7 +2,7 @@ name: Pip
 
 on:
   workflow_dispatch:
-  # pull_request:
+  pull_request:
   push:
     branches:
     - master
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 152763eb42..3b1f22b4f5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -105,7 +105,8 @@ set(PYBIND11_HEADERS
     include/pybind11/detail/descr.h
     include/pybind11/detail/init.h
     include/pybind11/detail/internals.h
-    include/pybind11/detail/type_caster_base.h
+    include/pybind11/detail/smart_holder_poc.h
+    include/pybind11/detail/smart_holder_type_casters.h
     include/pybind11/detail/typeid.h
     include/pybind11/attr.h
     include/pybind11/buffer_info.h
@@ -124,6 +125,7 @@ set(PYBIND11_HEADERS
     include/pybind11/operators.h
     include/pybind11/pybind11.h
     include/pybind11/pytypes.h
+    include/pybind11/smart_holder.h
     include/pybind11/stl.h
     include/pybind11/stl_bind.h)
 
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 9ff6c0dd9a..4eac0d6626 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -101,6 +101,9 @@ set(PYBIND11_TEST_FILES
     test_callbacks.cpp
     test_chrono.cpp
     test_class.cpp
+    test_class_sh_basic.cpp
+    test_class_sh_inheritance.cpp
+    test_class_sh_unique_ptr_member.cpp
     test_constants_and_functions.cpp
     test_copy_move.cpp
     test_custom_type_casters.cpp
@@ -129,6 +132,7 @@ set(PYBIND11_TEST_FILES
     test_stl.cpp
     test_stl_binders.cpp
     test_tagbased_polymorphic.cpp
+    test_type_caster_bare_interface.cpp
     test_union.cpp
     test_virtual_functions.cpp)
 
@@ -169,6 +173,8 @@ set(PYBIND11_CROSS_MODULE_TESTS test_exceptions.py test_local_bindings.py test_s
 
 set(PYBIND11_CROSS_MODULE_GIL_TESTS test_gil_scoped.py)
 
+set(PYBIND11_CLASS_SH_MODULE_LOCAL_TESTS test_class_sh_module_local.py)
+
 # Check if Eigen is available; if not, remove from PYBIND11_TEST_FILES (but
 # keep it in PYBIND11_PYTEST_FILES, so that we get the "eigen is not installed"
 # skip message).
@@ -304,6 +310,16 @@ foreach(t ${PYBIND11_CROSS_MODULE_GIL_TESTS})
   endif()
 endforeach()
 
+foreach(t ${PYBIND11_CLASS_SH_MODULE_LOCAL_TESTS})
+  list(FIND PYBIND11_PYTEST_FILES ${t} i)
+  if(i GREATER -1)
+    list(APPEND test_targets class_sh_module_local_0)
+    list(APPEND test_targets class_sh_module_local_1)
+    list(APPEND test_targets class_sh_module_local_2)
+    break()
+  endif()
+endforeach()
+
 # Support CUDA testing by forcing the target file to compile with NVCC
 if(PYBIND11_CUDA_TESTS)
   set_property(SOURCE ${PYBIND11_TEST_FILES} PROPERTY LANGUAGE CUDA)

From 8b04ea05aa7dedad3d6194ec833cadc67f819ab0 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 25 Jan 2021 13:56:04 -0800
Subject: [PATCH 108/206] Changing CMake file so that
 test_class_sh_module_local.py actually runs.

---
 tests/CMakeLists.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 4eac0d6626..f2af0eae07 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -164,6 +164,8 @@ if(PYBIND11_CUDA_TESTS)
 endif()
 
 string(REPLACE ".cpp" ".py" PYBIND11_PYTEST_FILES "${PYBIND11_TEST_FILES}")
+list(APPEND PYBIND11_PYTEST_FILES test_class_sh_module_local.py)
+list(SORT PYBIND11_PYTEST_FILES COMPARE NATURAL)
 
 # Contains the set of test files that require pybind11_cross_module_tests to be
 # built; if none of these are built (i.e. because TEST_OVERRIDE is used and

From e67d5a5cd38020e861c26c42021cf0ad15444889 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 25 Jan 2021 14:06:13 -0800
Subject: [PATCH 109/206] clang-tidy fixes.

---
 .../detail/smart_holder_type_casters.h        | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index 77297c454a..360df6b5ac 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -517,11 +517,11 @@ struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_l
             // MISSING: keep_alive.
             return existing_inst.second;
 
-        object inst            = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        instance *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
-        inst_raw_ptr->owned    = true;
-        void *&valueptr        = values_and_holders(inst_raw_ptr).begin()->value_ptr();
-        valueptr               = src_raw_void_ptr;
+        auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
+        inst_raw_ptr->owned = true;
+        void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+        valueptr            = src_raw_void_ptr;
 
         auto smhldr = pybindit::memory::smart_holder::from_shared_ptr(src);
         tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
@@ -578,11 +578,11 @@ struct smart_holder_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_l
         if (existing_inst.first)
             throw cast_error("Invalid unique_ptr: another instance owns this pointer already.");
 
-        object inst            = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        instance *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
-        inst_raw_ptr->owned    = true;
-        void *&valueptr        = values_and_holders(inst_raw_ptr).begin()->value_ptr();
-        valueptr               = src_raw_void_ptr;
+        auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
+        inst_raw_ptr->owned = true;
+        void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+        valueptr            = src_raw_void_ptr;
 
         auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(src));
         tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));

From 02c4e24bb61189359191297e6596b9003fdd28ef Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 25 Jan 2021 14:25:22 -0800
Subject: [PATCH 110/206] 32-bit compatibility.

---
 include/pybind11/detail/smart_holder_type_casters.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index 360df6b5ac..a4f8350a4f 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -122,7 +122,7 @@ class modified_type_caster_generic_load_impl {
             auto foreign_loader = std::unique_ptr<modified_type_caster_generic_load_impl>(
                 static_cast<modified_type_caster_generic_load_impl *>(foreign_loader_void_ptr));
             // Magic number intentionally hard-coded for simplicity and maximum robustness.
-            if (foreign_loader->local_load_safety_guard != 37726257887406645) {
+            if (foreign_loader->local_load_safety_guard != 1887406645) {
                 pybind11_fail(
                     "smart_holder_type_casters: Unexpected local_load_safety_guard,"
                     " possibly due to py::class_ holder mixup.");
@@ -234,7 +234,7 @@ class modified_type_caster_generic_load_impl {
     bool reinterpret_cast_deemed_ok = false;
     // Magic number intentionally hard-coded, to guard against class_ holder mixups.
     // Ideally type_caster_generic would have a similar guard, but this requires a change there.
-    std::size_t local_load_safety_guard = 37726257887406645;
+    std::size_t local_load_safety_guard = 1887406645; // 32-bit compatible value for portability.
 };
 // clang-format on
 

From 76a090e3873fab4b52f8652a3d3114553157d5a8 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 25 Jan 2021 23:47:40 -0800
Subject: [PATCH 111/206] Reusing type_caster_base make_copy_constructor,
 make_move_constructor with a trick.

---
 .../detail/smart_holder_type_casters.h        | 39 +++++--------------
 1 file changed, 9 insertions(+), 30 deletions(-)

diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index a4f8350a4f..ff517be187 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -23,7 +23,7 @@ namespace detail {
 inline std::pair<bool, handle> find_existing_python_instance(void *src_void_ptr,
                                                              const detail::type_info *tinfo) {
     // Loop copied from type_caster_generic::cast.
-    // IMPROVEABLE: Factor out of type_caster_generic::cast.
+    // IMPROVABLE: Factor out of type_caster_generic::cast.
     auto it_instances = get_internals().registered_instances.equal_range(src_void_ptr);
     for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
         for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
@@ -54,7 +54,7 @@ class modified_type_caster_generic_load_impl {
     void load_value_and_holder(value_and_holder &&v_h) {
         loaded_v_h = std::move(v_h);
         if (!loaded_v_h.holder_constructed()) {
-            // IMPROVEABLE: Error message. A change to the existing internals is
+            // IMPROVABLE: Error message. A change to the existing internals is
             // needed to cleanly distinguish between uninitialized or disowned.
             throw std::runtime_error("Missing value for wrapped C++ type:"
                                      " Python instance is uninitialized or was disowned.");
@@ -307,33 +307,12 @@ struct smart_holder_type_caster_load {
     }
 };
 
-// type_caster_base BEGIN
-// clang-format off
-// Helper factored out of type_caster_base.
-struct make_constructor {
-    using Constructor = void *(*)(const void *);
-
-    /* Only enabled when the types are {copy,move}-constructible *and* when the type
-       does not have a private operator new implementation. */
-    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
-    static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
-        return [](const void *arg) -> void * {
-            return new T(*reinterpret_cast<const T *>(arg));
-        };
-    }
-
-    template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
-    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
-        return [](const void *arg) -> void * {
-            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
-        };
-    }
-
-    static Constructor make_copy_constructor(...) { return nullptr; }
-    static Constructor make_move_constructor(...) { return nullptr; }
+// IMPROVABLE: Formally factor out of type_caster_base.
+struct make_constructor : private type_caster_base<int> { // Any type, nothing special about int.
+    using type_caster_base<int>::Constructor;
+    using type_caster_base<int>::make_copy_constructor;
+    using type_caster_base<int>::make_move_constructor;
 };
-// clang-format on
-// type_caster_base END
 
 template <typename T>
 struct smart_holder_type_caster : smart_holder_type_caster_load<T> {
@@ -500,7 +479,7 @@ struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_l
     static handle cast(const std::shared_ptr<T> &src, return_value_policy policy, handle parent) {
         if (policy != return_value_policy::automatic
             && policy != return_value_policy::reference_internal) {
-            // IMPROVEABLE: Error message.
+            // IMPROVABLE: Error message.
             throw cast_error("Invalid return_value_policy for shared_ptr.");
         }
 
@@ -563,7 +542,7 @@ struct smart_holder_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_l
     static handle cast(std::unique_ptr<T> &&src, return_value_policy policy, handle parent) {
         if (policy != return_value_policy::automatic
             && policy != return_value_policy::reference_internal) {
-            // IMPROVEABLE: Error message.
+            // IMPROVABLE: Error message.
             throw cast_error("Invalid return_value_policy for unique_ptr.");
         }
 

From b1ef8b64cc3335a6f043d3b964fca87c33efb537 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 26 Jan 2021 00:05:51 -0800
Subject: [PATCH 112/206] CMake COMPARE NATURAL is not available with older
 versions.

---
 tests/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index f2af0eae07..4f437d3169 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -165,7 +165,7 @@ endif()
 
 string(REPLACE ".cpp" ".py" PYBIND11_PYTEST_FILES "${PYBIND11_TEST_FILES}")
 list(APPEND PYBIND11_PYTEST_FILES test_class_sh_module_local.py)
-list(SORT PYBIND11_PYTEST_FILES COMPARE NATURAL)
+list(SORT PYBIND11_PYTEST_FILES)
 
 # Contains the set of test files that require pybind11_cross_module_tests to be
 # built; if none of these are built (i.e. because TEST_OVERRIDE is used and

From 6f6a1ad4ddc35f1782e1dc18c2050cb5cf638e4c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 26 Jan 2021 00:29:28 -0800
Subject: [PATCH 113/206] Adding copyright notices to new header files.

---
 include/pybind11/detail/smart_holder_poc.h          | 4 ++++
 include/pybind11/detail/smart_holder_type_casters.h | 4 ++++
 include/pybind11/smart_holder.h                     | 4 ++++
 3 files changed, 12 insertions(+)

diff --git a/include/pybind11/detail/smart_holder_poc.h b/include/pybind11/detail/smart_holder_poc.h
index d0a8ce368e..6ec1d1eff7 100644
--- a/include/pybind11/detail/smart_holder_poc.h
+++ b/include/pybind11/detail/smart_holder_poc.h
@@ -1,3 +1,7 @@
+// Copyright (c) 2020-2021 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
 /* Proof-of-Concept for smart pointer interoperability.
 
 High-level aspects:
diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index ff517be187..ff54c94554 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -1,3 +1,7 @@
+// Copyright (c) 2020-2021 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
 #pragma once
 
 #include "../cast.h"
diff --git a/include/pybind11/smart_holder.h b/include/pybind11/smart_holder.h
index fccc45ff19..0f9f6f4c05 100644
--- a/include/pybind11/smart_holder.h
+++ b/include/pybind11/smart_holder.h
@@ -1,3 +1,7 @@
+// Copyright (c) 2021 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
 #pragma once
 
 #include "detail/smart_holder_type_casters.h"

From ed68519006b2e0eec9e89e8ab00b9b144c1fb0c6 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 26 Jan 2021 00:48:10 -0800
Subject: [PATCH 114/206] Explicitly define copy/move constructors/assignments.

---
 tests/test_class_sh_inheritance.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/test_class_sh_inheritance.cpp b/tests/test_class_sh_inheritance.cpp
index 81049061fa..646b4fc31e 100644
--- a/tests/test_class_sh_inheritance.cpp
+++ b/tests/test_class_sh_inheritance.cpp
@@ -13,6 +13,12 @@ struct base_template {
     virtual ~base_template() = default;
     virtual int id() const { return base_id; }
     int base_id;
+
+    // Some compilers complain about implicitly defined versions of some of the following:
+    base_template(const base_template &) = default;
+    base_template(base_template &&)      = default;
+    base_template &operator=(const base_template &) = default;
+    base_template &operator=(base_template &&) = default;
 };
 
 using base = base_template<100>;

From 259d8247f7d7093bc6d0e47fd92883f1e1eec348 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 26 Jan 2021 01:02:46 -0800
Subject: [PATCH 115/206] Adding new header files to
 tests/extra_python_package/test_files.py.

---
 tests/extra_python_package/test_files.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/extra_python_package/test_files.py b/tests/extra_python_package/test_files.py
index 064a3e12fe..a5e47eeb76 100644
--- a/tests/extra_python_package/test_files.py
+++ b/tests/extra_python_package/test_files.py
@@ -32,6 +32,7 @@
     "include/pybind11/options.h",
     "include/pybind11/pybind11.h",
     "include/pybind11/pytypes.h",
+    "include/pybind11/smart_holder.h",
     "include/pybind11/stl.h",
     "include/pybind11/stl_bind.h",
 }
@@ -42,7 +43,8 @@
     "include/pybind11/detail/descr.h",
     "include/pybind11/detail/init.h",
     "include/pybind11/detail/internals.h",
-    "include/pybind11/detail/type_caster_base.h",
+    "include/pybind11/detail/smart_holder_poc.h",
+    "include/pybind11/detail/smart_holder_type_casters.h",
     "include/pybind11/detail/typeid.h",
 }
 

From ef3f789bbfeefb386a8599615b17c088614e32bf Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 26 Jan 2021 11:09:33 -0800
Subject: [PATCH 116/206] Adding tests/pure_cpp/CMakeLists.txt.

---
 tests/CMakeLists.txt          |  3 +++
 tests/pure_cpp/CMakeLists.txt | 20 ++++++++++++++++++++
 2 files changed, 23 insertions(+)
 create mode 100644 tests/pure_cpp/CMakeLists.txt

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 4f437d3169..b4ff298120 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -461,6 +461,9 @@ add_custom_command(
     ${CMAKE_CURRENT_BINARY_DIR}/sosize-$<TARGET_FILE_NAME:pybind11_tests>.txt)
 
 if(NOT PYBIND11_CUDA_TESTS)
+  # Test pure C++ code (not depending on Python). Provides the `test_pure_cpp` target.
+  add_subdirectory(pure_cpp)
+
   # Test embedding the interpreter. Provides the `cpptest` target.
   add_subdirectory(test_embed)
 
diff --git a/tests/pure_cpp/CMakeLists.txt b/tests/pure_cpp/CMakeLists.txt
new file mode 100644
index 0000000000..17be74b7f0
--- /dev/null
+++ b/tests/pure_cpp/CMakeLists.txt
@@ -0,0 +1,20 @@
+find_package(Catch 2.13.2)
+
+if(CATCH_FOUND)
+  message(STATUS "Building pure C++ tests (not depending on Python) using Catch v${CATCH_VERSION}")
+else()
+  message(STATUS "Catch not detected. Interpreter tests will be skipped. Install Catch headers"
+                 " manually or use `cmake -DDOWNLOAD_CATCH=ON` to fetch them automatically.")
+  return()
+endif()
+
+add_executable(smart_holder_poc_test smart_holder_poc_test.cpp)
+pybind11_enable_warnings(smart_holder_poc_test)
+target_link_libraries(smart_holder_poc_test PRIVATE pybind11::headers Catch2::Catch2)
+
+add_custom_target(
+  test_pure_cpp
+  COMMAND "$<TARGET_FILE:smart_holder_poc_test>"
+  WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+
+add_dependencies(check test_pure_cpp)

From 86dc9bd0d9d3269f987603d71e6a2de12a0d1ca5 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 27 Jan 2021 10:23:29 -0800
Subject: [PATCH 117/206] Making use of the new find_existing_python_instance()
 function factored out with PR #2822.

---
 .../detail/smart_holder_type_casters.h        | 27 ++++---------------
 1 file changed, 5 insertions(+), 22 deletions(-)

diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index ff54c94554..ec447ffbab 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -24,20 +24,6 @@ using pybindit::memory::smart_holder;
 
 namespace detail {
 
-inline std::pair<bool, handle> find_existing_python_instance(void *src_void_ptr,
-                                                             const detail::type_info *tinfo) {
-    // Loop copied from type_caster_generic::cast.
-    // IMPROVABLE: Factor out of type_caster_generic::cast.
-    auto it_instances = get_internals().registered_instances.equal_range(src_void_ptr);
-    for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
-        for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
-            if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
-                return std::make_pair(true, handle((PyObject *) it_i->second).inc_ref());
-        }
-    }
-    return std::make_pair(false, handle());
-}
-
 // The modified_type_caster_generic_load_impl could replace type_caster_generic::load_impl but not
 // vice versa. The main difference is that the original code only propagates a reference to the
 // held value, while the modified implementation propagates value_and_holder.
@@ -401,9 +387,8 @@ struct smart_holder_type_caster : smart_holder_type_caster_load<T> {
         if (src == nullptr)
             return none().release();
 
-        auto existing_inst = find_existing_python_instance(src, tinfo);
-        if (existing_inst.first)
-            return existing_inst.second;
+        if (handle existing_inst = find_registered_python_instance(src, tinfo))
+            return existing_inst;
 
         auto inst       = reinterpret_steal<object>(make_new_instance(tinfo->type));
         auto wrapper    = reinterpret_cast<instance *>(inst.ptr());
@@ -494,11 +479,10 @@ struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_l
 
         void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
         const detail::type_info *tinfo = st.second;
-        auto existing_inst             = find_existing_python_instance(src_raw_void_ptr, tinfo);
-        if (existing_inst.first)
+        if (handle existing_inst = find_registered_python_instance(src_raw_void_ptr, tinfo))
             // MISSING: Enforcement of consistency with existing smart_holder.
             // MISSING: keep_alive.
-            return existing_inst.second;
+            return existing_inst;
 
         auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
         auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
@@ -557,8 +541,7 @@ struct smart_holder_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_l
 
         void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
         const detail::type_info *tinfo = st.second;
-        auto existing_inst             = find_existing_python_instance(src_raw_void_ptr, tinfo);
-        if (existing_inst.first)
+        if (find_registered_python_instance(src_raw_void_ptr, tinfo))
             throw cast_error("Invalid unique_ptr: another instance owns this pointer already.");
 
         auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));

From 93e3d5869ae15c47154e7a96ae310b977e386d59 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 27 Jan 2021 12:30:32 -0800
Subject: [PATCH 118/206] Moving define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)
 down in the file. NO functional changes. Preparation for follow-up work (to
 keep that diff smaller).

---
 .../detail/smart_holder_type_casters.h        | 40 +++++++++----------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index ec447ffbab..28874d9732 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -582,26 +582,6 @@ struct smart_holder_type_caster<std::unique_ptr<T const>> : smart_holder_type_ca
     operator std::unique_ptr<T const>() { return this->loaded_as_unique_ptr(); }
 };
 
-#define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                     \
-    namespace pybind11 {                                                                          \
-    namespace detail {                                                                            \
-    template <>                                                                                   \
-    class type_caster<T> : public smart_holder_type_caster<T> {};                                 \
-    template <>                                                                                   \
-    class type_caster<std::shared_ptr<T>> : public smart_holder_type_caster<std::shared_ptr<T>> { \
-    };                                                                                            \
-    template <>                                                                                   \
-    class type_caster<std::shared_ptr<T const>>                                                   \
-        : public smart_holder_type_caster<std::shared_ptr<T const>> {};                           \
-    template <>                                                                                   \
-    class type_caster<std::unique_ptr<T>> : public smart_holder_type_caster<std::unique_ptr<T>> { \
-    };                                                                                            \
-    template <>                                                                                   \
-    class type_caster<std::unique_ptr<T const>>                                                   \
-        : public smart_holder_type_caster<std::unique_ptr<T const>> {};                           \
-    }                                                                                             \
-    }
-
 template <>
 struct is_smart_holder<pybindit::memory::smart_holder>
     : is_smart_holder<pybindit::memory::smart_holder, true> {
@@ -638,5 +618,25 @@ struct is_smart_holder<pybindit::memory::smart_holder>
     }
 };
 
+#define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                     \
+    namespace pybind11 {                                                                          \
+    namespace detail {                                                                            \
+    template <>                                                                                   \
+    class type_caster<T> : public smart_holder_type_caster<T> {};                                 \
+    template <>                                                                                   \
+    class type_caster<std::shared_ptr<T>> : public smart_holder_type_caster<std::shared_ptr<T>> { \
+    };                                                                                            \
+    template <>                                                                                   \
+    class type_caster<std::shared_ptr<T const>>                                                   \
+        : public smart_holder_type_caster<std::shared_ptr<T const>> {};                           \
+    template <>                                                                                   \
+    class type_caster<std::unique_ptr<T>> : public smart_holder_type_caster<std::unique_ptr<T>> { \
+    };                                                                                            \
+    template <>                                                                                   \
+    class type_caster<std::unique_ptr<T const>>                                                   \
+        : public smart_holder_type_caster<std::unique_ptr<T const>> {};                           \
+    }                                                                                             \
+    }
+
 } // namespace detail
 } // namespace pybind11

From 098630efc4c09b4c9289e92b6dc68e46f07b4e07 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 28 Jan 2021 07:31:40 -0800
Subject: [PATCH 119/206] Reintroducing py::classh, this time as a simple alias
 for py::class_<U, py::smart_holder>.

---
 include/pybind11/smart_holder.h           | 15 +++++++++++++++
 tests/class_sh_module_local_1.cpp         |  2 +-
 tests/class_sh_module_local_2.cpp         |  2 +-
 tests/test_class_sh_basic.cpp             | 12 +++++-------
 tests/test_class_sh_inheritance.cpp       | 10 +++++-----
 tests/test_class_sh_unique_ptr_member.cpp |  4 +---
 6 files changed, 28 insertions(+), 17 deletions(-)

diff --git a/include/pybind11/smart_holder.h b/include/pybind11/smart_holder.h
index 0f9f6f4c05..25f0e6b526 100644
--- a/include/pybind11/smart_holder.h
+++ b/include/pybind11/smart_holder.h
@@ -5,3 +5,18 @@
 #pragma once
 
 #include "detail/smart_holder_type_casters.h"
+#include "pybind11.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+// Supports easier switching between py::class_<U> and py::class_<U, py::smart_holder>:
+// users can simply replace the `_` in `class_` with `h` or vice versa.
+// Note though that the PYBIND11_SMART_HOLDER_TYPE_CASTERS(U) macro also needs to be
+// added (for `classh`) or commented out (for `class_`).
+template <typename type_, typename... options>
+class classh : public class_<type_, smart_holder, options...> {
+public:
+    using class_<type_, smart_holder, options...>::class_;
+};
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/tests/class_sh_module_local_1.cpp b/tests/class_sh_module_local_1.cpp
index 22adb733da..b8fd9591f3 100644
--- a/tests/class_sh_module_local_1.cpp
+++ b/tests/class_sh_module_local_1.cpp
@@ -22,7 +22,7 @@ PYBIND11_MODULE(class_sh_module_local_1, m) {
     namespace py = pybind11;
     using namespace pybind11_tests::class_sh_module_local;
 
-    py::class_<atyp, py::smart_holder>(m, "atyp", py::module_local())
+    py::classh<atyp>(m, "atyp", py::module_local())
         .def(py::init([](const std::string &mtxt) {
             atyp obj;
             obj.mtxt = mtxt;
diff --git a/tests/class_sh_module_local_2.cpp b/tests/class_sh_module_local_2.cpp
index e6f866267c..dd72cdcac0 100644
--- a/tests/class_sh_module_local_2.cpp
+++ b/tests/class_sh_module_local_2.cpp
@@ -22,7 +22,7 @@ PYBIND11_MODULE(class_sh_module_local_2, m) {
     namespace py = pybind11;
     using namespace pybind11_tests::class_sh_module_local;
 
-    py::class_<atyp, py::smart_holder>(m, "atyp", py::module_local())
+    py::classh<atyp>(m, "atyp", py::module_local())
         .def(py::init([](const std::string &mtxt) {
             atyp obj;
             obj.mtxt = mtxt;
diff --git a/tests/test_class_sh_basic.cpp b/tests/test_class_sh_basic.cpp
index 488b033fc7..96c9261fe1 100644
--- a/tests/test_class_sh_basic.cpp
+++ b/tests/test_class_sh_basic.cpp
@@ -57,13 +57,11 @@ namespace class_sh_basic {
 TEST_SUBMODULE(class_sh_basic, m) {
     namespace py = pybind11;
 
-    py::class_<atyp, py::smart_holder>(m, "atyp")
-        .def(py::init<>())
-        .def(py::init([](const std::string &mtxt) {
-            atyp obj;
-            obj.mtxt = mtxt;
-            return obj;
-        }));
+    py::classh<atyp>(m, "atyp").def(py::init<>()).def(py::init([](const std::string &mtxt) {
+        atyp obj;
+        obj.mtxt = mtxt;
+        return obj;
+    }));
 
     m.def("rtrn_valu_atyp", rtrn_valu_atyp);
     m.def("rtrn_rref_atyp", rtrn_rref_atyp);
diff --git a/tests/test_class_sh_inheritance.cpp b/tests/test_class_sh_inheritance.cpp
index 646b4fc31e..1c825d7f08 100644
--- a/tests/test_class_sh_inheritance.cpp
+++ b/tests/test_class_sh_inheritance.cpp
@@ -73,8 +73,8 @@ namespace pybind11_tests {
 namespace class_sh_inheritance {
 
 TEST_SUBMODULE(class_sh_inheritance, m) {
-    py::class_<base, py::smart_holder>(m, "base");
-    py::class_<drvd, base, py::smart_holder>(m, "drvd");
+    py::classh<base>(m, "base");
+    py::classh<drvd, base>(m, "drvd");
 
     auto rvto = py::return_value_policy::take_ownership;
 
@@ -89,9 +89,9 @@ TEST_SUBMODULE(class_sh_inheritance, m) {
     m.def("pass_shcp_drvd", pass_shcp_drvd);
 
     // __init__ needed for Python inheritance.
-    py::class_<base1, py::smart_holder>(m, "base1").def(py::init<>());
-    py::class_<base2, py::smart_holder>(m, "base2").def(py::init<>());
-    py::class_<drvd2, base1, base2, py::smart_holder>(m, "drvd2");
+    py::classh<base1>(m, "base1").def(py::init<>());
+    py::classh<base2>(m, "base2").def(py::init<>());
+    py::classh<drvd2, base1, base2>(m, "drvd2");
 
     m.def("rtrn_mptr_drvd2", rtrn_mptr_drvd2, rvto);
     m.def("rtrn_mptr_drvd2_up_cast1", rtrn_mptr_drvd2_up_cast1, rvto);
diff --git a/tests/test_class_sh_unique_ptr_member.cpp b/tests/test_class_sh_unique_ptr_member.cpp
index 0da05f4e3e..a34274a0ca 100644
--- a/tests/test_class_sh_unique_ptr_member.cpp
+++ b/tests/test_class_sh_unique_ptr_member.cpp
@@ -46,9 +46,7 @@ namespace pybind11_tests {
 namespace class_sh_unique_ptr_member {
 
 TEST_SUBMODULE(class_sh_unique_ptr_member, m) {
-    py::class_<pointee, py::smart_holder>(m, "pointee")
-        .def(py::init<>())
-        .def("get_int", &pointee::get_int);
+    py::classh<pointee>(m, "pointee").def(py::init<>()).def("get_int", &pointee::get_int);
 
     m.def("make_unique_pointee", make_unique_pointee);
 

From 7ed08cb7aa26c0e905633e7f396d77c74b0ebc34 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 28 Jan 2021 14:25:19 -0800
Subject: [PATCH 120/206] Replacing detail::is_smart_holder<H> in cast.h with
 detail::is_smart_holder_type_caster<T>. Moving get_local_load_function_ptr,
 init_instance_for_type to smart_holder_type_caster_class_hooks. Expanding
 static_assert in py::type::handle_of<> to accommodate
 smart_holder_type_casters.

---
 include/pybind11/cast.h                       | 19 ++--
 .../detail/smart_holder_type_casters.h        | 86 ++++++++++---------
 include/pybind11/pybind11.h                   | 28 ++++--
 tests/test_class_sh_basic.cpp                 |  4 +
 tests/test_class_sh_basic.py                  | 17 ++--
 5 files changed, 93 insertions(+), 61 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 7a32d67406..2dd225b9fe 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1636,7 +1636,6 @@ using type_caster_holder = conditional_t<is_copy_constructible<holder_type>::val
                                          copyable_holder_caster<type, holder_type>,
                                          move_only_holder_caster<type, holder_type>>;
 
-template <typename T, bool Value = false> struct is_smart_holder { static constexpr bool value = Value; };
 template <typename T, bool Value = false> struct always_construct_holder { static constexpr bool value = Value; };
 
 /// Create a specialization for custom holder types (silently ignores std::shared_ptr)
@@ -1651,8 +1650,7 @@ template <typename T, bool Value = false> struct always_construct_holder { stati
 
 // PYBIND11_DECLARE_HOLDER_TYPE holder types:
 template <typename base, typename holder> struct is_holder_type :
-    detail::any_of<std::is_base_of<detail::type_caster_holder<base, holder>, detail::type_caster<holder>>,
-                   detail::is_smart_holder<holder>> {};
+    std::is_base_of<detail::type_caster_holder<base, holder>, detail::type_caster<holder>> {};
 // Specialization for always-supported unique_ptr holders:
 template <typename base, typename deleter> struct is_holder_type<base, std::unique_ptr<base, deleter>> :
     std::true_type {};
@@ -2271,15 +2269,22 @@ object object_api<Derived>::call(Args &&...args) const {
     return operator()<policy>(std::forward<Args>(args)...);
 }
 
+template <typename T, typename SFINAE = void>
+struct is_smart_holder_type_caster : std::false_type {};
+template <typename T>
+struct is_smart_holder_type_caster<
+    T,
+    enable_if_t<type_caster<T>::is_smart_holder_type_caster::value, void>> : std::true_type {};
+
 PYBIND11_NAMESPACE_END(detail)
 
 
 template<typename T>
 handle type::handle_of() {
-   static_assert(
-      std::is_base_of<detail::type_caster_generic, detail::make_caster<T>>::value,
-      "py::type::of<T> only supports the case where T is a registered C++ types."
-    );
+    static_assert(
+        detail::any_of<std::is_base_of<detail::type_caster_generic, detail::make_caster<T>>,
+                       detail::is_smart_holder_type_caster<T>>::value,
+        "py::type::of<T> only supports the case where T is a registered C++ types.");
 
     return detail::get_type_handle(typeid(T), true);
 }
diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index 28874d9732..ec0aa774a3 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -228,6 +228,41 @@ class modified_type_caster_generic_load_impl {
 };
 // clang-format on
 
+struct smart_holder_type_caster_class_hooks {
+    using is_smart_holder_type_caster = std::true_type;
+
+    static decltype(&modified_type_caster_generic_load_impl::local_load)
+    get_local_load_function_ptr() {
+        return &modified_type_caster_generic_load_impl::local_load;
+    }
+
+    template <typename T>
+    static void init_instance_for_type(detail::instance *inst, const void *holder_const_void_ptr) {
+        // Need for const_cast is a consequence of the type_info::init_instance type:
+        // void (*init_instance)(instance *, const void *);
+        auto holder_void_ptr = const_cast<void *>(holder_const_void_ptr);
+
+        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(T)));
+        if (!v_h.instance_registered()) {
+            register_instance(inst, v_h.value_ptr(), v_h.type);
+            v_h.set_instance_registered();
+        }
+        using holder_type = pybindit::memory::smart_holder;
+        if (holder_void_ptr) {
+            // Note: inst->owned ignored.
+            auto holder_ptr = static_cast<holder_type *>(holder_void_ptr);
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*holder_ptr));
+        } else if (inst->owned) {
+            new (std::addressof(v_h.holder<holder_type>()))
+                holder_type(holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<T>()));
+        } else {
+            new (std::addressof(v_h.holder<holder_type>()))
+                holder_type(holder_type::from_raw_ptr_unowned(v_h.value_ptr<T>()));
+        }
+        v_h.set_holder_constructed();
+    }
+};
+
 template <typename T>
 struct smart_holder_type_caster_load {
     using holder_type = pybindit::memory::smart_holder;
@@ -305,7 +340,8 @@ struct make_constructor : private type_caster_base<int> { // Any type, nothing s
 };
 
 template <typename T>
-struct smart_holder_type_caster : smart_holder_type_caster_load<T> {
+struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
+                                  smart_holder_type_caster_class_hooks {
     static constexpr auto name = _<T>();
 
     // static handle cast(T, ...)
@@ -462,7 +498,8 @@ struct smart_holder_type_caster : smart_holder_type_caster_load<T> {
 };
 
 template <typename T>
-struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_load<T> {
+struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_load<T>,
+                                                      smart_holder_type_caster_class_hooks {
     static constexpr auto name = _<std::shared_ptr<T>>();
 
     static handle cast(const std::shared_ptr<T> &src, return_value_policy policy, handle parent) {
@@ -506,7 +543,8 @@ struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_l
 };
 
 template <typename T>
-struct smart_holder_type_caster<std::shared_ptr<T const>> : smart_holder_type_caster_load<T> {
+struct smart_holder_type_caster<std::shared_ptr<T const>> : smart_holder_type_caster_load<T>,
+                                                            smart_holder_type_caster_class_hooks {
     static constexpr auto name = _<std::shared_ptr<T const>>();
 
     static handle
@@ -524,7 +562,8 @@ struct smart_holder_type_caster<std::shared_ptr<T const>> : smart_holder_type_ca
 };
 
 template <typename T>
-struct smart_holder_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_load<T> {
+struct smart_holder_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_load<T>,
+                                                      smart_holder_type_caster_class_hooks {
     static constexpr auto name = _<std::unique_ptr<T>>();
 
     static handle cast(std::unique_ptr<T> &&src, return_value_policy policy, handle parent) {
@@ -566,7 +605,8 @@ struct smart_holder_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_l
 };
 
 template <typename T>
-struct smart_holder_type_caster<std::unique_ptr<T const>> : smart_holder_type_caster_load<T> {
+struct smart_holder_type_caster<std::unique_ptr<T const>> : smart_holder_type_caster_load<T>,
+                                                            smart_holder_type_caster_class_hooks {
     static constexpr auto name = _<std::unique_ptr<T const>>();
 
     static handle cast(std::unique_ptr<T const> &&src, return_value_policy policy, handle parent) {
@@ -582,42 +622,6 @@ struct smart_holder_type_caster<std::unique_ptr<T const>> : smart_holder_type_ca
     operator std::unique_ptr<T const>() { return this->loaded_as_unique_ptr(); }
 };
 
-template <>
-struct is_smart_holder<pybindit::memory::smart_holder>
-    : is_smart_holder<pybindit::memory::smart_holder, true> {
-
-    static decltype(&modified_type_caster_generic_load_impl::local_load)
-    get_type_caster_local_load_function_ptr() {
-        return &modified_type_caster_generic_load_impl::local_load;
-    }
-
-    template <typename T>
-    static void init_instance_for_type(detail::instance *inst, const void *holder_const_void_ptr) {
-        // Need for const_cast is a consequence of the type_info::init_instance type:
-        // void (*init_instance)(instance *, const void *);
-        auto holder_void_ptr = const_cast<void *>(holder_const_void_ptr);
-
-        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(T)));
-        if (!v_h.instance_registered()) {
-            register_instance(inst, v_h.value_ptr(), v_h.type);
-            v_h.set_instance_registered();
-        }
-        using holder_type = pybindit::memory::smart_holder;
-        if (holder_void_ptr) {
-            // Note: inst->owned ignored.
-            auto holder_ptr = static_cast<holder_type *>(holder_void_ptr);
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*holder_ptr));
-        } else if (inst->owned) {
-            new (std::addressof(v_h.holder<holder_type>()))
-                holder_type(holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<T>()));
-        } else {
-            new (std::addressof(v_h.holder<holder_type>()))
-                holder_type(holder_type::from_raw_ptr_unowned(v_h.value_ptr<T>()));
-        }
-        v_h.set_holder_constructed();
-    }
-};
-
 #define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                     \
     namespace pybind11 {                                                                          \
     namespace detail {                                                                            \
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 78376e47f9..aca3c73e80 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1243,9 +1243,13 @@ auto method_adaptor(Return (Class::*pmf)(Args...) const) -> Return (Derived::*)(
 
 template <typename type_, typename... options>
 class class_ : public detail::generic_type {
-    template <typename T> using is_holder = detail::is_holder_type<type_, T>;
     template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>;
     template <typename T> using is_base = detail::is_strict_base_of<T, type_>;
+    template <typename T>
+    using is_holder = detail::any_of<detail::is_holder_type<type_, T>,
+                                     detail::all_of<detail::negation<is_base<T>>,
+                                                    detail::negation<is_subtype<T>>,
+                                                    detail::is_smart_holder_type_caster<type_>>>;
     // struct instead of using here to help MSVC:
     template <typename T> struct is_valid_class_option :
         detail::any_of<is_holder<T>, is_subtype<T>, is_base<T>> {};
@@ -1503,14 +1507,19 @@ class class_ : public detail::generic_type {
     }
 
 private:
-    template <typename H = holder_type, detail::enable_if_t<!detail::is_smart_holder<H>::value, int> = 0>
+    template <typename T = type,
+              detail::enable_if_t<
+                  std::is_base_of<detail::type_caster_generic, detail::type_caster<T>>::value,
+                  int> = 0>
     void generic_type_initialize(const detail::type_record &record) {
         generic_type::initialize(record, &detail::type_caster_generic::local_load);
     }
 
-    template <typename H = holder_type, detail::enable_if_t<detail::is_smart_holder<H>::value, int> = 0>
+    template <
+        typename T = type,
+        detail::enable_if_t<detail::type_caster<T>::is_smart_holder_type_caster::value, int> = 0>
     void generic_type_initialize(const detail::type_record &record) {
-        generic_type::initialize(record, detail::is_smart_holder<H>::get_type_caster_local_load_function_ptr());
+        generic_type::initialize(record, detail::type_caster<T>::get_local_load_function_ptr());
     }
 
     /// Initialize holder object, variant 1: object derives from enable_shared_from_this
@@ -1557,7 +1566,10 @@ class class_ : public detail::generic_type {
     /// instance.  Should be called as soon as the `type` value_ptr is set for an instance.  Takes an
     /// optional pointer to an existing holder to use; if not specified and the instance is
     /// `.owned`, a new holder will be constructed to manage the value pointer.
-    template <typename H = holder_type, detail::enable_if_t<!detail::is_smart_holder<H>::value, int> = 0>
+    template <typename T = type,
+              detail::enable_if_t<
+                  std::is_base_of<detail::type_caster_generic, detail::type_caster<T>>::value,
+                  int> = 0>
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
         auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
         if (!v_h.instance_registered()) {
@@ -1567,9 +1579,11 @@ class class_ : public detail::generic_type {
         init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
     }
 
-    template <typename H = holder_type, detail::enable_if_t<detail::is_smart_holder<H>::value, int> = 0>
+    template <
+        typename T = type,
+        detail::enable_if_t<detail::type_caster<T>::is_smart_holder_type_caster::value, int> = 0>
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
-        detail::is_smart_holder<H>::template init_instance_for_type<type>(inst, holder_ptr);
+        detail::type_caster<T>::template init_instance_for_type<type>(inst, holder_ptr);
     }
 
     /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.
diff --git a/tests/test_class_sh_basic.cpp b/tests/test_class_sh_basic.cpp
index 96c9261fe1..b638fd854e 100644
--- a/tests/test_class_sh_basic.cpp
+++ b/tests/test_class_sh_basic.cpp
@@ -93,6 +93,10 @@ TEST_SUBMODULE(class_sh_basic, m) {
     // These require selected functions above to work first, as indicated:
     m.def("get_mtxt", get_mtxt);                         // pass_cref_atyp
     m.def("unique_ptr_roundtrip", unique_ptr_roundtrip); // pass_uqmp_atyp, rtrn_uqmp_atyp
+
+    m.def("py_type_handle_of_atyp", []() {
+        return py::type::handle_of<atyp>(); // Exercises static_cast in this function.
+    });
 }
 
 } // namespace class_sh_basic
diff --git a/tests/test_class_sh_basic.py b/tests/test_class_sh_basic.py
index 21a93b5dc1..62d365c98c 100644
--- a/tests/test_class_sh_basic.py
+++ b/tests/test_class_sh_basic.py
@@ -5,12 +5,12 @@
 
 
 def test_atyp_constructors():
-    e = m.atyp()
-    assert e.__class__.__name__ == "atyp"
-    e = m.atyp("")
-    assert e.__class__.__name__ == "atyp"
-    e = m.atyp("txtm")
-    assert e.__class__.__name__ == "atyp"
+    obj = m.atyp()
+    assert obj.__class__.__name__ == "atyp"
+    obj = m.atyp("")
+    assert obj.__class__.__name__ == "atyp"
+    obj = m.atyp("txtm")
+    assert obj.__class__.__name__ == "atyp"
 
 
 def test_cast():
@@ -80,3 +80,8 @@ def test_unique_ptr_roundtrip(num_round_trips=1000):
         # Ensure the returned object is a different Python instance.
         assert id_rtrn != id_orig
         id_orig = id_rtrn
+
+
+def test_py_type_handle_of_atyp():
+    obj = m.py_type_handle_of_atyp()
+    assert obj.__class__.__name__ == "pybind11_type"

From c9477c428ad72b0363e96f393222cb4ae8de5e30 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 28 Jan 2021 18:25:06 -0800
Subject: [PATCH 121/206] Fixing oversight.

---
 include/pybind11/detail/smart_holder_type_casters.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index ec0aa774a3..74624c5b7a 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -549,7 +549,7 @@ struct smart_holder_type_caster<std::shared_ptr<T const>> : smart_holder_type_ca
 
     static handle
     cast(const std::shared_ptr<T const> &src, return_value_policy policy, handle parent) {
-        return type_caster<std::shared_ptr<T>>::cast(
+        return smart_holder_type_caster<std::shared_ptr<T>>::cast(
             std::const_pointer_cast<T>(src), // Const2Mutbl
             policy,
             parent);
@@ -610,7 +610,7 @@ struct smart_holder_type_caster<std::unique_ptr<T const>> : smart_holder_type_ca
     static constexpr auto name = _<std::unique_ptr<T const>>();
 
     static handle cast(std::unique_ptr<T const> &&src, return_value_policy policy, handle parent) {
-        return type_caster<std::unique_ptr<T>>::cast(
+        return smart_holder_type_caster<std::unique_ptr<T>>::cast(
             std::unique_ptr<T>(const_cast<T *>(src.release())), // Const2Mutbl
             policy,
             parent);

From 71512877c2b7fb30c8c9babde37ed573fc1fa216 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 28 Jan 2021 18:34:59 -0800
Subject: [PATCH 122/206] Adding classu alias for class_<U,
 std::unique_ptr<U>>.

---
 include/pybind11/smart_holder.h           | 8 ++++++++
 tests/test_class_sh_unique_ptr_member.cpp | 3 ++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/include/pybind11/smart_holder.h b/include/pybind11/smart_holder.h
index 25f0e6b526..7d7e9f03e0 100644
--- a/include/pybind11/smart_holder.h
+++ b/include/pybind11/smart_holder.h
@@ -19,4 +19,12 @@ class classh : public class_<type_, smart_holder, options...> {
     using class_<type_, smart_holder, options...>::class_;
 };
 
+// Similar in idea to `py::classh`, but for `std::unique_ptr<U>` holder, to support
+// an easier transition to `py::smart_holder` as default holder.
+template <typename type_, typename... options>
+class classu : public class_<type_, std::unique_ptr<type_>, options...> {
+public:
+    using class_<type_, std::unique_ptr<type_>, options...>::class_;
+};
+
 PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/tests/test_class_sh_unique_ptr_member.cpp b/tests/test_class_sh_unique_ptr_member.cpp
index a34274a0ca..cb38651366 100644
--- a/tests/test_class_sh_unique_ptr_member.cpp
+++ b/tests/test_class_sh_unique_ptr_member.cpp
@@ -50,7 +50,8 @@ TEST_SUBMODULE(class_sh_unique_ptr_member, m) {
 
     m.def("make_unique_pointee", make_unique_pointee);
 
-    py::class_<ptr_owner>(m, "ptr_owner")
+    // Could also be class_, but can conveniently be used for testing classu.
+    py::classu<ptr_owner>(m, "ptr_owner")
         .def(py::init<std::unique_ptr<pointee>>(), py::arg("ptr"))
         .def("is_owner", &ptr_owner::is_owner)
         .def("give_up_ownership_via_unique_ptr", &ptr_owner::give_up_ownership_via_unique_ptr)

From 290f2d6025ac1f106ff3c96ffc39f884fd695e7a Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 28 Jan 2021 21:01:37 -0800
Subject: [PATCH 123/206] Giving up on idea to use legacy init_instance only if
 is_base_of<type_caster_generic, type_caster<T>. There are use cases in the
 wild that define both a custom type_caster and class_.

---
 include/pybind11/pybind11.h | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index aca3c73e80..351239e518 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1507,17 +1507,16 @@ class class_ : public detail::generic_type {
     }
 
 private:
-    template <typename T = type,
-              detail::enable_if_t<
-                  std::is_base_of<detail::type_caster_generic, detail::type_caster<T>>::value,
-                  int> = 0>
+    template <
+        typename T = type,
+        detail::enable_if_t<!detail::is_smart_holder_type_caster<T>::value, int> = 0>
     void generic_type_initialize(const detail::type_record &record) {
         generic_type::initialize(record, &detail::type_caster_generic::local_load);
     }
 
     template <
         typename T = type,
-        detail::enable_if_t<detail::type_caster<T>::is_smart_holder_type_caster::value, int> = 0>
+        detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
     void generic_type_initialize(const detail::type_record &record) {
         generic_type::initialize(record, detail::type_caster<T>::get_local_load_function_ptr());
     }
@@ -1566,10 +1565,9 @@ class class_ : public detail::generic_type {
     /// instance.  Should be called as soon as the `type` value_ptr is set for an instance.  Takes an
     /// optional pointer to an existing holder to use; if not specified and the instance is
     /// `.owned`, a new holder will be constructed to manage the value pointer.
-    template <typename T = type,
-              detail::enable_if_t<
-                  std::is_base_of<detail::type_caster_generic, detail::type_caster<T>>::value,
-                  int> = 0>
+    template <
+        typename T = type,
+        detail::enable_if_t<!detail::is_smart_holder_type_caster<T>::value, int> = 0>
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
         auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
         if (!v_h.instance_registered()) {
@@ -1581,7 +1579,7 @@ class class_ : public detail::generic_type {
 
     template <
         typename T = type,
-        detail::enable_if_t<detail::type_caster<T>::is_smart_holder_type_caster::value, int> = 0>
+        detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
         detail::type_caster<T>::template init_instance_for_type<type>(inst, holder_ptr);
     }

From 13d861fad4e34151e147ac997c305371f4efe4f2 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 29 Jan 2021 14:15:24 -0800
Subject: [PATCH 124/206] Removing test_type_caster_bare_interface, which was
 moved to the separate PR #2834.

---
 tests/CMakeLists.txt                      |   1 -
 tests/test_type_caster_bare_interface.cpp | 211 ----------------------
 tests/test_type_caster_bare_interface.py  |  41 -----
 3 files changed, 253 deletions(-)
 delete mode 100644 tests/test_type_caster_bare_interface.cpp
 delete mode 100644 tests/test_type_caster_bare_interface.py

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index b4ff298120..41f6d47bbc 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -132,7 +132,6 @@ set(PYBIND11_TEST_FILES
     test_stl.cpp
     test_stl_binders.cpp
     test_tagbased_polymorphic.cpp
-    test_type_caster_bare_interface.cpp
     test_union.cpp
     test_virtual_functions.cpp)
 
diff --git a/tests/test_type_caster_bare_interface.cpp b/tests/test_type_caster_bare_interface.cpp
deleted file mode 100644
index 02b6281c2e..0000000000
--- a/tests/test_type_caster_bare_interface.cpp
+++ /dev/null
@@ -1,211 +0,0 @@
-#include "pybind11_tests.h"
-
-#include <memory>
-
-namespace pybind11_tests {
-namespace type_caster_bare_interface {
-
-struct mpty {};
-
-// clang-format off
-
-mpty        rtrn_mpty_valu() { mpty obj; return obj; }
-mpty&&      rtrn_mpty_rref() { static mpty obj; return std::move(obj); }
-mpty const& rtrn_mpty_cref() { static mpty obj; return obj; }
-mpty&       rtrn_mpty_mref() { static mpty obj; return obj; }
-mpty const* rtrn_mpty_cptr() { return new mpty; }
-mpty*       rtrn_mpty_mptr() { return new mpty; }
-
-const char* pass_mpty_valu(mpty)        { return "load_valu"; }
-const char* pass_mpty_rref(mpty&&)      { return "load_rref"; }
-const char* pass_mpty_cref(mpty const&) { return "load_cref"; }
-const char* pass_mpty_mref(mpty&)       { return "load_mref"; }
-const char* pass_mpty_cptr(mpty const*) { return "load_cptr"; }
-const char* pass_mpty_mptr(mpty*)       { return "load_mptr"; }
-
-std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty      >(new mpty); }
-std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const>(new mpty); }
-
-const char* pass_mpty_shmp(std::shared_ptr<mpty>)       { return "load_shmp"; }
-const char* pass_mpty_shcp(std::shared_ptr<mpty const>) { return "load_shcp"; }
-
-std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty      >(new mpty); }
-std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty); }
-
-const char* pass_mpty_uqmp(std::unique_ptr<mpty>)       { return "load_uqmp"; }
-const char* pass_mpty_uqcp(std::unique_ptr<mpty const>) { return "load_uqcp"; }
-
-// clang-format on
-
-} // namespace type_caster_bare_interface
-} // namespace pybind11_tests
-
-namespace pybind11 {
-namespace detail {
-
-using namespace pybind11_tests::type_caster_bare_interface;
-
-template <>
-struct type_caster<mpty> {
-    static constexpr auto name = _<mpty>();
-
-    // static handle cast(mpty, ...)
-    // is redundant (leads to ambiguous overloads).
-
-    static handle cast(mpty && /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_rref").release();
-    }
-
-    static handle cast(mpty const & /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_cref").release();
-    }
-
-    static handle cast(mpty & /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_mref").release();
-    }
-
-    static handle cast(mpty const *src, return_value_policy /*policy*/, handle /*parent*/) {
-        delete src;
-        return str("cast_cptr").release();
-    }
-
-    static handle cast(mpty *src, return_value_policy /*policy*/, handle /*parent*/) {
-        delete src;
-        return str("cast_mptr").release();
-    }
-
-    template <typename T_>
-    using cast_op_type = conditional_t<
-        std::is_same<remove_reference_t<T_>, mpty const *>::value,
-        mpty const *,
-        conditional_t<
-            std::is_same<remove_reference_t<T_>, mpty *>::value,
-            mpty *,
-            conditional_t<
-                std::is_same<T_, mpty const &>::value,
-                mpty const &,
-                conditional_t<std::is_same<T_, mpty &>::value,
-                              mpty &,
-                              conditional_t<std::is_same<T_, mpty &&>::value, mpty &&, mpty>>>>>;
-
-    // clang-format off
-
-    operator mpty()        { return rtrn_mpty_valu(); }
-    operator mpty&&() &&   { return rtrn_mpty_rref(); }
-    operator mpty const&() { return rtrn_mpty_cref(); }
-    operator mpty&()       { return rtrn_mpty_mref(); }
-    operator mpty const*() { static mpty obj; return &obj; }
-    operator mpty*()       { static mpty obj; return &obj; }
-
-    // clang-format on
-
-    bool load(handle /*src*/, bool /*convert*/) { return true; }
-};
-
-template <>
-struct type_caster<std::shared_ptr<mpty>> {
-    static constexpr auto name = _<std::shared_ptr<mpty>>();
-
-    static handle cast(const std::shared_ptr<mpty> & /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
-        return str("cast_shmp").release();
-    }
-
-    template <typename>
-    using cast_op_type = std::shared_ptr<mpty>;
-
-    operator std::shared_ptr<mpty>() { return rtrn_mpty_shmp(); }
-
-    bool load(handle /*src*/, bool /*convert*/) { return true; }
-};
-
-template <>
-struct type_caster<std::shared_ptr<mpty const>> {
-    static constexpr auto name = _<std::shared_ptr<mpty const>>();
-
-    static handle cast(const std::shared_ptr<mpty const> & /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
-        return str("cast_shcp").release();
-    }
-
-    template <typename>
-    using cast_op_type = std::shared_ptr<mpty const>;
-
-    operator std::shared_ptr<mpty const>() { return rtrn_mpty_shcp(); }
-
-    bool load(handle /*src*/, bool /*convert*/) { return true; }
-};
-
-template <>
-struct type_caster<std::unique_ptr<mpty>> {
-    static constexpr auto name = _<std::unique_ptr<mpty>>();
-
-    static handle
-    cast(std::unique_ptr<mpty> && /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_uqmp").release();
-    }
-
-    template <typename>
-    using cast_op_type = std::unique_ptr<mpty>;
-
-    operator std::unique_ptr<mpty>() { return rtrn_mpty_uqmp(); }
-
-    bool load(handle /*src*/, bool /*convert*/) { return true; }
-};
-
-template <>
-struct type_caster<std::unique_ptr<mpty const>> {
-    static constexpr auto name = _<std::unique_ptr<mpty const>>();
-
-    static handle cast(std::unique_ptr<mpty const> && /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
-        return str("cast_uqcp").release();
-    }
-
-    template <typename>
-    using cast_op_type = std::unique_ptr<mpty const>;
-
-    operator std::unique_ptr<mpty const>() { return rtrn_mpty_uqcp(); }
-
-    bool load(handle /*src*/, bool /*convert*/) { return true; }
-};
-
-} // namespace detail
-} // namespace pybind11
-
-namespace pybind11_tests {
-namespace type_caster_bare_interface {
-
-TEST_SUBMODULE(type_caster_bare_interface, m) {
-    m.def("rtrn_mpty_valu", rtrn_mpty_valu);
-    m.def("rtrn_mpty_rref", rtrn_mpty_rref);
-    m.def("rtrn_mpty_cref", rtrn_mpty_cref);
-    m.def("rtrn_mpty_mref", rtrn_mpty_mref);
-    m.def("rtrn_mpty_cptr", rtrn_mpty_cptr);
-    m.def("rtrn_mpty_mptr", rtrn_mpty_mptr);
-
-    m.def("pass_mpty_valu", pass_mpty_valu);
-    m.def("pass_mpty_rref", pass_mpty_rref);
-    m.def("pass_mpty_cref", pass_mpty_cref);
-    m.def("pass_mpty_mref", pass_mpty_mref);
-    m.def("pass_mpty_cptr", pass_mpty_cptr);
-    m.def("pass_mpty_mptr", pass_mpty_mptr);
-
-    m.def("rtrn_mpty_shmp", rtrn_mpty_shmp);
-    m.def("rtrn_mpty_shcp", rtrn_mpty_shcp);
-
-    m.def("pass_mpty_shmp", pass_mpty_shmp);
-    m.def("pass_mpty_shcp", pass_mpty_shcp);
-
-    m.def("rtrn_mpty_uqmp", rtrn_mpty_uqmp);
-    m.def("rtrn_mpty_uqcp", rtrn_mpty_uqcp);
-
-    m.def("pass_mpty_uqmp", pass_mpty_uqmp);
-    m.def("pass_mpty_uqcp", pass_mpty_uqcp);
-}
-
-} // namespace type_caster_bare_interface
-} // namespace pybind11_tests
diff --git a/tests/test_type_caster_bare_interface.py b/tests/test_type_caster_bare_interface.py
deleted file mode 100644
index 5a19e1abcf..0000000000
--- a/tests/test_type_caster_bare_interface.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from pybind11_tests import type_caster_bare_interface as m
-
-
-def test_cast():
-    assert m.rtrn_mpty_valu() == "cast_rref"
-    assert m.rtrn_mpty_rref() == "cast_rref"
-    assert m.rtrn_mpty_cref() == "cast_cref"
-    assert m.rtrn_mpty_mref() == "cast_mref"
-    assert m.rtrn_mpty_cptr() == "cast_cptr"
-    assert m.rtrn_mpty_mptr() == "cast_mptr"
-
-
-def test_load():
-    assert m.pass_mpty_valu(None) == "load_valu"
-    assert m.pass_mpty_rref(None) == "load_rref"
-    assert m.pass_mpty_cref(None) == "load_cref"
-    assert m.pass_mpty_mref(None) == "load_mref"
-    assert m.pass_mpty_cptr(None) == "load_cptr"
-    assert m.pass_mpty_mptr(None) == "load_mptr"
-
-
-def test_cast_shared_ptr():
-    assert m.rtrn_mpty_shmp() == "cast_shmp"
-    assert m.rtrn_mpty_shcp() == "cast_shcp"
-
-
-def test_load_shared_ptr():
-    assert m.pass_mpty_shmp(None) == "load_shmp"
-    assert m.pass_mpty_shcp(None) == "load_shcp"
-
-
-def test_cast_unique_ptr():
-    assert m.rtrn_mpty_uqmp() == "cast_uqmp"
-    assert m.rtrn_mpty_uqcp() == "cast_uqcp"
-
-
-def test_load_unique_ptr():
-    assert m.pass_mpty_uqmp(None) == "load_uqmp"
-    assert m.pass_mpty_uqcp(None) == "load_uqcp"

From 8c87dc48462e4f533f34c1be3caba8ad58cae6b2 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 30 Jan 2021 00:42:36 -0800
Subject: [PATCH 125/206] Moving up is_smart_holder_type_caster, to also use in
 cast_is_temporary_value_reference.

---
 include/pybind11/cast.h | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 2dd225b9fe..8fe8ad1996 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1725,6 +1725,13 @@ template <typename T> struct move_if_unreferenced<T, enable_if_t<all_of<
 >::value>> : std::true_type {};
 template <typename T> using move_never = none_of<move_always<T>, move_if_unreferenced<T>>;
 
+template <typename T, typename SFINAE = void>
+struct is_smart_holder_type_caster : std::false_type {};
+template <typename T>
+struct is_smart_holder_type_caster<
+    T,
+    enable_if_t<type_caster<T>::is_smart_holder_type_caster::value, void>> : std::true_type {};
+
 // Detect whether returning a `type` from a cast on type's type_caster is going to result in a
 // reference or pointer to a local variable of the type_caster.  Basically, only
 // non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe;
@@ -1732,7 +1739,8 @@ template <typename T> using move_never = none_of<move_always<T>, move_if_unrefer
 template <typename type> using cast_is_temporary_value_reference = bool_constant<
     (std::is_reference<type>::value || std::is_pointer<type>::value) &&
     !std::is_base_of<type_caster_generic, make_caster<type>>::value &&
-    !std::is_same<intrinsic_t<type>, void>::value
+    !std::is_same<intrinsic_t<type>, void>::value &&
+    !is_smart_holder_type_caster<intrinsic_t<type>>::value
 >;
 
 // When a value returned from a C++ function is being cast back to Python, we almost always want to
@@ -2269,13 +2277,6 @@ object object_api<Derived>::call(Args &&...args) const {
     return operator()<policy>(std::forward<Args>(args)...);
 }
 
-template <typename T, typename SFINAE = void>
-struct is_smart_holder_type_caster : std::false_type {};
-template <typename T>
-struct is_smart_holder_type_caster<
-    T,
-    enable_if_t<type_caster<T>::is_smart_holder_type_caster::value, void>> : std::true_type {};
-
 PYBIND11_NAMESPACE_END(detail)
 
 

From aacc8acb9432897757d040b460c27d3f4a0844a4 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 1 Feb 2021 14:06:58 -0800
Subject: [PATCH 126/206] Adding smart_holder_type_casters for unique_ptr with
 custom deleter. SEVERE CODE DUPLICATION. This commit is to establish a
 baseline for consolidating the unique_ptr code.

---
 .../detail/smart_holder_type_casters.h        | 95 +++++++++++++++++++
 tests/test_class_sh_basic.cpp                 | 15 +++
 tests/test_class_sh_basic.py                  | 10 ++
 3 files changed, 120 insertions(+)

diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index 74624c5b7a..602a9301d7 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -318,6 +318,29 @@ struct smart_holder_type_caster_load {
         return result;
     }
 
+    template <typename D>
+    std::unique_ptr<T, D> loaded_as_unique_ptr_with_deleter() {
+        holder().template ensure_compatible_rtti_uqp_del<D>("loaded_as_unique_ptr_with_deleter");
+        holder().ensure_use_count_1("loaded_as_unique_ptr_with_deleter");
+        auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
+        // MISSING: Safety checks for type conversions
+        // (T must be polymorphic or meet certain other conditions).
+        T *raw_type_ptr = convert_type(raw_void_ptr);
+
+        // Critical transfer-of-ownership section. This must stay together.
+        holder().release_ownership();
+        auto result = std::unique_ptr<T, D>(raw_type_ptr);
+
+        void *value_void_ptr
+            = load_impl.loaded_v_h.value_ptr(); // Expected to be identical to raw_void_ptr.
+        load_impl.loaded_v_h.holder<holder_type>().~holder_type();
+        load_impl.loaded_v_h.set_holder_constructed(false);
+        load_impl.loaded_v_h.value_ptr() = nullptr;
+        deregister_instance(load_impl.loaded_v_h.inst, value_void_ptr, load_impl.loaded_v_h.type);
+
+        return result;
+    }
+
 private:
     modified_type_caster_generic_load_impl load_impl;
 
@@ -622,6 +645,72 @@ struct smart_holder_type_caster<std::unique_ptr<T const>> : smart_holder_type_ca
     operator std::unique_ptr<T const>() { return this->loaded_as_unique_ptr(); }
 };
 
+template <typename T, typename D>
+struct smart_holder_type_caster<std::unique_ptr<T, D>> : smart_holder_type_caster_load<T>,
+                                                         smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<std::unique_ptr<T, D>>();
+
+    static handle cast(std::unique_ptr<T, D> &&src, return_value_policy policy, handle parent) {
+        if (policy != return_value_policy::automatic
+            && policy != return_value_policy::reference_internal) {
+            // IMPROVABLE: Error message.
+            throw cast_error("Invalid return_value_policy for unique_ptr.");
+        }
+
+        auto src_raw_ptr = src.get();
+        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
+        if (st.first == nullptr)
+            return none().release(); // PyErr was set already.
+
+        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
+        const detail::type_info *tinfo = st.second;
+        if (find_registered_python_instance(src_raw_void_ptr, tinfo))
+            throw cast_error("Invalid unique_ptr: another instance owns this pointer already.");
+
+        auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
+        inst_raw_ptr->owned = true;
+        void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+        valueptr            = src_raw_void_ptr;
+
+        auto smhldr = pybindit::memory::smart_holder::from_unique_ptr_with_deleter(std::move(src));
+        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
+
+        if (policy == return_value_policy::reference_internal)
+            keep_alive_impl(inst, parent);
+
+        return inst.release();
+    }
+
+    template <typename>
+    using cast_op_type = std::unique_ptr<T, D>;
+
+    operator std::unique_ptr<T, D>() {
+        return this->template loaded_as_unique_ptr_with_deleter<D>();
+    }
+};
+
+template <typename T, typename D>
+struct smart_holder_type_caster<std::unique_ptr<T const, D>>
+    : smart_holder_type_caster_load<T>, smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<std::unique_ptr<T const, D>>();
+
+    static handle
+    cast(std::unique_ptr<T const, D> &&src, return_value_policy policy, handle parent) {
+        return smart_holder_type_caster<std::unique_ptr<T, D>>::cast(
+            std::unique_ptr<T, D>(const_cast<T *>(src.release())), // Const2Mutbl
+            policy,
+            parent);
+    }
+
+    template <typename>
+    using cast_op_type = std::unique_ptr<T const, D>;
+
+    operator std::unique_ptr<T const, D>() {
+        return this->template loaded_as_unique_ptr_with_deleter<D>();
+    }
+};
+
 #define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                     \
     namespace pybind11 {                                                                          \
     namespace detail {                                                                            \
@@ -639,6 +728,12 @@ struct smart_holder_type_caster<std::unique_ptr<T const>> : smart_holder_type_ca
     template <>                                                                                   \
     class type_caster<std::unique_ptr<T const>>                                                   \
         : public smart_holder_type_caster<std::unique_ptr<T const>> {};                           \
+    template <typename D>                                                                         \
+    class type_caster<std::unique_ptr<T, D>>                                                      \
+        : public smart_holder_type_caster<std::unique_ptr<T, D>> {};                              \
+    template <typename D>                                                                         \
+    class type_caster<std::unique_ptr<T const, D>>                                                \
+        : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};                        \
     }                                                                                             \
     }
 
diff --git a/tests/test_class_sh_basic.cpp b/tests/test_class_sh_basic.cpp
index b638fd854e..ef08f7e0ee 100644
--- a/tests/test_class_sh_basic.cpp
+++ b/tests/test_class_sh_basic.cpp
@@ -40,6 +40,15 @@ std::unique_ptr<atyp const> rtrn_uqcp_atyp() { return std::unique_ptr<atyp const
 std::string pass_uqmp_atyp(std::unique_ptr<atyp      > obj) { return "pass_uqmp:" + obj->mtxt; }
 std::string pass_uqcp_atyp(std::unique_ptr<atyp const> obj) { return "pass_uqcp:" + obj->mtxt; }
 
+struct uqmd : std::default_delete<atyp      > {};
+struct uqcd : std::default_delete<atyp const> {};
+
+std::unique_ptr<atyp,       uqmd> rtrn_uqmp_del_atyp() { return std::unique_ptr<atyp,       uqmd>(new atyp{"rtrn_uqmp_del"}); }
+std::unique_ptr<atyp const, uqcd> rtrn_uqcp_del_atyp() { return std::unique_ptr<atyp const, uqcd>(new atyp{"rtrn_uqcp_del"}); }
+
+std::string pass_uqmp_del_atyp(std::unique_ptr<atyp,       uqmd> obj) { return "pass_uqmp_del:" + obj->mtxt; }
+std::string pass_uqcp_del_atyp(std::unique_ptr<atyp const, uqcd> obj) { return "pass_uqcp_del:" + obj->mtxt; }
+
 // clang-format on
 
 // Helpers for testing.
@@ -89,6 +98,12 @@ TEST_SUBMODULE(class_sh_basic, m) {
     m.def("pass_uqmp_atyp", pass_uqmp_atyp);
     m.def("pass_uqcp_atyp", pass_uqcp_atyp);
 
+    m.def("rtrn_uqmp_del_atyp", rtrn_uqmp_del_atyp);
+    m.def("rtrn_uqcp_del_atyp", rtrn_uqcp_del_atyp);
+
+    m.def("pass_uqmp_del_atyp", pass_uqmp_del_atyp);
+    m.def("pass_uqcp_del_atyp", pass_uqcp_del_atyp);
+
     // Helpers for testing.
     // These require selected functions above to work first, as indicated:
     m.def("get_mtxt", get_mtxt);                         // pass_cref_atyp
diff --git a/tests/test_class_sh_basic.py b/tests/test_class_sh_basic.py
index 62d365c98c..6383a408cf 100644
--- a/tests/test_class_sh_basic.py
+++ b/tests/test_class_sh_basic.py
@@ -51,6 +51,16 @@ def test_load_unique_ptr():
     assert m.pass_uqcp_atyp(m.atyp("Uqcp")) == "pass_uqcp:Uqcp"
 
 
+def test_cast_unique_ptr_with_deleter():
+    assert m.get_mtxt(m.rtrn_uqmp_del_atyp()) == "rtrn_uqmp_del"
+    assert m.get_mtxt(m.rtrn_uqcp_del_atyp()) == "rtrn_uqcp_del"
+
+
+def test_load_unique_ptr_with_deleter():
+    assert m.pass_uqmp_del_atyp(m.rtrn_uqmp_del_atyp()) == "pass_uqmp_del:rtrn_uqmp_del"
+    assert m.pass_uqcp_del_atyp(m.rtrn_uqcp_del_atyp()) == "pass_uqcp_del:rtrn_uqcp_del"
+
+
 @pytest.mark.parametrize(
     "pass_atyp, argm, rtrn",
     [

From 6e515cc93ad5b724ee8020474f4f86e7369c13a3 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 1 Feb 2021 16:56:17 -0800
Subject: [PATCH 127/206] Unification of unique_ptr, unique_ptr_with_deleter
 code in smart_holder_poc.h. Leads to more fitting error messages. Enables use
 of unique_ptr<T, D> smart_holder_type_casters also for unique_ptr<T>.

---
 include/pybind11/detail/smart_holder_poc.h    |  86 +++++++-------
 .../detail/smart_holder_type_casters.h        | 106 ++----------------
 tests/pure_cpp/smart_holder_poc_test.cpp      |  43 ++++---
 3 files changed, 67 insertions(+), 168 deletions(-)

diff --git a/include/pybind11/detail/smart_holder_poc.h b/include/pybind11/detail/smart_holder_poc.h
index 6ec1d1eff7..e46f2fb0de 100644
--- a/include/pybind11/detail/smart_holder_poc.h
+++ b/include/pybind11/detail/smart_holder_poc.h
@@ -104,24 +104,6 @@ struct smart_holder {
         }
     }
 
-    template <typename D>
-    void ensure_compatible_rtti_uqp_del(const char *context) const {
-        if (!rtti_uqp_del) {
-            throw std::runtime_error(std::string("Missing unique_ptr deleter (") + context + ").");
-        }
-        const std::type_info *rtti_requested = &typeid(D);
-        if (!(*rtti_requested == *rtti_uqp_del)) {
-            throw std::runtime_error(std::string("Incompatible unique_ptr deleter (") + context
-                                     + ").");
-        }
-    }
-
-    void ensure_has_pointee(const char *context) const {
-        if (!has_pointee()) {
-            throw std::runtime_error(std::string("Disowned holder (") + context + ").");
-        }
-    }
-
     void ensure_vptr_is_using_builtin_delete(const char *context) const {
         if (vptr_is_external_shared_ptr) {
             throw std::runtime_error(std::string("Cannot disown external shared_ptr (") + context
@@ -137,6 +119,29 @@ struct smart_holder {
         }
     }
 
+    template <typename T, typename D>
+    void ensure_compatible_rtti_uqp_del(const char *context) const {
+        const std::type_info *rtti_requested = &typeid(D);
+        if (!rtti_uqp_del) {
+            // IMPROVABLE: const-correctness.
+            if (!(*rtti_requested == typeid(std::default_delete<T>)
+                  || *rtti_requested == typeid(std::default_delete<T const>))) {
+                throw std::runtime_error(std::string("Missing unique_ptr deleter (") + context
+                                         + ").");
+            }
+            ensure_vptr_is_using_builtin_delete(context);
+        } else if (!(*rtti_requested == *rtti_uqp_del)) {
+            throw std::runtime_error(std::string("Incompatible unique_ptr deleter (") + context
+                                     + ").");
+        }
+    }
+
+    void ensure_has_pointee(const char *context) const {
+        if (!has_pointee()) {
+            throw std::runtime_error(std::string("Disowned holder (") + context + ").");
+        }
+    }
+
     void ensure_use_count_1(const char *context) const {
         if (vptr.get() == nullptr) {
             throw std::runtime_error(std::string("Cannot disown nullptr (") + context + ").");
@@ -209,41 +214,30 @@ struct smart_holder {
         return raw_ptr;
     }
 
-    template <typename T>
-    static smart_holder from_unique_ptr(std::unique_ptr<T> &&unq_ptr) {
-        smart_holder hld(true);
-        hld.vptr.reset(unq_ptr.get(),
-                       guarded_builtin_delete<T>(hld.vptr_deleter_armed_flag_ptr.get()));
-        unq_ptr.release();
-        hld.vptr_is_using_builtin_delete = true;
-        hld.is_populated                 = true;
-        return hld;
-    }
-
-    template <typename T>
-    std::unique_ptr<T> as_unique_ptr() {
-        return std::unique_ptr<T>(as_raw_ptr_release_ownership<T>("as_unique_ptr"));
-    }
-
-    template <typename T, typename D>
-    static smart_holder from_unique_ptr_with_deleter(std::unique_ptr<T, D> &&unq_ptr) {
+    template <typename T, typename D = std::default_delete<T>>
+    static smart_holder from_unique_ptr(std::unique_ptr<T, D> &&unq_ptr) {
         smart_holder hld(true);
-        hld.rtti_uqp_del = &typeid(D);
-        hld.vptr.reset(unq_ptr.get(),
-                       guarded_custom_deleter<T, D>(hld.vptr_deleter_armed_flag_ptr.get()));
+        hld.rtti_uqp_del                 = &typeid(D);
+        hld.vptr_is_using_builtin_delete = (*hld.rtti_uqp_del == typeid(std::default_delete<T>));
+        if (hld.vptr_is_using_builtin_delete) {
+            hld.vptr.reset(unq_ptr.get(),
+                           guarded_builtin_delete<T>(hld.vptr_deleter_armed_flag_ptr.get()));
+        } else {
+            hld.vptr.reset(unq_ptr.get(),
+                           guarded_custom_deleter<T, D>(hld.vptr_deleter_armed_flag_ptr.get()));
+        }
         unq_ptr.release();
         hld.is_populated = true;
         return hld;
     }
 
-    template <typename T, typename D>
-    std::unique_ptr<T, D> as_unique_ptr_with_deleter() {
-        static const char *context = "as_unique_ptr_with_deleter";
-        ensure_compatible_rtti_uqp_del<D>(context);
+    template <typename T, typename D = std::default_delete<T>>
+    std::unique_ptr<T, D> as_unique_ptr() {
+        static const char *context = "as_unique_ptr";
+        ensure_compatible_rtti_uqp_del<T, D>(context);
         ensure_use_count_1(context);
-        T *raw_ptr                   = as_raw_ptr_unowned<T>();
-        *vptr_deleter_armed_flag_ptr = false;
-        vptr.reset();
+        T *raw_ptr = as_raw_ptr_unowned<T>();
+        release_ownership();
         return std::unique_ptr<T, D>(raw_ptr);
     }
 
diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index 602a9301d7..229250bc24 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -297,31 +297,10 @@ struct smart_holder_type_caster_load {
         return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
     }
 
-    std::unique_ptr<T> loaded_as_unique_ptr() {
-        holder().ensure_can_release_ownership();
-        auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
-        // MISSING: Safety checks for type conversions
-        // (T must be polymorphic or meet certain other conditions).
-        T *raw_type_ptr = convert_type(raw_void_ptr);
-
-        // Critical transfer-of-ownership section. This must stay together.
-        holder().release_ownership();
-        auto result = std::unique_ptr<T>(raw_type_ptr);
-
-        void *value_void_ptr
-            = load_impl.loaded_v_h.value_ptr(); // Expected to be identical to raw_void_ptr.
-        load_impl.loaded_v_h.holder<holder_type>().~holder_type();
-        load_impl.loaded_v_h.set_holder_constructed(false);
-        load_impl.loaded_v_h.value_ptr() = nullptr;
-        deregister_instance(load_impl.loaded_v_h.inst, value_void_ptr, load_impl.loaded_v_h.type);
-
-        return result;
-    }
-
-    template <typename D>
-    std::unique_ptr<T, D> loaded_as_unique_ptr_with_deleter() {
-        holder().template ensure_compatible_rtti_uqp_del<D>("loaded_as_unique_ptr_with_deleter");
-        holder().ensure_use_count_1("loaded_as_unique_ptr_with_deleter");
+    template <typename D = std::default_delete<T>>
+    std::unique_ptr<T, D> loaded_as_unique_ptr(const char *context = "loaded_as_unique_ptr") {
+        holder().template ensure_compatible_rtti_uqp_del<T, D>(context);
+        holder().ensure_use_count_1(context);
         auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
         // MISSING: Safety checks for type conversions
         // (T must be polymorphic or meet certain other conditions).
@@ -584,67 +563,6 @@ struct smart_holder_type_caster<std::shared_ptr<T const>> : smart_holder_type_ca
     operator std::shared_ptr<T const>() { return this->loaded_as_shared_ptr(); } // Mutbl2Const
 };
 
-template <typename T>
-struct smart_holder_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_load<T>,
-                                                      smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<std::unique_ptr<T>>();
-
-    static handle cast(std::unique_ptr<T> &&src, return_value_policy policy, handle parent) {
-        if (policy != return_value_policy::automatic
-            && policy != return_value_policy::reference_internal) {
-            // IMPROVABLE: Error message.
-            throw cast_error("Invalid return_value_policy for unique_ptr.");
-        }
-
-        auto src_raw_ptr = src.get();
-        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
-        if (st.first == nullptr)
-            return none().release(); // PyErr was set already.
-
-        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
-        const detail::type_info *tinfo = st.second;
-        if (find_registered_python_instance(src_raw_void_ptr, tinfo))
-            throw cast_error("Invalid unique_ptr: another instance owns this pointer already.");
-
-        auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
-        inst_raw_ptr->owned = true;
-        void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
-        valueptr            = src_raw_void_ptr;
-
-        auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(src));
-        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
-
-        if (policy == return_value_policy::reference_internal)
-            keep_alive_impl(inst, parent);
-
-        return inst.release();
-    }
-
-    template <typename>
-    using cast_op_type = std::unique_ptr<T>;
-
-    operator std::unique_ptr<T>() { return this->loaded_as_unique_ptr(); }
-};
-
-template <typename T>
-struct smart_holder_type_caster<std::unique_ptr<T const>> : smart_holder_type_caster_load<T>,
-                                                            smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<std::unique_ptr<T const>>();
-
-    static handle cast(std::unique_ptr<T const> &&src, return_value_policy policy, handle parent) {
-        return smart_holder_type_caster<std::unique_ptr<T>>::cast(
-            std::unique_ptr<T>(const_cast<T *>(src.release())), // Const2Mutbl
-            policy,
-            parent);
-    }
-
-    template <typename>
-    using cast_op_type = std::unique_ptr<T const>;
-
-    operator std::unique_ptr<T const>() { return this->loaded_as_unique_ptr(); }
-};
-
 template <typename T, typename D>
 struct smart_holder_type_caster<std::unique_ptr<T, D>> : smart_holder_type_caster_load<T>,
                                                          smart_holder_type_caster_class_hooks {
@@ -673,7 +591,7 @@ struct smart_holder_type_caster<std::unique_ptr<T, D>> : smart_holder_type_caste
         void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
         valueptr            = src_raw_void_ptr;
 
-        auto smhldr = pybindit::memory::smart_holder::from_unique_ptr_with_deleter(std::move(src));
+        auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(src));
         tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
 
         if (policy == return_value_policy::reference_internal)
@@ -685,9 +603,7 @@ struct smart_holder_type_caster<std::unique_ptr<T, D>> : smart_holder_type_caste
     template <typename>
     using cast_op_type = std::unique_ptr<T, D>;
 
-    operator std::unique_ptr<T, D>() {
-        return this->template loaded_as_unique_ptr_with_deleter<D>();
-    }
+    operator std::unique_ptr<T, D>() { return this->template loaded_as_unique_ptr<D>(); }
 };
 
 template <typename T, typename D>
@@ -706,9 +622,7 @@ struct smart_holder_type_caster<std::unique_ptr<T const, D>>
     template <typename>
     using cast_op_type = std::unique_ptr<T const, D>;
 
-    operator std::unique_ptr<T const, D>() {
-        return this->template loaded_as_unique_ptr_with_deleter<D>();
-    }
+    operator std::unique_ptr<T const, D>() { return this->template loaded_as_unique_ptr<D>(); }
 };
 
 #define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                     \
@@ -722,12 +636,6 @@ struct smart_holder_type_caster<std::unique_ptr<T const, D>>
     template <>                                                                                   \
     class type_caster<std::shared_ptr<T const>>                                                   \
         : public smart_holder_type_caster<std::shared_ptr<T const>> {};                           \
-    template <>                                                                                   \
-    class type_caster<std::unique_ptr<T>> : public smart_holder_type_caster<std::unique_ptr<T>> { \
-    };                                                                                            \
-    template <>                                                                                   \
-    class type_caster<std::unique_ptr<T const>>                                                   \
-        : public smart_holder_type_caster<std::unique_ptr<T const>> {};                           \
     template <typename D>                                                                         \
     class type_caster<std::unique_ptr<T, D>>                                                      \
         : public smart_holder_type_caster<std::unique_ptr<T, D>> {};                              \
diff --git a/tests/pure_cpp/smart_holder_poc_test.cpp b/tests/pure_cpp/smart_holder_poc_test.cpp
index dab47bded0..c61991a281 100644
--- a/tests/pure_cpp/smart_holder_poc_test.cpp
+++ b/tests/pure_cpp/smart_holder_poc_test.cpp
@@ -66,10 +66,9 @@ TEST_CASE("from_raw_ptr_unowned+as_unique_ptr_with_deleter", "[E]") {
     static int value        = 19;
     auto hld                = smart_holder::from_raw_ptr_unowned(&value);
     auto condense_for_macro = [](smart_holder &hld) {
-        hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+        hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>();
     };
-    REQUIRE_THROWS_WITH(condense_for_macro(hld),
-                        "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
+    REQUIRE_THROWS_WITH(condense_for_macro(hld), "Missing unique_ptr deleter (as_unique_ptr).");
 }
 
 TEST_CASE("from_raw_ptr_unowned+as_shared_ptr", "[S]") {
@@ -114,10 +113,9 @@ TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr2", "[E]") {
 TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr_with_deleter", "[E]") {
     auto hld                = smart_holder::from_raw_ptr_take_ownership(new int(19));
     auto condense_for_macro = [](smart_holder &hld) {
-        hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+        hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>();
     };
-    REQUIRE_THROWS_WITH(condense_for_macro(hld),
-                        "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
+    REQUIRE_THROWS_WITH(condense_for_macro(hld), "Missing unique_ptr deleter (as_unique_ptr).");
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_shared_ptr", "[S]") {
@@ -174,10 +172,10 @@ TEST_CASE("from_unique_ptr+as_unique_ptr_with_deleter", "[E]") {
     auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
     REQUIRE(orig_owner.get() == nullptr);
     auto condense_for_macro = [](smart_holder &hld) {
-        hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+        hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>();
     };
     REQUIRE_THROWS_WITH(condense_for_macro(hld),
-                        "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
+                        "Incompatible unique_ptr deleter (as_unique_ptr).");
 }
 
 TEST_CASE("from_unique_ptr+as_shared_ptr", "[S]") {
@@ -191,14 +189,14 @@ TEST_CASE("from_unique_ptr+as_shared_ptr", "[S]") {
 
 TEST_CASE("from_unique_ptr_with_deleter+as_lvalue_ref", "[S]") {
     std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
-    auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
     REQUIRE(orig_owner.get() == nullptr);
     REQUIRE(hld.as_lvalue_ref<int>() == 19);
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+as_raw_ptr_release_ownership", "[E]") {
     std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
-    auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
     REQUIRE(orig_owner.get() == nullptr);
     REQUIRE_THROWS_WITH(hld.as_raw_ptr_release_ownership<int>(),
                         "Cannot disown custom deleter (as_raw_ptr_release_ownership).");
@@ -206,35 +204,35 @@ TEST_CASE("from_unique_ptr_with_deleter+as_raw_ptr_release_ownership", "[E]") {
 
 TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr", "[E]") {
     std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
-    auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
     REQUIRE(orig_owner.get() == nullptr);
-    REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(), "Cannot disown custom deleter (as_unique_ptr).");
+    REQUIRE_THROWS_WITH(hld.as_unique_ptr<int>(),
+                        "Incompatible unique_ptr deleter (as_unique_ptr).");
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter1", "[S]") {
     std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
-    auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
     REQUIRE(orig_owner.get() == nullptr);
     std::unique_ptr<int, helpers::functor_builtin_delete<int>> new_owner
-        = hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+        = hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>();
     REQUIRE(!hld.has_pointee());
     REQUIRE(*new_owner == 19);
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter2", "[E]") {
     std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
-    auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
     REQUIRE(orig_owner.get() == nullptr);
-    auto condense_for_macro = [](smart_holder &hld) {
-        hld.as_unique_ptr_with_deleter<int, helpers::functor_other_delete<int>>();
-    };
+    auto condense_for_macro
+        = [](smart_holder &hld) { hld.as_unique_ptr<int, helpers::functor_other_delete<int>>(); };
     REQUIRE_THROWS_WITH(condense_for_macro(hld),
-                        "Incompatible unique_ptr deleter (as_unique_ptr_with_deleter).");
+                        "Incompatible unique_ptr deleter (as_unique_ptr).");
 }
 
 TEST_CASE("from_unique_ptr_with_deleter+as_shared_ptr", "[S]") {
     std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
-    auto hld = smart_holder::from_unique_ptr_with_deleter(std::move(orig_owner));
+    auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
     REQUIRE(orig_owner.get() == nullptr);
     std::shared_ptr<int> new_owner = hld.as_shared_ptr<int>();
     REQUIRE(hld.has_pointee());
@@ -265,10 +263,9 @@ TEST_CASE("from_shared_ptr+as_unique_ptr_with_deleter", "[E]") {
     std::shared_ptr<int> orig_owner(new int(19));
     auto hld                = smart_holder::from_shared_ptr(orig_owner);
     auto condense_for_macro = [](smart_holder &hld) {
-        hld.as_unique_ptr_with_deleter<int, helpers::functor_builtin_delete<int>>();
+        hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>();
     };
-    REQUIRE_THROWS_WITH(condense_for_macro(hld),
-                        "Missing unique_ptr deleter (as_unique_ptr_with_deleter).");
+    REQUIRE_THROWS_WITH(condense_for_macro(hld), "Missing unique_ptr deleter (as_unique_ptr).");
 }
 
 TEST_CASE("from_shared_ptr+as_shared_ptr", "[S]") {

From c3617bf28a2ff1ce07d0aecf581d4e81de75fe10 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 29 Jan 2021 13:42:52 -0800
Subject: [PATCH 128/206] Copying files as-is from branch
 test_unique_ptr_member (PR #2672).

---
 tests/test_type_caster_bare_interface.cpp | 211 ++++++++++++++++++++++
 tests/test_type_caster_bare_interface.py  |  41 +++++
 2 files changed, 252 insertions(+)
 create mode 100644 tests/test_type_caster_bare_interface.cpp
 create mode 100644 tests/test_type_caster_bare_interface.py

diff --git a/tests/test_type_caster_bare_interface.cpp b/tests/test_type_caster_bare_interface.cpp
new file mode 100644
index 0000000000..02b6281c2e
--- /dev/null
+++ b/tests/test_type_caster_bare_interface.cpp
@@ -0,0 +1,211 @@
+#include "pybind11_tests.h"
+
+#include <memory>
+
+namespace pybind11_tests {
+namespace type_caster_bare_interface {
+
+struct mpty {};
+
+// clang-format off
+
+mpty        rtrn_mpty_valu() { mpty obj; return obj; }
+mpty&&      rtrn_mpty_rref() { static mpty obj; return std::move(obj); }
+mpty const& rtrn_mpty_cref() { static mpty obj; return obj; }
+mpty&       rtrn_mpty_mref() { static mpty obj; return obj; }
+mpty const* rtrn_mpty_cptr() { return new mpty; }
+mpty*       rtrn_mpty_mptr() { return new mpty; }
+
+const char* pass_mpty_valu(mpty)        { return "load_valu"; }
+const char* pass_mpty_rref(mpty&&)      { return "load_rref"; }
+const char* pass_mpty_cref(mpty const&) { return "load_cref"; }
+const char* pass_mpty_mref(mpty&)       { return "load_mref"; }
+const char* pass_mpty_cptr(mpty const*) { return "load_cptr"; }
+const char* pass_mpty_mptr(mpty*)       { return "load_mptr"; }
+
+std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty      >(new mpty); }
+std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const>(new mpty); }
+
+const char* pass_mpty_shmp(std::shared_ptr<mpty>)       { return "load_shmp"; }
+const char* pass_mpty_shcp(std::shared_ptr<mpty const>) { return "load_shcp"; }
+
+std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty      >(new mpty); }
+std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty); }
+
+const char* pass_mpty_uqmp(std::unique_ptr<mpty>)       { return "load_uqmp"; }
+const char* pass_mpty_uqcp(std::unique_ptr<mpty const>) { return "load_uqcp"; }
+
+// clang-format on
+
+} // namespace type_caster_bare_interface
+} // namespace pybind11_tests
+
+namespace pybind11 {
+namespace detail {
+
+using namespace pybind11_tests::type_caster_bare_interface;
+
+template <>
+struct type_caster<mpty> {
+    static constexpr auto name = _<mpty>();
+
+    // static handle cast(mpty, ...)
+    // is redundant (leads to ambiguous overloads).
+
+    static handle cast(mpty && /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
+        return str("cast_rref").release();
+    }
+
+    static handle cast(mpty const & /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
+        return str("cast_cref").release();
+    }
+
+    static handle cast(mpty & /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
+        return str("cast_mref").release();
+    }
+
+    static handle cast(mpty const *src, return_value_policy /*policy*/, handle /*parent*/) {
+        delete src;
+        return str("cast_cptr").release();
+    }
+
+    static handle cast(mpty *src, return_value_policy /*policy*/, handle /*parent*/) {
+        delete src;
+        return str("cast_mptr").release();
+    }
+
+    template <typename T_>
+    using cast_op_type = conditional_t<
+        std::is_same<remove_reference_t<T_>, mpty const *>::value,
+        mpty const *,
+        conditional_t<
+            std::is_same<remove_reference_t<T_>, mpty *>::value,
+            mpty *,
+            conditional_t<
+                std::is_same<T_, mpty const &>::value,
+                mpty const &,
+                conditional_t<std::is_same<T_, mpty &>::value,
+                              mpty &,
+                              conditional_t<std::is_same<T_, mpty &&>::value, mpty &&, mpty>>>>>;
+
+    // clang-format off
+
+    operator mpty()        { return rtrn_mpty_valu(); }
+    operator mpty&&() &&   { return rtrn_mpty_rref(); }
+    operator mpty const&() { return rtrn_mpty_cref(); }
+    operator mpty&()       { return rtrn_mpty_mref(); }
+    operator mpty const*() { static mpty obj; return &obj; }
+    operator mpty*()       { static mpty obj; return &obj; }
+
+    // clang-format on
+
+    bool load(handle /*src*/, bool /*convert*/) { return true; }
+};
+
+template <>
+struct type_caster<std::shared_ptr<mpty>> {
+    static constexpr auto name = _<std::shared_ptr<mpty>>();
+
+    static handle cast(const std::shared_ptr<mpty> & /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_shmp").release();
+    }
+
+    template <typename>
+    using cast_op_type = std::shared_ptr<mpty>;
+
+    operator std::shared_ptr<mpty>() { return rtrn_mpty_shmp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) { return true; }
+};
+
+template <>
+struct type_caster<std::shared_ptr<mpty const>> {
+    static constexpr auto name = _<std::shared_ptr<mpty const>>();
+
+    static handle cast(const std::shared_ptr<mpty const> & /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_shcp").release();
+    }
+
+    template <typename>
+    using cast_op_type = std::shared_ptr<mpty const>;
+
+    operator std::shared_ptr<mpty const>() { return rtrn_mpty_shcp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) { return true; }
+};
+
+template <>
+struct type_caster<std::unique_ptr<mpty>> {
+    static constexpr auto name = _<std::unique_ptr<mpty>>();
+
+    static handle
+    cast(std::unique_ptr<mpty> && /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
+        return str("cast_uqmp").release();
+    }
+
+    template <typename>
+    using cast_op_type = std::unique_ptr<mpty>;
+
+    operator std::unique_ptr<mpty>() { return rtrn_mpty_uqmp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) { return true; }
+};
+
+template <>
+struct type_caster<std::unique_ptr<mpty const>> {
+    static constexpr auto name = _<std::unique_ptr<mpty const>>();
+
+    static handle cast(std::unique_ptr<mpty const> && /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_uqcp").release();
+    }
+
+    template <typename>
+    using cast_op_type = std::unique_ptr<mpty const>;
+
+    operator std::unique_ptr<mpty const>() { return rtrn_mpty_uqcp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) { return true; }
+};
+
+} // namespace detail
+} // namespace pybind11
+
+namespace pybind11_tests {
+namespace type_caster_bare_interface {
+
+TEST_SUBMODULE(type_caster_bare_interface, m) {
+    m.def("rtrn_mpty_valu", rtrn_mpty_valu);
+    m.def("rtrn_mpty_rref", rtrn_mpty_rref);
+    m.def("rtrn_mpty_cref", rtrn_mpty_cref);
+    m.def("rtrn_mpty_mref", rtrn_mpty_mref);
+    m.def("rtrn_mpty_cptr", rtrn_mpty_cptr);
+    m.def("rtrn_mpty_mptr", rtrn_mpty_mptr);
+
+    m.def("pass_mpty_valu", pass_mpty_valu);
+    m.def("pass_mpty_rref", pass_mpty_rref);
+    m.def("pass_mpty_cref", pass_mpty_cref);
+    m.def("pass_mpty_mref", pass_mpty_mref);
+    m.def("pass_mpty_cptr", pass_mpty_cptr);
+    m.def("pass_mpty_mptr", pass_mpty_mptr);
+
+    m.def("rtrn_mpty_shmp", rtrn_mpty_shmp);
+    m.def("rtrn_mpty_shcp", rtrn_mpty_shcp);
+
+    m.def("pass_mpty_shmp", pass_mpty_shmp);
+    m.def("pass_mpty_shcp", pass_mpty_shcp);
+
+    m.def("rtrn_mpty_uqmp", rtrn_mpty_uqmp);
+    m.def("rtrn_mpty_uqcp", rtrn_mpty_uqcp);
+
+    m.def("pass_mpty_uqmp", pass_mpty_uqmp);
+    m.def("pass_mpty_uqcp", pass_mpty_uqcp);
+}
+
+} // namespace type_caster_bare_interface
+} // namespace pybind11_tests
diff --git a/tests/test_type_caster_bare_interface.py b/tests/test_type_caster_bare_interface.py
new file mode 100644
index 0000000000..5a19e1abcf
--- /dev/null
+++ b/tests/test_type_caster_bare_interface.py
@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+from pybind11_tests import type_caster_bare_interface as m
+
+
+def test_cast():
+    assert m.rtrn_mpty_valu() == "cast_rref"
+    assert m.rtrn_mpty_rref() == "cast_rref"
+    assert m.rtrn_mpty_cref() == "cast_cref"
+    assert m.rtrn_mpty_mref() == "cast_mref"
+    assert m.rtrn_mpty_cptr() == "cast_cptr"
+    assert m.rtrn_mpty_mptr() == "cast_mptr"
+
+
+def test_load():
+    assert m.pass_mpty_valu(None) == "load_valu"
+    assert m.pass_mpty_rref(None) == "load_rref"
+    assert m.pass_mpty_cref(None) == "load_cref"
+    assert m.pass_mpty_mref(None) == "load_mref"
+    assert m.pass_mpty_cptr(None) == "load_cptr"
+    assert m.pass_mpty_mptr(None) == "load_mptr"
+
+
+def test_cast_shared_ptr():
+    assert m.rtrn_mpty_shmp() == "cast_shmp"
+    assert m.rtrn_mpty_shcp() == "cast_shcp"
+
+
+def test_load_shared_ptr():
+    assert m.pass_mpty_shmp(None) == "load_shmp"
+    assert m.pass_mpty_shcp(None) == "load_shcp"
+
+
+def test_cast_unique_ptr():
+    assert m.rtrn_mpty_uqmp() == "cast_uqmp"
+    assert m.rtrn_mpty_uqcp() == "cast_uqcp"
+
+
+def test_load_unique_ptr():
+    assert m.pass_mpty_uqmp(None) == "load_uqmp"
+    assert m.pass_mpty_uqcp(None) == "load_uqcp"

From d5cbfa85f9101b94aee3c404f3294ac2ded89fd1 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 29 Jan 2021 14:00:26 -0800
Subject: [PATCH 129/206] Adding comment, simplifying naming, cmake addition.

---
 tests/CMakeLists.txt                      |   1 +
 tests/test_type_caster_bare_interface.cpp | 110 +++++++++++-----------
 tests/test_type_caster_bare_interface.py  |  40 ++++----
 3 files changed, 78 insertions(+), 73 deletions(-)

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 41f6d47bbc..b4ff298120 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -132,6 +132,7 @@ set(PYBIND11_TEST_FILES
     test_stl.cpp
     test_stl_binders.cpp
     test_tagbased_polymorphic.cpp
+    test_type_caster_bare_interface.cpp
     test_union.cpp
     test_virtual_functions.cpp)
 
diff --git a/tests/test_type_caster_bare_interface.cpp b/tests/test_type_caster_bare_interface.cpp
index 02b6281c2e..e334635a45 100644
--- a/tests/test_type_caster_bare_interface.cpp
+++ b/tests/test_type_caster_bare_interface.cpp
@@ -1,3 +1,7 @@
+// Systematically exercises the detail::type_caster<> interface. This is going a step in the
+// direction of an integration test, to ensure multiple components of pybind11 work together
+// correctly. It is also useful to show the type_caster<> interface virtually clutter-free.
+
 #include "pybind11_tests.h"
 
 #include <memory>
@@ -9,31 +13,31 @@ struct mpty {};
 
 // clang-format off
 
-mpty        rtrn_mpty_valu() { mpty obj; return obj; }
-mpty&&      rtrn_mpty_rref() { static mpty obj; return std::move(obj); }
-mpty const& rtrn_mpty_cref() { static mpty obj; return obj; }
-mpty&       rtrn_mpty_mref() { static mpty obj; return obj; }
-mpty const* rtrn_mpty_cptr() { return new mpty; }
-mpty*       rtrn_mpty_mptr() { return new mpty; }
+mpty        rtrn_valu() { mpty obj; return obj; }
+mpty&&      rtrn_rref() { static mpty obj; return std::move(obj); }
+mpty const& rtrn_cref() { static mpty obj; return obj; }
+mpty&       rtrn_mref() { static mpty obj; return obj; }
+mpty const* rtrn_cptr() { return new mpty; }
+mpty*       rtrn_mptr() { return new mpty; }
 
-const char* pass_mpty_valu(mpty)        { return "load_valu"; }
-const char* pass_mpty_rref(mpty&&)      { return "load_rref"; }
-const char* pass_mpty_cref(mpty const&) { return "load_cref"; }
-const char* pass_mpty_mref(mpty&)       { return "load_mref"; }
-const char* pass_mpty_cptr(mpty const*) { return "load_cptr"; }
-const char* pass_mpty_mptr(mpty*)       { return "load_mptr"; }
+const char* pass_valu(mpty)        { return "load_valu"; }
+const char* pass_rref(mpty&&)      { return "load_rref"; }
+const char* pass_cref(mpty const&) { return "load_cref"; }
+const char* pass_mref(mpty&)       { return "load_mref"; }
+const char* pass_cptr(mpty const*) { return "load_cptr"; }
+const char* pass_mptr(mpty*)       { return "load_mptr"; }
 
-std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty      >(new mpty); }
-std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const>(new mpty); }
+std::shared_ptr<mpty>       rtrn_shmp() { return std::shared_ptr<mpty      >(new mpty); }
+std::shared_ptr<mpty const> rtrn_shcp() { return std::shared_ptr<mpty const>(new mpty); }
 
-const char* pass_mpty_shmp(std::shared_ptr<mpty>)       { return "load_shmp"; }
-const char* pass_mpty_shcp(std::shared_ptr<mpty const>) { return "load_shcp"; }
+const char* pass_shmp(std::shared_ptr<mpty>)       { return "load_shmp"; }
+const char* pass_shcp(std::shared_ptr<mpty const>) { return "load_shcp"; }
 
-std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty      >(new mpty); }
-std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty); }
+std::unique_ptr<mpty>       rtrn_uqmp() { return std::unique_ptr<mpty      >(new mpty); }
+std::unique_ptr<mpty const> rtrn_uqcp() { return std::unique_ptr<mpty const>(new mpty); }
 
-const char* pass_mpty_uqmp(std::unique_ptr<mpty>)       { return "load_uqmp"; }
-const char* pass_mpty_uqcp(std::unique_ptr<mpty const>) { return "load_uqcp"; }
+const char* pass_uqmp(std::unique_ptr<mpty>)       { return "load_uqmp"; }
+const char* pass_uqcp(std::unique_ptr<mpty const>) { return "load_uqcp"; }
 
 // clang-format on
 
@@ -90,10 +94,10 @@ struct type_caster<mpty> {
 
     // clang-format off
 
-    operator mpty()        { return rtrn_mpty_valu(); }
-    operator mpty&&() &&   { return rtrn_mpty_rref(); }
-    operator mpty const&() { return rtrn_mpty_cref(); }
-    operator mpty&()       { return rtrn_mpty_mref(); }
+    operator mpty()        { return rtrn_valu(); }
+    operator mpty&&() &&   { return rtrn_rref(); }
+    operator mpty const&() { return rtrn_cref(); }
+    operator mpty&()       { return rtrn_mref(); }
     operator mpty const*() { static mpty obj; return &obj; }
     operator mpty*()       { static mpty obj; return &obj; }
 
@@ -115,7 +119,7 @@ struct type_caster<std::shared_ptr<mpty>> {
     template <typename>
     using cast_op_type = std::shared_ptr<mpty>;
 
-    operator std::shared_ptr<mpty>() { return rtrn_mpty_shmp(); }
+    operator std::shared_ptr<mpty>() { return rtrn_shmp(); }
 
     bool load(handle /*src*/, bool /*convert*/) { return true; }
 };
@@ -133,7 +137,7 @@ struct type_caster<std::shared_ptr<mpty const>> {
     template <typename>
     using cast_op_type = std::shared_ptr<mpty const>;
 
-    operator std::shared_ptr<mpty const>() { return rtrn_mpty_shcp(); }
+    operator std::shared_ptr<mpty const>() { return rtrn_shcp(); }
 
     bool load(handle /*src*/, bool /*convert*/) { return true; }
 };
@@ -150,7 +154,7 @@ struct type_caster<std::unique_ptr<mpty>> {
     template <typename>
     using cast_op_type = std::unique_ptr<mpty>;
 
-    operator std::unique_ptr<mpty>() { return rtrn_mpty_uqmp(); }
+    operator std::unique_ptr<mpty>() { return rtrn_uqmp(); }
 
     bool load(handle /*src*/, bool /*convert*/) { return true; }
 };
@@ -168,7 +172,7 @@ struct type_caster<std::unique_ptr<mpty const>> {
     template <typename>
     using cast_op_type = std::unique_ptr<mpty const>;
 
-    operator std::unique_ptr<mpty const>() { return rtrn_mpty_uqcp(); }
+    operator std::unique_ptr<mpty const>() { return rtrn_uqcp(); }
 
     bool load(handle /*src*/, bool /*convert*/) { return true; }
 };
@@ -180,31 +184,31 @@ namespace pybind11_tests {
 namespace type_caster_bare_interface {
 
 TEST_SUBMODULE(type_caster_bare_interface, m) {
-    m.def("rtrn_mpty_valu", rtrn_mpty_valu);
-    m.def("rtrn_mpty_rref", rtrn_mpty_rref);
-    m.def("rtrn_mpty_cref", rtrn_mpty_cref);
-    m.def("rtrn_mpty_mref", rtrn_mpty_mref);
-    m.def("rtrn_mpty_cptr", rtrn_mpty_cptr);
-    m.def("rtrn_mpty_mptr", rtrn_mpty_mptr);
-
-    m.def("pass_mpty_valu", pass_mpty_valu);
-    m.def("pass_mpty_rref", pass_mpty_rref);
-    m.def("pass_mpty_cref", pass_mpty_cref);
-    m.def("pass_mpty_mref", pass_mpty_mref);
-    m.def("pass_mpty_cptr", pass_mpty_cptr);
-    m.def("pass_mpty_mptr", pass_mpty_mptr);
-
-    m.def("rtrn_mpty_shmp", rtrn_mpty_shmp);
-    m.def("rtrn_mpty_shcp", rtrn_mpty_shcp);
-
-    m.def("pass_mpty_shmp", pass_mpty_shmp);
-    m.def("pass_mpty_shcp", pass_mpty_shcp);
-
-    m.def("rtrn_mpty_uqmp", rtrn_mpty_uqmp);
-    m.def("rtrn_mpty_uqcp", rtrn_mpty_uqcp);
-
-    m.def("pass_mpty_uqmp", pass_mpty_uqmp);
-    m.def("pass_mpty_uqcp", pass_mpty_uqcp);
+    m.def("rtrn_valu", rtrn_valu);
+    m.def("rtrn_rref", rtrn_rref);
+    m.def("rtrn_cref", rtrn_cref);
+    m.def("rtrn_mref", rtrn_mref);
+    m.def("rtrn_cptr", rtrn_cptr);
+    m.def("rtrn_mptr", rtrn_mptr);
+
+    m.def("pass_valu", pass_valu);
+    m.def("pass_rref", pass_rref);
+    m.def("pass_cref", pass_cref);
+    m.def("pass_mref", pass_mref);
+    m.def("pass_cptr", pass_cptr);
+    m.def("pass_mptr", pass_mptr);
+
+    m.def("rtrn_shmp", rtrn_shmp);
+    m.def("rtrn_shcp", rtrn_shcp);
+
+    m.def("pass_shmp", pass_shmp);
+    m.def("pass_shcp", pass_shcp);
+
+    m.def("rtrn_uqmp", rtrn_uqmp);
+    m.def("rtrn_uqcp", rtrn_uqcp);
+
+    m.def("pass_uqmp", pass_uqmp);
+    m.def("pass_uqcp", pass_uqcp);
 }
 
 } // namespace type_caster_bare_interface
diff --git a/tests/test_type_caster_bare_interface.py b/tests/test_type_caster_bare_interface.py
index 5a19e1abcf..a427244dbc 100644
--- a/tests/test_type_caster_bare_interface.py
+++ b/tests/test_type_caster_bare_interface.py
@@ -4,38 +4,38 @@
 
 
 def test_cast():
-    assert m.rtrn_mpty_valu() == "cast_rref"
-    assert m.rtrn_mpty_rref() == "cast_rref"
-    assert m.rtrn_mpty_cref() == "cast_cref"
-    assert m.rtrn_mpty_mref() == "cast_mref"
-    assert m.rtrn_mpty_cptr() == "cast_cptr"
-    assert m.rtrn_mpty_mptr() == "cast_mptr"
+    assert m.rtrn_valu() == "cast_rref"
+    assert m.rtrn_rref() == "cast_rref"
+    assert m.rtrn_cref() == "cast_cref"
+    assert m.rtrn_mref() == "cast_mref"
+    assert m.rtrn_cptr() == "cast_cptr"
+    assert m.rtrn_mptr() == "cast_mptr"
 
 
 def test_load():
-    assert m.pass_mpty_valu(None) == "load_valu"
-    assert m.pass_mpty_rref(None) == "load_rref"
-    assert m.pass_mpty_cref(None) == "load_cref"
-    assert m.pass_mpty_mref(None) == "load_mref"
-    assert m.pass_mpty_cptr(None) == "load_cptr"
-    assert m.pass_mpty_mptr(None) == "load_mptr"
+    assert m.pass_valu(None) == "load_valu"
+    assert m.pass_rref(None) == "load_rref"
+    assert m.pass_cref(None) == "load_cref"
+    assert m.pass_mref(None) == "load_mref"
+    assert m.pass_cptr(None) == "load_cptr"
+    assert m.pass_mptr(None) == "load_mptr"
 
 
 def test_cast_shared_ptr():
-    assert m.rtrn_mpty_shmp() == "cast_shmp"
-    assert m.rtrn_mpty_shcp() == "cast_shcp"
+    assert m.rtrn_shmp() == "cast_shmp"
+    assert m.rtrn_shcp() == "cast_shcp"
 
 
 def test_load_shared_ptr():
-    assert m.pass_mpty_shmp(None) == "load_shmp"
-    assert m.pass_mpty_shcp(None) == "load_shcp"
+    assert m.pass_shmp(None) == "load_shmp"
+    assert m.pass_shcp(None) == "load_shcp"
 
 
 def test_cast_unique_ptr():
-    assert m.rtrn_mpty_uqmp() == "cast_uqmp"
-    assert m.rtrn_mpty_uqcp() == "cast_uqcp"
+    assert m.rtrn_uqmp() == "cast_uqmp"
+    assert m.rtrn_uqcp() == "cast_uqcp"
 
 
 def test_load_unique_ptr():
-    assert m.pass_mpty_uqmp(None) == "load_uqmp"
-    assert m.pass_mpty_uqcp(None) == "load_uqcp"
+    assert m.pass_uqmp(None) == "load_uqmp"
+    assert m.pass_uqcp(None) == "load_uqcp"

From 3d34ba39f4c967d72db66013293b961b8c866f07 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 28 Jan 2021 21:16:09 -0800
Subject: [PATCH 130/206] Introducing PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
 macro (tested only undefined; there are many errors with the macro defined).

---
 include/pybind11/cast.h     | 658 ++++++++++++++++++++++++++++++++++++
 include/pybind11/pybind11.h |   8 +-
 tests/test_class.cpp        |   9 +-
 3 files changed, 673 insertions(+), 2 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 8fe8ad1996..7efa45b3d1 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -959,7 +959,661 @@ template <typename type> class type_caster_base : public type_caster_generic {
     static Constructor make_move_constructor(...) { return nullptr; }
 };
 
+//DETAIL/SMART_HOLDER_TYPE_CASTERS_H///////////////////////////////////////////////////////////////
+
+//FWD begin
+inline void register_instance(instance *self, void *valptr, const type_info *tinfo);
+inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo);
+//FWD end
+
+// The modified_type_caster_generic_load_impl could replace type_caster_generic::load_impl but not
+// vice versa. The main difference is that the original code only propagates a reference to the
+// held value, while the modified implementation propagates value_and_holder.
+// clang-format off
+class modified_type_caster_generic_load_impl {
+public:
+    PYBIND11_NOINLINE modified_type_caster_generic_load_impl(const std::type_info &type_info)
+        : typeinfo(get_type_info(type_info)), cpptype(&type_info) { }
+
+    explicit modified_type_caster_generic_load_impl(const type_info *typeinfo = nullptr)
+        : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { }
+
+    bool load(handle src, bool convert) {
+        return load_impl<modified_type_caster_generic_load_impl>(src, convert);
+    }
+
+    // Base methods for generic caster; there are overridden in copyable_holder_caster
+    void load_value_and_holder(value_and_holder &&v_h) {
+        loaded_v_h = std::move(v_h);
+        if (!loaded_v_h.holder_constructed()) {
+            // IMPROVABLE: Error message. A change to the existing internals is
+            // needed to cleanly distinguish between uninitialized or disowned.
+            throw std::runtime_error("Missing value for wrapped C++ type:"
+                                     " Python instance is uninitialized or was disowned.");
+        }
+        if (v_h.value_ptr() == nullptr) {
+            pybind11_fail("smart_holder_type_casters: Unexpected v_h.value_ptr() nullptr.");
+        }
+        loaded_v_h.type = typeinfo;
+    }
+
+    bool try_implicit_casts(handle src, bool convert) {
+        for (auto &cast : typeinfo->implicit_casts) {
+            modified_type_caster_generic_load_impl sub_caster(*cast.first);
+            if (sub_caster.load(src, convert)) {
+                if (loaded_v_h_cpptype != nullptr) {
+                    pybind11_fail("smart_holder_type_casters: try_implicit_casts failure.");
+                }
+                loaded_v_h = sub_caster.loaded_v_h;
+                loaded_v_h_cpptype = cast.first;
+                implicit_cast = cast.second;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    bool try_direct_conversions(handle src) {
+        for (auto &converter : *typeinfo->direct_conversions) {
+            if (converter(src.ptr(), loaded_v_h.value_ptr()))
+                return true;
+        }
+        return false;
+    }
+
+    PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
+        std::unique_ptr<modified_type_caster_generic_load_impl> loader(
+            new modified_type_caster_generic_load_impl(ti));
+        if (loader->load(src, false)) {
+            // Trick to work with the existing pybind11 internals.
+            // The void pointer is immediately captured in a new unique_ptr in
+            // try_load_foreign_module_local. If this assumption is violated sanitizers
+            // will most likely flag a leak (verified to be the case with ASAN).
+            return static_cast<void *>(loader.release());
+        }
+        return nullptr;
+    }
+
+    /// Try to load with foreign typeinfo, if available. Used when there is no
+    /// native typeinfo, or when the native one wasn't able to produce a value.
+    PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) {
+        constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
+        const auto pytype = type::handle_of(src);
+        if (!hasattr(pytype, local_key))
+            return false;
+
+        type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key));
+        // Only consider this foreign loader if actually foreign and is a loader of the correct cpp type
+        if (foreign_typeinfo->module_local_load == &local_load
+            || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype)))
+            return false;
+
+        void* foreign_loader_void_ptr =
+            foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo);
+        if (foreign_loader_void_ptr != nullptr) {
+            auto foreign_loader = std::unique_ptr<modified_type_caster_generic_load_impl>(
+                static_cast<modified_type_caster_generic_load_impl *>(foreign_loader_void_ptr));
+            // Magic number intentionally hard-coded for simplicity and maximum robustness.
+            if (foreign_loader->local_load_safety_guard != 1887406645) {
+                pybind11_fail(
+                    "smart_holder_type_casters: Unexpected local_load_safety_guard,"
+                    " possibly due to py::class_ holder mixup.");
+            }
+            if (loaded_v_h_cpptype != nullptr) {
+                pybind11_fail("smart_holder_type_casters: try_load_foreign_module_local failure.");
+            }
+            loaded_v_h = foreign_loader->loaded_v_h;
+            loaded_v_h_cpptype = foreign_loader->loaded_v_h_cpptype;
+            implicit_cast = foreign_loader->implicit_cast;
+            return true;
+        }
+        return false;
+    }
+
+    // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
+    // bits of code between here and copyable_holder_caster where the two classes need different
+    // logic (without having to resort to virtual inheritance).
+    template <typename ThisT>
+    PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
+        if (!src) return false;
+        if (!typeinfo) return try_load_foreign_module_local(src);
+        if (src.is_none()) {
+            // Defer accepting None to other overloads (if we aren't in convert mode):
+            if (!convert) return false;
+            loaded_v_h = value_and_holder();
+            return true;
+        }
+
+        auto &this_ = static_cast<ThisT &>(*this);
+
+        PyTypeObject *srctype = Py_TYPE(src.ptr());
+
+        // Case 1: If src is an exact type match for the target type then we can reinterpret_cast
+        // the instance's value pointer to the target type:
+        if (srctype == typeinfo->type) {
+            this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
+            return true;
+        }
+        // Case 2: We have a derived class
+        else if (PyType_IsSubtype(srctype, typeinfo->type)) {
+            auto &bases = all_type_info(srctype); // subtype bases
+            bool no_cpp_mi = typeinfo->simple_type;
+
+            // Case 2a: the python type is a Python-inherited derived class that inherits from just
+            // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of
+            // the right type and we can use reinterpret_cast.
+            // (This is essentially the same as case 2b, but because not using multiple inheritance
+            // is extremely common, we handle it specially to avoid the loop iterator and type
+            // pointer lookup overhead)
+            if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
+                this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
+                loaded_v_h_cpptype = bases.front()->cpptype;
+                reinterpret_cast_deemed_ok = true;
+                return true;
+            }
+            // Case 2b: the python type inherits from multiple C++ bases.  Check the bases to see if
+            // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we
+            // can safely reinterpret_cast to the relevant pointer.
+            else if (bases.size() > 1) {
+                for (auto base : bases) {
+                    if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
+                        this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
+                        loaded_v_h_cpptype = base->cpptype;
+                        reinterpret_cast_deemed_ok = true;
+                        return true;
+                    }
+                }
+            }
+
+            // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match
+            // in the registered bases, above, so try implicit casting (needed for proper C++ casting
+            // when MI is involved).
+            if (this_.try_implicit_casts(src, convert)) {
+                return true;
+            }
+        }
+
+        // Perform an implicit conversion
+        if (convert) {
+            for (auto &converter : typeinfo->implicit_conversions) {
+                auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
+                if (load_impl<ThisT>(temp, false)) {
+                    loader_life_support::add_patient(temp);
+                    return true;
+                }
+            }
+            if (this_.try_direct_conversions(src))
+                return true;
+        }
+
+        // Failed to match local typeinfo. Try again with global.
+        if (typeinfo->module_local) {
+            if (auto gtype = get_global_type_info(*typeinfo->cpptype)) {
+                typeinfo = gtype;
+                return load(src, false);
+            }
+        }
+
+        // Global typeinfo has precedence over foreign module_local
+        return try_load_foreign_module_local(src);
+    }
+
+    const type_info *typeinfo = nullptr;
+    const std::type_info *cpptype = nullptr;
+    const std::type_info *loaded_v_h_cpptype = nullptr;
+    void *(*implicit_cast)(void *) = nullptr;
+    value_and_holder loaded_v_h;
+    bool reinterpret_cast_deemed_ok = false;
+    // Magic number intentionally hard-coded, to guard against class_ holder mixups.
+    // Ideally type_caster_generic would have a similar guard, but this requires a change there.
+    std::size_t local_load_safety_guard = 1887406645; // 32-bit compatible value for portability.
+};
+// clang-format on
+
+struct smart_holder_type_caster_class_hooks {
+    using is_smart_holder_type_caster = std::true_type;
+
+    static decltype(&modified_type_caster_generic_load_impl::local_load)
+    get_local_load_function_ptr() {
+        return &modified_type_caster_generic_load_impl::local_load;
+    }
+
+    template <typename T>
+    static void init_instance_for_type(detail::instance *inst, const void *holder_const_void_ptr) {
+        // Need for const_cast is a consequence of the type_info::init_instance type:
+        // void (*init_instance)(instance *, const void *);
+        auto holder_void_ptr = const_cast<void *>(holder_const_void_ptr);
+
+        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(T)));
+        if (!v_h.instance_registered()) {
+            register_instance(inst, v_h.value_ptr(), v_h.type);
+            v_h.set_instance_registered();
+        }
+        using holder_type = pybindit::memory::smart_holder;
+        if (holder_void_ptr) {
+            // Note: inst->owned ignored.
+            auto holder_ptr = static_cast<holder_type *>(holder_void_ptr);
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*holder_ptr));
+        } else if (inst->owned) {
+            new (std::addressof(v_h.holder<holder_type>()))
+                holder_type(holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<T>()));
+        } else {
+            new (std::addressof(v_h.holder<holder_type>()))
+                holder_type(holder_type::from_raw_ptr_unowned(v_h.value_ptr<T>()));
+        }
+        v_h.set_holder_constructed();
+    }
+};
+
+template <typename T>
+struct smart_holder_type_caster_load {
+    using holder_type = pybindit::memory::smart_holder;
+
+    bool load(handle src, bool convert) {
+        load_impl = modified_type_caster_generic_load_impl(typeid(T));
+        if (!load_impl.load(src, convert))
+            return false;
+        return true;
+    }
+
+    T *loaded_as_raw_ptr_unowned() const {
+        return convert_type(holder().template as_raw_ptr_unowned<void>());
+    }
+
+    T &loaded_as_lvalue_ref() const {
+        static const char *context = "loaded_as_lvalue_ref";
+        holder().ensure_is_populated(context);
+        holder().ensure_has_pointee(context);
+        return *loaded_as_raw_ptr_unowned();
+    }
+
+    T &&loaded_as_rvalue_ref() const {
+        static const char *context = "loaded_as_rvalue_ref";
+        holder().ensure_is_populated(context);
+        holder().ensure_has_pointee(context);
+        return std::move(*loaded_as_raw_ptr_unowned());
+    }
+
+    std::shared_ptr<T> loaded_as_shared_ptr() {
+        std::shared_ptr<void> void_ptr = holder().template as_shared_ptr<void>();
+        return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
+    }
+
+    std::unique_ptr<T> loaded_as_unique_ptr() {
+        holder().ensure_can_release_ownership();
+        auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
+        // MISSING: Safety checks for type conversions
+        // (T must be polymorphic or meet certain other conditions).
+        T *raw_type_ptr = convert_type(raw_void_ptr);
+
+        // Critical transfer-of-ownership section. This must stay together.
+        holder().release_ownership();
+        auto result = std::unique_ptr<T>(raw_type_ptr);
+
+        void *value_void_ptr
+            = load_impl.loaded_v_h.value_ptr(); // Expected to be identical to raw_void_ptr.
+        load_impl.loaded_v_h.holder<holder_type>().~holder_type();
+        load_impl.loaded_v_h.set_holder_constructed(false);
+        load_impl.loaded_v_h.value_ptr() = nullptr;
+        deregister_instance(load_impl.loaded_v_h.inst, value_void_ptr, load_impl.loaded_v_h.type);
+
+        return result;
+    }
+
+private:
+    modified_type_caster_generic_load_impl load_impl;
+
+    holder_type &holder() const { return load_impl.loaded_v_h.holder<holder_type>(); }
+
+    T *convert_type(void *void_ptr) const {
+        if (void_ptr != nullptr && load_impl.loaded_v_h_cpptype != nullptr
+            && !load_impl.reinterpret_cast_deemed_ok && load_impl.implicit_cast != nullptr) {
+            void_ptr = load_impl.implicit_cast(void_ptr);
+        }
+        return static_cast<T *>(void_ptr);
+    }
+};
+
+// IMPROVABLE: Formally factor out of type_caster_base.
+struct make_constructor : private type_caster_base<int> { // Any type, nothing special about int.
+    using type_caster_base<int>::Constructor;
+    using type_caster_base<int>::make_copy_constructor;
+    using type_caster_base<int>::make_move_constructor;
+};
+
+template <typename T>
+struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
+                                  smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<T>();
+
+    // static handle cast(T, ...)
+    // is redundant (leads to ambiguous overloads).
+
+    static handle cast(T &&src, return_value_policy /*policy*/, handle parent) {
+        // type_caster_base BEGIN
+        // clang-format off
+        return cast(&src, return_value_policy::move, parent);
+        // clang-format on
+        // type_caster_base END
+    }
+
+    static handle cast(T const &src, return_value_policy policy, handle parent) {
+        // type_caster_base BEGIN
+        // clang-format off
+        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
+            policy = return_value_policy::copy;
+        return cast(&src, policy, parent);
+        // clang-format on
+        // type_caster_base END
+    }
+
+    static handle cast(T &src, return_value_policy policy, handle parent) {
+        return cast(const_cast<T const &>(src), policy, parent); // Mutbl2Const
+    }
+
+    static handle cast(T const *src, return_value_policy policy, handle parent) {
+        auto st = type_caster_base<T>::src_and_type(src);
+        return cast_const_raw_ptr( // Originally type_caster_generic::cast.
+            st.first,
+            policy,
+            parent,
+            st.second,
+            make_constructor::make_copy_constructor(src),
+            make_constructor::make_move_constructor(src));
+    }
+
+    static handle cast(T *src, return_value_policy policy, handle parent) {
+        return cast(const_cast<T const *>(src), policy, parent); // Mutbl2Const
+    }
+
+    template <typename T_>
+    using cast_op_type = conditional_t<
+        std::is_same<remove_reference_t<T_>, T const *>::value,
+        T const *,
+        conditional_t<
+            std::is_same<remove_reference_t<T_>, T *>::value,
+            T *,
+            conditional_t<std::is_same<T_, T const &>::value,
+                          T const &,
+                          conditional_t<std::is_same<T_, T &>::value,
+                                        T &,
+                                        conditional_t<std::is_same<T_, T &&>::value, T &&, T>>>>>;
+
+    // clang-format off
+
+    operator T()        { return this->loaded_as_lvalue_ref(); }
+    operator T&&() &&   { return this->loaded_as_rvalue_ref(); }
+    operator T const&() { return this->loaded_as_lvalue_ref(); }
+    operator T&()       { return this->loaded_as_lvalue_ref(); }
+    operator T const*() { return this->loaded_as_raw_ptr_unowned(); }
+    operator T*()       { return this->loaded_as_raw_ptr_unowned(); }
+
+    // clang-format on
+
+    // Originally type_caster_generic::cast.
+    PYBIND11_NOINLINE static handle cast_const_raw_ptr(const void *_src,
+                                                       return_value_policy policy,
+                                                       handle parent,
+                                                       const detail::type_info *tinfo,
+                                                       void *(*copy_constructor)(const void *),
+                                                       void *(*move_constructor)(const void *),
+                                                       const void *existing_holder = nullptr) {
+        if (!tinfo) // no type info: error will be set already
+            return handle();
+
+        void *src = const_cast<void *>(_src);
+        if (src == nullptr)
+            return none().release();
+
+        if (handle existing_inst = find_registered_python_instance(src, tinfo))
+            return existing_inst;
+
+        auto inst       = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto wrapper    = reinterpret_cast<instance *>(inst.ptr());
+        wrapper->owned  = false;
+        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
+
+        switch (policy) {
+            case return_value_policy::automatic:
+            case return_value_policy::take_ownership:
+                valueptr       = src;
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::automatic_reference:
+            case return_value_policy::reference:
+                valueptr       = src;
+                wrapper->owned = false;
+                break;
+
+            case return_value_policy::copy:
+                if (copy_constructor)
+                    valueptr = copy_constructor(src);
+                else {
+#if defined(NDEBUG)
+                    throw cast_error("return_value_policy = copy, but type is "
+                                     "non-copyable! (compile in debug mode for details)");
+#else
+                    std::string type_name(tinfo->cpptype->name());
+                    detail::clean_type_id(type_name);
+                    throw cast_error("return_value_policy = copy, but type " + type_name
+                                     + " is non-copyable!");
+#endif
+                }
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::move:
+                if (move_constructor)
+                    valueptr = move_constructor(src);
+                else if (copy_constructor)
+                    valueptr = copy_constructor(src);
+                else {
+#if defined(NDEBUG)
+                    throw cast_error("return_value_policy = move, but type is neither "
+                                     "movable nor copyable! "
+                                     "(compile in debug mode for details)");
+#else
+                    std::string type_name(tinfo->cpptype->name());
+                    detail::clean_type_id(type_name);
+                    throw cast_error("return_value_policy = move, but type " + type_name
+                                     + " is neither movable nor copyable!");
+#endif
+                }
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::reference_internal:
+                valueptr       = src;
+                wrapper->owned = false;
+                keep_alive_impl(inst, parent);
+                break;
+
+            default:
+                throw cast_error("unhandled return_value_policy: should not happen!");
+        }
+
+        tinfo->init_instance(wrapper, existing_holder);
+
+        return inst.release();
+    }
+};
+
+template <typename T>
+struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_load<T>,
+                                                      smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<std::shared_ptr<T>>();
+
+    static handle cast(const std::shared_ptr<T> &src, return_value_policy policy, handle parent) {
+        if (policy != return_value_policy::automatic
+            && policy != return_value_policy::reference_internal) {
+            // IMPROVABLE: Error message.
+            throw cast_error("Invalid return_value_policy for shared_ptr.");
+        }
+
+        auto src_raw_ptr = src.get();
+        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
+        if (st.first == nullptr)
+            return none().release(); // PyErr was set already.
+
+        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
+        const detail::type_info *tinfo = st.second;
+        if (handle existing_inst = find_registered_python_instance(src_raw_void_ptr, tinfo))
+            // MISSING: Enforcement of consistency with existing smart_holder.
+            // MISSING: keep_alive.
+            return existing_inst;
+
+        auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
+        inst_raw_ptr->owned = true;
+        void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+        valueptr            = src_raw_void_ptr;
+
+        auto smhldr = pybindit::memory::smart_holder::from_shared_ptr(src);
+        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
+
+        if (policy == return_value_policy::reference_internal)
+            keep_alive_impl(inst, parent);
+
+        return inst.release();
+    }
+
+    template <typename>
+    using cast_op_type = std::shared_ptr<T>;
+
+    operator std::shared_ptr<T>() { return this->loaded_as_shared_ptr(); }
+};
+
+template <typename T>
+struct smart_holder_type_caster<std::shared_ptr<T const>> : smart_holder_type_caster_load<T>,
+                                                            smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<std::shared_ptr<T const>>();
+
+    static handle
+    cast(const std::shared_ptr<T const> &src, return_value_policy policy, handle parent) {
+        return smart_holder_type_caster<std::shared_ptr<T>>::cast(
+            std::const_pointer_cast<T>(src), // Const2Mutbl
+            policy,
+            parent);
+    }
+
+    template <typename>
+    using cast_op_type = std::shared_ptr<T const>;
+
+    operator std::shared_ptr<T const>() { return this->loaded_as_shared_ptr(); } // Mutbl2Const
+};
+
+template <typename T>
+struct smart_holder_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_load<T>,
+                                                      smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<std::unique_ptr<T>>();
+
+    static handle cast(std::unique_ptr<T> &&src, return_value_policy policy, handle parent) {
+        if (policy != return_value_policy::automatic
+            && policy != return_value_policy::reference_internal) {
+            // IMPROVABLE: Error message.
+            throw cast_error("Invalid return_value_policy for unique_ptr.");
+        }
+
+        auto src_raw_ptr = src.get();
+        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
+        if (st.first == nullptr)
+            return none().release(); // PyErr was set already.
+
+        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
+        const detail::type_info *tinfo = st.second;
+        if (find_registered_python_instance(src_raw_void_ptr, tinfo))
+            throw cast_error("Invalid unique_ptr: another instance owns this pointer already.");
+
+        auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
+        inst_raw_ptr->owned = true;
+        void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+        valueptr            = src_raw_void_ptr;
+
+        auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(src));
+        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
+
+        if (policy == return_value_policy::reference_internal)
+            keep_alive_impl(inst, parent);
+
+        return inst.release();
+    }
+
+    template <typename>
+    using cast_op_type = std::unique_ptr<T>;
+
+    operator std::unique_ptr<T>() { return this->loaded_as_unique_ptr(); }
+};
+
+template <typename T>
+struct smart_holder_type_caster<std::unique_ptr<T const>> : smart_holder_type_caster_load<T>,
+                                                            smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<std::unique_ptr<T const>>();
+
+    static handle cast(std::unique_ptr<T const> &&src, return_value_policy policy, handle parent) {
+        return smart_holder_type_caster<std::unique_ptr<T>>::cast(
+            std::unique_ptr<T>(const_cast<T *>(src.release())), // Const2Mutbl
+            policy,
+            parent);
+    }
+
+    template <typename>
+    using cast_op_type = std::unique_ptr<T const>;
+
+    operator std::unique_ptr<T const>() { return this->loaded_as_unique_ptr(); }
+};
+
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+#define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                     \
+    namespace pybind11 {                                                                          \
+    namespace detail {                                                                            \
+    template <>                                                                                   \
+    class type_caster<T> : public smart_holder_type_caster<T> {};                                 \
+    template <>                                                                                   \
+    class type_caster<std::shared_ptr<T>> : public smart_holder_type_caster<std::shared_ptr<T>> { \
+    };                                                                                            \
+    template <>                                                                                   \
+    class type_caster<std::shared_ptr<T const>>                                                   \
+        : public smart_holder_type_caster<std::shared_ptr<T const>> {};                           \
+    template <>                                                                                   \
+    class type_caster<std::unique_ptr<T>> : public smart_holder_type_caster<std::unique_ptr<T>> { \
+    };                                                                                            \
+    template <>                                                                                   \
+    class type_caster<std::unique_ptr<T const>>                                                   \
+        : public smart_holder_type_caster<std::unique_ptr<T const>> {};                           \
+    }                                                                                             \
+    }
+#endif
+
+//DETAIL/SMART_HOLDER_TYPE_CASTERS_H///////////////////////////////////////////////////////////////
+
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+
 template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
+
+#else
+
+template <typename type, typename SFINAE = void> class type_caster : public smart_holder_type_caster<type> {};
+
+template <typename T>
+class type_caster<std::shared_ptr<T>> : public smart_holder_type_caster<std::shared_ptr<T>> {};
+
+template <typename T>
+class type_caster<std::shared_ptr<T const>>
+    : public smart_holder_type_caster<std::shared_ptr<T const>> {};
+
+template <typename T>
+class type_caster<std::unique_ptr<T>> : public smart_holder_type_caster<std::unique_ptr<T>> {};
+
+template <typename T>
+class type_caster<std::unique_ptr<T const>>
+    : public smart_holder_type_caster<std::unique_ptr<T const>> {};
+
+#define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)
+
+#endif
+
 template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
 
 // Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T
@@ -1608,9 +2262,11 @@ struct copyable_holder_caster : public type_caster_base<type> {
     holder_type holder;
 };
 
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
 /// Specialize for the common std::shared_ptr, so users don't need to
 template <typename T>
 class type_caster<std::shared_ptr<T>> : public copyable_holder_caster<T, std::shared_ptr<T>> { };
+#endif
 
 /// Type caster for holder types like std::unique_ptr.
 /// Please consider the SFINAE hook an implementation detail, as explained
@@ -1627,9 +2283,11 @@ struct move_only_holder_caster {
     static constexpr auto name = type_caster_base<type>::name;
 };
 
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
 template <typename type, typename deleter>
 class type_caster<std::unique_ptr<type, deleter>>
     : public move_only_holder_caster<type, std::unique_ptr<type, deleter>> { };
+#endif
 
 template <typename type, typename holder_type>
 using type_caster_holder = conditional_t<is_copy_constructible<holder_type>::value,
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 351239e518..386a0c6317 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1258,7 +1258,13 @@ class class_ : public detail::generic_type {
     using type = type_;
     using type_alias = detail::exactly_one_t<is_subtype, void, options...>;
     constexpr static bool has_alias = !std::is_void<type_alias>::value;
-    using holder_type = detail::exactly_one_t<is_holder, std::unique_ptr<type>, options...>;
+    using holder_type = detail::exactly_one_t<is_holder,
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+        std::unique_ptr<type>
+#else
+        smart_holder
+#endif
+        , options...>;
 
     static_assert(detail::all_of<is_valid_class_option<options>...>::value,
             "Unknown/invalid class_ template parameters provided");
diff --git a/tests/test_class.cpp b/tests/test_class.cpp
index bd545e8c68..fd107c95cf 100644
--- a/tests/test_class.cpp
+++ b/tests/test_class.cpp
@@ -504,7 +504,14 @@ CHECK_BASE(1); CHECK_BASE(2); CHECK_BASE(3); CHECK_BASE(4); CHECK_BASE(5); CHECK
 CHECK_ALIAS(1); CHECK_ALIAS(2); CHECK_NOALIAS(3); CHECK_ALIAS(4); CHECK_NOALIAS(5); CHECK_ALIAS(6); CHECK_ALIAS(7); CHECK_NOALIAS(8);
 #define CHECK_HOLDER(N, TYPE) static_assert(std::is_same<typename DoesntBreak##N::holder_type, std::TYPE##_ptr<BreaksBase<N>>>::value, \
         "DoesntBreak" #N " has wrong holder_type!")
-CHECK_HOLDER(1, unique); CHECK_HOLDER(2, unique); CHECK_HOLDER(3, unique); CHECK_HOLDER(4, unique); CHECK_HOLDER(5, unique);
+#define CHECK_SMART_HOLDER(N) static_assert(std::is_same<typename DoesntBreak##N::holder_type, smart_holder, \
+        "DoesntBreak" #N " has wrong holder_type!")
+CHECK_HOLDER(1, unique); CHECK_HOLDER(2, unique); CHECK_HOLDER(3, unique);
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+CHECK_HOLDER(4, unique); CHECK_HOLDER(5, unique);
+#else
+CHECK_SMART_HOLDER(4); CHECK_SMART_HOLDER(5);
+#endif
 CHECK_HOLDER(6, shared); CHECK_HOLDER(7, shared); CHECK_HOLDER(8, shared);
 
 // There's no nice way to test that these fail because they fail to compile; leave them here,

From 98b2751de01b6648b63ecbf904d431dad1b4ed12 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 29 Jan 2021 15:13:04 -0800
Subject: [PATCH 131/206] Removing test_type_caster_bare_interface, which was
 moved to the separate PR #2834.

---
 tests/CMakeLists.txt                      |   1 -
 tests/test_type_caster_bare_interface.cpp | 215 ----------------------
 tests/test_type_caster_bare_interface.py  |  41 -----
 3 files changed, 257 deletions(-)
 delete mode 100644 tests/test_type_caster_bare_interface.cpp
 delete mode 100644 tests/test_type_caster_bare_interface.py

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index b4ff298120..41f6d47bbc 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -132,7 +132,6 @@ set(PYBIND11_TEST_FILES
     test_stl.cpp
     test_stl_binders.cpp
     test_tagbased_polymorphic.cpp
-    test_type_caster_bare_interface.cpp
     test_union.cpp
     test_virtual_functions.cpp)
 
diff --git a/tests/test_type_caster_bare_interface.cpp b/tests/test_type_caster_bare_interface.cpp
deleted file mode 100644
index e334635a45..0000000000
--- a/tests/test_type_caster_bare_interface.cpp
+++ /dev/null
@@ -1,215 +0,0 @@
-// Systematically exercises the detail::type_caster<> interface. This is going a step in the
-// direction of an integration test, to ensure multiple components of pybind11 work together
-// correctly. It is also useful to show the type_caster<> interface virtually clutter-free.
-
-#include "pybind11_tests.h"
-
-#include <memory>
-
-namespace pybind11_tests {
-namespace type_caster_bare_interface {
-
-struct mpty {};
-
-// clang-format off
-
-mpty        rtrn_valu() { mpty obj; return obj; }
-mpty&&      rtrn_rref() { static mpty obj; return std::move(obj); }
-mpty const& rtrn_cref() { static mpty obj; return obj; }
-mpty&       rtrn_mref() { static mpty obj; return obj; }
-mpty const* rtrn_cptr() { return new mpty; }
-mpty*       rtrn_mptr() { return new mpty; }
-
-const char* pass_valu(mpty)        { return "load_valu"; }
-const char* pass_rref(mpty&&)      { return "load_rref"; }
-const char* pass_cref(mpty const&) { return "load_cref"; }
-const char* pass_mref(mpty&)       { return "load_mref"; }
-const char* pass_cptr(mpty const*) { return "load_cptr"; }
-const char* pass_mptr(mpty*)       { return "load_mptr"; }
-
-std::shared_ptr<mpty>       rtrn_shmp() { return std::shared_ptr<mpty      >(new mpty); }
-std::shared_ptr<mpty const> rtrn_shcp() { return std::shared_ptr<mpty const>(new mpty); }
-
-const char* pass_shmp(std::shared_ptr<mpty>)       { return "load_shmp"; }
-const char* pass_shcp(std::shared_ptr<mpty const>) { return "load_shcp"; }
-
-std::unique_ptr<mpty>       rtrn_uqmp() { return std::unique_ptr<mpty      >(new mpty); }
-std::unique_ptr<mpty const> rtrn_uqcp() { return std::unique_ptr<mpty const>(new mpty); }
-
-const char* pass_uqmp(std::unique_ptr<mpty>)       { return "load_uqmp"; }
-const char* pass_uqcp(std::unique_ptr<mpty const>) { return "load_uqcp"; }
-
-// clang-format on
-
-} // namespace type_caster_bare_interface
-} // namespace pybind11_tests
-
-namespace pybind11 {
-namespace detail {
-
-using namespace pybind11_tests::type_caster_bare_interface;
-
-template <>
-struct type_caster<mpty> {
-    static constexpr auto name = _<mpty>();
-
-    // static handle cast(mpty, ...)
-    // is redundant (leads to ambiguous overloads).
-
-    static handle cast(mpty && /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_rref").release();
-    }
-
-    static handle cast(mpty const & /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_cref").release();
-    }
-
-    static handle cast(mpty & /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_mref").release();
-    }
-
-    static handle cast(mpty const *src, return_value_policy /*policy*/, handle /*parent*/) {
-        delete src;
-        return str("cast_cptr").release();
-    }
-
-    static handle cast(mpty *src, return_value_policy /*policy*/, handle /*parent*/) {
-        delete src;
-        return str("cast_mptr").release();
-    }
-
-    template <typename T_>
-    using cast_op_type = conditional_t<
-        std::is_same<remove_reference_t<T_>, mpty const *>::value,
-        mpty const *,
-        conditional_t<
-            std::is_same<remove_reference_t<T_>, mpty *>::value,
-            mpty *,
-            conditional_t<
-                std::is_same<T_, mpty const &>::value,
-                mpty const &,
-                conditional_t<std::is_same<T_, mpty &>::value,
-                              mpty &,
-                              conditional_t<std::is_same<T_, mpty &&>::value, mpty &&, mpty>>>>>;
-
-    // clang-format off
-
-    operator mpty()        { return rtrn_valu(); }
-    operator mpty&&() &&   { return rtrn_rref(); }
-    operator mpty const&() { return rtrn_cref(); }
-    operator mpty&()       { return rtrn_mref(); }
-    operator mpty const*() { static mpty obj; return &obj; }
-    operator mpty*()       { static mpty obj; return &obj; }
-
-    // clang-format on
-
-    bool load(handle /*src*/, bool /*convert*/) { return true; }
-};
-
-template <>
-struct type_caster<std::shared_ptr<mpty>> {
-    static constexpr auto name = _<std::shared_ptr<mpty>>();
-
-    static handle cast(const std::shared_ptr<mpty> & /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
-        return str("cast_shmp").release();
-    }
-
-    template <typename>
-    using cast_op_type = std::shared_ptr<mpty>;
-
-    operator std::shared_ptr<mpty>() { return rtrn_shmp(); }
-
-    bool load(handle /*src*/, bool /*convert*/) { return true; }
-};
-
-template <>
-struct type_caster<std::shared_ptr<mpty const>> {
-    static constexpr auto name = _<std::shared_ptr<mpty const>>();
-
-    static handle cast(const std::shared_ptr<mpty const> & /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
-        return str("cast_shcp").release();
-    }
-
-    template <typename>
-    using cast_op_type = std::shared_ptr<mpty const>;
-
-    operator std::shared_ptr<mpty const>() { return rtrn_shcp(); }
-
-    bool load(handle /*src*/, bool /*convert*/) { return true; }
-};
-
-template <>
-struct type_caster<std::unique_ptr<mpty>> {
-    static constexpr auto name = _<std::unique_ptr<mpty>>();
-
-    static handle
-    cast(std::unique_ptr<mpty> && /*src*/, return_value_policy /*policy*/, handle /*parent*/) {
-        return str("cast_uqmp").release();
-    }
-
-    template <typename>
-    using cast_op_type = std::unique_ptr<mpty>;
-
-    operator std::unique_ptr<mpty>() { return rtrn_uqmp(); }
-
-    bool load(handle /*src*/, bool /*convert*/) { return true; }
-};
-
-template <>
-struct type_caster<std::unique_ptr<mpty const>> {
-    static constexpr auto name = _<std::unique_ptr<mpty const>>();
-
-    static handle cast(std::unique_ptr<mpty const> && /*src*/,
-                       return_value_policy /*policy*/,
-                       handle /*parent*/) {
-        return str("cast_uqcp").release();
-    }
-
-    template <typename>
-    using cast_op_type = std::unique_ptr<mpty const>;
-
-    operator std::unique_ptr<mpty const>() { return rtrn_uqcp(); }
-
-    bool load(handle /*src*/, bool /*convert*/) { return true; }
-};
-
-} // namespace detail
-} // namespace pybind11
-
-namespace pybind11_tests {
-namespace type_caster_bare_interface {
-
-TEST_SUBMODULE(type_caster_bare_interface, m) {
-    m.def("rtrn_valu", rtrn_valu);
-    m.def("rtrn_rref", rtrn_rref);
-    m.def("rtrn_cref", rtrn_cref);
-    m.def("rtrn_mref", rtrn_mref);
-    m.def("rtrn_cptr", rtrn_cptr);
-    m.def("rtrn_mptr", rtrn_mptr);
-
-    m.def("pass_valu", pass_valu);
-    m.def("pass_rref", pass_rref);
-    m.def("pass_cref", pass_cref);
-    m.def("pass_mref", pass_mref);
-    m.def("pass_cptr", pass_cptr);
-    m.def("pass_mptr", pass_mptr);
-
-    m.def("rtrn_shmp", rtrn_shmp);
-    m.def("rtrn_shcp", rtrn_shcp);
-
-    m.def("pass_shmp", pass_shmp);
-    m.def("pass_shcp", pass_shcp);
-
-    m.def("rtrn_uqmp", rtrn_uqmp);
-    m.def("rtrn_uqcp", rtrn_uqcp);
-
-    m.def("pass_uqmp", pass_uqmp);
-    m.def("pass_uqcp", pass_uqcp);
-}
-
-} // namespace type_caster_bare_interface
-} // namespace pybind11_tests
diff --git a/tests/test_type_caster_bare_interface.py b/tests/test_type_caster_bare_interface.py
deleted file mode 100644
index a427244dbc..0000000000
--- a/tests/test_type_caster_bare_interface.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from pybind11_tests import type_caster_bare_interface as m
-
-
-def test_cast():
-    assert m.rtrn_valu() == "cast_rref"
-    assert m.rtrn_rref() == "cast_rref"
-    assert m.rtrn_cref() == "cast_cref"
-    assert m.rtrn_mref() == "cast_mref"
-    assert m.rtrn_cptr() == "cast_cptr"
-    assert m.rtrn_mptr() == "cast_mptr"
-
-
-def test_load():
-    assert m.pass_valu(None) == "load_valu"
-    assert m.pass_rref(None) == "load_rref"
-    assert m.pass_cref(None) == "load_cref"
-    assert m.pass_mref(None) == "load_mref"
-    assert m.pass_cptr(None) == "load_cptr"
-    assert m.pass_mptr(None) == "load_mptr"
-
-
-def test_cast_shared_ptr():
-    assert m.rtrn_shmp() == "cast_shmp"
-    assert m.rtrn_shcp() == "cast_shcp"
-
-
-def test_load_shared_ptr():
-    assert m.pass_shmp(None) == "load_shmp"
-    assert m.pass_shcp(None) == "load_shcp"
-
-
-def test_cast_unique_ptr():
-    assert m.rtrn_uqmp() == "cast_uqmp"
-    assert m.rtrn_uqcp() == "cast_uqcp"
-
-
-def test_load_unique_ptr():
-    assert m.pass_uqmp(None) == "load_uqmp"
-    assert m.pass_uqcp(None) == "load_uqcp"

From 26525b63ef9e4b5de929677bf020c60a7e357c1d Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 30 Jan 2021 00:34:22 -0800
Subject: [PATCH 132/206] Fixing oversight introduced with commit
 95425f13d6c14fcb6ee479b62b602dc8a605ec49.

---
 tests/test_class.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_class.cpp b/tests/test_class.cpp
index fd107c95cf..02aa52a297 100644
--- a/tests/test_class.cpp
+++ b/tests/test_class.cpp
@@ -504,7 +504,7 @@ CHECK_BASE(1); CHECK_BASE(2); CHECK_BASE(3); CHECK_BASE(4); CHECK_BASE(5); CHECK
 CHECK_ALIAS(1); CHECK_ALIAS(2); CHECK_NOALIAS(3); CHECK_ALIAS(4); CHECK_NOALIAS(5); CHECK_ALIAS(6); CHECK_ALIAS(7); CHECK_NOALIAS(8);
 #define CHECK_HOLDER(N, TYPE) static_assert(std::is_same<typename DoesntBreak##N::holder_type, std::TYPE##_ptr<BreaksBase<N>>>::value, \
         "DoesntBreak" #N " has wrong holder_type!")
-#define CHECK_SMART_HOLDER(N) static_assert(std::is_same<typename DoesntBreak##N::holder_type, smart_holder, \
+#define CHECK_SMART_HOLDER(N) static_assert(std::is_same<typename DoesntBreak##N::holder_type, py::smart_holder>::value, \
         "DoesntBreak" #N " has wrong holder_type!")
 CHECK_HOLDER(1, unique); CHECK_HOLDER(2, unique); CHECK_HOLDER(3, unique);
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT

From 6ed9cc905aefa819b0cf202844b2d79ceaec1899 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 30 Jan 2021 01:02:36 -0800
Subject: [PATCH 133/206] Setting record.default_holder correctly for
 PYBIND11_USE_SMART_HOLDER_AS_DEFAULT.

With this test_class.cpp builds and even mostly runs, except
`test_multiple_instances_with_same_pointer`, which segfaults because it is
using a `unique_ptr` holder but `smart_holder` `type_caster`.

Also adding `static_assert`s to generate build errors for such situations,
but guarding with `#if 0` to first pivot to test_factory_constructors.cpp.
---
 include/pybind11/pybind11.h | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 386a0c6317..8146354b95 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1295,7 +1295,16 @@ class class_ : public detail::generic_type {
         record.holder_size = sizeof(holder_type);
         record.init_instance = init_instance;
         record.dealloc = dealloc;
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
         record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
+#else
+        record.default_holder = std::is_same<holder_type, smart_holder>::value;
+#if 0
+        static_assert(!(detail::is_instantiation<std::unique_ptr, holder_type>::value && detail::is_smart_holder_type_caster<type>::value));
+        static_assert(!(detail::is_instantiation<std::shared_ptr, holder_type>::value && detail::is_smart_holder_type_caster<type>::value));
+        static_assert(detail::is_smart_holder_type_caster<type>::value == std::is_same<holder_type, smart_holder>::value);
+#endif
+#endif
 
         set_operator_new<type>(&record);
 

From 7070b526ae69165c5a61a154f4a31520242542b5 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 1 Feb 2021 18:31:40 -0800
Subject: [PATCH 134/206] Fixing up cast.h and smart_holder.h after rebase.

---
 include/pybind11/cast.h         | 71 ++++++++++++++++++---------------
 include/pybind11/smart_holder.h |  1 -
 2 files changed, 39 insertions(+), 33 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 7efa45b3d1..ca384b2a71 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -13,8 +13,8 @@
 #include "pytypes.h"
 #include "detail/common.h"
 #include "detail/descr.h"
-#include "detail/type_caster_base.h"
-#include "detail/typeid.h"
+#include "detail/internals.h"
+#include "detail/smart_holder_poc.h"
 #include <array>
 #include <cstring>
 #include <functional>
@@ -45,6 +45,9 @@
 #endif
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+using pybindit::memory::smart_holder;
+
 PYBIND11_NAMESPACE_BEGIN(detail)
 
 /// A life support system for temporary objects created by `type_caster::load()`.
@@ -1239,8 +1242,10 @@ struct smart_holder_type_caster_load {
         return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
     }
 
-    std::unique_ptr<T> loaded_as_unique_ptr() {
-        holder().ensure_can_release_ownership();
+    template <typename D = std::default_delete<T>>
+    std::unique_ptr<T, D> loaded_as_unique_ptr(const char *context = "loaded_as_unique_ptr") {
+        holder().template ensure_compatible_rtti_uqp_del<T, D>(context);
+        holder().ensure_use_count_1(context);
         auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
         // MISSING: Safety checks for type conversions
         // (T must be polymorphic or meet certain other conditions).
@@ -1248,7 +1253,7 @@ struct smart_holder_type_caster_load {
 
         // Critical transfer-of-ownership section. This must stay together.
         holder().release_ownership();
-        auto result = std::unique_ptr<T>(raw_type_ptr);
+        auto result = std::unique_ptr<T, D>(raw_type_ptr);
 
         void *value_void_ptr
             = load_impl.loaded_v_h.value_ptr(); // Expected to be identical to raw_void_ptr.
@@ -1503,12 +1508,12 @@ struct smart_holder_type_caster<std::shared_ptr<T const>> : smart_holder_type_ca
     operator std::shared_ptr<T const>() { return this->loaded_as_shared_ptr(); } // Mutbl2Const
 };
 
-template <typename T>
-struct smart_holder_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_load<T>,
-                                                      smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<std::unique_ptr<T>>();
+template <typename T, typename D>
+struct smart_holder_type_caster<std::unique_ptr<T, D>> : smart_holder_type_caster_load<T>,
+                                                         smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<std::unique_ptr<T, D>>();
 
-    static handle cast(std::unique_ptr<T> &&src, return_value_policy policy, handle parent) {
+    static handle cast(std::unique_ptr<T, D> &&src, return_value_policy policy, handle parent) {
         if (policy != return_value_policy::automatic
             && policy != return_value_policy::reference_internal) {
             // IMPROVABLE: Error message.
@@ -1541,27 +1546,28 @@ struct smart_holder_type_caster<std::unique_ptr<T>> : smart_holder_type_caster_l
     }
 
     template <typename>
-    using cast_op_type = std::unique_ptr<T>;
+    using cast_op_type = std::unique_ptr<T, D>;
 
-    operator std::unique_ptr<T>() { return this->loaded_as_unique_ptr(); }
+    operator std::unique_ptr<T, D>() { return this->template loaded_as_unique_ptr<D>(); }
 };
 
-template <typename T>
-struct smart_holder_type_caster<std::unique_ptr<T const>> : smart_holder_type_caster_load<T>,
-                                                            smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<std::unique_ptr<T const>>();
+template <typename T, typename D>
+struct smart_holder_type_caster<std::unique_ptr<T const, D>>
+    : smart_holder_type_caster_load<T>, smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<std::unique_ptr<T const, D>>();
 
-    static handle cast(std::unique_ptr<T const> &&src, return_value_policy policy, handle parent) {
-        return smart_holder_type_caster<std::unique_ptr<T>>::cast(
-            std::unique_ptr<T>(const_cast<T *>(src.release())), // Const2Mutbl
+    static handle
+    cast(std::unique_ptr<T const, D> &&src, return_value_policy policy, handle parent) {
+        return smart_holder_type_caster<std::unique_ptr<T, D>>::cast(
+            std::unique_ptr<T, D>(const_cast<T *>(src.release())), // Const2Mutbl
             policy,
             parent);
     }
 
     template <typename>
-    using cast_op_type = std::unique_ptr<T const>;
+    using cast_op_type = std::unique_ptr<T const, D>;
 
-    operator std::unique_ptr<T const>() { return this->loaded_as_unique_ptr(); }
+    operator std::unique_ptr<T const, D>() { return this->template loaded_as_unique_ptr<D>(); }
 };
 
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
@@ -1576,12 +1582,12 @@ struct smart_holder_type_caster<std::unique_ptr<T const>> : smart_holder_type_ca
     template <>                                                                                   \
     class type_caster<std::shared_ptr<T const>>                                                   \
         : public smart_holder_type_caster<std::shared_ptr<T const>> {};                           \
-    template <>                                                                                   \
-    class type_caster<std::unique_ptr<T>> : public smart_holder_type_caster<std::unique_ptr<T>> { \
-    };                                                                                            \
-    template <>                                                                                   \
-    class type_caster<std::unique_ptr<T const>>                                                   \
-        : public smart_holder_type_caster<std::unique_ptr<T const>> {};                           \
+    template <typename D>                                                                         \
+    class type_caster<std::unique_ptr<T, D>>                                                      \
+        : public smart_holder_type_caster<std::unique_ptr<T, D>> {};                              \
+    template <typename D>                                                                         \
+    class type_caster<std::unique_ptr<T const, D>>                                                \
+        : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};                        \
     }                                                                                             \
     }
 #endif
@@ -1603,12 +1609,13 @@ template <typename T>
 class type_caster<std::shared_ptr<T const>>
     : public smart_holder_type_caster<std::shared_ptr<T const>> {};
 
-template <typename T>
-class type_caster<std::unique_ptr<T>> : public smart_holder_type_caster<std::unique_ptr<T>> {};
+template <typename T, typename D>
+class type_caster<std::unique_ptr<T, D>>
+    : public smart_holder_type_caster<std::unique_ptr<T, D>> {};
 
-template <typename T>
-class type_caster<std::unique_ptr<T const>>
-    : public smart_holder_type_caster<std::unique_ptr<T const>> {};
+template <typename T, typename D>
+class type_caster<std::unique_ptr<T const, D>>
+    : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};
 
 #define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)
 
diff --git a/include/pybind11/smart_holder.h b/include/pybind11/smart_holder.h
index 7d7e9f03e0..ce24bbfc2e 100644
--- a/include/pybind11/smart_holder.h
+++ b/include/pybind11/smart_holder.h
@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include "detail/smart_holder_type_casters.h"
 #include "pybind11.h"
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)

From 07dab2eab426d402069307ed3fad3bed17f149bc Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 1 Feb 2021 18:32:06 -0800
Subject: [PATCH 135/206] Removing detail/smart_holder_type_casters.h in
 separate commit.

---
 .../detail/smart_holder_type_casters.h        | 649 ------------------
 1 file changed, 649 deletions(-)
 delete mode 100644 include/pybind11/detail/smart_holder_type_casters.h

diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
deleted file mode 100644
index 229250bc24..0000000000
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ /dev/null
@@ -1,649 +0,0 @@
-// Copyright (c) 2020-2021 The Pybind Development Team.
-// All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-#pragma once
-
-#include "../cast.h"
-#include "../pytypes.h"
-#include "class.h"
-#include "common.h"
-#include "descr.h"
-#include "internals.h"
-#include "smart_holder_poc.h"
-
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-namespace pybind11 {
-
-using pybindit::memory::smart_holder;
-
-namespace detail {
-
-// The modified_type_caster_generic_load_impl could replace type_caster_generic::load_impl but not
-// vice versa. The main difference is that the original code only propagates a reference to the
-// held value, while the modified implementation propagates value_and_holder.
-// clang-format off
-class modified_type_caster_generic_load_impl {
-public:
-    PYBIND11_NOINLINE modified_type_caster_generic_load_impl(const std::type_info &type_info)
-        : typeinfo(get_type_info(type_info)), cpptype(&type_info) { }
-
-    explicit modified_type_caster_generic_load_impl(const type_info *typeinfo = nullptr)
-        : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { }
-
-    bool load(handle src, bool convert) {
-        return load_impl<modified_type_caster_generic_load_impl>(src, convert);
-    }
-
-    // Base methods for generic caster; there are overridden in copyable_holder_caster
-    void load_value_and_holder(value_and_holder &&v_h) {
-        loaded_v_h = std::move(v_h);
-        if (!loaded_v_h.holder_constructed()) {
-            // IMPROVABLE: Error message. A change to the existing internals is
-            // needed to cleanly distinguish between uninitialized or disowned.
-            throw std::runtime_error("Missing value for wrapped C++ type:"
-                                     " Python instance is uninitialized or was disowned.");
-        }
-        if (v_h.value_ptr() == nullptr) {
-            pybind11_fail("smart_holder_type_casters: Unexpected v_h.value_ptr() nullptr.");
-        }
-        loaded_v_h.type = typeinfo;
-    }
-
-    bool try_implicit_casts(handle src, bool convert) {
-        for (auto &cast : typeinfo->implicit_casts) {
-            modified_type_caster_generic_load_impl sub_caster(*cast.first);
-            if (sub_caster.load(src, convert)) {
-                if (loaded_v_h_cpptype != nullptr) {
-                    pybind11_fail("smart_holder_type_casters: try_implicit_casts failure.");
-                }
-                loaded_v_h = sub_caster.loaded_v_h;
-                loaded_v_h_cpptype = cast.first;
-                implicit_cast = cast.second;
-                return true;
-            }
-        }
-        return false;
-    }
-
-    bool try_direct_conversions(handle src) {
-        for (auto &converter : *typeinfo->direct_conversions) {
-            if (converter(src.ptr(), loaded_v_h.value_ptr()))
-                return true;
-        }
-        return false;
-    }
-
-    PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
-        std::unique_ptr<modified_type_caster_generic_load_impl> loader(
-            new modified_type_caster_generic_load_impl(ti));
-        if (loader->load(src, false)) {
-            // Trick to work with the existing pybind11 internals.
-            // The void pointer is immediately captured in a new unique_ptr in
-            // try_load_foreign_module_local. If this assumption is violated sanitizers
-            // will most likely flag a leak (verified to be the case with ASAN).
-            return static_cast<void *>(loader.release());
-        }
-        return nullptr;
-    }
-
-    /// Try to load with foreign typeinfo, if available. Used when there is no
-    /// native typeinfo, or when the native one wasn't able to produce a value.
-    PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) {
-        constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
-        const auto pytype = type::handle_of(src);
-        if (!hasattr(pytype, local_key))
-            return false;
-
-        type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key));
-        // Only consider this foreign loader if actually foreign and is a loader of the correct cpp type
-        if (foreign_typeinfo->module_local_load == &local_load
-            || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype)))
-            return false;
-
-        void* foreign_loader_void_ptr =
-            foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo);
-        if (foreign_loader_void_ptr != nullptr) {
-            auto foreign_loader = std::unique_ptr<modified_type_caster_generic_load_impl>(
-                static_cast<modified_type_caster_generic_load_impl *>(foreign_loader_void_ptr));
-            // Magic number intentionally hard-coded for simplicity and maximum robustness.
-            if (foreign_loader->local_load_safety_guard != 1887406645) {
-                pybind11_fail(
-                    "smart_holder_type_casters: Unexpected local_load_safety_guard,"
-                    " possibly due to py::class_ holder mixup.");
-            }
-            if (loaded_v_h_cpptype != nullptr) {
-                pybind11_fail("smart_holder_type_casters: try_load_foreign_module_local failure.");
-            }
-            loaded_v_h = foreign_loader->loaded_v_h;
-            loaded_v_h_cpptype = foreign_loader->loaded_v_h_cpptype;
-            implicit_cast = foreign_loader->implicit_cast;
-            return true;
-        }
-        return false;
-    }
-
-    // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
-    // bits of code between here and copyable_holder_caster where the two classes need different
-    // logic (without having to resort to virtual inheritance).
-    template <typename ThisT>
-    PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
-        if (!src) return false;
-        if (!typeinfo) return try_load_foreign_module_local(src);
-        if (src.is_none()) {
-            // Defer accepting None to other overloads (if we aren't in convert mode):
-            if (!convert) return false;
-            loaded_v_h = value_and_holder();
-            return true;
-        }
-
-        auto &this_ = static_cast<ThisT &>(*this);
-
-        PyTypeObject *srctype = Py_TYPE(src.ptr());
-
-        // Case 1: If src is an exact type match for the target type then we can reinterpret_cast
-        // the instance's value pointer to the target type:
-        if (srctype == typeinfo->type) {
-            this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
-            return true;
-        }
-        // Case 2: We have a derived class
-        else if (PyType_IsSubtype(srctype, typeinfo->type)) {
-            auto &bases = all_type_info(srctype); // subtype bases
-            bool no_cpp_mi = typeinfo->simple_type;
-
-            // Case 2a: the python type is a Python-inherited derived class that inherits from just
-            // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of
-            // the right type and we can use reinterpret_cast.
-            // (This is essentially the same as case 2b, but because not using multiple inheritance
-            // is extremely common, we handle it specially to avoid the loop iterator and type
-            // pointer lookup overhead)
-            if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
-                this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
-                loaded_v_h_cpptype = bases.front()->cpptype;
-                reinterpret_cast_deemed_ok = true;
-                return true;
-            }
-            // Case 2b: the python type inherits from multiple C++ bases.  Check the bases to see if
-            // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we
-            // can safely reinterpret_cast to the relevant pointer.
-            else if (bases.size() > 1) {
-                for (auto base : bases) {
-                    if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
-                        this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
-                        loaded_v_h_cpptype = base->cpptype;
-                        reinterpret_cast_deemed_ok = true;
-                        return true;
-                    }
-                }
-            }
-
-            // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match
-            // in the registered bases, above, so try implicit casting (needed for proper C++ casting
-            // when MI is involved).
-            if (this_.try_implicit_casts(src, convert)) {
-                return true;
-            }
-        }
-
-        // Perform an implicit conversion
-        if (convert) {
-            for (auto &converter : typeinfo->implicit_conversions) {
-                auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
-                if (load_impl<ThisT>(temp, false)) {
-                    loader_life_support::add_patient(temp);
-                    return true;
-                }
-            }
-            if (this_.try_direct_conversions(src))
-                return true;
-        }
-
-        // Failed to match local typeinfo. Try again with global.
-        if (typeinfo->module_local) {
-            if (auto gtype = get_global_type_info(*typeinfo->cpptype)) {
-                typeinfo = gtype;
-                return load(src, false);
-            }
-        }
-
-        // Global typeinfo has precedence over foreign module_local
-        return try_load_foreign_module_local(src);
-    }
-
-    const type_info *typeinfo = nullptr;
-    const std::type_info *cpptype = nullptr;
-    const std::type_info *loaded_v_h_cpptype = nullptr;
-    void *(*implicit_cast)(void *) = nullptr;
-    value_and_holder loaded_v_h;
-    bool reinterpret_cast_deemed_ok = false;
-    // Magic number intentionally hard-coded, to guard against class_ holder mixups.
-    // Ideally type_caster_generic would have a similar guard, but this requires a change there.
-    std::size_t local_load_safety_guard = 1887406645; // 32-bit compatible value for portability.
-};
-// clang-format on
-
-struct smart_holder_type_caster_class_hooks {
-    using is_smart_holder_type_caster = std::true_type;
-
-    static decltype(&modified_type_caster_generic_load_impl::local_load)
-    get_local_load_function_ptr() {
-        return &modified_type_caster_generic_load_impl::local_load;
-    }
-
-    template <typename T>
-    static void init_instance_for_type(detail::instance *inst, const void *holder_const_void_ptr) {
-        // Need for const_cast is a consequence of the type_info::init_instance type:
-        // void (*init_instance)(instance *, const void *);
-        auto holder_void_ptr = const_cast<void *>(holder_const_void_ptr);
-
-        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(T)));
-        if (!v_h.instance_registered()) {
-            register_instance(inst, v_h.value_ptr(), v_h.type);
-            v_h.set_instance_registered();
-        }
-        using holder_type = pybindit::memory::smart_holder;
-        if (holder_void_ptr) {
-            // Note: inst->owned ignored.
-            auto holder_ptr = static_cast<holder_type *>(holder_void_ptr);
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*holder_ptr));
-        } else if (inst->owned) {
-            new (std::addressof(v_h.holder<holder_type>()))
-                holder_type(holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<T>()));
-        } else {
-            new (std::addressof(v_h.holder<holder_type>()))
-                holder_type(holder_type::from_raw_ptr_unowned(v_h.value_ptr<T>()));
-        }
-        v_h.set_holder_constructed();
-    }
-};
-
-template <typename T>
-struct smart_holder_type_caster_load {
-    using holder_type = pybindit::memory::smart_holder;
-
-    bool load(handle src, bool convert) {
-        load_impl = modified_type_caster_generic_load_impl(typeid(T));
-        if (!load_impl.load(src, convert))
-            return false;
-        return true;
-    }
-
-    T *loaded_as_raw_ptr_unowned() const {
-        return convert_type(holder().template as_raw_ptr_unowned<void>());
-    }
-
-    T &loaded_as_lvalue_ref() const {
-        static const char *context = "loaded_as_lvalue_ref";
-        holder().ensure_is_populated(context);
-        holder().ensure_has_pointee(context);
-        return *loaded_as_raw_ptr_unowned();
-    }
-
-    T &&loaded_as_rvalue_ref() const {
-        static const char *context = "loaded_as_rvalue_ref";
-        holder().ensure_is_populated(context);
-        holder().ensure_has_pointee(context);
-        return std::move(*loaded_as_raw_ptr_unowned());
-    }
-
-    std::shared_ptr<T> loaded_as_shared_ptr() {
-        std::shared_ptr<void> void_ptr = holder().template as_shared_ptr<void>();
-        return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
-    }
-
-    template <typename D = std::default_delete<T>>
-    std::unique_ptr<T, D> loaded_as_unique_ptr(const char *context = "loaded_as_unique_ptr") {
-        holder().template ensure_compatible_rtti_uqp_del<T, D>(context);
-        holder().ensure_use_count_1(context);
-        auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
-        // MISSING: Safety checks for type conversions
-        // (T must be polymorphic or meet certain other conditions).
-        T *raw_type_ptr = convert_type(raw_void_ptr);
-
-        // Critical transfer-of-ownership section. This must stay together.
-        holder().release_ownership();
-        auto result = std::unique_ptr<T, D>(raw_type_ptr);
-
-        void *value_void_ptr
-            = load_impl.loaded_v_h.value_ptr(); // Expected to be identical to raw_void_ptr.
-        load_impl.loaded_v_h.holder<holder_type>().~holder_type();
-        load_impl.loaded_v_h.set_holder_constructed(false);
-        load_impl.loaded_v_h.value_ptr() = nullptr;
-        deregister_instance(load_impl.loaded_v_h.inst, value_void_ptr, load_impl.loaded_v_h.type);
-
-        return result;
-    }
-
-private:
-    modified_type_caster_generic_load_impl load_impl;
-
-    holder_type &holder() const { return load_impl.loaded_v_h.holder<holder_type>(); }
-
-    T *convert_type(void *void_ptr) const {
-        if (void_ptr != nullptr && load_impl.loaded_v_h_cpptype != nullptr
-            && !load_impl.reinterpret_cast_deemed_ok && load_impl.implicit_cast != nullptr) {
-            void_ptr = load_impl.implicit_cast(void_ptr);
-        }
-        return static_cast<T *>(void_ptr);
-    }
-};
-
-// IMPROVABLE: Formally factor out of type_caster_base.
-struct make_constructor : private type_caster_base<int> { // Any type, nothing special about int.
-    using type_caster_base<int>::Constructor;
-    using type_caster_base<int>::make_copy_constructor;
-    using type_caster_base<int>::make_move_constructor;
-};
-
-template <typename T>
-struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
-                                  smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<T>();
-
-    // static handle cast(T, ...)
-    // is redundant (leads to ambiguous overloads).
-
-    static handle cast(T &&src, return_value_policy /*policy*/, handle parent) {
-        // type_caster_base BEGIN
-        // clang-format off
-        return cast(&src, return_value_policy::move, parent);
-        // clang-format on
-        // type_caster_base END
-    }
-
-    static handle cast(T const &src, return_value_policy policy, handle parent) {
-        // type_caster_base BEGIN
-        // clang-format off
-        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
-            policy = return_value_policy::copy;
-        return cast(&src, policy, parent);
-        // clang-format on
-        // type_caster_base END
-    }
-
-    static handle cast(T &src, return_value_policy policy, handle parent) {
-        return cast(const_cast<T const &>(src), policy, parent); // Mutbl2Const
-    }
-
-    static handle cast(T const *src, return_value_policy policy, handle parent) {
-        auto st = type_caster_base<T>::src_and_type(src);
-        return cast_const_raw_ptr( // Originally type_caster_generic::cast.
-            st.first,
-            policy,
-            parent,
-            st.second,
-            make_constructor::make_copy_constructor(src),
-            make_constructor::make_move_constructor(src));
-    }
-
-    static handle cast(T *src, return_value_policy policy, handle parent) {
-        return cast(const_cast<T const *>(src), policy, parent); // Mutbl2Const
-    }
-
-    template <typename T_>
-    using cast_op_type = conditional_t<
-        std::is_same<remove_reference_t<T_>, T const *>::value,
-        T const *,
-        conditional_t<
-            std::is_same<remove_reference_t<T_>, T *>::value,
-            T *,
-            conditional_t<std::is_same<T_, T const &>::value,
-                          T const &,
-                          conditional_t<std::is_same<T_, T &>::value,
-                                        T &,
-                                        conditional_t<std::is_same<T_, T &&>::value, T &&, T>>>>>;
-
-    // clang-format off
-
-    operator T()        { return this->loaded_as_lvalue_ref(); }
-    operator T&&() &&   { return this->loaded_as_rvalue_ref(); }
-    operator T const&() { return this->loaded_as_lvalue_ref(); }
-    operator T&()       { return this->loaded_as_lvalue_ref(); }
-    operator T const*() { return this->loaded_as_raw_ptr_unowned(); }
-    operator T*()       { return this->loaded_as_raw_ptr_unowned(); }
-
-    // clang-format on
-
-    // Originally type_caster_generic::cast.
-    PYBIND11_NOINLINE static handle cast_const_raw_ptr(const void *_src,
-                                                       return_value_policy policy,
-                                                       handle parent,
-                                                       const detail::type_info *tinfo,
-                                                       void *(*copy_constructor)(const void *),
-                                                       void *(*move_constructor)(const void *),
-                                                       const void *existing_holder = nullptr) {
-        if (!tinfo) // no type info: error will be set already
-            return handle();
-
-        void *src = const_cast<void *>(_src);
-        if (src == nullptr)
-            return none().release();
-
-        if (handle existing_inst = find_registered_python_instance(src, tinfo))
-            return existing_inst;
-
-        auto inst       = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        auto wrapper    = reinterpret_cast<instance *>(inst.ptr());
-        wrapper->owned  = false;
-        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
-
-        switch (policy) {
-            case return_value_policy::automatic:
-            case return_value_policy::take_ownership:
-                valueptr       = src;
-                wrapper->owned = true;
-                break;
-
-            case return_value_policy::automatic_reference:
-            case return_value_policy::reference:
-                valueptr       = src;
-                wrapper->owned = false;
-                break;
-
-            case return_value_policy::copy:
-                if (copy_constructor)
-                    valueptr = copy_constructor(src);
-                else {
-#if defined(NDEBUG)
-                    throw cast_error("return_value_policy = copy, but type is "
-                                     "non-copyable! (compile in debug mode for details)");
-#else
-                    std::string type_name(tinfo->cpptype->name());
-                    detail::clean_type_id(type_name);
-                    throw cast_error("return_value_policy = copy, but type " + type_name
-                                     + " is non-copyable!");
-#endif
-                }
-                wrapper->owned = true;
-                break;
-
-            case return_value_policy::move:
-                if (move_constructor)
-                    valueptr = move_constructor(src);
-                else if (copy_constructor)
-                    valueptr = copy_constructor(src);
-                else {
-#if defined(NDEBUG)
-                    throw cast_error("return_value_policy = move, but type is neither "
-                                     "movable nor copyable! "
-                                     "(compile in debug mode for details)");
-#else
-                    std::string type_name(tinfo->cpptype->name());
-                    detail::clean_type_id(type_name);
-                    throw cast_error("return_value_policy = move, but type " + type_name
-                                     + " is neither movable nor copyable!");
-#endif
-                }
-                wrapper->owned = true;
-                break;
-
-            case return_value_policy::reference_internal:
-                valueptr       = src;
-                wrapper->owned = false;
-                keep_alive_impl(inst, parent);
-                break;
-
-            default:
-                throw cast_error("unhandled return_value_policy: should not happen!");
-        }
-
-        tinfo->init_instance(wrapper, existing_holder);
-
-        return inst.release();
-    }
-};
-
-template <typename T>
-struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_load<T>,
-                                                      smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<std::shared_ptr<T>>();
-
-    static handle cast(const std::shared_ptr<T> &src, return_value_policy policy, handle parent) {
-        if (policy != return_value_policy::automatic
-            && policy != return_value_policy::reference_internal) {
-            // IMPROVABLE: Error message.
-            throw cast_error("Invalid return_value_policy for shared_ptr.");
-        }
-
-        auto src_raw_ptr = src.get();
-        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
-        if (st.first == nullptr)
-            return none().release(); // PyErr was set already.
-
-        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
-        const detail::type_info *tinfo = st.second;
-        if (handle existing_inst = find_registered_python_instance(src_raw_void_ptr, tinfo))
-            // MISSING: Enforcement of consistency with existing smart_holder.
-            // MISSING: keep_alive.
-            return existing_inst;
-
-        auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
-        inst_raw_ptr->owned = true;
-        void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
-        valueptr            = src_raw_void_ptr;
-
-        auto smhldr = pybindit::memory::smart_holder::from_shared_ptr(src);
-        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
-
-        if (policy == return_value_policy::reference_internal)
-            keep_alive_impl(inst, parent);
-
-        return inst.release();
-    }
-
-    template <typename>
-    using cast_op_type = std::shared_ptr<T>;
-
-    operator std::shared_ptr<T>() { return this->loaded_as_shared_ptr(); }
-};
-
-template <typename T>
-struct smart_holder_type_caster<std::shared_ptr<T const>> : smart_holder_type_caster_load<T>,
-                                                            smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<std::shared_ptr<T const>>();
-
-    static handle
-    cast(const std::shared_ptr<T const> &src, return_value_policy policy, handle parent) {
-        return smart_holder_type_caster<std::shared_ptr<T>>::cast(
-            std::const_pointer_cast<T>(src), // Const2Mutbl
-            policy,
-            parent);
-    }
-
-    template <typename>
-    using cast_op_type = std::shared_ptr<T const>;
-
-    operator std::shared_ptr<T const>() { return this->loaded_as_shared_ptr(); } // Mutbl2Const
-};
-
-template <typename T, typename D>
-struct smart_holder_type_caster<std::unique_ptr<T, D>> : smart_holder_type_caster_load<T>,
-                                                         smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<std::unique_ptr<T, D>>();
-
-    static handle cast(std::unique_ptr<T, D> &&src, return_value_policy policy, handle parent) {
-        if (policy != return_value_policy::automatic
-            && policy != return_value_policy::reference_internal) {
-            // IMPROVABLE: Error message.
-            throw cast_error("Invalid return_value_policy for unique_ptr.");
-        }
-
-        auto src_raw_ptr = src.get();
-        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
-        if (st.first == nullptr)
-            return none().release(); // PyErr was set already.
-
-        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
-        const detail::type_info *tinfo = st.second;
-        if (find_registered_python_instance(src_raw_void_ptr, tinfo))
-            throw cast_error("Invalid unique_ptr: another instance owns this pointer already.");
-
-        auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
-        inst_raw_ptr->owned = true;
-        void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
-        valueptr            = src_raw_void_ptr;
-
-        auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(src));
-        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
-
-        if (policy == return_value_policy::reference_internal)
-            keep_alive_impl(inst, parent);
-
-        return inst.release();
-    }
-
-    template <typename>
-    using cast_op_type = std::unique_ptr<T, D>;
-
-    operator std::unique_ptr<T, D>() { return this->template loaded_as_unique_ptr<D>(); }
-};
-
-template <typename T, typename D>
-struct smart_holder_type_caster<std::unique_ptr<T const, D>>
-    : smart_holder_type_caster_load<T>, smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<std::unique_ptr<T const, D>>();
-
-    static handle
-    cast(std::unique_ptr<T const, D> &&src, return_value_policy policy, handle parent) {
-        return smart_holder_type_caster<std::unique_ptr<T, D>>::cast(
-            std::unique_ptr<T, D>(const_cast<T *>(src.release())), // Const2Mutbl
-            policy,
-            parent);
-    }
-
-    template <typename>
-    using cast_op_type = std::unique_ptr<T const, D>;
-
-    operator std::unique_ptr<T const, D>() { return this->template loaded_as_unique_ptr<D>(); }
-};
-
-#define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                     \
-    namespace pybind11 {                                                                          \
-    namespace detail {                                                                            \
-    template <>                                                                                   \
-    class type_caster<T> : public smart_holder_type_caster<T> {};                                 \
-    template <>                                                                                   \
-    class type_caster<std::shared_ptr<T>> : public smart_holder_type_caster<std::shared_ptr<T>> { \
-    };                                                                                            \
-    template <>                                                                                   \
-    class type_caster<std::shared_ptr<T const>>                                                   \
-        : public smart_holder_type_caster<std::shared_ptr<T const>> {};                           \
-    template <typename D>                                                                         \
-    class type_caster<std::unique_ptr<T, D>>                                                      \
-        : public smart_holder_type_caster<std::unique_ptr<T, D>> {};                              \
-    template <typename D>                                                                         \
-    class type_caster<std::unique_ptr<T const, D>>                                                \
-        : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};                        \
-    }                                                                                             \
-    }
-
-} // namespace detail
-} // namespace pybind11

From 3f8da236351d453bb69adbd301d2f50cdc8b7f39 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 2 Feb 2021 13:47:46 -0800
Subject: [PATCH 136/206] Commenting out const in def_buffer(... const). With
 this, test_buffers builds and runs with PYBIND11_USE_SMART_HOLDER_AS_DEFAULT.
 Explanation why the const needs to be removed, or fix elsewhere, is still
 needed, but left for later.

---
 include/pybind11/pybind11.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 8146354b95..a2eb63840a 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1410,7 +1410,8 @@ class class_ : public detail::generic_type {
 
     template <typename Return, typename Class, typename... Args>
     class_ &def_buffer(Return (Class::*func)(Args...) const) {
-        return def_buffer([func] (const type &obj) { return (obj.*func)(); });
+        // NEEDED: Explanation why the const needs to be removed, or fix elsewhere.
+        return def_buffer([func] (/*const*/ type &obj) { return (obj.*func)(); });
     }
 
     template <typename C, typename D, typename... Extra>

From 9f6fa1cd876ac97859fe635d86fe47fcd6a552e1 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 2 Feb 2021 15:35:19 -0800
Subject: [PATCH 137/206] Adding test_class_sh_factory_constructors,
 reproducing test_factory_constructors failure. Using py::class_ in this
 commit, to be changed to py::classh for debugging.

---
 tests/test_class_sh_basic.cpp                |  20 +--
 tests/test_class_sh_basic.py                 |  20 +--
 tests/test_class_sh_factory_constructors.cpp | 129 +++++++++++++++++++
 tests/test_class_sh_factory_constructors.py  |  18 +++
 4 files changed, 168 insertions(+), 19 deletions(-)
 create mode 100644 tests/test_class_sh_factory_constructors.cpp
 create mode 100644 tests/test_class_sh_factory_constructors.py

diff --git a/tests/test_class_sh_basic.cpp b/tests/test_class_sh_basic.cpp
index ef08f7e0ee..c1cacccf96 100644
--- a/tests/test_class_sh_basic.cpp
+++ b/tests/test_class_sh_basic.cpp
@@ -40,14 +40,14 @@ std::unique_ptr<atyp const> rtrn_uqcp_atyp() { return std::unique_ptr<atyp const
 std::string pass_uqmp_atyp(std::unique_ptr<atyp      > obj) { return "pass_uqmp:" + obj->mtxt; }
 std::string pass_uqcp_atyp(std::unique_ptr<atyp const> obj) { return "pass_uqcp:" + obj->mtxt; }
 
-struct uqmd : std::default_delete<atyp      > {};
-struct uqcd : std::default_delete<atyp const> {};
+struct sddm : std::default_delete<atyp      > {};
+struct sddc : std::default_delete<atyp const> {};
 
-std::unique_ptr<atyp,       uqmd> rtrn_uqmp_del_atyp() { return std::unique_ptr<atyp,       uqmd>(new atyp{"rtrn_uqmp_del"}); }
-std::unique_ptr<atyp const, uqcd> rtrn_uqcp_del_atyp() { return std::unique_ptr<atyp const, uqcd>(new atyp{"rtrn_uqcp_del"}); }
+std::unique_ptr<atyp,       sddm> rtrn_udmp_atyp() { return std::unique_ptr<atyp,       sddm>(new atyp{"rtrn_udmp"}); }
+std::unique_ptr<atyp const, sddc> rtrn_udcp_atyp() { return std::unique_ptr<atyp const, sddc>(new atyp{"rtrn_udcp"}); }
 
-std::string pass_uqmp_del_atyp(std::unique_ptr<atyp,       uqmd> obj) { return "pass_uqmp_del:" + obj->mtxt; }
-std::string pass_uqcp_del_atyp(std::unique_ptr<atyp const, uqcd> obj) { return "pass_uqcp_del:" + obj->mtxt; }
+std::string pass_udmp_atyp(std::unique_ptr<atyp,       sddm> obj) { return "pass_udmp:" + obj->mtxt; }
+std::string pass_udcp_atyp(std::unique_ptr<atyp const, sddc> obj) { return "pass_udcp:" + obj->mtxt; }
 
 // clang-format on
 
@@ -98,11 +98,11 @@ TEST_SUBMODULE(class_sh_basic, m) {
     m.def("pass_uqmp_atyp", pass_uqmp_atyp);
     m.def("pass_uqcp_atyp", pass_uqcp_atyp);
 
-    m.def("rtrn_uqmp_del_atyp", rtrn_uqmp_del_atyp);
-    m.def("rtrn_uqcp_del_atyp", rtrn_uqcp_del_atyp);
+    m.def("rtrn_udmp_atyp", rtrn_udmp_atyp);
+    m.def("rtrn_udcp_atyp", rtrn_udcp_atyp);
 
-    m.def("pass_uqmp_del_atyp", pass_uqmp_del_atyp);
-    m.def("pass_uqcp_del_atyp", pass_uqcp_del_atyp);
+    m.def("pass_udmp_atyp", pass_udmp_atyp);
+    m.def("pass_udcp_atyp", pass_udcp_atyp);
 
     // Helpers for testing.
     // These require selected functions above to work first, as indicated:
diff --git a/tests/test_class_sh_basic.py b/tests/test_class_sh_basic.py
index 6383a408cf..1cc9264d67 100644
--- a/tests/test_class_sh_basic.py
+++ b/tests/test_class_sh_basic.py
@@ -52,24 +52,26 @@ def test_load_unique_ptr():
 
 
 def test_cast_unique_ptr_with_deleter():
-    assert m.get_mtxt(m.rtrn_uqmp_del_atyp()) == "rtrn_uqmp_del"
-    assert m.get_mtxt(m.rtrn_uqcp_del_atyp()) == "rtrn_uqcp_del"
+    assert m.get_mtxt(m.rtrn_udmp_atyp()) == "rtrn_udmp"
+    assert m.get_mtxt(m.rtrn_udcp_atyp()) == "rtrn_udcp"
 
 
 def test_load_unique_ptr_with_deleter():
-    assert m.pass_uqmp_del_atyp(m.rtrn_uqmp_del_atyp()) == "pass_uqmp_del:rtrn_uqmp_del"
-    assert m.pass_uqcp_del_atyp(m.rtrn_uqcp_del_atyp()) == "pass_uqcp_del:rtrn_uqcp_del"
+    assert m.pass_udmp_atyp(m.rtrn_udmp_atyp()) == "pass_udmp:rtrn_udmp"
+    assert m.pass_udcp_atyp(m.rtrn_udcp_atyp()) == "pass_udcp:rtrn_udcp"
 
 
 @pytest.mark.parametrize(
-    "pass_atyp, argm, rtrn",
+    "rtrn_atyp, pass_atyp, rtrn",
     [
-        (m.pass_uqmp_atyp, "Uqmp", "pass_uqmp:Uqmp"),
-        (m.pass_uqcp_atyp, "Uqcp", "pass_uqcp:Uqcp"),
+        (m.rtrn_uqmp_atyp, m.pass_uqmp_atyp, "pass_uqmp:rtrn_uqmp"),
+        (m.rtrn_uqcp_atyp, m.pass_uqcp_atyp, "pass_uqcp:rtrn_uqcp"),
+        (m.rtrn_udmp_atyp, m.pass_udmp_atyp, "pass_udmp:rtrn_udmp"),
+        (m.rtrn_udcp_atyp, m.pass_udcp_atyp, "pass_udcp:rtrn_udcp"),
     ],
 )
-def test_pass_unique_ptr_disowns(pass_atyp, argm, rtrn):
-    obj = m.atyp(argm)
+def test_pass_unique_ptr_disowns(rtrn_atyp, pass_atyp, rtrn):
+    obj = rtrn_atyp()
     assert pass_atyp(obj) == rtrn
     with pytest.raises(RuntimeError) as exc_info:
         m.pass_uqmp_atyp(obj)
diff --git a/tests/test_class_sh_factory_constructors.cpp b/tests/test_class_sh_factory_constructors.cpp
new file mode 100644
index 0000000000..a820b4268b
--- /dev/null
+++ b/tests/test_class_sh_factory_constructors.cpp
@@ -0,0 +1,129 @@
+#include "pybind11_tests.h"
+
+#include <pybind11/smart_holder.h>
+
+#include <memory>
+#include <string>
+
+namespace pybind11_tests {
+namespace test_class_sh_factory_constructors {
+
+template <int> // Using int as a trick to easily generate a series of types.
+struct atyp {  // Short for "any type".
+    std::string mtxt;
+};
+
+template <typename T>
+std::string get_mtxt(const T &obj) {
+    return obj.mtxt;
+}
+
+using atyp_valu = atyp<0x0>;
+using atyp_rref = atyp<0x1>;
+using atyp_cref = atyp<0x2>;
+using atyp_mref = atyp<0x3>;
+using atyp_cptr = atyp<0x4>;
+using atyp_mptr = atyp<0x5>;
+using atyp_shmp = atyp<0x6>;
+using atyp_shcp = atyp<0x7>;
+using atyp_uqmp = atyp<0x8>;
+using atyp_uqcp = atyp<0x9>;
+using atyp_udmp = atyp<0xA>;
+using atyp_udcp = atyp<0xB>;
+
+// clang-format off
+
+atyp_valu        rtrn_valu() { atyp_valu obj{"Valu"}; return obj; }
+atyp_rref&&      rtrn_rref() { static atyp_rref obj; obj.mtxt = "Rref"; return std::move(obj); }
+atyp_cref const& rtrn_cref() { static atyp_cref obj; obj.mtxt = "Cref"; return obj; }
+atyp_mref&       rtrn_mref() { static atyp_mref obj; obj.mtxt = "Mref"; return obj; }
+atyp_cptr const* rtrn_cptr() { return new atyp_cptr{"Cptr"}; }
+atyp_mptr*       rtrn_mptr() { return new atyp_mptr{"Mptr"}; }
+
+std::shared_ptr<atyp_shmp>       rtrn_shmp() { return std::shared_ptr<atyp_shmp      >(new atyp_shmp{"Shmp"}); }
+std::shared_ptr<atyp_shcp const> rtrn_shcp() { return std::shared_ptr<atyp_shcp const>(new atyp_shcp{"Shcp"}); }
+
+std::unique_ptr<atyp_uqmp>       rtrn_uqmp() { return std::unique_ptr<atyp_uqmp      >(new atyp_uqmp{"Uqmp"}); }
+std::unique_ptr<atyp_uqcp const> rtrn_uqcp() { return std::unique_ptr<atyp_uqcp const>(new atyp_uqcp{"Uqcp"}); }
+
+struct sddm : std::default_delete<atyp_udmp      > {};
+struct sddc : std::default_delete<atyp_udcp const> {};
+
+std::unique_ptr<atyp_udmp,       sddm> rtrn_udmp() { return std::unique_ptr<atyp_udmp,       sddm>(new atyp_udmp{"Udmp"}); }
+std::unique_ptr<atyp_udcp const, sddc> rtrn_udcp() { return std::unique_ptr<atyp_udcp const, sddc>(new atyp_udcp{"Udcp"}); }
+
+// clang-format on
+
+} // namespace test_class_sh_factory_constructors
+} // namespace pybind11_tests
+
+// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_valu)
+// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_rref)
+// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_cref)
+// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_mref)
+// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_cptr)
+// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_mptr)
+// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_shmp)
+// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_shcp)
+// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_uqmp)
+// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_uqcp)
+// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_udmp)
+// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_udcp)
+
+TEST_SUBMODULE(class_sh_factory_constructors, m) {
+    using namespace pybind11_tests::test_class_sh_factory_constructors;
+
+    py::class_<atyp_valu>(m, "atyp_valu")
+        .def(py::init(&rtrn_valu))
+        .def("get_mtxt", get_mtxt<atyp_valu>);
+
+    py::class_<atyp_rref>(m, "atyp_rref")
+        .def(py::init(&rtrn_rref))
+        .def("get_mtxt", get_mtxt<atyp_rref>);
+
+    py::class_<atyp_cref>(m, "atyp_cref")
+        // ... must return a compatible ...
+        // .def(py::init(&rtrn_cref))
+        .def("get_mtxt", get_mtxt<atyp_cref>);
+
+    py::class_<atyp_mref>(m, "atyp_mref")
+        // ... must return a compatible ...
+        // .def(py::init(&rtrn_mref))
+        .def("get_mtxt", get_mtxt<atyp_mref>);
+
+    py::class_<atyp_cptr>(m, "atyp_cptr")
+        // ... must return a compatible ...
+        // .def(py::init(&rtrn_cptr))
+        .def("get_mtxt", get_mtxt<atyp_cptr>);
+
+    py::class_<atyp_mptr>(m, "atyp_mptr")
+        .def(py::init(&rtrn_mptr))
+        .def("get_mtxt", get_mtxt<atyp_mptr>);
+
+    py::class_<atyp_shmp, std::shared_ptr<atyp_shmp>>(m, "atyp_shmp")
+        .def(py::init(&rtrn_shmp))
+        .def("get_mtxt", get_mtxt<atyp_shmp>);
+
+    py::class_<atyp_shcp, std::shared_ptr<atyp_shcp>>(m, "atyp_shcp")
+        // ... must return a compatible ...
+        // .def(py::init(&rtrn_shcp))
+        .def("get_mtxt", get_mtxt<atyp_shcp>);
+
+    py::class_<atyp_uqmp>(m, "atyp_uqmp")
+        .def(py::init(&rtrn_uqmp))
+        .def("get_mtxt", get_mtxt<atyp_uqmp>);
+
+    py::class_<atyp_uqcp>(m, "atyp_uqcp")
+        // ... cannot pass object of non-trivial type ...
+        // .def(py::init(&rtrn_uqcp))
+        .def("get_mtxt", get_mtxt<atyp_uqcp>);
+
+    py::class_<atyp_udmp, std::unique_ptr<atyp_udmp, sddm>>(m, "atyp_udmp")
+        .def(py::init(&rtrn_udmp))
+        .def("get_mtxt", get_mtxt<atyp_udmp>);
+
+    py::class_<atyp_udcp, std::unique_ptr<atyp_udcp, sddc>>(m, "atyp_udcp")
+        // ... must return a compatible ...
+        // .def(py::init(&rtrn_udcp))
+        .def("get_mtxt", get_mtxt<atyp_udcp>);
+}
diff --git a/tests/test_class_sh_factory_constructors.py b/tests/test_class_sh_factory_constructors.py
new file mode 100644
index 0000000000..c28db561ee
--- /dev/null
+++ b/tests/test_class_sh_factory_constructors.py
@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+from pybind11_tests import class_sh_factory_constructors as m
+
+
+def test_atyp_factories():
+    assert m.atyp_valu().get_mtxt() == "Valu"
+    assert m.atyp_rref().get_mtxt() == "Rref"
+    # sert m.atyp_cref().get_mtxt() == "Cref"
+    # sert m.atyp_mref().get_mtxt() == "Mref"
+    # sert m.atyp_cptr().get_mtxt() == "Cptr"
+    assert m.atyp_mptr().get_mtxt() == "Mptr"
+    assert m.atyp_shmp().get_mtxt() == "Shmp"
+    # sert m.atyp_shcp().get_mtxt() == "Shcp"
+    assert m.atyp_uqmp().get_mtxt() == "Uqmp"
+    # sert m.atyp_uqcp().get_mtxt() == "Uqcp"
+    assert m.atyp_udmp().get_mtxt() == "Udmp"
+    # sert m.atyp_udcp().get_mtxt() == "Udcp"

From 5bd693ef2fe94d9eb36a95d90571780ea94f23d1 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 2 Feb 2021 20:07:41 -0800
Subject: [PATCH 138/206] Removing
 include/pybind11/detail/smart_holder_type_casters.h from CMakeLists.txt,
 test_files.py (since it does not exist in this branch).

---
 CMakeLists.txt                           | 1 -
 tests/extra_python_package/test_files.py | 1 -
 2 files changed, 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3b1f22b4f5..5daba8f9e7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -106,7 +106,6 @@ set(PYBIND11_HEADERS
     include/pybind11/detail/init.h
     include/pybind11/detail/internals.h
     include/pybind11/detail/smart_holder_poc.h
-    include/pybind11/detail/smart_holder_type_casters.h
     include/pybind11/detail/typeid.h
     include/pybind11/attr.h
     include/pybind11/buffer_info.h
diff --git a/tests/extra_python_package/test_files.py b/tests/extra_python_package/test_files.py
index a5e47eeb76..2b8f2ebf34 100644
--- a/tests/extra_python_package/test_files.py
+++ b/tests/extra_python_package/test_files.py
@@ -44,7 +44,6 @@
     "include/pybind11/detail/init.h",
     "include/pybind11/detail/internals.h",
     "include/pybind11/detail/smart_holder_poc.h",
-    "include/pybind11/detail/smart_holder_type_casters.h",
     "include/pybind11/detail/typeid.h",
 }
 

From 16748f562794d85caeab236dc8cc2329d332d57e Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 3 Feb 2021 13:30:01 -0800
Subject: [PATCH 139/206] Adding // DANGER ZONE reminders.

---
 include/pybind11/detail/init.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index 3ef78c1179..7f620f27a4 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -105,11 +105,13 @@ void construct(value_and_holder &v_h, Cpp<Class> *ptr, bool need_alias) {
         // the holder and destruction happens when we leave the C++ scope, and the holder
         // class gets to handle the destruction however it likes.
         v_h.value_ptr() = ptr;
-        v_h.set_instance_registered(true); // To prevent init_instance from registering it
+        v_h.set_instance_registered(true); // SHORTCUT To prevent init_instance from registering it
+        // DANGER ZONE BEGIN: exceptions will leave v_h in an invalid state.
         v_h.type->init_instance(v_h.inst, nullptr); // Set up the holder
         Holder<Class> temp_holder(std::move(v_h.holder<Holder<Class>>())); // Steal the holder
         v_h.type->dealloc(v_h); // Destroys the moved-out holder remains, resets value ptr to null
         v_h.set_instance_registered(false);
+        // DANGER ZONE END.
 
         construct_alias_from_cpp<Class>(is_alias_constructible<Class>{}, v_h, std::move(*ptr));
     } else {

From e6e441d23645349be04d88b0aad51a73b7708eb8 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 3 Feb 2021 13:31:29 -0800
Subject: [PATCH 140/206] Converting as many py::class_ to py::classh as
 possible, not breaking tests.

---
 tests/test_class_sh_factory_constructors.cpp | 64 ++++++++++++--------
 1 file changed, 40 insertions(+), 24 deletions(-)

diff --git a/tests/test_class_sh_factory_constructors.cpp b/tests/test_class_sh_factory_constructors.cpp
index a820b4268b..1cf45087fa 100644
--- a/tests/test_class_sh_factory_constructors.cpp
+++ b/tests/test_class_sh_factory_constructors.cpp
@@ -57,73 +57,89 @@ std::unique_ptr<atyp_udcp const, sddc> rtrn_udcp() { return std::unique_ptr<atyp
 } // namespace test_class_sh_factory_constructors
 } // namespace pybind11_tests
 
-// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_valu)
-// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_rref)
-// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_cref)
-// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_mref)
-// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_cptr)
-// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_mptr)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_valu)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_rref)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_cref)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_mref)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_cptr)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_mptr)
 // PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_shmp)
-// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_shcp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_shcp)
 // PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_uqmp)
-// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_uqcp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_uqcp)
 // PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_udmp)
-// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_udcp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_udcp)
 
 TEST_SUBMODULE(class_sh_factory_constructors, m) {
     using namespace pybind11_tests::test_class_sh_factory_constructors;
 
-    py::class_<atyp_valu>(m, "atyp_valu")
+    py::classh<atyp_valu>(m, "atyp_valu")
         .def(py::init(&rtrn_valu))
         .def("get_mtxt", get_mtxt<atyp_valu>);
 
-    py::class_<atyp_rref>(m, "atyp_rref")
+    py::classh<atyp_rref>(m, "atyp_rref")
         .def(py::init(&rtrn_rref))
         .def("get_mtxt", get_mtxt<atyp_rref>);
 
-    py::class_<atyp_cref>(m, "atyp_cref")
-        // ... must return a compatible ...
+    py::classh<atyp_cref>(m, "atyp_cref")
+        // class_: ... must return a compatible ...
+        // classh: ... cannot pass object of non-trivial type ...
         // .def(py::init(&rtrn_cref))
         .def("get_mtxt", get_mtxt<atyp_cref>);
 
-    py::class_<atyp_mref>(m, "atyp_mref")
-        // ... must return a compatible ...
+    py::classh<atyp_mref>(m, "atyp_mref")
+        // class_: ... must return a compatible ...
+        // classh: ... cannot pass object of non-trivial type ...
         // .def(py::init(&rtrn_mref))
         .def("get_mtxt", get_mtxt<atyp_mref>);
 
-    py::class_<atyp_cptr>(m, "atyp_cptr")
-        // ... must return a compatible ...
+    py::classh<atyp_cptr>(m, "atyp_cptr")
+        // class_: ... must return a compatible ...
+        // classh: ... must return a compatible ...
         // .def(py::init(&rtrn_cptr))
         .def("get_mtxt", get_mtxt<atyp_cptr>);
 
-    py::class_<atyp_mptr>(m, "atyp_mptr")
+    py::classh<atyp_mptr>(m, "atyp_mptr")
         .def(py::init(&rtrn_mptr))
         .def("get_mtxt", get_mtxt<atyp_mptr>);
 
+    // NEEDED FOR FEATURE PARITY: shmp
     py::class_<atyp_shmp, std::shared_ptr<atyp_shmp>>(m, "atyp_shmp")
+        // py::classh<atyp_shmp>(m, "atyp_shmp")
+        // classh: ... cannot pass object of non-trivial type ...
         .def(py::init(&rtrn_shmp))
         .def("get_mtxt", get_mtxt<atyp_shmp>);
 
-    py::class_<atyp_shcp, std::shared_ptr<atyp_shcp>>(m, "atyp_shcp")
-        // ... must return a compatible ...
+    // py::class_<atyp_shcp, std::shared_ptr<atyp_shcp>>(m, "atyp_shcp")
+    py::classh<atyp_shcp>(m, "atyp_shcp")
+        // class_: ... must return a compatible ...
+        // classh: ... cannot pass object of non-trivial type ...
         // .def(py::init(&rtrn_shcp))
         .def("get_mtxt", get_mtxt<atyp_shcp>);
 
+    // NEEDED FOR FEATURE PARITY: uqmp
     py::class_<atyp_uqmp>(m, "atyp_uqmp")
+        // classh: ... cannot pass object of non-trivial type ...
         .def(py::init(&rtrn_uqmp))
         .def("get_mtxt", get_mtxt<atyp_uqmp>);
 
-    py::class_<atyp_uqcp>(m, "atyp_uqcp")
-        // ... cannot pass object of non-trivial type ...
+    py::classh<atyp_uqcp>(m, "atyp_uqcp")
+        // class_: ... cannot pass object of non-trivial type ...
+        // classh: ... cannot pass object of non-trivial type ...
         // .def(py::init(&rtrn_uqcp))
         .def("get_mtxt", get_mtxt<atyp_uqcp>);
 
+    // NEEDED FOR FEATURE PARITY: udmp
     py::class_<atyp_udmp, std::unique_ptr<atyp_udmp, sddm>>(m, "atyp_udmp")
+        // py::classh<atyp_udmp>(m, "atyp_udmp")
+        // classh: ... cannot pass object of non-trivial type ...
         .def(py::init(&rtrn_udmp))
         .def("get_mtxt", get_mtxt<atyp_udmp>);
 
-    py::class_<atyp_udcp, std::unique_ptr<atyp_udcp, sddc>>(m, "atyp_udcp")
-        // ... must return a compatible ...
+    // py::class_<atyp_udcp, std::unique_ptr<atyp_udcp, sddc>>(m, "atyp_udcp")
+    py::classh<atyp_udcp>(m, "atyp_udcp")
+        // class_: ... must return a compatible ...
+        // classh: ... cannot pass object of non-trivial type ...
         // .def(py::init(&rtrn_udcp))
         .def("get_mtxt", get_mtxt<atyp_udcp>);
 }

From dfa00a1b14e91f7336aa6e041e568c940917f89f Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 3 Feb 2021 15:58:01 -0800
Subject: [PATCH 141/206] Adding initimpl::construct() overloads, resulting in
 test_class_sh_factory_constructors feature parity for py::class_ and
 py::classh.

---
 include/pybind11/detail/init.h               | 36 ++++++++++++++++++++
 tests/test_class_sh_factory_constructors.cpp | 24 +++++--------
 2 files changed, 44 insertions(+), 16 deletions(-)

diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index 7f620f27a4..23e05bacf0 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -168,6 +168,42 @@ void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
     v_h.value_ptr() = new Alias<Class>(std::move(result));
 }
 
+//DETAIL/SMART_HOLDER_INIT_H/BEGIN/////////////////////////////////////////////////////////////////
+
+template <typename Class, typename D = std::default_delete<Cpp<Class>>,
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
+    auto *ptr = unq_ptr.get();
+    no_nullptr(ptr);
+    // If we need an alias, check that the held pointer is actually an alias instance
+    if (Class::has_alias && need_alias && !is_alias<Class>(ptr))
+        throw type_error("pybind11::init(): construction failed: returned holder-wrapped instance "
+                         "is not an alias instance");
+
+    auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(unq_ptr));
+
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+
+template <typename Class,
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, bool need_alias) {
+    auto *ptr = shd_ptr.get();
+    no_nullptr(ptr);
+    // If we need an alias, check that the held pointer is actually an alias instance
+    if (Class::has_alias && need_alias && !is_alias<Class>(ptr))
+        throw type_error("pybind11::init(): construction failed: returned holder-wrapped instance "
+                         "is not an alias instance");
+
+    auto smhldr = pybindit::memory::smart_holder::from_shared_ptr(std::move(shd_ptr));
+
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+
+//DETAIL/SMART_HOLDER_INIT_H/END///////////////////////////////////////////////////////////////////
+
 // Implementing class for py::init<...>()
 template <typename... Args>
 struct constructor {
diff --git a/tests/test_class_sh_factory_constructors.cpp b/tests/test_class_sh_factory_constructors.cpp
index 1cf45087fa..33bb50af2b 100644
--- a/tests/test_class_sh_factory_constructors.cpp
+++ b/tests/test_class_sh_factory_constructors.cpp
@@ -63,11 +63,11 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constru
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_mref)
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_cptr)
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_mptr)
-// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_shmp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_shmp)
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_shcp)
-// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_uqmp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_uqmp)
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_uqcp)
-// PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_udmp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_udmp)
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_udcp)
 
 TEST_SUBMODULE(class_sh_factory_constructors, m) {
@@ -103,23 +103,18 @@ TEST_SUBMODULE(class_sh_factory_constructors, m) {
         .def(py::init(&rtrn_mptr))
         .def("get_mtxt", get_mtxt<atyp_mptr>);
 
-    // NEEDED FOR FEATURE PARITY: shmp
-    py::class_<atyp_shmp, std::shared_ptr<atyp_shmp>>(m, "atyp_shmp")
-        // py::classh<atyp_shmp>(m, "atyp_shmp")
-        // classh: ... cannot pass object of non-trivial type ...
+    py::classh<atyp_shmp>(m, "atyp_shmp")
         .def(py::init(&rtrn_shmp))
         .def("get_mtxt", get_mtxt<atyp_shmp>);
 
-    // py::class_<atyp_shcp, std::shared_ptr<atyp_shcp>>(m, "atyp_shcp")
     py::classh<atyp_shcp>(m, "atyp_shcp")
+        // py::class_<atyp_shcp, std::shared_ptr<atyp_shcp>>(m, "atyp_shcp")
         // class_: ... must return a compatible ...
         // classh: ... cannot pass object of non-trivial type ...
         // .def(py::init(&rtrn_shcp))
         .def("get_mtxt", get_mtxt<atyp_shcp>);
 
-    // NEEDED FOR FEATURE PARITY: uqmp
-    py::class_<atyp_uqmp>(m, "atyp_uqmp")
-        // classh: ... cannot pass object of non-trivial type ...
+    py::classh<atyp_uqmp>(m, "atyp_uqmp")
         .def(py::init(&rtrn_uqmp))
         .def("get_mtxt", get_mtxt<atyp_uqmp>);
 
@@ -129,15 +124,12 @@ TEST_SUBMODULE(class_sh_factory_constructors, m) {
         // .def(py::init(&rtrn_uqcp))
         .def("get_mtxt", get_mtxt<atyp_uqcp>);
 
-    // NEEDED FOR FEATURE PARITY: udmp
-    py::class_<atyp_udmp, std::unique_ptr<atyp_udmp, sddm>>(m, "atyp_udmp")
-        // py::classh<atyp_udmp>(m, "atyp_udmp")
-        // classh: ... cannot pass object of non-trivial type ...
+    py::classh<atyp_udmp>(m, "atyp_udmp")
         .def(py::init(&rtrn_udmp))
         .def("get_mtxt", get_mtxt<atyp_udmp>);
 
-    // py::class_<atyp_udcp, std::unique_ptr<atyp_udcp, sddc>>(m, "atyp_udcp")
     py::classh<atyp_udcp>(m, "atyp_udcp")
+        // py::class_<atyp_udcp, std::unique_ptr<atyp_udcp, sddc>>(m, "atyp_udcp")
         // class_: ... must return a compatible ...
         // classh: ... cannot pass object of non-trivial type ...
         // .def(py::init(&rtrn_udcp))

From 9dd82f10f5ebc5fcbce3457cd14716d392c3cce5 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 3 Feb 2021 21:00:42 -0800
Subject: [PATCH 142/206] Adding enable_if !is_smart_holder_type_caster to
 existing initimpl::construct(). With this test_factory_constructors.cpp
 builds with PYBIND11_USE_SMART_HOLDER_AS_DEFAULT.

---
 include/pybind11/detail/init.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index 23e05bacf0..132b5c3d78 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -131,7 +131,8 @@ void construct(value_and_holder &v_h, Alias<Class> *alias_ptr, bool) {
 // Holder return: copy its pointer, and move or copy the returned holder into the new instance's
 // holder.  This also handles types like std::shared_ptr<T> and std::unique_ptr<T> where T is a
 // derived type (through those holder's implicit conversion from derived class holder constructors).
-template <typename Class>
+template <typename Class,
+          detail::enable_if_t<!detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h, Holder<Class> holder, bool need_alias) {
     auto *ptr = holder_helper<Holder<Class>>::get(holder);
     no_nullptr(ptr);
@@ -161,7 +162,8 @@ void construct(value_and_holder &v_h, Cpp<Class> &&result, bool need_alias) {
 // return-by-value version 2: returning a value of the alias type itself.  We move-construct an
 // Alias instance (even if no the python-side inheritance is involved).  The is intended for
 // cases where Alias initialization is always desired.
-template <typename Class>
+template <typename Class,
+          detail::enable_if_t<!detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
     static_assert(std::is_move_constructible<Alias<Class>>::value,
         "pybind11::init() return-by-alias-value factory function requires a movable alias class");

From fba0729e886213279736ab2e2a39b5c53e7c8b0f Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 3 Feb 2021 21:16:01 -0800
Subject: [PATCH 143/206] Disabling shared_ptr&, shared_ptr* tests when
 building with PYBIND11_USE_SMART_HOLDER_AS_DEFAULT for now, pending work on
 smart_holder_type_caster<shared_ptr>.

---
 tests/test_methods_and_attributes.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/test_methods_and_attributes.cpp b/tests/test_methods_and_attributes.cpp
index f99909bda7..30202bcba5 100644
--- a/tests/test_methods_and_attributes.cpp
+++ b/tests/test_methods_and_attributes.cpp
@@ -112,8 +112,10 @@ UserType TestPropRVP::sv2(1);
 class NoneTester { public: int answer = 42; };
 int none1(const NoneTester &obj) { return obj.answer; }
 int none2(NoneTester *obj) { return obj ? obj->answer : -1; }
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
 int none3(std::shared_ptr<NoneTester> &obj) { return obj ? obj->answer : -1; }
 int none4(std::shared_ptr<NoneTester> *obj) { return obj && *obj ? (*obj)->answer : -1; }
+#endif
 int none5(std::shared_ptr<NoneTester> obj) { return obj ? obj->answer : -1; }
 
 struct StrIssue {
@@ -329,13 +331,17 @@ TEST_SUBMODULE(methods_and_attributes, m) {
         .def(py::init<>());
     m.def("no_none1", &none1, py::arg{}.none(false));
     m.def("no_none2", &none2, py::arg{}.none(false));
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
     m.def("no_none3", &none3, py::arg{}.none(false));
     m.def("no_none4", &none4, py::arg{}.none(false));
+#endif
     m.def("no_none5", &none5, py::arg{}.none(false));
     m.def("ok_none1", &none1);
     m.def("ok_none2", &none2, py::arg{}.none(true));
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
     m.def("ok_none3", &none3);
     m.def("ok_none4", &none4, py::arg{}.none(true));
+#endif
     m.def("ok_none5", &none5);
 
     m.def("no_none_kwarg", &none2, "a"_a.none(false));

From c4e4da89977d5a12c41d455ed94d7c6ed6cbd161 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 3 Feb 2021 22:03:52 -0800
Subject: [PATCH 144/206] Factoring out struct and class definitions into
 anonymous namespace. Preparation for building with
 PYBIND11_USE_SMART_HOLDER_AS_DEFAULT.

---
 tests/test_smart_ptr.cpp | 257 +++++++++++++++++++++------------------
 1 file changed, 137 insertions(+), 120 deletions(-)

diff --git a/tests/test_smart_ptr.cpp b/tests/test_smart_ptr.cpp
index 59996edeb4..cf31b83864 100644
--- a/tests/test_smart_ptr.cpp
+++ b/tests/test_smart_ptr.cpp
@@ -85,15 +85,7 @@ class unique_ptr_with_addressof_operator {
 };
 PYBIND11_DECLARE_HOLDER_TYPE(T, unique_ptr_with_addressof_operator<T>);
 
-
-TEST_SUBMODULE(smart_ptr, m) {
-
-    // test_smart_ptr
-
-    // Object implementation in `object.h`
-    py::class_<Object, ref<Object>> obj(m, "Object");
-    obj.def("getRefCount", &Object::getRefCount);
-
+namespace {
     // Custom object with builtin reference counting (see 'object.h' for the implementation)
     class MyObject1 : public Object {
     public:
@@ -104,26 +96,6 @@ TEST_SUBMODULE(smart_ptr, m) {
     private:
         int value;
     };
-    py::class_<MyObject1, ref<MyObject1>>(m, "MyObject1", obj)
-        .def(py::init<int>());
-    py::implicitly_convertible<py::int_, MyObject1>();
-
-    m.def("make_object_1", []() -> Object * { return new MyObject1(1); });
-    m.def("make_object_2", []() -> ref<Object> { return new MyObject1(2); });
-    m.def("make_myobject1_1", []() -> MyObject1 * { return new MyObject1(4); });
-    m.def("make_myobject1_2", []() -> ref<MyObject1> { return new MyObject1(5); });
-    m.def("print_object_1", [](const Object *obj) { py::print(obj->toString()); });
-    m.def("print_object_2", [](ref<Object> obj) { py::print(obj->toString()); });
-    m.def("print_object_3", [](const ref<Object> &obj) { py::print(obj->toString()); });
-    m.def("print_object_4", [](const ref<Object> *obj) { py::print((*obj)->toString()); });
-    m.def("print_myobject1_1", [](const MyObject1 *obj) { py::print(obj->toString()); });
-    m.def("print_myobject1_2", [](ref<MyObject1> obj) { py::print(obj->toString()); });
-    m.def("print_myobject1_3", [](const ref<MyObject1> &obj) { py::print(obj->toString()); });
-    m.def("print_myobject1_4", [](const ref<MyObject1> *obj) { py::print((*obj)->toString()); });
-
-    // Expose constructor stats for the ref type
-    m.def("cstats_ref", &ConstructorStats::get<ref_tag>);
-
 
     // Object managed by a std::shared_ptr<>
     class MyObject2 {
@@ -135,14 +107,6 @@ TEST_SUBMODULE(smart_ptr, m) {
     private:
         int value;
     };
-    py::class_<MyObject2, std::shared_ptr<MyObject2>>(m, "MyObject2")
-        .def(py::init<int>());
-    m.def("make_myobject2_1", []() { return new MyObject2(6); });
-    m.def("make_myobject2_2", []() { return std::make_shared<MyObject2>(7); });
-    m.def("print_myobject2_1", [](const MyObject2 *obj) { py::print(obj->toString()); });
-    m.def("print_myobject2_2", [](std::shared_ptr<MyObject2> obj) { py::print(obj->toString()); });
-    m.def("print_myobject2_3", [](const std::shared_ptr<MyObject2> &obj) { py::print(obj->toString()); });
-    m.def("print_myobject2_4", [](const std::shared_ptr<MyObject2> *obj) { py::print((*obj)->toString()); });
 
     // Object managed by a std::shared_ptr<>, additionally derives from std::enable_shared_from_this<>
     class MyObject3 : public std::enable_shared_from_this<MyObject3> {
@@ -154,25 +118,6 @@ TEST_SUBMODULE(smart_ptr, m) {
     private:
         int value;
     };
-    py::class_<MyObject3, std::shared_ptr<MyObject3>>(m, "MyObject3")
-        .def(py::init<int>());
-    m.def("make_myobject3_1", []() { return new MyObject3(8); });
-    m.def("make_myobject3_2", []() { return std::make_shared<MyObject3>(9); });
-    m.def("print_myobject3_1", [](const MyObject3 *obj) { py::print(obj->toString()); });
-    m.def("print_myobject3_2", [](std::shared_ptr<MyObject3> obj) { py::print(obj->toString()); });
-    m.def("print_myobject3_3", [](const std::shared_ptr<MyObject3> &obj) { py::print(obj->toString()); });
-    m.def("print_myobject3_4", [](const std::shared_ptr<MyObject3> *obj) { py::print((*obj)->toString()); });
-
-    // test_smart_ptr_refcounting
-    m.def("test_object1_refcounting", []() {
-        ref<MyObject1> o = new MyObject1(0);
-        bool good = o->getRefCount() == 1;
-        py::object o2 = py::cast(o, py::return_value_policy::reference);
-        // always request (partial) ownership for objects with intrusive
-        // reference counting even when using the 'reference' RVP
-        good &= o->getRefCount() == 2;
-        return good;
-    });
 
     // test_unique_nodelete
     // Object with a private destructor
@@ -198,10 +143,6 @@ TEST_SUBMODULE(smart_ptr, m) {
             print_destroyed(this);
         }
     };
-    py::class_<MyObject4, std::unique_ptr<MyObject4, py::nodelete>>(m, "MyObject4")
-        .def(py::init<int>())
-        .def_readwrite("value", &MyObject4::value)
-        .def_static("cleanup_all_instances", &MyObject4::cleanupAllInstances);
 
     // test_unique_deleter
     // Object with std::unique_ptr<T, D> where D is not matching the base class
@@ -229,10 +170,6 @@ TEST_SUBMODULE(smart_ptr, m) {
             print_destroyed(this);
         }
     };
-    py::class_<MyObject4a, std::unique_ptr<MyObject4a, py::nodelete>>(m, "MyObject4a")
-        .def(py::init<int>())
-        .def_readwrite("value", &MyObject4a::value)
-        .def_static("cleanup_all_instances", &MyObject4a::cleanupAllInstances);
 
     // Object derived but with public destructor and no Deleter in default holder
     class MyObject4b : public MyObject4a {
@@ -240,8 +177,6 @@ TEST_SUBMODULE(smart_ptr, m) {
         MyObject4b(int i) : MyObject4a(i) { print_created(this); }
         ~MyObject4b() override { print_destroyed(this); }
     };
-    py::class_<MyObject4b, MyObject4a>(m, "MyObject4b")
-        .def(py::init<int>());
 
     // test_large_holder
     class MyObject5 { // managed by huge_unique_ptr
@@ -250,9 +185,6 @@ TEST_SUBMODULE(smart_ptr, m) {
         ~MyObject5() { print_destroyed(this); }
         int value;
     };
-    py::class_<MyObject5, huge_unique_ptr<MyObject5>>(m, "MyObject5")
-        .def(py::init<int>())
-        .def_readwrite("value", &MyObject5::value);
 
     // test_shared_ptr_and_references
     struct SharedPtrRef {
@@ -266,18 +198,6 @@ TEST_SUBMODULE(smart_ptr, m) {
         A value = {};
         std::shared_ptr<A> shared = std::make_shared<A>();
     };
-    using A = SharedPtrRef::A;
-    py::class_<A, std::shared_ptr<A>>(m, "A");
-    py::class_<SharedPtrRef>(m, "SharedPtrRef")
-        .def(py::init<>())
-        .def_readonly("ref", &SharedPtrRef::value)
-        .def_property_readonly("copy", [](const SharedPtrRef &s) { return s.value; },
-                               py::return_value_policy::copy)
-        .def_readonly("holder_ref", &SharedPtrRef::shared)
-        .def_property_readonly("holder_copy", [](const SharedPtrRef &s) { return s.shared; },
-                               py::return_value_policy::copy)
-        .def("set_ref", [](SharedPtrRef &, const A &) { return true; })
-        .def("set_holder", [](SharedPtrRef &, std::shared_ptr<A>) { return true; });
 
     // test_shared_ptr_from_this_and_references
     struct SharedFromThisRef {
@@ -291,19 +211,6 @@ TEST_SUBMODULE(smart_ptr, m) {
         B value = {};
         std::shared_ptr<B> shared = std::make_shared<B>();
     };
-    using B = SharedFromThisRef::B;
-    py::class_<B, std::shared_ptr<B>>(m, "B");
-    py::class_<SharedFromThisRef>(m, "SharedFromThisRef")
-        .def(py::init<>())
-        .def_readonly("bad_wp", &SharedFromThisRef::value)
-        .def_property_readonly("ref", [](const SharedFromThisRef &s) -> const B & { return *s.shared; })
-        .def_property_readonly("copy", [](const SharedFromThisRef &s) { return s.value; },
-                               py::return_value_policy::copy)
-        .def_readonly("holder_ref", &SharedFromThisRef::shared)
-        .def_property_readonly("holder_copy", [](const SharedFromThisRef &s) { return s.shared; },
-                               py::return_value_policy::copy)
-        .def("set_ref", [](SharedFromThisRef &, const B &) { return true; })
-        .def("set_holder", [](SharedFromThisRef &, std::shared_ptr<B>) { return true; });
 
     // Issue #865: shared_from_this doesn't work with virtual inheritance
     struct SharedFromThisVBase : std::enable_shared_from_this<SharedFromThisVBase> {
@@ -312,18 +219,12 @@ TEST_SUBMODULE(smart_ptr, m) {
         virtual ~SharedFromThisVBase() = default;
     };
     struct SharedFromThisVirt : virtual SharedFromThisVBase {};
-    static std::shared_ptr<SharedFromThisVirt> sft(new SharedFromThisVirt());
-    py::class_<SharedFromThisVirt, std::shared_ptr<SharedFromThisVirt>>(m, "SharedFromThisVirt")
-        .def_static("get", []() { return sft.get(); });
 
     // test_move_only_holder
     struct C {
         C() { print_created(this); }
         ~C() { print_destroyed(this); }
     };
-    py::class_<C, custom_unique_ptr<C>>(m, "TypeWithMoveOnlyHolder")
-        .def_static("make", []() { return custom_unique_ptr<C>(new C); })
-        .def_static("make_as_object", []() { return py::cast(custom_unique_ptr<C>(new C)); });
 
     // test_holder_with_addressof_operator
     struct TypeForHolderWithAddressOf {
@@ -336,14 +237,6 @@ TEST_SUBMODULE(smart_ptr, m) {
         }
         int value = 42;
     };
-    using HolderWithAddressOf = shared_ptr_with_addressof_operator<TypeForHolderWithAddressOf>;
-    py::class_<TypeForHolderWithAddressOf, HolderWithAddressOf>(m, "TypeForHolderWithAddressOf")
-        .def_static("make", []() { return HolderWithAddressOf(new TypeForHolderWithAddressOf); })
-        .def("get", [](const HolderWithAddressOf &self) { return self.get(); })
-        .def("print_object_1", [](const TypeForHolderWithAddressOf *obj) { py::print(obj->toString()); })
-        .def("print_object_2", [](HolderWithAddressOf obj) { py::print(obj.get()->toString()); })
-        .def("print_object_3", [](const HolderWithAddressOf &obj) { py::print(obj.get()->toString()); })
-        .def("print_object_4", [](const HolderWithAddressOf *obj) { py::print((*obj).get()->toString()); });
 
     // test_move_only_holder_with_addressof_operator
     struct TypeForMoveOnlyHolderWithAddressOf {
@@ -354,17 +247,9 @@ TEST_SUBMODULE(smart_ptr, m) {
         }
         int value;
     };
-    using MoveOnlyHolderWithAddressOf = unique_ptr_with_addressof_operator<TypeForMoveOnlyHolderWithAddressOf>;
-    py::class_<TypeForMoveOnlyHolderWithAddressOf, MoveOnlyHolderWithAddressOf>(m, "TypeForMoveOnlyHolderWithAddressOf")
-        .def_static("make", []() { return MoveOnlyHolderWithAddressOf(new TypeForMoveOnlyHolderWithAddressOf(0)); })
-        .def_readwrite("value", &TypeForMoveOnlyHolderWithAddressOf::value)
-        .def("print_object", [](const TypeForMoveOnlyHolderWithAddressOf *obj) { py::print(obj->toString()); });
 
     // test_smart_ptr_from_default
     struct HeldByDefaultHolder { };
-    py::class_<HeldByDefaultHolder>(m, "HeldByDefaultHolder")
-        .def(py::init<>())
-        .def_static("load_shared_ptr", [](std::shared_ptr<HeldByDefaultHolder>) {});
 
     // test_shared_ptr_gc
     // #187: issue involving std::shared_ptr<> return value policy & garbage collection
@@ -373,21 +258,153 @@ TEST_SUBMODULE(smart_ptr, m) {
         ElementBase() = default;
         ElementBase(const ElementBase&) = delete;
     };
-    py::class_<ElementBase, std::shared_ptr<ElementBase>>(m, "ElementBase");
 
     struct ElementA : ElementBase {
         ElementA(int v) : v(v) { }
         int value() { return v; }
         int v;
     };
-    py::class_<ElementA, ElementBase, std::shared_ptr<ElementA>>(m, "ElementA")
-        .def(py::init<int>())
-        .def("value", &ElementA::value);
 
     struct ElementList {
         void add(std::shared_ptr<ElementBase> e) { l.push_back(e); }
         std::vector<std::shared_ptr<ElementBase>> l;
     };
+}
+
+TEST_SUBMODULE(smart_ptr, m) {
+
+    // test_smart_ptr
+
+    // Object implementation in `object.h`
+    py::class_<Object, ref<Object>> obj(m, "Object");
+    obj.def("getRefCount", &Object::getRefCount);
+
+    py::class_<MyObject1, ref<MyObject1>>(m, "MyObject1", obj)
+        .def(py::init<int>());
+    py::implicitly_convertible<py::int_, MyObject1>();
+
+    m.def("make_object_1", []() -> Object * { return new MyObject1(1); });
+    m.def("make_object_2", []() -> ref<Object> { return new MyObject1(2); });
+    m.def("make_myobject1_1", []() -> MyObject1 * { return new MyObject1(4); });
+    m.def("make_myobject1_2", []() -> ref<MyObject1> { return new MyObject1(5); });
+    m.def("print_object_1", [](const Object *obj) { py::print(obj->toString()); });
+    m.def("print_object_2", [](ref<Object> obj) { py::print(obj->toString()); });
+    m.def("print_object_3", [](const ref<Object> &obj) { py::print(obj->toString()); });
+    m.def("print_object_4", [](const ref<Object> *obj) { py::print((*obj)->toString()); });
+    m.def("print_myobject1_1", [](const MyObject1 *obj) { py::print(obj->toString()); });
+    m.def("print_myobject1_2", [](ref<MyObject1> obj) { py::print(obj->toString()); });
+    m.def("print_myobject1_3", [](const ref<MyObject1> &obj) { py::print(obj->toString()); });
+    m.def("print_myobject1_4", [](const ref<MyObject1> *obj) { py::print((*obj)->toString()); });
+
+    // Expose constructor stats for the ref type
+    m.def("cstats_ref", &ConstructorStats::get<ref_tag>);
+
+    py::class_<MyObject2, std::shared_ptr<MyObject2>>(m, "MyObject2")
+        .def(py::init<int>());
+    m.def("make_myobject2_1", []() { return new MyObject2(6); });
+    m.def("make_myobject2_2", []() { return std::make_shared<MyObject2>(7); });
+    m.def("print_myobject2_1", [](const MyObject2 *obj) { py::print(obj->toString()); });
+    m.def("print_myobject2_2", [](std::shared_ptr<MyObject2> obj) { py::print(obj->toString()); });
+    m.def("print_myobject2_3", [](const std::shared_ptr<MyObject2> &obj) { py::print(obj->toString()); });
+    m.def("print_myobject2_4", [](const std::shared_ptr<MyObject2> *obj) { py::print((*obj)->toString()); });
+
+    py::class_<MyObject3, std::shared_ptr<MyObject3>>(m, "MyObject3")
+        .def(py::init<int>());
+    m.def("make_myobject3_1", []() { return new MyObject3(8); });
+    m.def("make_myobject3_2", []() { return std::make_shared<MyObject3>(9); });
+    m.def("print_myobject3_1", [](const MyObject3 *obj) { py::print(obj->toString()); });
+    m.def("print_myobject3_2", [](std::shared_ptr<MyObject3> obj) { py::print(obj->toString()); });
+    m.def("print_myobject3_3", [](const std::shared_ptr<MyObject3> &obj) { py::print(obj->toString()); });
+    m.def("print_myobject3_4", [](const std::shared_ptr<MyObject3> *obj) { py::print((*obj)->toString()); });
+
+    // test_smart_ptr_refcounting
+    m.def("test_object1_refcounting", []() {
+        ref<MyObject1> o = new MyObject1(0);
+        bool good = o->getRefCount() == 1;
+        py::object o2 = py::cast(o, py::return_value_policy::reference);
+        // always request (partial) ownership for objects with intrusive
+        // reference counting even when using the 'reference' RVP
+        good &= o->getRefCount() == 2;
+        return good;
+    });
+
+    py::class_<MyObject4, std::unique_ptr<MyObject4, py::nodelete>>(m, "MyObject4")
+        .def(py::init<int>())
+        .def_readwrite("value", &MyObject4::value)
+        .def_static("cleanup_all_instances", &MyObject4::cleanupAllInstances);
+
+    py::class_<MyObject4a, std::unique_ptr<MyObject4a, py::nodelete>>(m, "MyObject4a")
+        .def(py::init<int>())
+        .def_readwrite("value", &MyObject4a::value)
+        .def_static("cleanup_all_instances", &MyObject4a::cleanupAllInstances);
+
+    py::class_<MyObject4b, MyObject4a>(m, "MyObject4b")
+        .def(py::init<int>());
+
+    py::class_<MyObject5, huge_unique_ptr<MyObject5>>(m, "MyObject5")
+        .def(py::init<int>())
+        .def_readwrite("value", &MyObject5::value);
+
+    using A = SharedPtrRef::A;
+    py::class_<A, std::shared_ptr<A>>(m, "A");
+    py::class_<SharedPtrRef>(m, "SharedPtrRef")
+        .def(py::init<>())
+        .def_readonly("ref", &SharedPtrRef::value)
+        .def_property_readonly("copy", [](const SharedPtrRef &s) { return s.value; },
+                               py::return_value_policy::copy)
+        .def_readonly("holder_ref", &SharedPtrRef::shared)
+        .def_property_readonly("holder_copy", [](const SharedPtrRef &s) { return s.shared; },
+                               py::return_value_policy::copy)
+        .def("set_ref", [](SharedPtrRef &, const A &) { return true; })
+        .def("set_holder", [](SharedPtrRef &, std::shared_ptr<A>) { return true; });
+
+    using B = SharedFromThisRef::B;
+    py::class_<B, std::shared_ptr<B>>(m, "B");
+    py::class_<SharedFromThisRef>(m, "SharedFromThisRef")
+        .def(py::init<>())
+        .def_readonly("bad_wp", &SharedFromThisRef::value)
+        .def_property_readonly("ref", [](const SharedFromThisRef &s) -> const B & { return *s.shared; })
+        .def_property_readonly("copy", [](const SharedFromThisRef &s) { return s.value; },
+                               py::return_value_policy::copy)
+        .def_readonly("holder_ref", &SharedFromThisRef::shared)
+        .def_property_readonly("holder_copy", [](const SharedFromThisRef &s) { return s.shared; },
+                               py::return_value_policy::copy)
+        .def("set_ref", [](SharedFromThisRef &, const B &) { return true; })
+        .def("set_holder", [](SharedFromThisRef &, std::shared_ptr<B>) { return true; });
+
+    static std::shared_ptr<SharedFromThisVirt> sft(new SharedFromThisVirt());
+    py::class_<SharedFromThisVirt, std::shared_ptr<SharedFromThisVirt>>(m, "SharedFromThisVirt")
+        .def_static("get", []() { return sft.get(); });
+
+    py::class_<C, custom_unique_ptr<C>>(m, "TypeWithMoveOnlyHolder")
+        .def_static("make", []() { return custom_unique_ptr<C>(new C); })
+        .def_static("make_as_object", []() { return py::cast(custom_unique_ptr<C>(new C)); });
+
+    using HolderWithAddressOf = shared_ptr_with_addressof_operator<TypeForHolderWithAddressOf>;
+    py::class_<TypeForHolderWithAddressOf, HolderWithAddressOf>(m, "TypeForHolderWithAddressOf")
+        .def_static("make", []() { return HolderWithAddressOf(new TypeForHolderWithAddressOf); })
+        .def("get", [](const HolderWithAddressOf &self) { return self.get(); })
+        .def("print_object_1", [](const TypeForHolderWithAddressOf *obj) { py::print(obj->toString()); })
+        .def("print_object_2", [](HolderWithAddressOf obj) { py::print(obj.get()->toString()); })
+        .def("print_object_3", [](const HolderWithAddressOf &obj) { py::print(obj.get()->toString()); })
+        .def("print_object_4", [](const HolderWithAddressOf *obj) { py::print((*obj).get()->toString()); });
+
+    using MoveOnlyHolderWithAddressOf = unique_ptr_with_addressof_operator<TypeForMoveOnlyHolderWithAddressOf>;
+    py::class_<TypeForMoveOnlyHolderWithAddressOf, MoveOnlyHolderWithAddressOf>(m, "TypeForMoveOnlyHolderWithAddressOf")
+        .def_static("make", []() { return MoveOnlyHolderWithAddressOf(new TypeForMoveOnlyHolderWithAddressOf(0)); })
+        .def_readwrite("value", &TypeForMoveOnlyHolderWithAddressOf::value)
+        .def("print_object", [](const TypeForMoveOnlyHolderWithAddressOf *obj) { py::print(obj->toString()); });
+
+    py::class_<HeldByDefaultHolder>(m, "HeldByDefaultHolder")
+        .def(py::init<>())
+        .def_static("load_shared_ptr", [](std::shared_ptr<HeldByDefaultHolder>) {});
+
+    py::class_<ElementBase, std::shared_ptr<ElementBase>>(m, "ElementBase");
+
+    py::class_<ElementA, ElementBase, std::shared_ptr<ElementA>>(m, "ElementA")
+        .def(py::init<int>())
+        .def("value", &ElementA::value);
+
     py::class_<ElementList, std::shared_ptr<ElementList>>(m, "ElementList")
         .def(py::init<>())
         .def("add", &ElementList::add)

From 0b73ef4813013264de311f8eb7c2018c84045a04 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 4 Feb 2021 10:15:46 -0800
Subject: [PATCH 145/206] Simplifying from_unique_ptr(): typename D =
 std::default_delete<T> is not needed. Factoring out
 is_std_default_delete<T>() for consistentcy between
 ensure_compatible_rtti_uqp_del() and from_unique_ptr().

---
 include/pybind11/cast.h                    |  2 +-
 include/pybind11/detail/smart_holder_poc.h | 14 +++++++++-----
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index ca384b2a71..1f8f784df6 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1242,7 +1242,7 @@ struct smart_holder_type_caster_load {
         return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
     }
 
-    template <typename D = std::default_delete<T>>
+    template <typename D>
     std::unique_ptr<T, D> loaded_as_unique_ptr(const char *context = "loaded_as_unique_ptr") {
         holder().template ensure_compatible_rtti_uqp_del<T, D>(context);
         holder().ensure_use_count_1(context);
diff --git a/include/pybind11/detail/smart_holder_poc.h b/include/pybind11/detail/smart_holder_poc.h
index e46f2fb0de..d5c60403a4 100644
--- a/include/pybind11/detail/smart_holder_poc.h
+++ b/include/pybind11/detail/smart_holder_poc.h
@@ -77,6 +77,12 @@ struct guarded_custom_deleter {
     }
 };
 
+template <typename T>
+inline bool is_std_default_delete(const std::type_info &rtti_deleter) {
+    return rtti_deleter == typeid(std::default_delete<T>)
+           || rtti_deleter == typeid(std::default_delete<T const>);
+}
+
 struct smart_holder {
     const std::type_info *rtti_uqp_del;
     std::unique_ptr<bool> vptr_deleter_armed_flag_ptr;
@@ -123,9 +129,7 @@ struct smart_holder {
     void ensure_compatible_rtti_uqp_del(const char *context) const {
         const std::type_info *rtti_requested = &typeid(D);
         if (!rtti_uqp_del) {
-            // IMPROVABLE: const-correctness.
-            if (!(*rtti_requested == typeid(std::default_delete<T>)
-                  || *rtti_requested == typeid(std::default_delete<T const>))) {
+            if (!is_std_default_delete<T>(*rtti_requested)) {
                 throw std::runtime_error(std::string("Missing unique_ptr deleter (") + context
                                          + ").");
             }
@@ -214,11 +218,11 @@ struct smart_holder {
         return raw_ptr;
     }
 
-    template <typename T, typename D = std::default_delete<T>>
+    template <typename T, typename D>
     static smart_holder from_unique_ptr(std::unique_ptr<T, D> &&unq_ptr) {
         smart_holder hld(true);
         hld.rtti_uqp_del                 = &typeid(D);
-        hld.vptr_is_using_builtin_delete = (*hld.rtti_uqp_del == typeid(std::default_delete<T>));
+        hld.vptr_is_using_builtin_delete = is_std_default_delete<T>(*hld.rtti_uqp_del);
         if (hld.vptr_is_using_builtin_delete) {
             hld.vptr.reset(unq_ptr.get(),
                            guarded_builtin_delete<T>(hld.vptr_deleter_armed_flag_ptr.get()));

From 576a456a7b08239573578a1c165c35f6d8363873 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 4 Feb 2021 12:09:49 -0800
Subject: [PATCH 146/206] Introducing
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS. Using it in test_smart_ptr.cpp.
 With this test_smart_ptr builds with PYBIND11_USE_SMART_HOLDER_AS_DEFAULT and
 all but one test run successfully.

---
 include/pybind11/cast.h  | 16 ++++++++++++++--
 tests/test_smart_ptr.cpp | 31 +++++++++++++++++++++++++++----
 2 files changed, 41 insertions(+), 6 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 1f8f784df6..061afd7580 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -962,7 +962,7 @@ template <typename type> class type_caster_base : public type_caster_generic {
     static Constructor make_move_constructor(...) { return nullptr; }
 };
 
-//DETAIL/SMART_HOLDER_TYPE_CASTERS_H///////////////////////////////////////////////////////////////
+//DETAIL/SMART_HOLDER_TYPE_CASTERS_H/BEGIN/////////////////////////////////////////////////////////
 
 //FWD begin
 inline void register_instance(instance *self, void *valptr, const type_info *tinfo);
@@ -1592,14 +1592,26 @@ struct smart_holder_type_caster<std::unique_ptr<T const, D>>
     }
 #endif
 
-//DETAIL/SMART_HOLDER_TYPE_CASTERS_H///////////////////////////////////////////////////////////////
+//DETAIL/SMART_HOLDER_TYPE_CASTERS_H/END///////////////////////////////////////////////////////////
 
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
 
+#define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, H)
+
 template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
 
 #else
 
+#define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, H)                                          \
+    namespace pybind11 {                                                                          \
+    namespace detail {                                                                            \
+    template <>                                                                                   \
+    class type_caster<T> : public type_caster_base<T> {};                                         \
+    template <>                                                                                   \
+    class type_caster<H> : public type_caster_holder<T, H> {};                                    \
+    }                                                                                             \
+    }
+
 template <typename type, typename SFINAE = void> class type_caster : public smart_holder_type_caster<type> {};
 
 template <typename T>
diff --git a/tests/test_smart_ptr.cpp b/tests/test_smart_ptr.cpp
index cf31b83864..bebc336b04 100644
--- a/tests/test_smart_ptr.cpp
+++ b/tests/test_smart_ptr.cpp
@@ -271,6 +271,29 @@ namespace {
     };
 }
 
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(Object, ref<Object>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject1, ref<MyObject1>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject2, std::shared_ptr<MyObject2>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject3, std::shared_ptr<MyObject3>)
+using unique_ptr_myobject4_nodelete = std::unique_ptr<MyObject4, py::nodelete>;
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject4, unique_ptr_myobject4_nodelete)
+using unique_ptr_myobject4a_nodelete = std::unique_ptr<MyObject4a, py::nodelete>;
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject4a, unique_ptr_myobject4a_nodelete)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject4b, std::unique_ptr<MyObject4b>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject5, huge_unique_ptr<MyObject5>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(SharedPtrRef::A, std::shared_ptr<SharedPtrRef::A>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(SharedPtrRef, std::unique_ptr<SharedPtrRef>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(SharedFromThisRef::B, std::shared_ptr<SharedFromThisRef::B>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(SharedFromThisRef, std::unique_ptr<SharedFromThisRef>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(SharedFromThisVirt, std::shared_ptr<SharedFromThisVirt>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(C, custom_unique_ptr<C>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(TypeForHolderWithAddressOf, shared_ptr_with_addressof_operator<TypeForHolderWithAddressOf>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(TypeForMoveOnlyHolderWithAddressOf, unique_ptr_with_addressof_operator<TypeForMoveOnlyHolderWithAddressOf>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(HeldByDefaultHolder, std::unique_ptr<HeldByDefaultHolder>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(ElementBase, std::shared_ptr<ElementBase>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(ElementA, std::shared_ptr<ElementA>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(ElementList, std::shared_ptr<ElementList>)
+
 TEST_SUBMODULE(smart_ptr, m) {
 
     // test_smart_ptr
@@ -338,7 +361,7 @@ TEST_SUBMODULE(smart_ptr, m) {
         .def_readwrite("value", &MyObject4a::value)
         .def_static("cleanup_all_instances", &MyObject4a::cleanupAllInstances);
 
-    py::class_<MyObject4b, MyObject4a>(m, "MyObject4b")
+    py::class_<MyObject4b, MyObject4a, std::unique_ptr<MyObject4b>>(m, "MyObject4b")
         .def(py::init<int>());
 
     py::class_<MyObject5, huge_unique_ptr<MyObject5>>(m, "MyObject5")
@@ -347,7 +370,7 @@ TEST_SUBMODULE(smart_ptr, m) {
 
     using A = SharedPtrRef::A;
     py::class_<A, std::shared_ptr<A>>(m, "A");
-    py::class_<SharedPtrRef>(m, "SharedPtrRef")
+    py::class_<SharedPtrRef, std::unique_ptr<SharedPtrRef>>(m, "SharedPtrRef")
         .def(py::init<>())
         .def_readonly("ref", &SharedPtrRef::value)
         .def_property_readonly("copy", [](const SharedPtrRef &s) { return s.value; },
@@ -360,7 +383,7 @@ TEST_SUBMODULE(smart_ptr, m) {
 
     using B = SharedFromThisRef::B;
     py::class_<B, std::shared_ptr<B>>(m, "B");
-    py::class_<SharedFromThisRef>(m, "SharedFromThisRef")
+    py::class_<SharedFromThisRef, std::unique_ptr<SharedFromThisRef>>(m, "SharedFromThisRef")
         .def(py::init<>())
         .def_readonly("bad_wp", &SharedFromThisRef::value)
         .def_property_readonly("ref", [](const SharedFromThisRef &s) -> const B & { return *s.shared; })
@@ -395,7 +418,7 @@ TEST_SUBMODULE(smart_ptr, m) {
         .def_readwrite("value", &TypeForMoveOnlyHolderWithAddressOf::value)
         .def("print_object", [](const TypeForMoveOnlyHolderWithAddressOf *obj) { py::print(obj->toString()); });
 
-    py::class_<HeldByDefaultHolder>(m, "HeldByDefaultHolder")
+    py::class_<HeldByDefaultHolder, std::unique_ptr<HeldByDefaultHolder>>(m, "HeldByDefaultHolder")
         .def(py::init<>())
         .def_static("load_shared_ptr", [](std::shared_ptr<HeldByDefaultHolder>) {});
 

From f65cb0c0fee3259374021b283df7510dee6774c0 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 4 Feb 2021 21:13:54 -0800
Subject: [PATCH 147/206] Introducing 1. type_caster_for_class_, used in
 PYBIND11_MAKE_OPAQUE, and 2. default_holder_type, used in stl_bind.h.

---
 include/pybind11/cast.h                   | 16 ++++++++------
 include/pybind11/pybind11.h               | 26 ++++++++++++-----------
 include/pybind11/stl_bind.h               |  4 ++--
 tests/test_class_sh_unique_ptr_member.cpp |  3 +++
 4 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 061afd7580..08475c4e84 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1598,7 +1598,7 @@ struct smart_holder_type_caster<std::unique_ptr<T const, D>>
 
 #define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, H)
 
-template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
+template <typename T> class type_caster_for_class_ : public type_caster_base<T> {};
 
 #else
 
@@ -1612,27 +1612,29 @@ template <typename type, typename SFINAE = void> class type_caster : public type
     }                                                                                             \
     }
 
-template <typename type, typename SFINAE = void> class type_caster : public smart_holder_type_caster<type> {};
+template <typename T> class type_caster_for_class_ : public smart_holder_type_caster<T> {};
 
 template <typename T>
-class type_caster<std::shared_ptr<T>> : public smart_holder_type_caster<std::shared_ptr<T>> {};
+class type_caster_for_class_<std::shared_ptr<T>> : public smart_holder_type_caster<std::shared_ptr<T>> {};
 
 template <typename T>
-class type_caster<std::shared_ptr<T const>>
+class type_caster_for_class_<std::shared_ptr<T const>>
     : public smart_holder_type_caster<std::shared_ptr<T const>> {};
 
 template <typename T, typename D>
-class type_caster<std::unique_ptr<T, D>>
+class type_caster_for_class_<std::unique_ptr<T, D>>
     : public smart_holder_type_caster<std::unique_ptr<T, D>> {};
 
 template <typename T, typename D>
-class type_caster<std::unique_ptr<T const, D>>
+class type_caster_for_class_<std::unique_ptr<T const, D>>
     : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};
 
 #define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)
 
 #endif
 
+template <typename type, typename SFINAE = void> class type_caster : public type_caster_for_class_<type> { };
+
 template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
 
 // Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T
@@ -2970,7 +2972,7 @@ handle type::handle_of() {
 
 #define PYBIND11_MAKE_OPAQUE(...) \
     namespace pybind11 { namespace detail { \
-        template<> class type_caster<__VA_ARGS__> : public type_caster_base<__VA_ARGS__> { }; \
+        template<> class type_caster<__VA_ARGS__> : public type_caster_for_class_<__VA_ARGS__> { }; \
     }}
 
 /// Lets you pass a type containing a `,` through a macro parameter without needing a separate
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index a2eb63840a..4b7d940ca9 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1241,6 +1241,13 @@ auto method_adaptor(Return (Class::*pmf)(Args...) const) -> Return (Derived::*)(
     return pmf;
 }
 
+template <typename T>
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+using default_holder_type = std::unique_ptr<T>;
+#else
+using default_holder_type = smart_holder;
+#endif
+
 template <typename type_, typename... options>
 class class_ : public detail::generic_type {
     template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>;
@@ -1258,13 +1265,7 @@ class class_ : public detail::generic_type {
     using type = type_;
     using type_alias = detail::exactly_one_t<is_subtype, void, options...>;
     constexpr static bool has_alias = !std::is_void<type_alias>::value;
-    using holder_type = detail::exactly_one_t<is_holder,
-#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
-        std::unique_ptr<type>
-#else
-        smart_holder
-#endif
-        , options...>;
+    using holder_type = detail::exactly_one_t<is_holder, default_holder_type<type>, options...>;
 
     static_assert(detail::all_of<is_valid_class_option<options>...>::value,
             "Unknown/invalid class_ template parameters provided");
@@ -1298,14 +1299,15 @@ class class_ : public detail::generic_type {
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
         record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
 #else
-        record.default_holder = std::is_same<holder_type, smart_holder>::value;
+        static constexpr bool holder_is_smart_holder = std::is_same<holder_type, smart_holder>::value;
+        record.default_holder = holder_is_smart_holder;
 #if 0
-        static_assert(!(detail::is_instantiation<std::unique_ptr, holder_type>::value && detail::is_smart_holder_type_caster<type>::value));
-        static_assert(!(detail::is_instantiation<std::shared_ptr, holder_type>::value && detail::is_smart_holder_type_caster<type>::value));
-        static_assert(detail::is_smart_holder_type_caster<type>::value == std::is_same<holder_type, smart_holder>::value);
+        static constexpr bool type_caster_type_is_smart_holder_type_caster = detail::is_smart_holder_type_caster<type>::value;
+        static_assert(!(detail::is_instantiation<std::unique_ptr, holder_type>::value && type_caster_type_is_smart_holder_type_caster));
+        static_assert(!(detail::is_instantiation<std::shared_ptr, holder_type>::value && type_caster_type_is_smart_holder_type_caster));
+        static_assert(holder_is_smart_holder == type_caster_type_is_smart_holder_type_caster);
 #endif
 #endif
-
         set_operator_new<type>(&record);
 
         /* Register base classes specified via template arguments to class_, if any */
diff --git a/include/pybind11/stl_bind.h b/include/pybind11/stl_bind.h
index 83195ee496..39499f3491 100644
--- a/include/pybind11/stl_bind.h
+++ b/include/pybind11/stl_bind.h
@@ -438,7 +438,7 @@ PYBIND11_NAMESPACE_END(detail)
 //
 // std::vector
 //
-template <typename Vector, typename holder_type = std::unique_ptr<Vector>, typename... Args>
+template <typename Vector, typename holder_type = default_holder_type<Vector>, typename... Args>
 class_<Vector, holder_type> bind_vector(handle scope, std::string const &name, Args&&... args) {
     using Class_ = class_<Vector, holder_type>;
 
@@ -599,7 +599,7 @@ template <typename Map, typename Class_> auto map_if_insertion_operator(Class_ &
 
 PYBIND11_NAMESPACE_END(detail)
 
-template <typename Map, typename holder_type = std::unique_ptr<Map>, typename... Args>
+template <typename Map, typename holder_type = default_holder_type<Map>, typename... Args>
 class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args&&... args) {
     using KeyType = typename Map::key_type;
     using MappedType = typename Map::mapped_type;
diff --git a/tests/test_class_sh_unique_ptr_member.cpp b/tests/test_class_sh_unique_ptr_member.cpp
index cb38651366..e73d667935 100644
--- a/tests/test_class_sh_unique_ptr_member.cpp
+++ b/tests/test_class_sh_unique_ptr_member.cpp
@@ -41,6 +41,9 @@ class ptr_owner {
 } // namespace pybind11_tests
 
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_unique_ptr_member::pointee)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(
+    pybind11_tests::class_sh_unique_ptr_member::ptr_owner,
+    std::unique_ptr<pybind11_tests::class_sh_unique_ptr_member::ptr_owner>)
 
 namespace pybind11_tests {
 namespace class_sh_unique_ptr_member {

From 4665ff6488867c6f2c77ef05481297892f2e0055 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 4 Feb 2021 21:25:39 -0800
Subject: [PATCH 148/206] Using __VA_ARGS__ in
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS.

---
 include/pybind11/cast.h  | 6 +++---
 tests/test_smart_ptr.cpp | 6 ++----
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 08475c4e84..eb07fda952 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1596,19 +1596,19 @@ struct smart_holder_type_caster<std::unique_ptr<T const, D>>
 
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
 
-#define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, H)
+#define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, ...)
 
 template <typename T> class type_caster_for_class_ : public type_caster_base<T> {};
 
 #else
 
-#define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, H)                                          \
+#define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, ...)                                        \
     namespace pybind11 {                                                                          \
     namespace detail {                                                                            \
     template <>                                                                                   \
     class type_caster<T> : public type_caster_base<T> {};                                         \
     template <>                                                                                   \
-    class type_caster<H> : public type_caster_holder<T, H> {};                                    \
+    class type_caster<__VA_ARGS__> : public type_caster_holder<T, __VA_ARGS__> {};                \
     }                                                                                             \
     }
 
diff --git a/tests/test_smart_ptr.cpp b/tests/test_smart_ptr.cpp
index bebc336b04..de8bb44973 100644
--- a/tests/test_smart_ptr.cpp
+++ b/tests/test_smart_ptr.cpp
@@ -275,10 +275,8 @@ PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(Object, ref<Object>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject1, ref<MyObject1>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject2, std::shared_ptr<MyObject2>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject3, std::shared_ptr<MyObject3>)
-using unique_ptr_myobject4_nodelete = std::unique_ptr<MyObject4, py::nodelete>;
-PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject4, unique_ptr_myobject4_nodelete)
-using unique_ptr_myobject4a_nodelete = std::unique_ptr<MyObject4a, py::nodelete>;
-PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject4a, unique_ptr_myobject4a_nodelete)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject4, std::unique_ptr<MyObject4, py::nodelete>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject4a, std::unique_ptr<MyObject4a, py::nodelete>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject4b, std::unique_ptr<MyObject4b>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject5, huge_unique_ptr<MyObject5>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(SharedPtrRef::A, std::shared_ptr<SharedPtrRef::A>)

From 6582fb3d70db90424653ea0af6168c820be4da5e Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 4 Feb 2021 21:36:49 -0800
Subject: [PATCH 149/206] Replacing condense_for_macro with much simpler
 approach.

---
 tests/pure_cpp/smart_holder_poc_test.cpp | 35 ++++++++----------------
 1 file changed, 12 insertions(+), 23 deletions(-)

diff --git a/tests/pure_cpp/smart_holder_poc_test.cpp b/tests/pure_cpp/smart_holder_poc_test.cpp
index c61991a281..4d05147a17 100644
--- a/tests/pure_cpp/smart_holder_poc_test.cpp
+++ b/tests/pure_cpp/smart_holder_poc_test.cpp
@@ -63,12 +63,10 @@ TEST_CASE("from_raw_ptr_unowned+as_unique_ptr", "[E]") {
 }
 
 TEST_CASE("from_raw_ptr_unowned+as_unique_ptr_with_deleter", "[E]") {
-    static int value        = 19;
-    auto hld                = smart_holder::from_raw_ptr_unowned(&value);
-    auto condense_for_macro = [](smart_holder &hld) {
-        hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>();
-    };
-    REQUIRE_THROWS_WITH(condense_for_macro(hld), "Missing unique_ptr deleter (as_unique_ptr).");
+    static int value = 19;
+    auto hld         = smart_holder::from_raw_ptr_unowned(&value);
+    REQUIRE_THROWS_WITH((hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>()),
+                        "Missing unique_ptr deleter (as_unique_ptr).");
 }
 
 TEST_CASE("from_raw_ptr_unowned+as_shared_ptr", "[S]") {
@@ -111,11 +109,9 @@ TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr2", "[E]") {
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_unique_ptr_with_deleter", "[E]") {
-    auto hld                = smart_holder::from_raw_ptr_take_ownership(new int(19));
-    auto condense_for_macro = [](smart_holder &hld) {
-        hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>();
-    };
-    REQUIRE_THROWS_WITH(condense_for_macro(hld), "Missing unique_ptr deleter (as_unique_ptr).");
+    auto hld = smart_holder::from_raw_ptr_take_ownership(new int(19));
+    REQUIRE_THROWS_WITH((hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>()),
+                        "Missing unique_ptr deleter (as_unique_ptr).");
 }
 
 TEST_CASE("from_raw_ptr_take_ownership+as_shared_ptr", "[S]") {
@@ -171,10 +167,7 @@ TEST_CASE("from_unique_ptr+as_unique_ptr_with_deleter", "[E]") {
     std::unique_ptr<int> orig_owner(new int(19));
     auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
     REQUIRE(orig_owner.get() == nullptr);
-    auto condense_for_macro = [](smart_holder &hld) {
-        hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>();
-    };
-    REQUIRE_THROWS_WITH(condense_for_macro(hld),
+    REQUIRE_THROWS_WITH((hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>()),
                         "Incompatible unique_ptr deleter (as_unique_ptr).");
 }
 
@@ -224,9 +217,7 @@ TEST_CASE("from_unique_ptr_with_deleter+as_unique_ptr_with_deleter2", "[E]") {
     std::unique_ptr<int, helpers::functor_builtin_delete<int>> orig_owner(new int(19));
     auto hld = smart_holder::from_unique_ptr(std::move(orig_owner));
     REQUIRE(orig_owner.get() == nullptr);
-    auto condense_for_macro
-        = [](smart_holder &hld) { hld.as_unique_ptr<int, helpers::functor_other_delete<int>>(); };
-    REQUIRE_THROWS_WITH(condense_for_macro(hld),
+    REQUIRE_THROWS_WITH((hld.as_unique_ptr<int, helpers::functor_other_delete<int>>()),
                         "Incompatible unique_ptr deleter (as_unique_ptr).");
 }
 
@@ -261,11 +252,9 @@ TEST_CASE("from_shared_ptr+as_unique_ptr", "[E]") {
 
 TEST_CASE("from_shared_ptr+as_unique_ptr_with_deleter", "[E]") {
     std::shared_ptr<int> orig_owner(new int(19));
-    auto hld                = smart_holder::from_shared_ptr(orig_owner);
-    auto condense_for_macro = [](smart_holder &hld) {
-        hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>();
-    };
-    REQUIRE_THROWS_WITH(condense_for_macro(hld), "Missing unique_ptr deleter (as_unique_ptr).");
+    auto hld = smart_holder::from_shared_ptr(orig_owner);
+    REQUIRE_THROWS_WITH((hld.as_unique_ptr<int, helpers::functor_builtin_delete<int>>()),
+                        "Missing unique_ptr deleter (as_unique_ptr).");
 }
 
 TEST_CASE("from_shared_ptr+as_shared_ptr", "[S]") {

From 4a9bc72cd10abe372df7429fd81ada87a12bba7a Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 4 Feb 2021 22:30:11 -0800
Subject: [PATCH 150/206] Softening static_assert, to only check specifically
 that smart_holder is not mixed with type_caster_base, and
 unique_ptr/shared_ptr holders are not mixed with smart_holder_type_casters.

---
 include/pybind11/pybind11.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 4b7d940ca9..a0ca3961de 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1303,9 +1303,10 @@ class class_ : public detail::generic_type {
         record.default_holder = holder_is_smart_holder;
 #if 0
         static constexpr bool type_caster_type_is_smart_holder_type_caster = detail::is_smart_holder_type_caster<type>::value;
+        static constexpr bool type_caster_type_is_type_caster_base_subtype = std::is_base_of<detail::type_caster_base<type>, detail::type_caster<type>>::value;
         static_assert(!(detail::is_instantiation<std::unique_ptr, holder_type>::value && type_caster_type_is_smart_holder_type_caster));
         static_assert(!(detail::is_instantiation<std::shared_ptr, holder_type>::value && type_caster_type_is_smart_holder_type_caster));
-        static_assert(holder_is_smart_holder == type_caster_type_is_smart_holder_type_caster);
+        static_assert(!(holder_is_smart_holder && type_caster_type_is_type_caster_base_subtype));
 #endif
 #endif
         set_operator_new<type>(&record);

From f439b2bb198f6361030bec606e930d76d9f43b9b Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 4 Feb 2021 22:32:27 -0800
Subject: [PATCH 151/206] Adding PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS in
 test_class.cpp (with this all but one test succeed with
 PYBIND11_USE_SMART_HOLDER_AS_DEFAULT).

---
 tests/test_class.cpp | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/tests/test_class.cpp b/tests/test_class.cpp
index 02aa52a297..e6e7e5d62b 100644
--- a/tests/test_class.cpp
+++ b/tests/test_class.cpp
@@ -32,6 +32,20 @@ struct NoBraceInitialization {
     std::vector<int> vec;
 };
 
+struct MismatchBase1 { };
+struct MismatchDerived1 : MismatchBase1 { };
+
+struct MismatchBase2 { };
+struct MismatchDerived2 : MismatchBase2 { };
+
+struct SamePointer {};
+
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MismatchBase1, std::shared_ptr<MismatchBase1>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MismatchDerived1, std::unique_ptr<MismatchDerived1>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MismatchBase2, std::unique_ptr<MismatchBase2>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MismatchDerived2, std::shared_ptr<MismatchDerived2>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(SamePointer, std::unique_ptr<SamePointer>)
+
 TEST_SUBMODULE(class_, m) {
     // test_instance
     struct NoConstructor {
@@ -168,20 +182,15 @@ TEST_SUBMODULE(class_, m) {
     });
 
     // test_mismatched_holder
-    struct MismatchBase1 { };
-    struct MismatchDerived1 : MismatchBase1 { };
-
-    struct MismatchBase2 { };
-    struct MismatchDerived2 : MismatchBase2 { };
-
     m.def("mismatched_holder_1", []() {
         auto mod = py::module_::import("__main__");
         py::class_<MismatchBase1, std::shared_ptr<MismatchBase1>>(mod, "MismatchBase1");
-        py::class_<MismatchDerived1, MismatchBase1>(mod, "MismatchDerived1");
+        py::class_<MismatchDerived1, std::unique_ptr<MismatchDerived1>,
+                   MismatchBase1>(mod, "MismatchDerived1");
     });
     m.def("mismatched_holder_2", []() {
         auto mod = py::module_::import("__main__");
-        py::class_<MismatchBase2>(mod, "MismatchBase2");
+        py::class_<MismatchBase2, std::unique_ptr<MismatchBase2>>(mod, "MismatchBase2");
         py::class_<MismatchDerived2, std::shared_ptr<MismatchDerived2>,
                    MismatchBase2>(mod, "MismatchDerived2");
     });
@@ -431,7 +440,6 @@ TEST_SUBMODULE(class_, m) {
         .def("throw_something", &PyPrintDestructor::throw_something);
 
     // test_multiple_instances_with_same_pointer
-    struct SamePointer {};
     static SamePointer samePointer;
     py::class_<SamePointer, std::unique_ptr<SamePointer, py::nodelete>>(m, "SamePointer")
         .def(py::init([]() { return &samePointer; }));

From efa7adb578e9605c75d8ff4813a2f85a259c7e1b Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 5 Feb 2021 11:59:23 -0800
Subject: [PATCH 152/206] Adding remaining
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS. static_assert for "necessary
 conditions" for both types of default holder, static_assert for "strict
 conditions" guarded by new
 PYBIND11_STRICT_ASSERTS_CLASS_HOLDER_VS_TYPE_CASTER_MIX. All tests build &
 run as before with unique_ptr as the default holder, all tests build for
 smart_holder as the default holder, even with the strict static_assert.

---
 include/pybind11/pybind11.h           | 20 ++++++-----
 tests/test_factory_constructors.cpp   |  5 +++
 tests/test_methods_and_attributes.cpp |  2 ++
 tests/test_multiple_inheritance.cpp   | 48 +++++++++++++++++----------
 4 files changed, 50 insertions(+), 25 deletions(-)

diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index a0ca3961de..c4dc9d08fe 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1287,6 +1287,18 @@ class class_ : public detail::generic_type {
                 none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
             "Error: multiple inheritance bases must be specified via class_ template options");
 
+        static constexpr bool holder_is_smart_holder = std::is_same<holder_type, smart_holder>::value;
+        static constexpr bool type_caster_type_is_smart_holder_type_caster = detail::is_smart_holder_type_caster<type>::value;
+        static constexpr bool type_caster_type_is_type_caster_base_subtype = std::is_base_of<detail::type_caster_base<type>, detail::type_caster<type>>::value;
+        // Necessary conditions, but not strict.
+        static_assert(!(detail::is_instantiation<std::unique_ptr, holder_type>::value && type_caster_type_is_smart_holder_type_caster));
+        static_assert(!(detail::is_instantiation<std::shared_ptr, holder_type>::value && type_caster_type_is_smart_holder_type_caster));
+        static_assert(!(holder_is_smart_holder && type_caster_type_is_type_caster_base_subtype));
+#ifdef PYBIND11_STRICT_ASSERTS_CLASS_HOLDER_VS_TYPE_CASTER_MIX
+        // Strict conditions cannot be enforced universally at the moment (PR #2836).
+        static_assert(holder_is_smart_holder == type_caster_type_is_smart_holder_type_caster);
+        static_assert(!holder_is_smart_holder == type_caster_type_is_type_caster_base_subtype);
+#endif
         type_record record;
         record.scope = scope;
         record.name = name;
@@ -1299,15 +1311,7 @@ class class_ : public detail::generic_type {
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
         record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
 #else
-        static constexpr bool holder_is_smart_holder = std::is_same<holder_type, smart_holder>::value;
         record.default_holder = holder_is_smart_holder;
-#if 0
-        static constexpr bool type_caster_type_is_smart_holder_type_caster = detail::is_smart_holder_type_caster<type>::value;
-        static constexpr bool type_caster_type_is_type_caster_base_subtype = std::is_base_of<detail::type_caster_base<type>, detail::type_caster<type>>::value;
-        static_assert(!(detail::is_instantiation<std::unique_ptr, holder_type>::value && type_caster_type_is_smart_holder_type_caster));
-        static_assert(!(detail::is_instantiation<std::shared_ptr, holder_type>::value && type_caster_type_is_smart_holder_type_caster));
-        static_assert(!(holder_is_smart_holder && type_caster_type_is_type_caster_base_subtype));
-#endif
 #endif
         set_operator_new<type>(&record);
 
diff --git a/tests/test_factory_constructors.cpp b/tests/test_factory_constructors.cpp
index 7ff7e7b52c..26d081dc38 100644
--- a/tests/test_factory_constructors.cpp
+++ b/tests/test_factory_constructors.cpp
@@ -139,6 +139,11 @@ class TestFactoryHelper {
     static std::shared_ptr<TestFactory3> construct3(int a) { return std::shared_ptr<TestFactory3>(new TestFactory3(a)); }
 };
 
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(TestFactory3, std::shared_ptr<TestFactory3>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(TestFactory4, std::shared_ptr<TestFactory4>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(TestFactory5, std::shared_ptr<TestFactory5>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(TestFactory7, std::shared_ptr<TestFactory7>)
+
 TEST_SUBMODULE(factory_constructors, m) {
 
     // Define various trivial types to allow simpler overload resolution:
diff --git a/tests/test_methods_and_attributes.cpp b/tests/test_methods_and_attributes.cpp
index 30202bcba5..a53bc611fb 100644
--- a/tests/test_methods_and_attributes.cpp
+++ b/tests/test_methods_and_attributes.cpp
@@ -150,6 +150,8 @@ struct RefQualified {
     int constRefQualified(int other) const & { return value + other; }
 };
 
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(NoneTester, std::shared_ptr<NoneTester>)
+
 TEST_SUBMODULE(methods_and_attributes, m) {
     // test_methods_and_attributes
     py::class_<ExampleMandA> emna(m, "ExampleMandA");
diff --git a/tests/test_multiple_inheritance.cpp b/tests/test_multiple_inheritance.cpp
index e67200809d..f4d1b63fcb 100644
--- a/tests/test_multiple_inheritance.cpp
+++ b/tests/test_multiple_inheritance.cpp
@@ -43,6 +43,37 @@ int WithStatic2::static_value2 = 2;
 int VanillaStaticMix1::static_value = 12;
 int VanillaStaticMix2::static_value = 12;
 
+namespace {
+
+    struct Base1a {
+        Base1a(int i) : i(i) { }
+        int foo() { return i; }
+        int i;
+    };
+    struct Base2a {
+        Base2a(int i) : i(i) { }
+        int bar() { return i; }
+        int i;
+    };
+    struct Base12a : Base1a, Base2a {
+        Base12a(int i, int j) : Base1a(i), Base2a(j) { }
+    };
+
+    struct I801B1 { int a = 1; I801B1() = default; I801B1(const I801B1 &) = default; virtual ~I801B1() = default; };
+    struct I801B2 { int b = 2; I801B2() = default; I801B2(const I801B2 &) = default; virtual ~I801B2() = default; };
+    struct I801C : I801B1, I801B2 {};
+    struct I801D : I801C {}; // Indirect MI
+
+} // namespace anonymous
+
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(Base1a, std::shared_ptr<Base1a>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(Base2a, std::shared_ptr<Base2a>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(Base12a, std::shared_ptr<Base12a>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(I801B1, std::shared_ptr<I801B1>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(I801B2, std::shared_ptr<I801B2>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(I801C, std::shared_ptr<I801C>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(I801D, std::shared_ptr<I801D>)
+
 TEST_SUBMODULE(multiple_inheritance, m) {
 
     // test_multiple_inheritance_mix1
@@ -99,27 +130,14 @@ TEST_SUBMODULE(multiple_inheritance, m) {
     // test_multiple_inheritance_virtbase
     // Test the case where not all base classes are specified, and where pybind11 requires the
     // py::multiple_inheritance flag to perform proper casting between types.
-    struct Base1a {
-        Base1a(int i) : i(i) { }
-        int foo() { return i; }
-        int i;
-    };
     py::class_<Base1a, std::shared_ptr<Base1a>>(m, "Base1a")
         .def(py::init<int>())
         .def("foo", &Base1a::foo);
 
-    struct Base2a {
-        Base2a(int i) : i(i) { }
-        int bar() { return i; }
-        int i;
-    };
     py::class_<Base2a, std::shared_ptr<Base2a>>(m, "Base2a")
         .def(py::init<int>())
         .def("bar", &Base2a::bar);
 
-    struct Base12a : Base1a, Base2a {
-        Base12a(int i, int j) : Base1a(i), Base2a(j) { }
-    };
     py::class_<Base12a, /* Base1 missing */ Base2a,
                std::shared_ptr<Base12a>>(m, "Base12a", py::multiple_inheritance())
         .def(py::init<int, int>());
@@ -130,10 +148,6 @@ TEST_SUBMODULE(multiple_inheritance, m) {
     // test_mi_unaligned_base
     // test_mi_base_return
     // Issue #801: invalid casting to derived type with MI bases
-    struct I801B1 { int a = 1; I801B1() = default; I801B1(const I801B1 &) = default; virtual ~I801B1() = default; };
-    struct I801B2 { int b = 2; I801B2() = default; I801B2(const I801B2 &) = default; virtual ~I801B2() = default; };
-    struct I801C : I801B1, I801B2 {};
-    struct I801D : I801C {}; // Indirect MI
     // Unregistered classes:
     struct I801B3 { int c = 3; virtual ~I801B3() = default; };
     struct I801E : I801B3, I801D {};

From 523bfd32c3caa8e4ca11caf1e26407dad77c6e1c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 5 Feb 2021 13:37:06 -0800
Subject: [PATCH 153/206] Introducing check_is_smart_holder_type_caster()
 function for runtime check, and reinterpreting record.default_holder as
 "uses_unique_ptr_holder". With this test_smart_ptr succeeds. (All 42 tests
 build, 35 tests succeed, 5 run but have some failures, 2 segfault.)

---
 include/pybind11/cast.h     | 12 ++++++++++++
 include/pybind11/pybind11.h |  7 +++----
 tests/test_smart_ptr.py     |  7 +++----
 3 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index eb07fda952..530639643e 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1208,11 +1208,18 @@ struct smart_holder_type_caster_class_hooks {
     }
 };
 
+template <typename T>
+inline bool check_is_smart_holder_type_caster();
+
 template <typename T>
 struct smart_holder_type_caster_load {
     using holder_type = pybindit::memory::smart_holder;
 
     bool load(handle src, bool convert) {
+        if (!check_is_smart_holder_type_caster<T>()) {
+            throw cast_error(
+                "Unable to load a smart-pointer type from a non-smart_holder instance.");
+        }
         load_impl = modified_type_caster_generic_load_impl(typeid(T));
         if (!load_impl.load(src, convert))
             return false;
@@ -2411,6 +2418,11 @@ struct is_smart_holder_type_caster<
     T,
     enable_if_t<type_caster<T>::is_smart_holder_type_caster::value, void>> : std::true_type {};
 
+template <typename T>
+inline bool check_is_smart_holder_type_caster() {
+    return detail::is_smart_holder_type_caster<T>::value;
+}
+
 // Detect whether returning a `type` from a cast on type's type_caster is going to result in a
 // reference or pointer to a local variable of the type_caster.  Basically, only
 // non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe;
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index c4dc9d08fe..e1cddbb796 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1308,11 +1308,10 @@ class class_ : public detail::generic_type {
         record.holder_size = sizeof(holder_type);
         record.init_instance = init_instance;
         record.dealloc = dealloc;
-#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+
+        // A better name would be uses_unique_ptr_holder.
         record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
-#else
-        record.default_holder = holder_is_smart_holder;
-#endif
+
         set_operator_new<type>(&record);
 
         /* Register base classes specified via template arguments to class_, if any */
diff --git a/tests/test_smart_ptr.py b/tests/test_smart_ptr.py
index 85f61a3223..592556c9a3 100644
--- a/tests/test_smart_ptr.py
+++ b/tests/test_smart_ptr.py
@@ -302,10 +302,9 @@ def test_smart_ptr_from_default():
     instance = m.HeldByDefaultHolder()
     with pytest.raises(RuntimeError) as excinfo:
         m.HeldByDefaultHolder.load_shared_ptr(instance)
-    assert (
-        "Unable to load a custom holder type from a "
-        "default-holder instance" in str(excinfo.value)
-    )
+    assert str(excinfo.value) in (
+        "Unable to load a smart-pointer type from a non-smart_holder instance.",
+        "Unable to load a custom holder type from a default-holder instance")
 
 
 def test_shared_ptr_gc():

From 706ffbd3306199f0a38c4a5dac75c68a0d8a6ced Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 5 Feb 2021 16:04:58 -0800
Subject: [PATCH 154/206] Bug fix: Adding have_value() to
 smart_holder_type_caster_load. With this test_builtin_casters succeeds. (All
 42 tests build, 36 tests succeed, 5 run but have some failures, 1 segfault.)

---
 include/pybind11/cast.h | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 530639643e..853563cc4a 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1227,10 +1227,12 @@ struct smart_holder_type_caster_load {
     }
 
     T *loaded_as_raw_ptr_unowned() const {
+        if (!have_value()) return nullptr;
         return convert_type(holder().template as_raw_ptr_unowned<void>());
     }
 
     T &loaded_as_lvalue_ref() const {
+        if (!have_value()) throw reference_cast_error();
         static const char *context = "loaded_as_lvalue_ref";
         holder().ensure_is_populated(context);
         holder().ensure_has_pointee(context);
@@ -1238,6 +1240,7 @@ struct smart_holder_type_caster_load {
     }
 
     T &&loaded_as_rvalue_ref() const {
+        if (!have_value()) throw reference_cast_error();
         static const char *context = "loaded_as_rvalue_ref";
         holder().ensure_is_populated(context);
         holder().ensure_has_pointee(context);
@@ -1245,12 +1248,14 @@ struct smart_holder_type_caster_load {
     }
 
     std::shared_ptr<T> loaded_as_shared_ptr() {
+        if (!have_value()) return nullptr;
         std::shared_ptr<void> void_ptr = holder().template as_shared_ptr<void>();
         return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
     }
 
     template <typename D>
     std::unique_ptr<T, D> loaded_as_unique_ptr(const char *context = "loaded_as_unique_ptr") {
+        if (!have_value()) return nullptr;
         holder().template ensure_compatible_rtti_uqp_del<T, D>(context);
         holder().ensure_use_count_1(context);
         auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
@@ -1275,6 +1280,8 @@ struct smart_holder_type_caster_load {
 private:
     modified_type_caster_generic_load_impl load_impl;
 
+    bool have_value() const { return load_impl.loaded_v_h.vh != nullptr; }
+
     holder_type &holder() const { return load_impl.loaded_v_h.holder<holder_type>(); }
 
     T *convert_type(void *void_ptr) const {

From 8176a366605deaf8c516f1495db0190fdacfc789 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 5 Feb 2021 20:18:21 -0800
Subject: [PATCH 155/206] Adding unowned_void_ptr_from_direct_conversion to
 modified_type_caster_generic_load_impl. This fixes the last remaining
 segfault (test_numpy_dtypes). New stats for all tests combined: 12 failed,
 458 passed.

---
 include/pybind11/cast.h | 31 ++++++++++++++++++++++++-------
 1 file changed, 24 insertions(+), 7 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 853563cc4a..9a1a0b4fc0 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1018,8 +1018,9 @@ class modified_type_caster_generic_load_impl {
 
     bool try_direct_conversions(handle src) {
         for (auto &converter : *typeinfo->direct_conversions) {
-            if (converter(src.ptr(), loaded_v_h.value_ptr()))
+            if (converter(src.ptr(), unowned_void_ptr_from_direct_conversion)) {
                 return true;
+            }
         }
         return false;
     }
@@ -1163,6 +1164,7 @@ class modified_type_caster_generic_load_impl {
 
     const type_info *typeinfo = nullptr;
     const std::type_info *cpptype = nullptr;
+    void *unowned_void_ptr_from_direct_conversion = nullptr;
     const std::type_info *loaded_v_h_cpptype = nullptr;
     void *(*implicit_cast)(void *) = nullptr;
     value_and_holder loaded_v_h;
@@ -1227,12 +1229,18 @@ struct smart_holder_type_caster_load {
     }
 
     T *loaded_as_raw_ptr_unowned() const {
-        if (!have_value()) return nullptr;
+        if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
+            // UNTESTED.
+            return convert_type(load_impl.unowned_void_ptr_from_direct_conversion);
+        if (!have_holder()) return nullptr;
         return convert_type(holder().template as_raw_ptr_unowned<void>());
     }
 
     T &loaded_as_lvalue_ref() const {
-        if (!have_value()) throw reference_cast_error();
+        if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
+            // UNTESTED.
+            return *convert_type(load_impl.unowned_void_ptr_from_direct_conversion);
+        if (!have_holder()) throw reference_cast_error();
         static const char *context = "loaded_as_lvalue_ref";
         holder().ensure_is_populated(context);
         holder().ensure_has_pointee(context);
@@ -1240,7 +1248,10 @@ struct smart_holder_type_caster_load {
     }
 
     T &&loaded_as_rvalue_ref() const {
-        if (!have_value()) throw reference_cast_error();
+        if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
+            // UNTESTED.
+            return std::move(*convert_type(load_impl.unowned_void_ptr_from_direct_conversion));
+        if (!have_holder()) throw reference_cast_error();
         static const char *context = "loaded_as_rvalue_ref";
         holder().ensure_is_populated(context);
         holder().ensure_has_pointee(context);
@@ -1248,14 +1259,20 @@ struct smart_holder_type_caster_load {
     }
 
     std::shared_ptr<T> loaded_as_shared_ptr() {
-        if (!have_value()) return nullptr;
+        if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
+            throw cast_error("Unowned pointer from direct conversion cannot be converted to a"
+                             " std::shared_ptr."); // UNTESTED.
+        if (!have_holder()) return nullptr;
         std::shared_ptr<void> void_ptr = holder().template as_shared_ptr<void>();
         return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
     }
 
     template <typename D>
     std::unique_ptr<T, D> loaded_as_unique_ptr(const char *context = "loaded_as_unique_ptr") {
-        if (!have_value()) return nullptr;
+        if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
+            throw cast_error("Unowned pointer from direct conversion cannot be converted to a"
+                             " std::unique_ptr."); // UNTESTED.
+        if (!have_holder()) return nullptr;
         holder().template ensure_compatible_rtti_uqp_del<T, D>(context);
         holder().ensure_use_count_1(context);
         auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
@@ -1280,7 +1297,7 @@ struct smart_holder_type_caster_load {
 private:
     modified_type_caster_generic_load_impl load_impl;
 
-    bool have_value() const { return load_impl.loaded_v_h.vh != nullptr; }
+    bool have_holder() const { return load_impl.loaded_v_h.vh != nullptr; }
 
     holder_type &holder() const { return load_impl.loaded_v_h.holder<holder_type>(); }
 

From 50685242e8c1c4735e0a49cfa6e65edb7e059aba Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 9 Feb 2021 01:00:13 -0800
Subject: [PATCH 156/206] Adding "Lazy allocation for unallocated values" (for
 old-style __init__) into load_value_and_holder. Deferring destruction of
 disowned holder until clear_instance, to remain inspectable for
 "uninitialized" or "disowned" detection. New stats for all tests combined: 5
 failed, 465 passed.

---
 include/pybind11/cast.h                    | 98 ++++++++++++++--------
 include/pybind11/detail/class.h            |  2 +
 include/pybind11/detail/smart_holder_poc.h |  1 +
 tests/test_class_sh_basic.py               |  2 +-
 tests/test_class_sh_unique_ptr_member.py   |  2 +-
 5 files changed, 67 insertions(+), 38 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 9a1a0b4fc0..eb2bc5888f 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -987,16 +987,29 @@ class modified_type_caster_generic_load_impl {
 
     // Base methods for generic caster; there are overridden in copyable_holder_caster
     void load_value_and_holder(value_and_holder &&v_h) {
-        loaded_v_h = std::move(v_h);
-        if (!loaded_v_h.holder_constructed()) {
-            // IMPROVABLE: Error message. A change to the existing internals is
-            // needed to cleanly distinguish between uninitialized or disowned.
-            throw std::runtime_error("Missing value for wrapped C++ type:"
-                                     " Python instance is uninitialized or was disowned.");
-        }
-        if (v_h.value_ptr() == nullptr) {
-            pybind11_fail("smart_holder_type_casters: Unexpected v_h.value_ptr() nullptr.");
+        if (!v_h.holder_constructed()) {
+            // This is needed for old-style __init__.
+            // type_caster_generic::load_value BEGIN
+            auto *&vptr = v_h.value_ptr();
+            // Lazy allocation for unallocated values:
+            if (vptr == nullptr) {
+                // Lazy allocation for unallocated values:
+                auto *type = v_h.type ? v_h.type : typeinfo;
+                if (type->operator_new) {
+                    vptr = type->operator_new(type->type_size);
+                } else {
+                    #if defined(__cpp_aligned_new) && (!defined(_MSC_VER) || _MSC_VER >= 1912)
+                        if (type->type_align > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
+                            vptr = ::operator new(type->type_size,
+                                                  std::align_val_t(type->type_align));
+                        else
+                    #endif
+                    vptr = ::operator new(type->type_size);
+                }
+            }
+            // type_caster_generic::load_value END
         }
+        loaded_v_h = std::move(v_h);
         loaded_v_h.type = typeinfo;
     }
 
@@ -1229,40 +1242,37 @@ struct smart_holder_type_caster_load {
     }
 
     T *loaded_as_raw_ptr_unowned() const {
-        if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
-            // UNTESTED.
-            return convert_type(load_impl.unowned_void_ptr_from_direct_conversion);
-        if (!have_holder()) return nullptr;
-        return convert_type(holder().template as_raw_ptr_unowned<void>());
+        void *void_ptr = load_impl.unowned_void_ptr_from_direct_conversion; // UNTESTED.
+        if (void_ptr == nullptr) {
+            if (have_holder()) {
+                throw_if_uninitialized_or_disowned_holder();
+                void_ptr = holder().template as_raw_ptr_unowned<void>();
+            } else if (load_impl.loaded_v_h.vh != nullptr)
+                void_ptr = load_impl.loaded_v_h.value_ptr();
+            if (void_ptr == nullptr)
+                return nullptr;
+        }
+        return convert_type(void_ptr);
     }
 
     T &loaded_as_lvalue_ref() const {
-        if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
-            // UNTESTED.
-            return *convert_type(load_impl.unowned_void_ptr_from_direct_conversion);
-        if (!have_holder()) throw reference_cast_error();
-        static const char *context = "loaded_as_lvalue_ref";
-        holder().ensure_is_populated(context);
-        holder().ensure_has_pointee(context);
-        return *loaded_as_raw_ptr_unowned();
+        T *raw_ptr = loaded_as_raw_ptr_unowned();
+        if (raw_ptr == nullptr) throw reference_cast_error();
+        return *raw_ptr;
     }
 
     T &&loaded_as_rvalue_ref() const {
-        if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
-            // UNTESTED.
-            return std::move(*convert_type(load_impl.unowned_void_ptr_from_direct_conversion));
-        if (!have_holder()) throw reference_cast_error();
-        static const char *context = "loaded_as_rvalue_ref";
-        holder().ensure_is_populated(context);
-        holder().ensure_has_pointee(context);
-        return std::move(*loaded_as_raw_ptr_unowned());
+        T *raw_ptr = loaded_as_raw_ptr_unowned();
+        if (raw_ptr == nullptr) throw reference_cast_error();
+        return std::move(*raw_ptr);
     }
 
-    std::shared_ptr<T> loaded_as_shared_ptr() {
+    std::shared_ptr<T> loaded_as_shared_ptr() const {
         if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
             throw cast_error("Unowned pointer from direct conversion cannot be converted to a"
                              " std::shared_ptr."); // UNTESTED.
         if (!have_holder()) return nullptr;
+        throw_if_uninitialized_or_disowned_holder();
         std::shared_ptr<void> void_ptr = holder().template as_shared_ptr<void>();
         return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
     }
@@ -1273,6 +1283,7 @@ struct smart_holder_type_caster_load {
             throw cast_error("Unowned pointer from direct conversion cannot be converted to a"
                              " std::unique_ptr."); // UNTESTED.
         if (!have_holder()) return nullptr;
+        throw_if_uninitialized_or_disowned_holder();
         holder().template ensure_compatible_rtti_uqp_del<T, D>(context);
         holder().ensure_use_count_1(context);
         auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
@@ -1284,10 +1295,11 @@ struct smart_holder_type_caster_load {
         holder().release_ownership();
         auto result = std::unique_ptr<T, D>(raw_type_ptr);
 
-        void *value_void_ptr
-            = load_impl.loaded_v_h.value_ptr(); // Expected to be identical to raw_void_ptr.
-        load_impl.loaded_v_h.holder<holder_type>().~holder_type();
-        load_impl.loaded_v_h.set_holder_constructed(false);
+        void *value_void_ptr = load_impl.loaded_v_h.value_ptr();
+        if (value_void_ptr != raw_void_ptr) {
+            pybind11_fail("smart_holder_type_casters: loaded_as_unique_ptr failure:"
+                          " value_void_ptr != raw_void_ptr");
+        }
         load_impl.loaded_v_h.value_ptr() = nullptr;
         deregister_instance(load_impl.loaded_v_h.inst, value_void_ptr, load_impl.loaded_v_h.type);
 
@@ -1297,10 +1309,24 @@ struct smart_holder_type_caster_load {
 private:
     modified_type_caster_generic_load_impl load_impl;
 
-    bool have_holder() const { return load_impl.loaded_v_h.vh != nullptr; }
+    bool have_holder() const {
+        return load_impl.loaded_v_h.vh != nullptr && load_impl.loaded_v_h.holder_constructed();
+    }
 
     holder_type &holder() const { return load_impl.loaded_v_h.holder<holder_type>(); }
 
+    // have_holder() must be true or this function will fail.
+    void throw_if_uninitialized_or_disowned_holder() const {
+        if (!holder().is_populated) {
+            pybind11_fail("Missing value for wrapped C++ type:"
+                          " Python instance is uninitialized.");
+        }
+        if (!holder().has_pointee()) {
+            throw cast_error("Missing value for wrapped C++ type:"
+                             " Python instance was disowned.");
+        }
+    }
+
     T *convert_type(void *void_ptr) const {
         if (void_ptr != nullptr && load_impl.loaded_v_h_cpptype != nullptr
             && !load_impl.reinterpret_cast_deemed_ok && load_impl.implicit_cast != nullptr) {
diff --git a/include/pybind11/detail/class.h b/include/pybind11/detail/class.h
index 2f414e5c7c..f5be75e1a7 100644
--- a/include/pybind11/detail/class.h
+++ b/include/pybind11/detail/class.h
@@ -398,6 +398,8 @@ inline void clear_instance(PyObject *self) {
 
             if (instance->owned || v_h.holder_constructed())
                 v_h.type->dealloc(v_h);
+        } else if (v_h.holder_constructed()) {
+            v_h.type->dealloc(v_h); // Disowned instance.
         }
     }
     // Deallocate the value/holder layout internals:
diff --git a/include/pybind11/detail/smart_holder_poc.h b/include/pybind11/detail/smart_holder_poc.h
index d5c60403a4..5e3fcfaf28 100644
--- a/include/pybind11/detail/smart_holder_poc.h
+++ b/include/pybind11/detail/smart_holder_poc.h
@@ -208,6 +208,7 @@ struct smart_holder {
     void release_ownership() {
         *vptr_deleter_armed_flag_ptr = false;
         vptr.reset();
+        vptr_deleter_armed_flag_ptr.reset();
     }
 
     template <typename T>
diff --git a/tests/test_class_sh_basic.py b/tests/test_class_sh_basic.py
index 1cc9264d67..a78d503f80 100644
--- a/tests/test_class_sh_basic.py
+++ b/tests/test_class_sh_basic.py
@@ -77,7 +77,7 @@ def test_pass_unique_ptr_disowns(rtrn_atyp, pass_atyp, rtrn):
         m.pass_uqmp_atyp(obj)
     assert str(exc_info.value) == (
         "Missing value for wrapped C++ type:"
-        " Python instance is uninitialized or was disowned."
+        " Python instance was disowned."
     )
 
 
diff --git a/tests/test_class_sh_unique_ptr_member.py b/tests/test_class_sh_unique_ptr_member.py
index 5537ac7a98..1528753a5e 100644
--- a/tests/test_class_sh_unique_ptr_member.py
+++ b/tests/test_class_sh_unique_ptr_member.py
@@ -21,7 +21,7 @@ def test_pointee_and_ptr_owner(give_up_ownership_via):
         obj.get_int()
     assert (
         str(exc_info.value)
-        == "Missing value for wrapped C++ type: Python instance is uninitialized or was disowned."
+        == "Missing value for wrapped C++ type: Python instance was disowned."
     )
     assert owner.is_owner()
     reclaimed = getattr(owner, give_up_ownership_via)()

From 64e6a80746d9d91e1717dda851107edeeb73dfd3 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 9 Feb 2021 07:11:30 -0800
Subject: [PATCH 157/206] Changing std::shared_ptr pointer/reference to const
 pointer/reference. New stats for all tests combined: 4 failed, 466 passed.

---
 tests/test_methods_and_attributes.cpp | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/tests/test_methods_and_attributes.cpp b/tests/test_methods_and_attributes.cpp
index a53bc611fb..53855c3671 100644
--- a/tests/test_methods_and_attributes.cpp
+++ b/tests/test_methods_and_attributes.cpp
@@ -112,10 +112,8 @@ UserType TestPropRVP::sv2(1);
 class NoneTester { public: int answer = 42; };
 int none1(const NoneTester &obj) { return obj.answer; }
 int none2(NoneTester *obj) { return obj ? obj->answer : -1; }
-#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
-int none3(std::shared_ptr<NoneTester> &obj) { return obj ? obj->answer : -1; }
-int none4(std::shared_ptr<NoneTester> *obj) { return obj && *obj ? (*obj)->answer : -1; }
-#endif
+int none3(const std::shared_ptr<NoneTester> &obj) { return obj ? obj->answer : -1; }
+int none4(const std::shared_ptr<NoneTester> *obj) { return obj && *obj ? (*obj)->answer : -1; }
 int none5(std::shared_ptr<NoneTester> obj) { return obj ? obj->answer : -1; }
 
 struct StrIssue {
@@ -333,17 +331,13 @@ TEST_SUBMODULE(methods_and_attributes, m) {
         .def(py::init<>());
     m.def("no_none1", &none1, py::arg{}.none(false));
     m.def("no_none2", &none2, py::arg{}.none(false));
-#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
     m.def("no_none3", &none3, py::arg{}.none(false));
     m.def("no_none4", &none4, py::arg{}.none(false));
-#endif
     m.def("no_none5", &none5, py::arg{}.none(false));
     m.def("ok_none1", &none1);
     m.def("ok_none2", &none2, py::arg{}.none(true));
-#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
     m.def("ok_none3", &none3);
     m.def("ok_none4", &none4, py::arg{}.none(true));
-#endif
     m.def("ok_none5", &none5);
 
     m.def("no_none_kwarg", &none2, "a"_a.none(false));

From 2f79cd94ea5b9311820a8fe49ccc834203462974 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 9 Feb 2021 09:02:00 -0800
Subject: [PATCH 158/206] Adding return_value_policy::move to permissible
 policies for unique_ptr returns. New stats for all tests combined: 3 failed,
 467 passed.

---
 include/pybind11/cast.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index eb2bc5888f..c87e077d2f 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1572,7 +1572,8 @@ struct smart_holder_type_caster<std::unique_ptr<T, D>> : smart_holder_type_caste
 
     static handle cast(std::unique_ptr<T, D> &&src, return_value_policy policy, handle parent) {
         if (policy != return_value_policy::automatic
-            && policy != return_value_policy::reference_internal) {
+            && policy != return_value_policy::reference_internal
+            && policy != return_value_policy::move) {
             // IMPROVABLE: Error message.
             throw cast_error("Invalid return_value_policy for unique_ptr.");
         }

From 40a3afa21b79b87a4a67040385628de73b1f421d Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 9 Feb 2021 15:57:59 -0800
Subject: [PATCH 159/206] Overlooked flake8 fixes.

---
 tests/test_class_sh_basic.py | 3 +--
 tests/test_smart_ptr.py      | 3 ++-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/test_class_sh_basic.py b/tests/test_class_sh_basic.py
index a78d503f80..5d75e48117 100644
--- a/tests/test_class_sh_basic.py
+++ b/tests/test_class_sh_basic.py
@@ -76,8 +76,7 @@ def test_pass_unique_ptr_disowns(rtrn_atyp, pass_atyp, rtrn):
     with pytest.raises(RuntimeError) as exc_info:
         m.pass_uqmp_atyp(obj)
     assert str(exc_info.value) == (
-        "Missing value for wrapped C++ type:"
-        " Python instance was disowned."
+        "Missing value for wrapped C++ type: Python instance was disowned."
     )
 
 
diff --git a/tests/test_smart_ptr.py b/tests/test_smart_ptr.py
index 592556c9a3..d4e8e2e063 100644
--- a/tests/test_smart_ptr.py
+++ b/tests/test_smart_ptr.py
@@ -304,7 +304,8 @@ def test_smart_ptr_from_default():
         m.HeldByDefaultHolder.load_shared_ptr(instance)
     assert str(excinfo.value) in (
         "Unable to load a smart-pointer type from a non-smart_holder instance.",
-        "Unable to load a custom holder type from a default-holder instance")
+        "Unable to load a custom holder type from a default-holder instance",
+    )
 
 
 def test_shared_ptr_gc():

From 095d265155dbbe1f28bd5ee68a286dddfc37774a Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 9 Feb 2021 16:14:47 -0800
Subject: [PATCH 160/206] Manipulating failing ConstructorStats test to pass,
 to be able to run all tests with ASAN.

This version of the code is ASAN clean with unique_ptr or smart_holder as the default.

This change needs to be reverted after adopting the existing move-only-if-refcount-is-1
logic used by type_caster_base.
---
 tests/test_factory_constructors.py   | 12 ++++++------
 tests/test_methods_and_attributes.py |  2 +-
 tests/test_virtual_functions.py      |  2 +-
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/tests/test_factory_constructors.py b/tests/test_factory_constructors.py
index ffcce6fd4d..e28be2de26 100644
--- a/tests/test_factory_constructors.py
+++ b/tests/test_factory_constructors.py
@@ -177,10 +177,10 @@ def test_init_factory_alias():
     assert f.has_alias()
 
     assert ConstructorStats.detail_reg_inst() == n_inst + 6
-    assert [i.alive() for i in cstats] == [6, 4]
+    assert [i.alive() for i in cstats] in ([6, 4], [6, 2])  # SMART_HOLDER_WIP
 
     del a, b, e
-    assert [i.alive() for i in cstats] == [3, 3]
+    assert [i.alive() for i in cstats] in ([3, 3], [3, 2])  # SMART_HOLDER_WIP
     assert ConstructorStats.detail_reg_inst() == n_inst + 3
     del f, c, d
     assert [i.alive() for i in cstats] == [0, 0]
@@ -214,10 +214,10 @@ def get(self):
     assert [i.alive() for i in cstats] == [0, 0]
     assert ConstructorStats.detail_reg_inst() == n_inst
 
-    assert [i.values() for i in cstats] == [
-        ["1", "8", "3", "4", "5", "6", "123", "10", "47"],
-        ["hi there", "3", "4", "6", "move", "123", "why hello!", "move", "47"],
-    ]
+    line1 = ["1", "8", "3", "4", "5", "6", "123", "10", "47"]
+    line2 = ["hi there", "3", "4", "6", "move", "123", "why hello!", "move", "47"]
+    line2b = line2[:-2] + ["move", "10"] + line2[-2:]  # SMART_HOLDER_WIP
+    assert [i.values() for i in cstats] in ([line1, line2], [line1, line2b])
 
 
 def test_init_factory_dual():
diff --git a/tests/test_methods_and_attributes.py b/tests/test_methods_and_attributes.py
index 2aaf9331fd..28e9afe3b4 100644
--- a/tests/test_methods_and_attributes.py
+++ b/tests/test_methods_and_attributes.py
@@ -62,7 +62,7 @@ def test_methods_and_attributes():
     assert cstats.alive() == 0
     assert cstats.values() == ["32"]
     assert cstats.default_constructions == 1
-    assert cstats.copy_constructions == 2
+    assert cstats.copy_constructions in (2, 1)  # SMART_HOLDER_WIP
     assert cstats.move_constructions >= 2
     assert cstats.copy_assignments == 0
     assert cstats.move_assignments == 0
diff --git a/tests/test_virtual_functions.py b/tests/test_virtual_functions.py
index f7d3bd1e4b..4619d5f78f 100644
--- a/tests/test_virtual_functions.py
+++ b/tests/test_virtual_functions.py
@@ -230,7 +230,7 @@ def get_movable(self, a, b):
     assert nc_stats.values() == ["4", "9", "9", "9"]
     assert mv_stats.values() == ["4", "5", "7", "7"]
     assert nc_stats.copy_constructions == 0
-    assert mv_stats.copy_constructions == 1
+    assert mv_stats.copy_constructions in (1, 0)  # SMART_HOLDER_WIP
     assert nc_stats.move_constructions >= 0
     assert mv_stats.move_constructions >= 0
 

From dab4495ac3923fa7300b47ad2b964d20d05d2149 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 11 Feb 2021 18:00:22 -0800
Subject: [PATCH 161/206] Adding copy constructor and move constructor tracking
 to atyp. Preparation for a follow-up change in smart_holder_type_caster, to
 make this test sensitive to the changing behavior.

[skip ci]
---
 tests/test_class_sh_basic.cpp |  4 ++++
 tests/test_class_sh_basic.py  | 30 +++++++++++++++---------------
 2 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/tests/test_class_sh_basic.cpp b/tests/test_class_sh_basic.cpp
index c1cacccf96..415841f3e7 100644
--- a/tests/test_class_sh_basic.cpp
+++ b/tests/test_class_sh_basic.cpp
@@ -10,6 +10,10 @@ namespace class_sh_basic {
 
 struct atyp { // Short for "any type".
     std::string mtxt;
+    atyp() : mtxt("DefaultConstructor") {}
+    atyp(const std::string &mtxt_) : mtxt(mtxt_) {}
+    atyp(const atyp &other) { mtxt = other.mtxt + ".CpCtor"; }
+    atyp(atyp &&other) { mtxt = other.mtxt + ".MvCtor"; }
 };
 
 // clang-format off
diff --git a/tests/test_class_sh_basic.py b/tests/test_class_sh_basic.py
index 5d75e48117..7c665e47ad 100644
--- a/tests/test_class_sh_basic.py
+++ b/tests/test_class_sh_basic.py
@@ -14,21 +14,21 @@ def test_atyp_constructors():
 
 
 def test_cast():
-    assert m.get_mtxt(m.rtrn_valu_atyp()) == "rtrn_valu"
-    assert m.get_mtxt(m.rtrn_rref_atyp()) == "rtrn_rref"
-    assert m.get_mtxt(m.rtrn_cref_atyp()) == "rtrn_cref"
-    assert m.get_mtxt(m.rtrn_mref_atyp()) == "rtrn_mref"
+    assert m.get_mtxt(m.rtrn_valu_atyp()) == "rtrn_valu.MvCtor"
+    assert m.get_mtxt(m.rtrn_rref_atyp()) == "rtrn_rref.MvCtor"
+    assert m.get_mtxt(m.rtrn_cref_atyp()) == "rtrn_cref.CpCtor"
+    assert m.get_mtxt(m.rtrn_mref_atyp()) == "rtrn_mref.CpCtor"
     assert m.get_mtxt(m.rtrn_cptr_atyp()) == "rtrn_cptr"
     assert m.get_mtxt(m.rtrn_mptr_atyp()) == "rtrn_mptr"
 
 
 def test_load():
-    assert m.pass_valu_atyp(m.atyp("Valu")) == "pass_valu:Valu"
-    assert m.pass_rref_atyp(m.atyp("Rref")) == "pass_rref:Rref"
-    assert m.pass_cref_atyp(m.atyp("Cref")) == "pass_cref:Cref"
-    assert m.pass_mref_atyp(m.atyp("Mref")) == "pass_mref:Mref"
-    assert m.pass_cptr_atyp(m.atyp("Cptr")) == "pass_cptr:Cptr"
-    assert m.pass_mptr_atyp(m.atyp("Mptr")) == "pass_mptr:Mptr"
+    assert m.pass_valu_atyp(m.atyp("Valu")) == "pass_valu:Valu.MvCtor.MvCtor"
+    assert m.pass_rref_atyp(m.atyp("Rref")) == "pass_rref:Rref.MvCtor"
+    assert m.pass_cref_atyp(m.atyp("Cref")) == "pass_cref:Cref.MvCtor"
+    assert m.pass_mref_atyp(m.atyp("Mref")) == "pass_mref:Mref.MvCtor"
+    assert m.pass_cptr_atyp(m.atyp("Cptr")) == "pass_cptr:Cptr.MvCtor"
+    assert m.pass_mptr_atyp(m.atyp("Mptr")) == "pass_mptr:Mptr.MvCtor"
 
 
 def test_cast_shared_ptr():
@@ -37,8 +37,8 @@ def test_cast_shared_ptr():
 
 
 def test_load_shared_ptr():
-    assert m.pass_shmp_atyp(m.atyp("Shmp")) == "pass_shmp:Shmp"
-    assert m.pass_shcp_atyp(m.atyp("Shcp")) == "pass_shcp:Shcp"
+    assert m.pass_shmp_atyp(m.atyp("Shmp")) == "pass_shmp:Shmp.MvCtor"
+    assert m.pass_shcp_atyp(m.atyp("Shcp")) == "pass_shcp:Shcp.MvCtor"
 
 
 def test_cast_unique_ptr():
@@ -47,8 +47,8 @@ def test_cast_unique_ptr():
 
 
 def test_load_unique_ptr():
-    assert m.pass_uqmp_atyp(m.atyp("Uqmp")) == "pass_uqmp:Uqmp"
-    assert m.pass_uqcp_atyp(m.atyp("Uqcp")) == "pass_uqcp:Uqcp"
+    assert m.pass_uqmp_atyp(m.atyp("Uqmp")) == "pass_uqmp:Uqmp.MvCtor"
+    assert m.pass_uqcp_atyp(m.atyp("Uqcp")) == "pass_uqcp:Uqcp.MvCtor"
 
 
 def test_cast_unique_ptr_with_deleter():
@@ -86,7 +86,7 @@ def test_unique_ptr_roundtrip(num_round_trips=1000):
     for _ in range(num_round_trips):
         id_orig = id(recycled)
         recycled = m.unique_ptr_roundtrip(recycled)
-        assert m.get_mtxt(recycled) == "passenger"
+        assert m.get_mtxt(recycled) == "passenger.MvCtor"
         id_rtrn = id(recycled)
         # Ensure the returned object is a different Python instance.
         assert id_rtrn != id_orig

From 20446f1abad116d8725d80a22352d437f9ef7801 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 11 Feb 2021 18:28:39 -0800
Subject: [PATCH 162/206] Removing `operator T&&() &&` from
 smart_holder_type_caster, for compatibility with the behavior of
 type_caster_base. Enables reverting 2 of 3 test manipulations applied under
 commit 249df7cbdb09817fed0ddf80f01ba5af12466820. The manipulation in
 test_factory_constructors.py is NOT reverted in this commit.

[skip ci]
---
 include/pybind11/cast.h              | 14 +++++---------
 tests/test_class_sh_basic.py         |  4 ++--
 tests/test_methods_and_attributes.py |  2 +-
 tests/test_virtual_functions.py      |  2 +-
 4 files changed, 9 insertions(+), 13 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index c87e077d2f..2e3f6ff9d0 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1392,19 +1392,15 @@ struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
     using cast_op_type = conditional_t<
         std::is_same<remove_reference_t<T_>, T const *>::value,
         T const *,
-        conditional_t<
-            std::is_same<remove_reference_t<T_>, T *>::value,
-            T *,
-            conditional_t<std::is_same<T_, T const &>::value,
-                          T const &,
-                          conditional_t<std::is_same<T_, T &>::value,
-                                        T &,
-                                        conditional_t<std::is_same<T_, T &&>::value, T &&, T>>>>>;
+        conditional_t<std::is_same<remove_reference_t<T_>, T *>::value,
+                      T *,
+                      conditional_t<std::is_same<T_, T const &>::value,
+                                    T const &,
+                                    conditional_t<std::is_same<T_, T &>::value, T &, T>>>>;
 
     // clang-format off
 
     operator T()        { return this->loaded_as_lvalue_ref(); }
-    operator T&&() &&   { return this->loaded_as_rvalue_ref(); }
     operator T const&() { return this->loaded_as_lvalue_ref(); }
     operator T&()       { return this->loaded_as_lvalue_ref(); }
     operator T const*() { return this->loaded_as_raw_ptr_unowned(); }
diff --git a/tests/test_class_sh_basic.py b/tests/test_class_sh_basic.py
index 7c665e47ad..8792c7cb8c 100644
--- a/tests/test_class_sh_basic.py
+++ b/tests/test_class_sh_basic.py
@@ -23,8 +23,8 @@ def test_cast():
 
 
 def test_load():
-    assert m.pass_valu_atyp(m.atyp("Valu")) == "pass_valu:Valu.MvCtor.MvCtor"
-    assert m.pass_rref_atyp(m.atyp("Rref")) == "pass_rref:Rref.MvCtor"
+    assert m.pass_valu_atyp(m.atyp("Valu")) == "pass_valu:Valu.MvCtor.CpCtor"
+    assert m.pass_rref_atyp(m.atyp("Rref")) == "pass_rref:Rref.MvCtor.CpCtor"
     assert m.pass_cref_atyp(m.atyp("Cref")) == "pass_cref:Cref.MvCtor"
     assert m.pass_mref_atyp(m.atyp("Mref")) == "pass_mref:Mref.MvCtor"
     assert m.pass_cptr_atyp(m.atyp("Cptr")) == "pass_cptr:Cptr.MvCtor"
diff --git a/tests/test_methods_and_attributes.py b/tests/test_methods_and_attributes.py
index 28e9afe3b4..2aaf9331fd 100644
--- a/tests/test_methods_and_attributes.py
+++ b/tests/test_methods_and_attributes.py
@@ -62,7 +62,7 @@ def test_methods_and_attributes():
     assert cstats.alive() == 0
     assert cstats.values() == ["32"]
     assert cstats.default_constructions == 1
-    assert cstats.copy_constructions in (2, 1)  # SMART_HOLDER_WIP
+    assert cstats.copy_constructions == 2
     assert cstats.move_constructions >= 2
     assert cstats.copy_assignments == 0
     assert cstats.move_assignments == 0
diff --git a/tests/test_virtual_functions.py b/tests/test_virtual_functions.py
index 4619d5f78f..f7d3bd1e4b 100644
--- a/tests/test_virtual_functions.py
+++ b/tests/test_virtual_functions.py
@@ -230,7 +230,7 @@ def get_movable(self, a, b):
     assert nc_stats.values() == ["4", "9", "9", "9"]
     assert mv_stats.values() == ["4", "5", "7", "7"]
     assert nc_stats.copy_constructions == 0
-    assert mv_stats.copy_constructions in (1, 0)  # SMART_HOLDER_WIP
+    assert mv_stats.copy_constructions == 1
     assert nc_stats.move_constructions >= 0
     assert mv_stats.move_constructions >= 0
 

From bb797034bfbfb1c370d9516d24c7fdff3ef5c2c3 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 11 Feb 2021 19:56:22 -0800
Subject: [PATCH 163/206] Fixing unfortunate editing mishap. This reverts the
 last remaining test manipulation in commit
 249df7cbdb09817fed0ddf80f01ba5af12466820 and makes all existing unit tests
 pass with smart_holder as default holder.

---
 include/pybind11/detail/init.h     |  3 +--
 tests/test_factory_constructors.py | 12 ++++++------
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index 132b5c3d78..b351f21d1e 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -162,8 +162,7 @@ void construct(value_and_holder &v_h, Cpp<Class> &&result, bool need_alias) {
 // return-by-value version 2: returning a value of the alias type itself.  We move-construct an
 // Alias instance (even if no the python-side inheritance is involved).  The is intended for
 // cases where Alias initialization is always desired.
-template <typename Class,
-          detail::enable_if_t<!detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+template <typename Class>
 void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
     static_assert(std::is_move_constructible<Alias<Class>>::value,
         "pybind11::init() return-by-alias-value factory function requires a movable alias class");
diff --git a/tests/test_factory_constructors.py b/tests/test_factory_constructors.py
index e28be2de26..ffcce6fd4d 100644
--- a/tests/test_factory_constructors.py
+++ b/tests/test_factory_constructors.py
@@ -177,10 +177,10 @@ def test_init_factory_alias():
     assert f.has_alias()
 
     assert ConstructorStats.detail_reg_inst() == n_inst + 6
-    assert [i.alive() for i in cstats] in ([6, 4], [6, 2])  # SMART_HOLDER_WIP
+    assert [i.alive() for i in cstats] == [6, 4]
 
     del a, b, e
-    assert [i.alive() for i in cstats] in ([3, 3], [3, 2])  # SMART_HOLDER_WIP
+    assert [i.alive() for i in cstats] == [3, 3]
     assert ConstructorStats.detail_reg_inst() == n_inst + 3
     del f, c, d
     assert [i.alive() for i in cstats] == [0, 0]
@@ -214,10 +214,10 @@ def get(self):
     assert [i.alive() for i in cstats] == [0, 0]
     assert ConstructorStats.detail_reg_inst() == n_inst
 
-    line1 = ["1", "8", "3", "4", "5", "6", "123", "10", "47"]
-    line2 = ["hi there", "3", "4", "6", "move", "123", "why hello!", "move", "47"]
-    line2b = line2[:-2] + ["move", "10"] + line2[-2:]  # SMART_HOLDER_WIP
-    assert [i.values() for i in cstats] in ([line1, line2], [line1, line2b])
+    assert [i.values() for i in cstats] == [
+        ["1", "8", "3", "4", "5", "6", "123", "10", "47"],
+        ["hi there", "3", "4", "6", "move", "123", "why hello!", "move", "47"],
+    ]
 
 
 def test_init_factory_dual():

From 8736910645b59376854db8b8af0e2386505e4da8 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 11 Feb 2021 20:40:15 -0800
Subject: [PATCH 164/206] GitHub CI clang-tidy fixes.

---
 tests/test_multiple_inheritance.cpp | 2 +-
 tests/test_smart_ptr.cpp            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/test_multiple_inheritance.cpp b/tests/test_multiple_inheritance.cpp
index f4d1b63fcb..f1aea0340f 100644
--- a/tests/test_multiple_inheritance.cpp
+++ b/tests/test_multiple_inheritance.cpp
@@ -64,7 +64,7 @@ namespace {
     struct I801C : I801B1, I801B2 {};
     struct I801D : I801C {}; // Indirect MI
 
-} // namespace anonymous
+} // namespace
 
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(Base1a, std::shared_ptr<Base1a>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(Base2a, std::shared_ptr<Base2a>)
diff --git a/tests/test_smart_ptr.cpp b/tests/test_smart_ptr.cpp
index de8bb44973..ab649f7257 100644
--- a/tests/test_smart_ptr.cpp
+++ b/tests/test_smart_ptr.cpp
@@ -269,7 +269,7 @@ namespace {
         void add(std::shared_ptr<ElementBase> e) { l.push_back(e); }
         std::vector<std::shared_ptr<ElementBase>> l;
     };
-}
+} // namespace
 
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(Object, ref<Object>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject1, ref<MyObject1>)

From 52238cb9ba0714ec78fc4f66aa1dd550408be291 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Thu, 11 Feb 2021 21:00:25 -0800
Subject: [PATCH 165/206] Adding messages to terse `static_assert`s, for
 pre-C++17 compatibility.

---
 include/pybind11/pybind11.h | 24 +++++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index e1cddbb796..11e75b8474 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1291,13 +1291,27 @@ class class_ : public detail::generic_type {
         static constexpr bool type_caster_type_is_smart_holder_type_caster = detail::is_smart_holder_type_caster<type>::value;
         static constexpr bool type_caster_type_is_type_caster_base_subtype = std::is_base_of<detail::type_caster_base<type>, detail::type_caster<type>>::value;
         // Necessary conditions, but not strict.
-        static_assert(!(detail::is_instantiation<std::unique_ptr, holder_type>::value && type_caster_type_is_smart_holder_type_caster));
-        static_assert(!(detail::is_instantiation<std::shared_ptr, holder_type>::value && type_caster_type_is_smart_holder_type_caster));
-        static_assert(!(holder_is_smart_holder && type_caster_type_is_type_caster_base_subtype));
+        static_assert(!(detail::is_instantiation<std::unique_ptr, holder_type>::value &&
+                        type_caster_type_is_smart_holder_type_caster),
+                      "py::class_ holder vs type_caster mismatch:"
+                      " missing PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, std::unique_ptr<T>)?");
+        static_assert(!(detail::is_instantiation<std::shared_ptr, holder_type>::value &&
+                        type_caster_type_is_smart_holder_type_caster),
+                      "py::class_ holder vs type_caster mismatch:"
+                      " missing PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, std::shared_ptr<T>)?");
+        static_assert(!(holder_is_smart_holder && type_caster_type_is_type_caster_base_subtype),
+                      "py::class_ holder vs type_caster mismatch:"
+                      " missing PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)?");
 #ifdef PYBIND11_STRICT_ASSERTS_CLASS_HOLDER_VS_TYPE_CASTER_MIX
         // Strict conditions cannot be enforced universally at the moment (PR #2836).
-        static_assert(holder_is_smart_holder == type_caster_type_is_smart_holder_type_caster);
-        static_assert(!holder_is_smart_holder == type_caster_type_is_type_caster_base_subtype);
+        static_assert(holder_is_smart_holder == type_caster_type_is_smart_holder_type_caster,
+                      "py::class_ holder vs type_caster mismatch:"
+                      " missing PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)"
+                      " or collision with custom py::detail::type_caster<T>?");
+        static_assert(!holder_is_smart_holder == type_caster_type_is_type_caster_base_subtype,
+                      "py::class_ holder vs type_caster mismatch:"
+                      " missing PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, ...)"
+                      " or collision with custom py::detail::type_caster<T>?");
 #endif
         type_record record;
         record.scope = scope;

From 3346a615d171e52a9b421616507f640038f3efc9 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 12 Feb 2021 06:43:15 -0800
Subject: [PATCH 166/206] Using @pytest.mark.parametrize to run each assert
 separately (to see all errors, not just the first).

---
 tests/test_class_sh_basic.py | 105 ++++++++++++++++++-----------------
 1 file changed, 54 insertions(+), 51 deletions(-)

diff --git a/tests/test_class_sh_basic.py b/tests/test_class_sh_basic.py
index 8792c7cb8c..bceabd1328 100644
--- a/tests/test_class_sh_basic.py
+++ b/tests/test_class_sh_basic.py
@@ -13,68 +13,71 @@ def test_atyp_constructors():
     assert obj.__class__.__name__ == "atyp"
 
 
-def test_cast():
-    assert m.get_mtxt(m.rtrn_valu_atyp()) == "rtrn_valu.MvCtor"
-    assert m.get_mtxt(m.rtrn_rref_atyp()) == "rtrn_rref.MvCtor"
-    assert m.get_mtxt(m.rtrn_cref_atyp()) == "rtrn_cref.CpCtor"
-    assert m.get_mtxt(m.rtrn_mref_atyp()) == "rtrn_mref.CpCtor"
-    assert m.get_mtxt(m.rtrn_cptr_atyp()) == "rtrn_cptr"
-    assert m.get_mtxt(m.rtrn_mptr_atyp()) == "rtrn_mptr"
-
-
-def test_load():
-    assert m.pass_valu_atyp(m.atyp("Valu")) == "pass_valu:Valu.MvCtor.CpCtor"
-    assert m.pass_rref_atyp(m.atyp("Rref")) == "pass_rref:Rref.MvCtor.CpCtor"
-    assert m.pass_cref_atyp(m.atyp("Cref")) == "pass_cref:Cref.MvCtor"
-    assert m.pass_mref_atyp(m.atyp("Mref")) == "pass_mref:Mref.MvCtor"
-    assert m.pass_cptr_atyp(m.atyp("Cptr")) == "pass_cptr:Cptr.MvCtor"
-    assert m.pass_mptr_atyp(m.atyp("Mptr")) == "pass_mptr:Mptr.MvCtor"
-
-
-def test_cast_shared_ptr():
-    assert m.get_mtxt(m.rtrn_shmp_atyp()) == "rtrn_shmp"
-    assert m.get_mtxt(m.rtrn_shcp_atyp()) == "rtrn_shcp"
-
-
-def test_load_shared_ptr():
-    assert m.pass_shmp_atyp(m.atyp("Shmp")) == "pass_shmp:Shmp.MvCtor"
-    assert m.pass_shcp_atyp(m.atyp("Shcp")) == "pass_shcp:Shcp.MvCtor"
-
-
-def test_cast_unique_ptr():
-    assert m.get_mtxt(m.rtrn_uqmp_atyp()) == "rtrn_uqmp"
-    assert m.get_mtxt(m.rtrn_uqcp_atyp()) == "rtrn_uqcp"
-
-
-def test_load_unique_ptr():
-    assert m.pass_uqmp_atyp(m.atyp("Uqmp")) == "pass_uqmp:Uqmp.MvCtor"
-    assert m.pass_uqcp_atyp(m.atyp("Uqcp")) == "pass_uqcp:Uqcp.MvCtor"
+@pytest.mark.parametrize(
+    "rtrn_f, expected",
+    [
+        (m.rtrn_valu_atyp, "rtrn_valu.MvCtor"),
+        (m.rtrn_rref_atyp, "rtrn_rref.MvCtor"),
+        (m.rtrn_cref_atyp, "rtrn_cref.CpCtor"),
+        (m.rtrn_mref_atyp, "rtrn_mref.CpCtor"),
+        (m.rtrn_cptr_atyp, "rtrn_cptr"),
+        (m.rtrn_mptr_atyp, "rtrn_mptr"),
+        (m.rtrn_shmp_atyp, "rtrn_shmp"),
+        (m.rtrn_shcp_atyp, "rtrn_shcp"),
+        (m.rtrn_uqmp_atyp, "rtrn_uqmp"),
+        (m.rtrn_uqcp_atyp, "rtrn_uqcp"),
+        (m.rtrn_udmp_atyp, "rtrn_udmp"),
+        (m.rtrn_udcp_atyp, "rtrn_udcp"),
+    ],
+)
+def test_cast(rtrn_f, expected):
+    assert m.get_mtxt(rtrn_f()) == expected
 
 
-def test_cast_unique_ptr_with_deleter():
-    assert m.get_mtxt(m.rtrn_udmp_atyp()) == "rtrn_udmp"
-    assert m.get_mtxt(m.rtrn_udcp_atyp()) == "rtrn_udcp"
+@pytest.mark.parametrize(
+    "pass_f, mtxt, expected",
+    [
+        (m.pass_valu_atyp, "Valu", "pass_valu:Valu.MvCtor.CpCtor"),
+        (m.pass_rref_atyp, "Rref", "pass_rref:Rref.MvCtor.CpCtor"),
+        (m.pass_cref_atyp, "Cref", "pass_cref:Cref.MvCtor"),
+        (m.pass_mref_atyp, "Mref", "pass_mref:Mref.MvCtor"),
+        (m.pass_cptr_atyp, "Cptr", "pass_cptr:Cptr.MvCtor"),
+        (m.pass_mptr_atyp, "Mptr", "pass_mptr:Mptr.MvCtor"),
+        (m.pass_shmp_atyp, "Shmp", "pass_shmp:Shmp.MvCtor"),
+        (m.pass_shcp_atyp, "Shcp", "pass_shcp:Shcp.MvCtor"),
+        (m.pass_uqmp_atyp, "Uqmp", "pass_uqmp:Uqmp.MvCtor"),
+        (m.pass_uqcp_atyp, "Uqcp", "pass_uqcp:Uqcp.MvCtor"),
+    ],
+)
+def test_load_with_mtxt(pass_f, mtxt, expected):
+    assert pass_f(m.atyp(mtxt)) == expected
 
 
-def test_load_unique_ptr_with_deleter():
-    assert m.pass_udmp_atyp(m.rtrn_udmp_atyp()) == "pass_udmp:rtrn_udmp"
-    assert m.pass_udcp_atyp(m.rtrn_udcp_atyp()) == "pass_udcp:rtrn_udcp"
+@pytest.mark.parametrize(
+    "pass_f, rtrn_f, expected",
+    [
+        (m.pass_udmp_atyp, m.rtrn_udmp_atyp, "pass_udmp:rtrn_udmp"),
+        (m.pass_udcp_atyp, m.rtrn_udcp_atyp, "pass_udcp:rtrn_udcp"),
+    ],
+)
+def test_load_with_rtrn_f(pass_f, rtrn_f, expected):
+    assert pass_f(rtrn_f()) == expected
 
 
 @pytest.mark.parametrize(
-    "rtrn_atyp, pass_atyp, rtrn",
+    "pass_f, rtrn_f, expected",
     [
-        (m.rtrn_uqmp_atyp, m.pass_uqmp_atyp, "pass_uqmp:rtrn_uqmp"),
-        (m.rtrn_uqcp_atyp, m.pass_uqcp_atyp, "pass_uqcp:rtrn_uqcp"),
-        (m.rtrn_udmp_atyp, m.pass_udmp_atyp, "pass_udmp:rtrn_udmp"),
-        (m.rtrn_udcp_atyp, m.pass_udcp_atyp, "pass_udcp:rtrn_udcp"),
+        (m.pass_uqmp_atyp, m.rtrn_uqmp_atyp, "pass_uqmp:rtrn_uqmp"),
+        (m.pass_uqcp_atyp, m.rtrn_uqcp_atyp, "pass_uqcp:rtrn_uqcp"),
+        (m.pass_udmp_atyp, m.rtrn_udmp_atyp, "pass_udmp:rtrn_udmp"),
+        (m.pass_udcp_atyp, m.rtrn_udcp_atyp, "pass_udcp:rtrn_udcp"),
     ],
 )
-def test_pass_unique_ptr_disowns(rtrn_atyp, pass_atyp, rtrn):
-    obj = rtrn_atyp()
-    assert pass_atyp(obj) == rtrn
+def test_pass_unique_ptr_disowns(pass_f, rtrn_f, expected):
+    obj = rtrn_f()
+    assert pass_f(obj) == expected
     with pytest.raises(RuntimeError) as exc_info:
-        m.pass_uqmp_atyp(obj)
+        pass_f(obj)
     assert str(exc_info.value) == (
         "Missing value for wrapped C++ type: Python instance was disowned."
     )

From b79208080052e627e8983e5c7d228d5311383f18 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 12 Feb 2021 07:05:11 -0800
Subject: [PATCH 167/206] Systematically removing _atyp from function names, to
 make the test code simpler.

---
 tests/test_class_sh_basic.cpp | 100 +++++++++++++++++-----------------
 tests/test_class_sh_basic.py  |  56 +++++++++----------
 2 files changed, 78 insertions(+), 78 deletions(-)

diff --git a/tests/test_class_sh_basic.cpp b/tests/test_class_sh_basic.cpp
index 415841f3e7..8d407573b8 100644
--- a/tests/test_class_sh_basic.cpp
+++ b/tests/test_class_sh_basic.cpp
@@ -18,40 +18,40 @@ struct atyp { // Short for "any type".
 
 // clang-format off
 
-atyp        rtrn_valu_atyp() { atyp obj{"rtrn_valu"}; return obj; }
-atyp&&      rtrn_rref_atyp() { static atyp obj; obj.mtxt = "rtrn_rref"; return std::move(obj); }
-atyp const& rtrn_cref_atyp() { static atyp obj; obj.mtxt = "rtrn_cref"; return obj; }
-atyp&       rtrn_mref_atyp() { static atyp obj; obj.mtxt = "rtrn_mref"; return obj; }
-atyp const* rtrn_cptr_atyp() { return new atyp{"rtrn_cptr"}; }
-atyp*       rtrn_mptr_atyp() { return new atyp{"rtrn_mptr"}; }
+atyp        rtrn_valu() { atyp obj{"rtrn_valu"}; return obj; }
+atyp&&      rtrn_rref() { static atyp obj; obj.mtxt = "rtrn_rref"; return std::move(obj); }
+atyp const& rtrn_cref() { static atyp obj; obj.mtxt = "rtrn_cref"; return obj; }
+atyp&       rtrn_mref() { static atyp obj; obj.mtxt = "rtrn_mref"; return obj; }
+atyp const* rtrn_cptr() { return new atyp{"rtrn_cptr"}; }
+atyp*       rtrn_mptr() { return new atyp{"rtrn_mptr"}; }
 
-std::string pass_valu_atyp(atyp obj)        { return "pass_valu:" + obj.mtxt; }
-std::string pass_rref_atyp(atyp&& obj)      { return "pass_rref:" + obj.mtxt; }
-std::string pass_cref_atyp(atyp const& obj) { return "pass_cref:" + obj.mtxt; }
-std::string pass_mref_atyp(atyp& obj)       { return "pass_mref:" + obj.mtxt; }
-std::string pass_cptr_atyp(atyp const* obj) { return "pass_cptr:" + obj->mtxt; }
-std::string pass_mptr_atyp(atyp* obj)       { return "pass_mptr:" + obj->mtxt; }
+std::string pass_valu(atyp obj)        { return "pass_valu:" + obj.mtxt; }
+std::string pass_rref(atyp&& obj)      { return "pass_rref:" + obj.mtxt; }
+std::string pass_cref(atyp const& obj) { return "pass_cref:" + obj.mtxt; }
+std::string pass_mref(atyp& obj)       { return "pass_mref:" + obj.mtxt; }
+std::string pass_cptr(atyp const* obj) { return "pass_cptr:" + obj->mtxt; }
+std::string pass_mptr(atyp* obj)       { return "pass_mptr:" + obj->mtxt; }
 
-std::shared_ptr<atyp>       rtrn_shmp_atyp() { return std::shared_ptr<atyp      >(new atyp{"rtrn_shmp"}); }
-std::shared_ptr<atyp const> rtrn_shcp_atyp() { return std::shared_ptr<atyp const>(new atyp{"rtrn_shcp"}); }
+std::shared_ptr<atyp>       rtrn_shmp() { return std::shared_ptr<atyp      >(new atyp{"rtrn_shmp"}); }
+std::shared_ptr<atyp const> rtrn_shcp() { return std::shared_ptr<atyp const>(new atyp{"rtrn_shcp"}); }
 
-std::string pass_shmp_atyp(std::shared_ptr<atyp>       obj) { return "pass_shmp:" + obj->mtxt; }
-std::string pass_shcp_atyp(std::shared_ptr<atyp const> obj) { return "pass_shcp:" + obj->mtxt; }
+std::string pass_shmp(std::shared_ptr<atyp>       obj) { return "pass_shmp:" + obj->mtxt; }
+std::string pass_shcp(std::shared_ptr<atyp const> obj) { return "pass_shcp:" + obj->mtxt; }
 
-std::unique_ptr<atyp>       rtrn_uqmp_atyp() { return std::unique_ptr<atyp      >(new atyp{"rtrn_uqmp"}); }
-std::unique_ptr<atyp const> rtrn_uqcp_atyp() { return std::unique_ptr<atyp const>(new atyp{"rtrn_uqcp"}); }
+std::unique_ptr<atyp>       rtrn_uqmp() { return std::unique_ptr<atyp      >(new atyp{"rtrn_uqmp"}); }
+std::unique_ptr<atyp const> rtrn_uqcp() { return std::unique_ptr<atyp const>(new atyp{"rtrn_uqcp"}); }
 
-std::string pass_uqmp_atyp(std::unique_ptr<atyp      > obj) { return "pass_uqmp:" + obj->mtxt; }
-std::string pass_uqcp_atyp(std::unique_ptr<atyp const> obj) { return "pass_uqcp:" + obj->mtxt; }
+std::string pass_uqmp(std::unique_ptr<atyp      > obj) { return "pass_uqmp:" + obj->mtxt; }
+std::string pass_uqcp(std::unique_ptr<atyp const> obj) { return "pass_uqcp:" + obj->mtxt; }
 
 struct sddm : std::default_delete<atyp      > {};
 struct sddc : std::default_delete<atyp const> {};
 
-std::unique_ptr<atyp,       sddm> rtrn_udmp_atyp() { return std::unique_ptr<atyp,       sddm>(new atyp{"rtrn_udmp"}); }
-std::unique_ptr<atyp const, sddc> rtrn_udcp_atyp() { return std::unique_ptr<atyp const, sddc>(new atyp{"rtrn_udcp"}); }
+std::unique_ptr<atyp,       sddm> rtrn_udmp() { return std::unique_ptr<atyp,       sddm>(new atyp{"rtrn_udmp"}); }
+std::unique_ptr<atyp const, sddc> rtrn_udcp() { return std::unique_ptr<atyp const, sddc>(new atyp{"rtrn_udcp"}); }
 
-std::string pass_udmp_atyp(std::unique_ptr<atyp,       sddm> obj) { return "pass_udmp:" + obj->mtxt; }
-std::string pass_udcp_atyp(std::unique_ptr<atyp const, sddc> obj) { return "pass_udcp:" + obj->mtxt; }
+std::string pass_udmp(std::unique_ptr<atyp,       sddm> obj) { return "pass_udmp:" + obj->mtxt; }
+std::string pass_udcp(std::unique_ptr<atyp const, sddc> obj) { return "pass_udcp:" + obj->mtxt; }
 
 // clang-format on
 
@@ -76,42 +76,42 @@ TEST_SUBMODULE(class_sh_basic, m) {
         return obj;
     }));
 
-    m.def("rtrn_valu_atyp", rtrn_valu_atyp);
-    m.def("rtrn_rref_atyp", rtrn_rref_atyp);
-    m.def("rtrn_cref_atyp", rtrn_cref_atyp);
-    m.def("rtrn_mref_atyp", rtrn_mref_atyp);
-    m.def("rtrn_cptr_atyp", rtrn_cptr_atyp);
-    m.def("rtrn_mptr_atyp", rtrn_mptr_atyp);
+    m.def("rtrn_valu", rtrn_valu);
+    m.def("rtrn_rref", rtrn_rref);
+    m.def("rtrn_cref", rtrn_cref);
+    m.def("rtrn_mref", rtrn_mref);
+    m.def("rtrn_cptr", rtrn_cptr);
+    m.def("rtrn_mptr", rtrn_mptr);
 
-    m.def("pass_valu_atyp", pass_valu_atyp);
-    m.def("pass_rref_atyp", pass_rref_atyp);
-    m.def("pass_cref_atyp", pass_cref_atyp);
-    m.def("pass_mref_atyp", pass_mref_atyp);
-    m.def("pass_cptr_atyp", pass_cptr_atyp);
-    m.def("pass_mptr_atyp", pass_mptr_atyp);
+    m.def("pass_valu", pass_valu);
+    m.def("pass_rref", pass_rref);
+    m.def("pass_cref", pass_cref);
+    m.def("pass_mref", pass_mref);
+    m.def("pass_cptr", pass_cptr);
+    m.def("pass_mptr", pass_mptr);
 
-    m.def("rtrn_shmp_atyp", rtrn_shmp_atyp);
-    m.def("rtrn_shcp_atyp", rtrn_shcp_atyp);
+    m.def("rtrn_shmp", rtrn_shmp);
+    m.def("rtrn_shcp", rtrn_shcp);
 
-    m.def("pass_shmp_atyp", pass_shmp_atyp);
-    m.def("pass_shcp_atyp", pass_shcp_atyp);
+    m.def("pass_shmp", pass_shmp);
+    m.def("pass_shcp", pass_shcp);
 
-    m.def("rtrn_uqmp_atyp", rtrn_uqmp_atyp);
-    m.def("rtrn_uqcp_atyp", rtrn_uqcp_atyp);
+    m.def("rtrn_uqmp", rtrn_uqmp);
+    m.def("rtrn_uqcp", rtrn_uqcp);
 
-    m.def("pass_uqmp_atyp", pass_uqmp_atyp);
-    m.def("pass_uqcp_atyp", pass_uqcp_atyp);
+    m.def("pass_uqmp", pass_uqmp);
+    m.def("pass_uqcp", pass_uqcp);
 
-    m.def("rtrn_udmp_atyp", rtrn_udmp_atyp);
-    m.def("rtrn_udcp_atyp", rtrn_udcp_atyp);
+    m.def("rtrn_udmp", rtrn_udmp);
+    m.def("rtrn_udcp", rtrn_udcp);
 
-    m.def("pass_udmp_atyp", pass_udmp_atyp);
-    m.def("pass_udcp_atyp", pass_udcp_atyp);
+    m.def("pass_udmp", pass_udmp);
+    m.def("pass_udcp", pass_udcp);
 
     // Helpers for testing.
     // These require selected functions above to work first, as indicated:
-    m.def("get_mtxt", get_mtxt);                         // pass_cref_atyp
-    m.def("unique_ptr_roundtrip", unique_ptr_roundtrip); // pass_uqmp_atyp, rtrn_uqmp_atyp
+    m.def("get_mtxt", get_mtxt);                         // pass_cref
+    m.def("unique_ptr_roundtrip", unique_ptr_roundtrip); // pass_uqmp, rtrn_uqmp
 
     m.def("py_type_handle_of_atyp", []() {
         return py::type::handle_of<atyp>(); // Exercises static_cast in this function.
diff --git a/tests/test_class_sh_basic.py b/tests/test_class_sh_basic.py
index bceabd1328..764b1604d3 100644
--- a/tests/test_class_sh_basic.py
+++ b/tests/test_class_sh_basic.py
@@ -16,18 +16,18 @@ def test_atyp_constructors():
 @pytest.mark.parametrize(
     "rtrn_f, expected",
     [
-        (m.rtrn_valu_atyp, "rtrn_valu.MvCtor"),
-        (m.rtrn_rref_atyp, "rtrn_rref.MvCtor"),
-        (m.rtrn_cref_atyp, "rtrn_cref.CpCtor"),
-        (m.rtrn_mref_atyp, "rtrn_mref.CpCtor"),
-        (m.rtrn_cptr_atyp, "rtrn_cptr"),
-        (m.rtrn_mptr_atyp, "rtrn_mptr"),
-        (m.rtrn_shmp_atyp, "rtrn_shmp"),
-        (m.rtrn_shcp_atyp, "rtrn_shcp"),
-        (m.rtrn_uqmp_atyp, "rtrn_uqmp"),
-        (m.rtrn_uqcp_atyp, "rtrn_uqcp"),
-        (m.rtrn_udmp_atyp, "rtrn_udmp"),
-        (m.rtrn_udcp_atyp, "rtrn_udcp"),
+        (m.rtrn_valu, "rtrn_valu.MvCtor"),
+        (m.rtrn_rref, "rtrn_rref.MvCtor"),
+        (m.rtrn_cref, "rtrn_cref.CpCtor"),
+        (m.rtrn_mref, "rtrn_mref.CpCtor"),
+        (m.rtrn_cptr, "rtrn_cptr"),
+        (m.rtrn_mptr, "rtrn_mptr"),
+        (m.rtrn_shmp, "rtrn_shmp"),
+        (m.rtrn_shcp, "rtrn_shcp"),
+        (m.rtrn_uqmp, "rtrn_uqmp"),
+        (m.rtrn_uqcp, "rtrn_uqcp"),
+        (m.rtrn_udmp, "rtrn_udmp"),
+        (m.rtrn_udcp, "rtrn_udcp"),
     ],
 )
 def test_cast(rtrn_f, expected):
@@ -37,16 +37,16 @@ def test_cast(rtrn_f, expected):
 @pytest.mark.parametrize(
     "pass_f, mtxt, expected",
     [
-        (m.pass_valu_atyp, "Valu", "pass_valu:Valu.MvCtor.CpCtor"),
-        (m.pass_rref_atyp, "Rref", "pass_rref:Rref.MvCtor.CpCtor"),
-        (m.pass_cref_atyp, "Cref", "pass_cref:Cref.MvCtor"),
-        (m.pass_mref_atyp, "Mref", "pass_mref:Mref.MvCtor"),
-        (m.pass_cptr_atyp, "Cptr", "pass_cptr:Cptr.MvCtor"),
-        (m.pass_mptr_atyp, "Mptr", "pass_mptr:Mptr.MvCtor"),
-        (m.pass_shmp_atyp, "Shmp", "pass_shmp:Shmp.MvCtor"),
-        (m.pass_shcp_atyp, "Shcp", "pass_shcp:Shcp.MvCtor"),
-        (m.pass_uqmp_atyp, "Uqmp", "pass_uqmp:Uqmp.MvCtor"),
-        (m.pass_uqcp_atyp, "Uqcp", "pass_uqcp:Uqcp.MvCtor"),
+        (m.pass_valu, "Valu", "pass_valu:Valu.MvCtor.CpCtor"),
+        (m.pass_rref, "Rref", "pass_rref:Rref.MvCtor.CpCtor"),
+        (m.pass_cref, "Cref", "pass_cref:Cref.MvCtor"),
+        (m.pass_mref, "Mref", "pass_mref:Mref.MvCtor"),
+        (m.pass_cptr, "Cptr", "pass_cptr:Cptr.MvCtor"),
+        (m.pass_mptr, "Mptr", "pass_mptr:Mptr.MvCtor"),
+        (m.pass_shmp, "Shmp", "pass_shmp:Shmp.MvCtor"),
+        (m.pass_shcp, "Shcp", "pass_shcp:Shcp.MvCtor"),
+        (m.pass_uqmp, "Uqmp", "pass_uqmp:Uqmp.MvCtor"),
+        (m.pass_uqcp, "Uqcp", "pass_uqcp:Uqcp.MvCtor"),
     ],
 )
 def test_load_with_mtxt(pass_f, mtxt, expected):
@@ -56,8 +56,8 @@ def test_load_with_mtxt(pass_f, mtxt, expected):
 @pytest.mark.parametrize(
     "pass_f, rtrn_f, expected",
     [
-        (m.pass_udmp_atyp, m.rtrn_udmp_atyp, "pass_udmp:rtrn_udmp"),
-        (m.pass_udcp_atyp, m.rtrn_udcp_atyp, "pass_udcp:rtrn_udcp"),
+        (m.pass_udmp, m.rtrn_udmp, "pass_udmp:rtrn_udmp"),
+        (m.pass_udcp, m.rtrn_udcp, "pass_udcp:rtrn_udcp"),
     ],
 )
 def test_load_with_rtrn_f(pass_f, rtrn_f, expected):
@@ -67,10 +67,10 @@ def test_load_with_rtrn_f(pass_f, rtrn_f, expected):
 @pytest.mark.parametrize(
     "pass_f, rtrn_f, expected",
     [
-        (m.pass_uqmp_atyp, m.rtrn_uqmp_atyp, "pass_uqmp:rtrn_uqmp"),
-        (m.pass_uqcp_atyp, m.rtrn_uqcp_atyp, "pass_uqcp:rtrn_uqcp"),
-        (m.pass_udmp_atyp, m.rtrn_udmp_atyp, "pass_udmp:rtrn_udmp"),
-        (m.pass_udcp_atyp, m.rtrn_udcp_atyp, "pass_udcp:rtrn_udcp"),
+        (m.pass_uqmp, m.rtrn_uqmp, "pass_uqmp:rtrn_uqmp"),
+        (m.pass_uqcp, m.rtrn_uqcp, "pass_uqcp:rtrn_uqcp"),
+        (m.pass_udmp, m.rtrn_udmp, "pass_udmp:rtrn_udmp"),
+        (m.pass_udcp, m.rtrn_udcp, "pass_udcp:rtrn_udcp"),
     ],
 )
 def test_pass_unique_ptr_disowns(pass_f, rtrn_f, expected):

From 2003b508abdc469fa1ec3697c31f381878984fc4 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 12 Feb 2021 07:25:32 -0800
Subject: [PATCH 168/206] Using re.match to accommodate variable number of
 intermediate MvCtor.

---
 tests/test_class_sh_basic.cpp |  4 ++--
 tests/test_class_sh_basic.py  | 35 ++++++++++++++++++-----------------
 2 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/tests/test_class_sh_basic.cpp b/tests/test_class_sh_basic.cpp
index 8d407573b8..4aae04a918 100644
--- a/tests/test_class_sh_basic.cpp
+++ b/tests/test_class_sh_basic.cpp
@@ -12,8 +12,8 @@ struct atyp { // Short for "any type".
     std::string mtxt;
     atyp() : mtxt("DefaultConstructor") {}
     atyp(const std::string &mtxt_) : mtxt(mtxt_) {}
-    atyp(const atyp &other) { mtxt = other.mtxt + ".CpCtor"; }
-    atyp(atyp &&other) { mtxt = other.mtxt + ".MvCtor"; }
+    atyp(const atyp &other) { mtxt = other.mtxt + "_CpCtor"; }
+    atyp(atyp &&other) { mtxt = other.mtxt + "_MvCtor"; }
 };
 
 // clang-format off
diff --git a/tests/test_class_sh_basic.py b/tests/test_class_sh_basic.py
index 764b1604d3..f369f6b273 100644
--- a/tests/test_class_sh_basic.py
+++ b/tests/test_class_sh_basic.py
@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import pytest
+import re
 
 from pybind11_tests import class_sh_basic as m
 
@@ -16,10 +17,10 @@ def test_atyp_constructors():
 @pytest.mark.parametrize(
     "rtrn_f, expected",
     [
-        (m.rtrn_valu, "rtrn_valu.MvCtor"),
-        (m.rtrn_rref, "rtrn_rref.MvCtor"),
-        (m.rtrn_cref, "rtrn_cref.CpCtor"),
-        (m.rtrn_mref, "rtrn_mref.CpCtor"),
+        (m.rtrn_valu, "rtrn_valu(_MvCtor)*_MvCtor"),
+        (m.rtrn_rref, "rtrn_rref(_MvCtor)*_MvCtor"),
+        (m.rtrn_cref, "rtrn_cref(_MvCtor)*_CpCtor"),
+        (m.rtrn_mref, "rtrn_mref(_MvCtor)*_CpCtor"),
         (m.rtrn_cptr, "rtrn_cptr"),
         (m.rtrn_mptr, "rtrn_mptr"),
         (m.rtrn_shmp, "rtrn_shmp"),
@@ -31,26 +32,26 @@ def test_atyp_constructors():
     ],
 )
 def test_cast(rtrn_f, expected):
-    assert m.get_mtxt(rtrn_f()) == expected
+    assert re.match(expected, m.get_mtxt(rtrn_f()))
 
 
 @pytest.mark.parametrize(
     "pass_f, mtxt, expected",
     [
-        (m.pass_valu, "Valu", "pass_valu:Valu.MvCtor.CpCtor"),
-        (m.pass_rref, "Rref", "pass_rref:Rref.MvCtor.CpCtor"),
-        (m.pass_cref, "Cref", "pass_cref:Cref.MvCtor"),
-        (m.pass_mref, "Mref", "pass_mref:Mref.MvCtor"),
-        (m.pass_cptr, "Cptr", "pass_cptr:Cptr.MvCtor"),
-        (m.pass_mptr, "Mptr", "pass_mptr:Mptr.MvCtor"),
-        (m.pass_shmp, "Shmp", "pass_shmp:Shmp.MvCtor"),
-        (m.pass_shcp, "Shcp", "pass_shcp:Shcp.MvCtor"),
-        (m.pass_uqmp, "Uqmp", "pass_uqmp:Uqmp.MvCtor"),
-        (m.pass_uqcp, "Uqcp", "pass_uqcp:Uqcp.MvCtor"),
+        (m.pass_valu, "Valu", "pass_valu:Valu(_MvCtor)*_CpCtor"),
+        (m.pass_rref, "Rref", "pass_rref:Rref(_MvCtor)*_CpCtor"),
+        (m.pass_cref, "Cref", "pass_cref:Cref(_MvCtor)*_MvCtor"),
+        (m.pass_mref, "Mref", "pass_mref:Mref(_MvCtor)*_MvCtor"),
+        (m.pass_cptr, "Cptr", "pass_cptr:Cptr(_MvCtor)*_MvCtor"),
+        (m.pass_mptr, "Mptr", "pass_mptr:Mptr(_MvCtor)*_MvCtor"),
+        (m.pass_shmp, "Shmp", "pass_shmp:Shmp(_MvCtor)*_MvCtor"),
+        (m.pass_shcp, "Shcp", "pass_shcp:Shcp(_MvCtor)*_MvCtor"),
+        (m.pass_uqmp, "Uqmp", "pass_uqmp:Uqmp(_MvCtor)*_MvCtor"),
+        (m.pass_uqcp, "Uqcp", "pass_uqcp:Uqcp(_MvCtor)*_MvCtor"),
     ],
 )
 def test_load_with_mtxt(pass_f, mtxt, expected):
-    assert pass_f(m.atyp(mtxt)) == expected
+    assert re.match(expected, pass_f(m.atyp(mtxt)))
 
 
 @pytest.mark.parametrize(
@@ -89,7 +90,7 @@ def test_unique_ptr_roundtrip(num_round_trips=1000):
     for _ in range(num_round_trips):
         id_orig = id(recycled)
         recycled = m.unique_ptr_roundtrip(recycled)
-        assert m.get_mtxt(recycled) == "passenger.MvCtor"
+        assert re.match("passenger(_MvCtor)*_MvCtor", m.get_mtxt(recycled))
         id_rtrn = id(recycled)
         # Ensure the returned object is a different Python instance.
         assert id_rtrn != id_orig

From 823934f26eacd28951bf460e0f867219224a239e Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 12 Feb 2021 10:36:18 -0800
Subject: [PATCH 169/206] Also removing `operator T()` from
 smart_holder_type_caster, to fix gcc compilation errors. The only loss is
 pass_rref in test_class_sh_basic.

---
 include/pybind11/cast.h       | 11 +++++++----
 tests/test_class_sh_basic.cpp |  2 --
 tests/test_class_sh_basic.py  |  1 -
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 2e3f6ff9d0..142be8c5d3 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -10,6 +10,10 @@
 
 #pragma once
 
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+// #define PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+#endif
+
 #include "pytypes.h"
 #include "detail/common.h"
 #include "detail/descr.h"
@@ -1388,6 +1392,8 @@ struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
         return cast(const_cast<T const *>(src), policy, parent); // Mutbl2Const
     }
 
+    // clang-format off
+
     template <typename T_>
     using cast_op_type = conditional_t<
         std::is_same<remove_reference_t<T_>, T const *>::value,
@@ -1396,11 +1402,8 @@ struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
                       T *,
                       conditional_t<std::is_same<T_, T const &>::value,
                                     T const &,
-                                    conditional_t<std::is_same<T_, T &>::value, T &, T>>>>;
-
-    // clang-format off
+                                    T &>>>;
 
-    operator T()        { return this->loaded_as_lvalue_ref(); }
     operator T const&() { return this->loaded_as_lvalue_ref(); }
     operator T&()       { return this->loaded_as_lvalue_ref(); }
     operator T const*() { return this->loaded_as_raw_ptr_unowned(); }
diff --git a/tests/test_class_sh_basic.cpp b/tests/test_class_sh_basic.cpp
index 4aae04a918..f66b5623d3 100644
--- a/tests/test_class_sh_basic.cpp
+++ b/tests/test_class_sh_basic.cpp
@@ -26,7 +26,6 @@ atyp const* rtrn_cptr() { return new atyp{"rtrn_cptr"}; }
 atyp*       rtrn_mptr() { return new atyp{"rtrn_mptr"}; }
 
 std::string pass_valu(atyp obj)        { return "pass_valu:" + obj.mtxt; }
-std::string pass_rref(atyp&& obj)      { return "pass_rref:" + obj.mtxt; }
 std::string pass_cref(atyp const& obj) { return "pass_cref:" + obj.mtxt; }
 std::string pass_mref(atyp& obj)       { return "pass_mref:" + obj.mtxt; }
 std::string pass_cptr(atyp const* obj) { return "pass_cptr:" + obj->mtxt; }
@@ -84,7 +83,6 @@ TEST_SUBMODULE(class_sh_basic, m) {
     m.def("rtrn_mptr", rtrn_mptr);
 
     m.def("pass_valu", pass_valu);
-    m.def("pass_rref", pass_rref);
     m.def("pass_cref", pass_cref);
     m.def("pass_mref", pass_mref);
     m.def("pass_cptr", pass_cptr);
diff --git a/tests/test_class_sh_basic.py b/tests/test_class_sh_basic.py
index f369f6b273..88d926a1d5 100644
--- a/tests/test_class_sh_basic.py
+++ b/tests/test_class_sh_basic.py
@@ -39,7 +39,6 @@ def test_cast(rtrn_f, expected):
     "pass_f, mtxt, expected",
     [
         (m.pass_valu, "Valu", "pass_valu:Valu(_MvCtor)*_CpCtor"),
-        (m.pass_rref, "Rref", "pass_rref:Rref(_MvCtor)*_CpCtor"),
         (m.pass_cref, "Cref", "pass_cref:Cref(_MvCtor)*_MvCtor"),
         (m.pass_mref, "Mref", "pass_mref:Mref(_MvCtor)*_MvCtor"),
         (m.pass_cptr, "Cptr", "pass_cptr:Cptr(_MvCtor)*_MvCtor"),

From 1909436cc5646cf3c5ee35bbf97b30bacb4f02e4 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 12 Feb 2021 13:46:18 -0800
Subject: [PATCH 170/206] Systematically replacing
 `detail::enable_if_t<...smart_holder...>` with `typename
 std::enable_if<...smart_holder...>::type`. Attempt to work around MSVC 2015
 issues, to be tested via GitHub CI. The idea for this change originates from
 this comment:
 https://github.com/pybind/pybind11/issues/1616#issuecomment-444536813

---
 include/pybind11/cast.h        | 2 +-
 include/pybind11/detail/init.h | 6 +++---
 include/pybind11/pybind11.h    | 8 ++++----
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 142be8c5d3..b3adc9dc09 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -2466,7 +2466,7 @@ struct is_smart_holder_type_caster : std::false_type {};
 template <typename T>
 struct is_smart_holder_type_caster<
     T,
-    enable_if_t<type_caster<T>::is_smart_holder_type_caster::value, void>> : std::true_type {};
+    typename std::enable_if<type_caster<T>::is_smart_holder_type_caster::value, void>::type> : std::true_type {};
 
 template <typename T>
 inline bool check_is_smart_holder_type_caster() {
diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index b351f21d1e..ef5eb0da8f 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -132,7 +132,7 @@ void construct(value_and_holder &v_h, Alias<Class> *alias_ptr, bool) {
 // holder.  This also handles types like std::shared_ptr<T> and std::unique_ptr<T> where T is a
 // derived type (through those holder's implicit conversion from derived class holder constructors).
 template <typename Class,
-          detail::enable_if_t<!detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+          typename std::enable_if<!detail::is_smart_holder_type_caster<Cpp<Class>>::value, int>::type = 0>
 void construct(value_and_holder &v_h, Holder<Class> holder, bool need_alias) {
     auto *ptr = holder_helper<Holder<Class>>::get(holder);
     no_nullptr(ptr);
@@ -172,7 +172,7 @@ void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
 //DETAIL/SMART_HOLDER_INIT_H/BEGIN/////////////////////////////////////////////////////////////////
 
 template <typename Class, typename D = std::default_delete<Cpp<Class>>,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+          typename std::enable_if<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int>::type = 0>
 void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
     auto *ptr = unq_ptr.get();
     no_nullptr(ptr);
@@ -188,7 +188,7 @@ void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr,
 }
 
 template <typename Class,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+          typename std::enable_if<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int>::type = 0>
 void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, bool need_alias) {
     auto *ptr = shd_ptr.get();
     no_nullptr(ptr);
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 11e75b8474..249a0028f4 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1545,14 +1545,14 @@ class class_ : public detail::generic_type {
 private:
     template <
         typename T = type,
-        detail::enable_if_t<!detail::is_smart_holder_type_caster<T>::value, int> = 0>
+        typename std::enable_if<!detail::is_smart_holder_type_caster<T>::value, int>::type = 0>
     void generic_type_initialize(const detail::type_record &record) {
         generic_type::initialize(record, &detail::type_caster_generic::local_load);
     }
 
     template <
         typename T = type,
-        detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
+        typename std::enable_if<detail::is_smart_holder_type_caster<T>::value, int>::type = 0>
     void generic_type_initialize(const detail::type_record &record) {
         generic_type::initialize(record, detail::type_caster<T>::get_local_load_function_ptr());
     }
@@ -1603,7 +1603,7 @@ class class_ : public detail::generic_type {
     /// `.owned`, a new holder will be constructed to manage the value pointer.
     template <
         typename T = type,
-        detail::enable_if_t<!detail::is_smart_holder_type_caster<T>::value, int> = 0>
+        typename std::enable_if<!detail::is_smart_holder_type_caster<T>::value, int>::type = 0>
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
         auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
         if (!v_h.instance_registered()) {
@@ -1615,7 +1615,7 @@ class class_ : public detail::generic_type {
 
     template <
         typename T = type,
-        detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
+        typename std::enable_if<detail::is_smart_holder_type_caster<T>::value, int>::type = 0>
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
         detail::type_caster<T>::template init_instance_for_type<type>(inst, holder_ptr);
     }

From 823ae0a967550fdffd332677f1e1368cebd645db Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 12 Feb 2021 14:17:13 -0800
Subject: [PATCH 171/206] Importing re before pytest after observing a PyPy CI
 flake when importing pytest first.

---
 tests/test_class_sh_basic.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/test_class_sh_basic.py b/tests/test_class_sh_basic.py
index 88d926a1d5..4bd793f15b 100644
--- a/tests/test_class_sh_basic.py
+++ b/tests/test_class_sh_basic.py
@@ -1,7 +1,9 @@
 # -*- coding: utf-8 -*-
-import pytest
+# Importing re before pytest after observing a PyPy CI flake when importing pytest first.
 import re
 
+import pytest
+
 from pybind11_tests import class_sh_basic as m
 
 

From 0bfa99333936e05f2e13dda1eb0ef0e9b8d279fc Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 13 Feb 2021 20:17:00 -0800
Subject: [PATCH 172/206] Copying MSVC 2015 compatibility change from branch
 pr2672_use_smart_holder_as_default.

---
 include/pybind11/cast.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index b3adc9dc09..7ceaaa08f8 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1193,8 +1193,6 @@ class modified_type_caster_generic_load_impl {
 // clang-format on
 
 struct smart_holder_type_caster_class_hooks {
-    using is_smart_holder_type_caster = std::true_type;
-
     static decltype(&modified_type_caster_generic_load_impl::local_load)
     get_local_load_function_ptr() {
         return &modified_type_caster_generic_load_impl::local_load;
@@ -2463,14 +2461,17 @@ template <typename T> using move_never = none_of<move_always<T>, move_if_unrefer
 
 template <typename T, typename SFINAE = void>
 struct is_smart_holder_type_caster : std::false_type {};
+
 template <typename T>
 struct is_smart_holder_type_caster<
     T,
-    typename std::enable_if<type_caster<T>::is_smart_holder_type_caster::value, void>::type> : std::true_type {};
+    typename std::enable_if<
+        std::is_base_of<smart_holder_type_caster_class_hooks, make_caster<T>>::value>::type>
+    : std::true_type {};
 
 template <typename T>
 inline bool check_is_smart_holder_type_caster() {
-    return detail::is_smart_holder_type_caster<T>::value;
+    return is_smart_holder_type_caster<T>::value;
 }
 
 // Detect whether returning a `type` from a cast on type's type_caster is going to result in a

From 44bdc1465ef043d9f13a11f4e6c95b199c90d9de Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 14 Feb 2021 00:48:33 -0800
Subject: [PATCH 173/206] Introducing is_smart_holder_type_caster_base_tag, to
 keep smart_holder code more disconnected.

---
 include/pybind11/cast.h  | 38 +++++++++++++++-----------------------
 tests/test_smart_ptr.cpp | 12 ++++++++++++
 2 files changed, 27 insertions(+), 23 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 7ceaaa08f8..6ad5f09bc9 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -966,6 +966,12 @@ template <typename type> class type_caster_base : public type_caster_generic {
     static Constructor make_move_constructor(...) { return nullptr; }
 };
 
+// Tag to be used as base class, inspected by is_smart_holder_type_caster<T> test.
+struct is_smart_holder_type_caster_base_tag {};
+
+template <typename T>
+struct is_smart_holder_type_caster;
+
 //DETAIL/SMART_HOLDER_TYPE_CASTERS_H/BEGIN/////////////////////////////////////////////////////////
 
 //FWD begin
@@ -1192,7 +1198,7 @@ class modified_type_caster_generic_load_impl {
 };
 // clang-format on
 
-struct smart_holder_type_caster_class_hooks {
+struct smart_holder_type_caster_class_hooks : is_smart_holder_type_caster_base_tag {
     static decltype(&modified_type_caster_generic_load_impl::local_load)
     get_local_load_function_ptr() {
         return &modified_type_caster_generic_load_impl::local_load;
@@ -1225,18 +1231,12 @@ struct smart_holder_type_caster_class_hooks {
     }
 };
 
-template <typename T>
-inline bool check_is_smart_holder_type_caster();
-
 template <typename T>
 struct smart_holder_type_caster_load {
     using holder_type = pybindit::memory::smart_holder;
 
     bool load(handle src, bool convert) {
-        if (!check_is_smart_holder_type_caster<T>()) {
-            throw cast_error(
-                "Unable to load a smart-pointer type from a non-smart_holder instance.");
-        }
+        static_assert(is_smart_holder_type_caster<T>::value, "Internal consistency error.");
         load_impl = modified_type_caster_generic_load_impl(typeid(T));
         if (!load_impl.load(src, convert))
             return false;
@@ -1692,6 +1692,13 @@ template <typename type, typename SFINAE = void> class type_caster : public type
 
 template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
 
+template <typename T>
+struct is_smart_holder_type_caster {
+    static constexpr bool value = std::is_base_of<
+        is_smart_holder_type_caster_base_tag,
+        make_caster<T>>::value;
+};
+
 // Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T
 template <typename T> typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &caster) {
     return caster.operator typename make_caster<T>::template cast_op_type<T>();
@@ -2459,21 +2466,6 @@ template <typename T> struct move_if_unreferenced<T, enable_if_t<all_of<
 >::value>> : std::true_type {};
 template <typename T> using move_never = none_of<move_always<T>, move_if_unreferenced<T>>;
 
-template <typename T, typename SFINAE = void>
-struct is_smart_holder_type_caster : std::false_type {};
-
-template <typename T>
-struct is_smart_holder_type_caster<
-    T,
-    typename std::enable_if<
-        std::is_base_of<smart_holder_type_caster_class_hooks, make_caster<T>>::value>::type>
-    : std::true_type {};
-
-template <typename T>
-inline bool check_is_smart_holder_type_caster() {
-    return is_smart_holder_type_caster<T>::value;
-}
-
 // Detect whether returning a `type` from a cast on type's type_caster is going to result in a
 // reference or pointer to a local variable of the type_caster.  Basically, only
 // non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe;
diff --git a/tests/test_smart_ptr.cpp b/tests/test_smart_ptr.cpp
index ab649f7257..50062c59ff 100644
--- a/tests/test_smart_ptr.cpp
+++ b/tests/test_smart_ptr.cpp
@@ -292,6 +292,18 @@ PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(ElementBase, std::shared_ptr<ElementB
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(ElementA, std::shared_ptr<ElementA>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(ElementList, std::shared_ptr<ElementList>)
 
+#ifdef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+// To prevent triggering a static_assert in the smart_holder code.
+// This is a very special case, because the associated test exercises a holder mismatch.
+namespace pybind11 {
+namespace detail {
+template <>
+class type_caster<std::shared_ptr<HeldByDefaultHolder>>
+    : public copyable_holder_caster<HeldByDefaultHolder, std::shared_ptr<HeldByDefaultHolder>> {};
+} // namespace detail
+} // namespace pybind11
+#endif
+
 TEST_SUBMODULE(smart_ptr, m) {
 
     // test_smart_ptr

From c51dec400bb3e2b9ad61213bef0386523998942b Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 14 Feb 2021 00:52:00 -0800
Subject: [PATCH 174/206] Working around MSVC 2015 bug.

---
 include/pybind11/cast.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 6ad5f09bc9..0d5f149e00 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1392,6 +1392,10 @@ struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
 
     // clang-format off
 
+#if defined(_MSC_VER) && _MSC_VER < 1910
+    // Working around MSVC 2015 bug.
+    template <typename T_> using cast_op_type = detail::cast_op_type<T_>;
+#else
     template <typename T_>
     using cast_op_type = conditional_t<
         std::is_same<remove_reference_t<T_>, T const *>::value,
@@ -1401,6 +1405,7 @@ struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
                       conditional_t<std::is_same<T_, T const &>::value,
                                     T const &,
                                     T &>>>;
+#endif
 
     operator T const&() { return this->loaded_as_lvalue_ref(); }
     operator T&()       { return this->loaded_as_lvalue_ref(); }

From 23cbc2b7e37d81a035a0a0964647bad866bf6641 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 14 Feb 2021 00:56:12 -0800
Subject: [PATCH 175/206] Expanding comment for MSVC 2015 workaround.

---
 include/pybind11/cast.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 0d5f149e00..b4c3c54900 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1393,7 +1393,8 @@ struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
     // clang-format off
 
 #if defined(_MSC_VER) && _MSC_VER < 1910
-    // Working around MSVC 2015 bug.
+    // Working around MSVC 2015 bug. `const` sensitivity is lost.
+    // SMART_HOLDER_WIP: IMPROVABLE: make common code work with MSVC 2015.
     template <typename T_> using cast_op_type = detail::cast_op_type<T_>;
 #else
     template <typename T_>

From e0e3ff0be9a33f3c11245b79f6f4756c7564e7e5 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 14 Feb 2021 06:54:18 -0800
Subject: [PATCH 176/206] Systematically changing std::enable_if back to
 detail::enable_if_t, effectively reverting commit
 5d4b6890a337ae1bbaec4091f4195606f89a3b06.

---
 include/pybind11/detail/init.h | 6 +++---
 include/pybind11/pybind11.h    | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index ef5eb0da8f..b351f21d1e 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -132,7 +132,7 @@ void construct(value_and_holder &v_h, Alias<Class> *alias_ptr, bool) {
 // holder.  This also handles types like std::shared_ptr<T> and std::unique_ptr<T> where T is a
 // derived type (through those holder's implicit conversion from derived class holder constructors).
 template <typename Class,
-          typename std::enable_if<!detail::is_smart_holder_type_caster<Cpp<Class>>::value, int>::type = 0>
+          detail::enable_if_t<!detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h, Holder<Class> holder, bool need_alias) {
     auto *ptr = holder_helper<Holder<Class>>::get(holder);
     no_nullptr(ptr);
@@ -172,7 +172,7 @@ void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
 //DETAIL/SMART_HOLDER_INIT_H/BEGIN/////////////////////////////////////////////////////////////////
 
 template <typename Class, typename D = std::default_delete<Cpp<Class>>,
-          typename std::enable_if<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int>::type = 0>
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
     auto *ptr = unq_ptr.get();
     no_nullptr(ptr);
@@ -188,7 +188,7 @@ void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr,
 }
 
 template <typename Class,
-          typename std::enable_if<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int>::type = 0>
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, bool need_alias) {
     auto *ptr = shd_ptr.get();
     no_nullptr(ptr);
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 249a0028f4..11e75b8474 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1545,14 +1545,14 @@ class class_ : public detail::generic_type {
 private:
     template <
         typename T = type,
-        typename std::enable_if<!detail::is_smart_holder_type_caster<T>::value, int>::type = 0>
+        detail::enable_if_t<!detail::is_smart_holder_type_caster<T>::value, int> = 0>
     void generic_type_initialize(const detail::type_record &record) {
         generic_type::initialize(record, &detail::type_caster_generic::local_load);
     }
 
     template <
         typename T = type,
-        typename std::enable_if<detail::is_smart_holder_type_caster<T>::value, int>::type = 0>
+        detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
     void generic_type_initialize(const detail::type_record &record) {
         generic_type::initialize(record, detail::type_caster<T>::get_local_load_function_ptr());
     }
@@ -1603,7 +1603,7 @@ class class_ : public detail::generic_type {
     /// `.owned`, a new holder will be constructed to manage the value pointer.
     template <
         typename T = type,
-        typename std::enable_if<!detail::is_smart_holder_type_caster<T>::value, int>::type = 0>
+        detail::enable_if_t<!detail::is_smart_holder_type_caster<T>::value, int> = 0>
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
         auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
         if (!v_h.instance_registered()) {
@@ -1615,7 +1615,7 @@ class class_ : public detail::generic_type {
 
     template <
         typename T = type,
-        typename std::enable_if<detail::is_smart_holder_type_caster<T>::value, int>::type = 0>
+        detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
         detail::type_caster<T>::template init_instance_for_type<type>(inst, holder_ptr);
     }

From 795b2bc9c6b8fb661db8664e7b39386fd3189395 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 14 Feb 2021 07:00:54 -0800
Subject: [PATCH 177/206] Removing unused
 smart_holder_type_caster_load::loaded_as_rvalue_ref (it was an oversight that
 it was not removed with commit 23036a45eb4731a06b488ec1fdf83bca677b7f67).

---
 include/pybind11/cast.h | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index b4c3c54900..edf8a65d67 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1263,12 +1263,6 @@ struct smart_holder_type_caster_load {
         return *raw_ptr;
     }
 
-    T &&loaded_as_rvalue_ref() const {
-        T *raw_ptr = loaded_as_raw_ptr_unowned();
-        if (raw_ptr == nullptr) throw reference_cast_error();
-        return std::move(*raw_ptr);
-    }
-
     std::shared_ptr<T> loaded_as_shared_ptr() const {
         if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
             throw cast_error("Unowned pointer from direct conversion cannot be converted to a"

From ceb0ea7ccd629615941e21b30c31f05d67e6ac02 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 14 Feb 2021 07:08:46 -0800
Subject: [PATCH 178/206] Removing py::classu, because it does not seem useful
 enough.

---
 include/pybind11/smart_holder.h           | 8 --------
 tests/test_class_sh_unique_ptr_member.cpp | 6 +-----
 2 files changed, 1 insertion(+), 13 deletions(-)

diff --git a/include/pybind11/smart_holder.h b/include/pybind11/smart_holder.h
index ce24bbfc2e..470d445a3a 100644
--- a/include/pybind11/smart_holder.h
+++ b/include/pybind11/smart_holder.h
@@ -18,12 +18,4 @@ class classh : public class_<type_, smart_holder, options...> {
     using class_<type_, smart_holder, options...>::class_;
 };
 
-// Similar in idea to `py::classh`, but for `std::unique_ptr<U>` holder, to support
-// an easier transition to `py::smart_holder` as default holder.
-template <typename type_, typename... options>
-class classu : public class_<type_, std::unique_ptr<type_>, options...> {
-public:
-    using class_<type_, std::unique_ptr<type_>, options...>::class_;
-};
-
 PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/tests/test_class_sh_unique_ptr_member.cpp b/tests/test_class_sh_unique_ptr_member.cpp
index e73d667935..a34274a0ca 100644
--- a/tests/test_class_sh_unique_ptr_member.cpp
+++ b/tests/test_class_sh_unique_ptr_member.cpp
@@ -41,9 +41,6 @@ class ptr_owner {
 } // namespace pybind11_tests
 
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_unique_ptr_member::pointee)
-PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(
-    pybind11_tests::class_sh_unique_ptr_member::ptr_owner,
-    std::unique_ptr<pybind11_tests::class_sh_unique_ptr_member::ptr_owner>)
 
 namespace pybind11_tests {
 namespace class_sh_unique_ptr_member {
@@ -53,8 +50,7 @@ TEST_SUBMODULE(class_sh_unique_ptr_member, m) {
 
     m.def("make_unique_pointee", make_unique_pointee);
 
-    // Could also be class_, but can conveniently be used for testing classu.
-    py::classu<ptr_owner>(m, "ptr_owner")
+    py::class_<ptr_owner>(m, "ptr_owner")
         .def(py::init<std::unique_ptr<pointee>>(), py::arg("ptr"))
         .def("is_owner", &ptr_owner::is_owner)
         .def("give_up_ownership_via_unique_ptr", &ptr_owner::give_up_ownership_via_unique_ptr)

From 3709ab3abf958bc2296ecbddff95d9d7d7b42dfd Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 14 Feb 2021 07:43:11 -0800
Subject: [PATCH 179/206] Reverting commit
 63495313066119dcf7510c2ae8b468b46c12ef8f by un-commenting `const` in
 `def_buffer(...)`. To make this possible, `operator T const&` and `operator T
 const*` in `smart_holder_type_caster` need to be marked as `const` member
 functions.

---
 include/pybind11/cast.h     | 28 +++++++++++++++-------------
 include/pybind11/pybind11.h |  3 +--
 2 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index edf8a65d67..ca69bde8ab 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1384,12 +1384,11 @@ struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
         return cast(const_cast<T const *>(src), policy, parent); // Mutbl2Const
     }
 
-    // clang-format off
-
 #if defined(_MSC_VER) && _MSC_VER < 1910
-    // Working around MSVC 2015 bug. `const` sensitivity is lost.
+    // Working around MSVC 2015 bug. const-correctness is lost.
     // SMART_HOLDER_WIP: IMPROVABLE: make common code work with MSVC 2015.
-    template <typename T_> using cast_op_type = detail::cast_op_type<T_>;
+    template <typename T_>
+    using cast_op_type = detail::cast_op_type<T_>;
 #else
     template <typename T_>
     using cast_op_type = conditional_t<
@@ -1397,17 +1396,20 @@ struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
         T const *,
         conditional_t<std::is_same<remove_reference_t<T_>, T *>::value,
                       T *,
-                      conditional_t<std::is_same<T_, T const &>::value,
-                                    T const &,
-                                    T &>>>;
+                      conditional_t<std::is_same<T_, T const &>::value, T const &, T &>>>;
 #endif
 
-    operator T const&() { return this->loaded_as_lvalue_ref(); }
-    operator T&()       { return this->loaded_as_lvalue_ref(); }
-    operator T const*() { return this->loaded_as_raw_ptr_unowned(); }
-    operator T*()       { return this->loaded_as_raw_ptr_unowned(); }
-
-    // clang-format on
+    // The const operators here prove that the existing type_caster mechanism already supports
+    // const-correctness. However, fully implementing const-correctness inside this type_caster
+    // is still a major project.
+    operator T const &() const {
+        return const_cast<smart_holder_type_caster *>(this)->loaded_as_lvalue_ref();
+    }
+    operator T const *() const {
+        return const_cast<smart_holder_type_caster *>(this)->loaded_as_raw_ptr_unowned();
+    }
+    operator T &() { return this->loaded_as_lvalue_ref(); }
+    operator T *() { return this->loaded_as_raw_ptr_unowned(); }
 
     // Originally type_caster_generic::cast.
     PYBIND11_NOINLINE static handle cast_const_raw_ptr(const void *_src,
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 11e75b8474..ee6f4134ba 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1430,8 +1430,7 @@ class class_ : public detail::generic_type {
 
     template <typename Return, typename Class, typename... Args>
     class_ &def_buffer(Return (Class::*func)(Args...) const) {
-        // NEEDED: Explanation why the const needs to be removed, or fix elsewhere.
-        return def_buffer([func] (/*const*/ type &obj) { return (obj.*func)(); });
+        return def_buffer([func] (const type &obj) { return (obj.*func)(); });
     }
 
     template <typename C, typename D, typename... Extra>

From 53c10649dd12a11a84bb5e28a18df8857aaab042 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 14 Feb 2021 10:40:26 -0800
Subject: [PATCH 180/206] Adding construct() overloads for constructing
 smart_holder from alias unique_ptr, shared_ptr returns.

---
 include/pybind11/detail/init.h               | 34 ++++++++++++------
 tests/test_class_sh_factory_constructors.cpp | 37 ++++++++++++++++++++
 tests/test_class_sh_factory_constructors.py  | 34 ++++++++++++++++++
 3 files changed, 95 insertions(+), 10 deletions(-)

diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index b351f21d1e..44d652f290 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -176,13 +176,20 @@ template <typename Class, typename D = std::default_delete<Cpp<Class>>,
 void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
     auto *ptr = unq_ptr.get();
     no_nullptr(ptr);
-    // If we need an alias, check that the held pointer is actually an alias instance
-    if (Class::has_alias && need_alias && !is_alias<Class>(ptr))
-        throw type_error("pybind11::init(): construction failed: returned holder-wrapped instance "
+    if (Class::has_alias && need_alias)
+        throw type_error("pybind11::init(): construction failed: returned std::unique_ptr pointee "
                          "is not an alias instance");
+    auto smhldr = smart_holder::from_unique_ptr(std::move(unq_ptr));
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
 
-    auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(unq_ptr));
-
+template <typename Class, typename D = std::default_delete<Alias<Class>>,
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, std::unique_ptr<Alias<Class>, D> &&unq_ptr, bool /*need_alias*/) {
+    auto *ptr = unq_ptr.get();
+    no_nullptr(ptr);
+    auto smhldr = smart_holder::from_unique_ptr(std::move(unq_ptr));
     v_h.value_ptr() = ptr;
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
@@ -192,13 +199,20 @@ template <typename Class,
 void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, bool need_alias) {
     auto *ptr = shd_ptr.get();
     no_nullptr(ptr);
-    // If we need an alias, check that the held pointer is actually an alias instance
-    if (Class::has_alias && need_alias && !is_alias<Class>(ptr))
-        throw type_error("pybind11::init(): construction failed: returned holder-wrapped instance "
+    if (Class::has_alias && need_alias)
+        throw type_error("pybind11::init(): construction failed: returned std::shared_ptr pointee "
                          "is not an alias instance");
+    auto smhldr = smart_holder::from_shared_ptr(std::move(shd_ptr));
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
 
-    auto smhldr = pybindit::memory::smart_holder::from_shared_ptr(std::move(shd_ptr));
-
+template <typename Class,
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, std::shared_ptr<Alias<Class>> &&shd_ptr, bool /*need_alias*/) {
+    auto *ptr = shd_ptr.get();
+    no_nullptr(ptr);
+    auto smhldr = smart_holder::from_shared_ptr(std::move(shd_ptr));
     v_h.value_ptr() = ptr;
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
diff --git a/tests/test_class_sh_factory_constructors.cpp b/tests/test_class_sh_factory_constructors.cpp
index 33bb50af2b..93dcb9938b 100644
--- a/tests/test_class_sh_factory_constructors.cpp
+++ b/tests/test_class_sh_factory_constructors.cpp
@@ -54,6 +54,15 @@ std::unique_ptr<atyp_udcp const, sddc> rtrn_udcp() { return std::unique_ptr<atyp
 
 // clang-format on
 
+// Minimalistic approach to achieve full coverage of construct() overloads for constructing
+// smart_holder from unique_ptr and shared_ptr returns.
+struct with_alias {
+    int val               = 0;
+    virtual ~with_alias() = default;
+};
+struct with_alias_alias : with_alias {};
+struct sddwaa : std::default_delete<with_alias_alias> {};
+
 } // namespace test_class_sh_factory_constructors
 } // namespace pybind11_tests
 
@@ -69,6 +78,7 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constru
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_uqcp)
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_udmp)
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::atyp_udcp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_factory_constructors::with_alias)
 
 TEST_SUBMODULE(class_sh_factory_constructors, m) {
     using namespace pybind11_tests::test_class_sh_factory_constructors;
@@ -134,4 +144,31 @@ TEST_SUBMODULE(class_sh_factory_constructors, m) {
         // classh: ... cannot pass object of non-trivial type ...
         // .def(py::init(&rtrn_udcp))
         .def("get_mtxt", get_mtxt<atyp_udcp>);
+
+    py::classh<with_alias, with_alias_alias>(m, "with_alias")
+        .def_readonly("val", &with_alias::val)
+        .def(py::init([](int i) {
+            auto p = std::unique_ptr<with_alias_alias, sddwaa>(new with_alias_alias);
+            p->val = i * 100;
+            return p;
+        }))
+        .def(py::init([](int i, int j) {
+            auto p = std::unique_ptr<with_alias_alias>(new with_alias_alias);
+            p->val = i * 100 + j * 10;
+            return p;
+        }))
+        .def(py::init([](int i, int j, int k) {
+            auto p = std::shared_ptr<with_alias_alias>(new with_alias_alias);
+            p->val = i * 100 + j * 10 + k;
+            return p;
+        }))
+        .def(py::init(
+            [](int, int, int, int) { return std::unique_ptr<with_alias>(new with_alias); },
+            [](int, int, int, int) {
+                return std::unique_ptr<with_alias>(new with_alias); // Invalid alias factory.
+            }))
+        .def(py::init([](int, int, int, int, int) { return std::make_shared<with_alias>(); },
+                      [](int, int, int, int, int) {
+                          return std::make_shared<with_alias>(); // Invalid alias factory.
+                      }));
 }
diff --git a/tests/test_class_sh_factory_constructors.py b/tests/test_class_sh_factory_constructors.py
index c28db561ee..c5227b40d5 100644
--- a/tests/test_class_sh_factory_constructors.py
+++ b/tests/test_class_sh_factory_constructors.py
@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import pytest
 
 from pybind11_tests import class_sh_factory_constructors as m
 
@@ -16,3 +17,36 @@ def test_atyp_factories():
     # sert m.atyp_uqcp().get_mtxt() == "Uqcp"
     assert m.atyp_udmp().get_mtxt() == "Udmp"
     # sert m.atyp_udcp().get_mtxt() == "Udcp"
+
+
+@pytest.mark.parametrize(
+    "init_args, expected",
+    [
+        ((3,), 300),
+        ((5, 7), 570),
+        ((9, 11, 13), 1023),
+    ],
+)
+def test_with_alias_success(init_args, expected):
+    assert m.with_alias(*init_args).val == expected
+
+
+@pytest.mark.parametrize(
+    "num_init_args, smart_ptr",
+    [
+        (4, "std::unique_ptr"),
+        (5, "std::shared_ptr"),
+    ],
+)
+def test_with_alias_invalid(num_init_args, smart_ptr):
+    class PyDrvdWithAlias(m.with_alias):
+        pass
+
+    with pytest.raises(TypeError) as excinfo:
+        PyDrvdWithAlias(*((0,) * num_init_args))
+    assert (
+        str(excinfo.value)
+        == "pybind11::init(): construction failed: returned "
+        + smart_ptr
+        + " pointee is not an alias instance"
+    )

From 2bf0721595bc79cdca7c38221c61d08f753df6f8 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 14 Feb 2021 21:30:14 -0800
Subject: [PATCH 181/206] Adding test_class_sh_factory_constructors.cpp to
 tests/CMakeLists.txt (fixes oversight, this should have been added long
 before).

---
 tests/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 41f6d47bbc..ef6fc28f11 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -102,6 +102,7 @@ set(PYBIND11_TEST_FILES
     test_chrono.cpp
     test_class.cpp
     test_class_sh_basic.cpp
+    test_class_sh_factory_constructors.cpp
     test_class_sh_inheritance.cpp
     test_class_sh_unique_ptr_member.cpp
     test_constants_and_functions.cpp

From fa54ccb31bf2d3bfbec93a64c045fcb394da5abe Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 14 Feb 2021 21:54:56 -0800
Subject: [PATCH 182/206] Compatibility with old clang versions (clang 3.6, 3.7
 C++11).

---
 tests/test_class_sh_factory_constructors.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/test_class_sh_factory_constructors.cpp b/tests/test_class_sh_factory_constructors.cpp
index 93dcb9938b..9a0e5f18d9 100644
--- a/tests/test_class_sh_factory_constructors.cpp
+++ b/tests/test_class_sh_factory_constructors.cpp
@@ -59,6 +59,12 @@ std::unique_ptr<atyp_udcp const, sddc> rtrn_udcp() { return std::unique_ptr<atyp
 struct with_alias {
     int val               = 0;
     virtual ~with_alias() = default;
+    // Some compilers complain about implicitly defined versions of some of the following:
+    with_alias()                   = default;
+    with_alias(const with_alias &) = default;
+    with_alias(with_alias &&)      = default;
+    with_alias &operator=(const with_alias &) = default;
+    with_alias &operator=(with_alias &&) = default;
 };
 struct with_alias_alias : with_alias {};
 struct sddwaa : std::default_delete<with_alias_alias> {};

From 010cdec12a6df6bc446eeca39257dbf2fc0afe17 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 15 Feb 2021 12:49:34 -0800
Subject: [PATCH 183/206] Cleaning up changes to existing unit tests.

---
 tests/test_class.cpp                |   7 +-
 tests/test_multiple_inheritance.cpp |  41 +--
 tests/test_smart_ptr.cpp            | 376 ++++++++++++++--------------
 3 files changed, 216 insertions(+), 208 deletions(-)

diff --git a/tests/test_class.cpp b/tests/test_class.cpp
index e6e7e5d62b..4b1857e85b 100644
--- a/tests/test_class.cpp
+++ b/tests/test_class.cpp
@@ -23,6 +23,8 @@
 #  pragma warning(disable: 4324) // warning C4324: structure was padded due to alignment specifier
 #endif
 
+namespace {
+
 // test_brace_initialization
 struct NoBraceInitialization {
     NoBraceInitialization(std::vector<int> v) : vec{std::move(v)} {}
@@ -32,14 +34,17 @@ struct NoBraceInitialization {
     std::vector<int> vec;
 };
 
+// test_mismatched_holder
 struct MismatchBase1 { };
 struct MismatchDerived1 : MismatchBase1 { };
-
 struct MismatchBase2 { };
 struct MismatchDerived2 : MismatchBase2 { };
 
+// test_multiple_instances_with_same_pointer
 struct SamePointer {};
 
+} // namespace
+
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MismatchBase1, std::shared_ptr<MismatchBase1>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MismatchDerived1, std::unique_ptr<MismatchDerived1>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MismatchBase2, std::unique_ptr<MismatchBase2>)
diff --git a/tests/test_multiple_inheritance.cpp b/tests/test_multiple_inheritance.cpp
index f1aea0340f..bf307fc7ea 100644
--- a/tests/test_multiple_inheritance.cpp
+++ b/tests/test_multiple_inheritance.cpp
@@ -11,6 +11,8 @@
 #include "pybind11_tests.h"
 #include "constructor_stats.h"
 
+namespace {
+
 // Many bases for testing that multiple inheritance from many classes (i.e. requiring extra
 // space for holder constructed flags) works.
 template <int N> struct BaseN {
@@ -43,26 +45,27 @@ int WithStatic2::static_value2 = 2;
 int VanillaStaticMix1::static_value = 12;
 int VanillaStaticMix2::static_value = 12;
 
-namespace {
-
-    struct Base1a {
-        Base1a(int i) : i(i) { }
-        int foo() { return i; }
-        int i;
-    };
-    struct Base2a {
-        Base2a(int i) : i(i) { }
-        int bar() { return i; }
-        int i;
-    };
-    struct Base12a : Base1a, Base2a {
-        Base12a(int i, int j) : Base1a(i), Base2a(j) { }
-    };
+// test_multiple_inheritance_virtbase
+struct Base1a {
+    Base1a(int i) : i(i) { }
+    int foo() { return i; }
+    int i;
+};
+struct Base2a {
+    Base2a(int i) : i(i) { }
+    int bar() { return i; }
+    int i;
+};
+struct Base12a : Base1a, Base2a {
+    Base12a(int i, int j) : Base1a(i), Base2a(j) { }
+};
 
-    struct I801B1 { int a = 1; I801B1() = default; I801B1(const I801B1 &) = default; virtual ~I801B1() = default; };
-    struct I801B2 { int b = 2; I801B2() = default; I801B2(const I801B2 &) = default; virtual ~I801B2() = default; };
-    struct I801C : I801B1, I801B2 {};
-    struct I801D : I801C {}; // Indirect MI
+// test_mi_unaligned_base
+// test_mi_base_return
+struct I801B1 { int a = 1; I801B1() = default; I801B1(const I801B1 &) = default; virtual ~I801B1() = default; };
+struct I801B2 { int b = 2; I801B2() = default; I801B2(const I801B2 &) = default; virtual ~I801B2() = default; };
+struct I801C : I801B1, I801B2 {};
+struct I801D : I801C {}; // Indirect MI
 
 } // namespace
 
diff --git a/tests/test_smart_ptr.cpp b/tests/test_smart_ptr.cpp
index 50062c59ff..6ffa2972f2 100644
--- a/tests/test_smart_ptr.cpp
+++ b/tests/test_smart_ptr.cpp
@@ -15,23 +15,7 @@
 #include "pybind11_tests.h"
 #include "object.h"
 
-// Make pybind aware of the ref-counted wrapper type (s):
-
-// ref<T> is a wrapper for 'Object' which uses intrusive reference counting
-// It is always possible to construct a ref<T> from an Object* pointer without
-// possible inconsistencies, hence the 'true' argument at the end.
-PYBIND11_DECLARE_HOLDER_TYPE(T, ref<T>, true);
-// Make pybind11 aware of the non-standard getter member function
-namespace pybind11 { namespace detail {
-    template <typename T>
-    struct holder_helper<ref<T>> {
-        static const T *get(const ref<T> &p) { return p.get_ptr(); }
-    };
-} // namespace detail
-} // namespace pybind11
-
-// The following is not required anymore for std::shared_ptr, but it should compile without error:
-PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>);
+namespace {
 
 // This is just a wrapper around unique_ptr, but with extra fields to deliberately bloat up the
 // holder size to trigger the non-simple-layout internal instance layout for single inheritance with
@@ -43,7 +27,6 @@ template <typename T> class huge_unique_ptr {
     huge_unique_ptr(T *p) : ptr(p) {};
     T *get() { return ptr.get(); }
 };
-PYBIND11_DECLARE_HOLDER_TYPE(T, huge_unique_ptr<T>);
 
 // Simple custom holder that works like unique_ptr
 template <typename T>
@@ -54,7 +37,6 @@ class custom_unique_ptr {
     T* get() const { return impl.get(); }
     T* release_ptr() { return impl.release(); }
 };
-PYBIND11_DECLARE_HOLDER_TYPE(T, custom_unique_ptr<T>);
 
 // Simple custom holder that works like shared_ptr and has operator& overload
 // To obtain address of an instance of this holder pybind should use std::addressof
@@ -68,7 +50,6 @@ class shared_ptr_with_addressof_operator {
     T* get() const { return impl.get(); }
     T** operator&() { throw std::logic_error("Call of overloaded operator& is not expected"); }
 };
-PYBIND11_DECLARE_HOLDER_TYPE(T, shared_ptr_with_addressof_operator<T>);
 
 // Simple custom holder that works like unique_ptr and has operator& overload
 // To obtain address of an instance of this holder pybind should use std::addressof
@@ -83,194 +64,214 @@ class unique_ptr_with_addressof_operator {
     T* release_ptr() { return impl.release(); }
     T** operator&() { throw std::logic_error("Call of overloaded operator& is not expected"); }
 };
-PYBIND11_DECLARE_HOLDER_TYPE(T, unique_ptr_with_addressof_operator<T>);
 
-namespace {
-    // Custom object with builtin reference counting (see 'object.h' for the implementation)
-    class MyObject1 : public Object {
-    public:
-        MyObject1(int value) : value(value) { print_created(this, toString()); }
-        std::string toString() const override { return "MyObject1[" + std::to_string(value) + "]"; }
-    protected:
-        ~MyObject1() override { print_destroyed(this); }
-    private:
-        int value;
-    };
+// Custom object with builtin reference counting (see 'object.h' for the implementation)
+class MyObject1 : public Object {
+public:
+    MyObject1(int value) : value(value) { print_created(this, toString()); }
+    std::string toString() const override { return "MyObject1[" + std::to_string(value) + "]"; }
+protected:
+    ~MyObject1() override { print_destroyed(this); }
+private:
+    int value;
+};
 
-    // Object managed by a std::shared_ptr<>
-    class MyObject2 {
-    public:
-        MyObject2(const MyObject2 &) = default;
-        MyObject2(int value) : value(value) { print_created(this, toString()); }
-        std::string toString() const { return "MyObject2[" + std::to_string(value) + "]"; }
-        virtual ~MyObject2() { print_destroyed(this); }
-    private:
-        int value;
-    };
+// Object managed by a std::shared_ptr<>
+class MyObject2 {
+public:
+    MyObject2(const MyObject2 &) = default;
+    MyObject2(int value) : value(value) { print_created(this, toString()); }
+    std::string toString() const { return "MyObject2[" + std::to_string(value) + "]"; }
+    virtual ~MyObject2() { print_destroyed(this); }
+private:
+    int value;
+};
 
-    // Object managed by a std::shared_ptr<>, additionally derives from std::enable_shared_from_this<>
-    class MyObject3 : public std::enable_shared_from_this<MyObject3> {
-    public:
-        MyObject3(const MyObject3 &) = default;
-        MyObject3(int value) : value(value) { print_created(this, toString()); }
-        std::string toString() const { return "MyObject3[" + std::to_string(value) + "]"; }
-        virtual ~MyObject3() { print_destroyed(this); }
-    private:
-        int value;
-    };
+// Object managed by a std::shared_ptr<>, additionally derives from std::enable_shared_from_this<>
+class MyObject3 : public std::enable_shared_from_this<MyObject3> {
+public:
+    MyObject3(const MyObject3 &) = default;
+    MyObject3(int value) : value(value) { print_created(this, toString()); }
+    std::string toString() const { return "MyObject3[" + std::to_string(value) + "]"; }
+    virtual ~MyObject3() { print_destroyed(this); }
+private:
+    int value;
+};
 
-    // test_unique_nodelete
-    // Object with a private destructor
-    class MyObject4;
-    static std::unordered_set<MyObject4 *> myobject4_instances;
-    class MyObject4 {
-    public:
-        MyObject4(int value) : value{value} {
-            print_created(this);
-            myobject4_instances.insert(this);
-        }
-        int value;
-
-        static void cleanupAllInstances() {
-            auto tmp = std::move(myobject4_instances);
-            myobject4_instances.clear();
-            for (auto o : tmp)
-                delete o;
-        }
-    private:
-        ~MyObject4() {
-            myobject4_instances.erase(this);
-            print_destroyed(this);
-        }
-    };
+// test_unique_nodelete
+// Object with a private destructor
+class MyObject4;
+static std::unordered_set<MyObject4 *> myobject4_instances;
+class MyObject4 {
+public:
+    MyObject4(int value) : value{value} {
+        print_created(this);
+        myobject4_instances.insert(this);
+    }
+    int value;
+
+    static void cleanupAllInstances() {
+        auto tmp = std::move(myobject4_instances);
+        myobject4_instances.clear();
+        for (auto o : tmp)
+            delete o;
+    }
+private:
+    ~MyObject4() {
+        myobject4_instances.erase(this);
+        print_destroyed(this);
+    }
+};
 
-    // test_unique_deleter
-    // Object with std::unique_ptr<T, D> where D is not matching the base class
-    // Object with a protected destructor
-    class MyObject4a;
-    static std::unordered_set<MyObject4a *> myobject4a_instances;
-    class MyObject4a {
-    public:
-        MyObject4a(int i) {
-            value = i;
-            print_created(this);
-            myobject4a_instances.insert(this);
-        };
-        int value;
-
-        static void cleanupAllInstances() {
-            auto tmp = std::move(myobject4a_instances);
-            myobject4a_instances.clear();
-            for (auto o : tmp)
-                delete o;
-        }
-    protected:
-        virtual ~MyObject4a() {
-            myobject4a_instances.erase(this);
-            print_destroyed(this);
-        }
+// test_unique_deleter
+// Object with std::unique_ptr<T, D> where D is not matching the base class
+// Object with a protected destructor
+class MyObject4a;
+static std::unordered_set<MyObject4a *> myobject4a_instances;
+class MyObject4a {
+public:
+    MyObject4a(int i) {
+        value = i;
+        print_created(this);
+        myobject4a_instances.insert(this);
     };
+    int value;
+
+    static void cleanupAllInstances() {
+        auto tmp = std::move(myobject4a_instances);
+        myobject4a_instances.clear();
+        for (auto o : tmp)
+            delete o;
+    }
+protected:
+    virtual ~MyObject4a() {
+        myobject4a_instances.erase(this);
+        print_destroyed(this);
+    }
+};
 
-    // Object derived but with public destructor and no Deleter in default holder
-    class MyObject4b : public MyObject4a {
-    public:
-        MyObject4b(int i) : MyObject4a(i) { print_created(this); }
-        ~MyObject4b() override { print_destroyed(this); }
-    };
+// Object derived but with public destructor and no Deleter in default holder
+class MyObject4b : public MyObject4a {
+public:
+    MyObject4b(int i) : MyObject4a(i) { print_created(this); }
+    ~MyObject4b() override { print_destroyed(this); }
+};
 
-    // test_large_holder
-    class MyObject5 { // managed by huge_unique_ptr
-    public:
-        MyObject5(int value) : value{value} { print_created(this); }
-        ~MyObject5() { print_destroyed(this); }
-        int value;
-    };
+// test_large_holder
+class MyObject5 { // managed by huge_unique_ptr
+public:
+    MyObject5(int value) : value{value} { print_created(this); }
+    ~MyObject5() { print_destroyed(this); }
+    int value;
+};
 
-    // test_shared_ptr_and_references
-    struct SharedPtrRef {
-        struct A {
-            A() { print_created(this); }
-            A(const A &) { print_copy_created(this); }
-            A(A &&) { print_move_created(this); }
-            ~A() { print_destroyed(this); }
-        };
-
-        A value = {};
-        std::shared_ptr<A> shared = std::make_shared<A>();
+// test_shared_ptr_and_references
+struct SharedPtrRef {
+    struct A {
+        A() { print_created(this); }
+        A(const A &) { print_copy_created(this); }
+        A(A &&) { print_move_created(this); }
+        ~A() { print_destroyed(this); }
     };
 
-    // test_shared_ptr_from_this_and_references
-    struct SharedFromThisRef {
-        struct B : std::enable_shared_from_this<B> {
-            B() { print_created(this); }
-            B(const B &) : std::enable_shared_from_this<B>() { print_copy_created(this); }
-            B(B &&) : std::enable_shared_from_this<B>() { print_move_created(this); }
-            ~B() { print_destroyed(this); }
-        };
-
-        B value = {};
-        std::shared_ptr<B> shared = std::make_shared<B>();
-    };
+    A value = {};
+    std::shared_ptr<A> shared = std::make_shared<A>();
+};
 
-    // Issue #865: shared_from_this doesn't work with virtual inheritance
-    struct SharedFromThisVBase : std::enable_shared_from_this<SharedFromThisVBase> {
-        SharedFromThisVBase() = default;
-        SharedFromThisVBase(const SharedFromThisVBase &) = default;
-        virtual ~SharedFromThisVBase() = default;
+// test_shared_ptr_from_this_and_references
+struct SharedFromThisRef {
+    struct B : std::enable_shared_from_this<B> {
+        B() { print_created(this); }
+        B(const B &) : std::enable_shared_from_this<B>() { print_copy_created(this); }
+        B(B &&) : std::enable_shared_from_this<B>() { print_move_created(this); }
+        ~B() { print_destroyed(this); }
     };
-    struct SharedFromThisVirt : virtual SharedFromThisVBase {};
 
-    // test_move_only_holder
-    struct C {
-        C() { print_created(this); }
-        ~C() { print_destroyed(this); }
-    };
+    B value = {};
+    std::shared_ptr<B> shared = std::make_shared<B>();
+};
 
-    // test_holder_with_addressof_operator
-    struct TypeForHolderWithAddressOf {
-        TypeForHolderWithAddressOf() { print_created(this); }
-        TypeForHolderWithAddressOf(const TypeForHolderWithAddressOf &) { print_copy_created(this); }
-        TypeForHolderWithAddressOf(TypeForHolderWithAddressOf &&) { print_move_created(this); }
-        ~TypeForHolderWithAddressOf() { print_destroyed(this); }
-        std::string toString() const {
-            return "TypeForHolderWithAddressOf[" + std::to_string(value) + "]";
-        }
-        int value = 42;
-    };
+// Issue #865: shared_from_this doesn't work with virtual inheritance
+struct SharedFromThisVBase : std::enable_shared_from_this<SharedFromThisVBase> {
+    SharedFromThisVBase() = default;
+    SharedFromThisVBase(const SharedFromThisVBase &) = default;
+    virtual ~SharedFromThisVBase() = default;
+};
+struct SharedFromThisVirt : virtual SharedFromThisVBase {};
 
-    // test_move_only_holder_with_addressof_operator
-    struct TypeForMoveOnlyHolderWithAddressOf {
-        TypeForMoveOnlyHolderWithAddressOf(int value) : value{value} { print_created(this); }
-        ~TypeForMoveOnlyHolderWithAddressOf() { print_destroyed(this); }
-        std::string toString() const {
-            return "MoveOnlyHolderWithAddressOf[" + std::to_string(value) + "]";
-        }
-        int value;
-    };
+// test_move_only_holder
+struct C {
+    C() { print_created(this); }
+    ~C() { print_destroyed(this); }
+};
 
-    // test_smart_ptr_from_default
-    struct HeldByDefaultHolder { };
+// test_holder_with_addressof_operator
+struct TypeForHolderWithAddressOf {
+    TypeForHolderWithAddressOf() { print_created(this); }
+    TypeForHolderWithAddressOf(const TypeForHolderWithAddressOf &) { print_copy_created(this); }
+    TypeForHolderWithAddressOf(TypeForHolderWithAddressOf &&) { print_move_created(this); }
+    ~TypeForHolderWithAddressOf() { print_destroyed(this); }
+    std::string toString() const {
+        return "TypeForHolderWithAddressOf[" + std::to_string(value) + "]";
+    }
+    int value = 42;
+};
 
-    // test_shared_ptr_gc
-    // #187: issue involving std::shared_ptr<> return value policy & garbage collection
-    struct ElementBase {
-        virtual ~ElementBase() = default; /* Force creation of virtual table */
-        ElementBase() = default;
-        ElementBase(const ElementBase&) = delete;
-    };
+// test_move_only_holder_with_addressof_operator
+struct TypeForMoveOnlyHolderWithAddressOf {
+    TypeForMoveOnlyHolderWithAddressOf(int value) : value{value} { print_created(this); }
+    ~TypeForMoveOnlyHolderWithAddressOf() { print_destroyed(this); }
+    std::string toString() const {
+        return "MoveOnlyHolderWithAddressOf[" + std::to_string(value) + "]";
+    }
+    int value;
+};
 
-    struct ElementA : ElementBase {
-        ElementA(int v) : v(v) { }
-        int value() { return v; }
-        int v;
-    };
+// test_smart_ptr_from_default
+struct HeldByDefaultHolder { };
+
+// test_shared_ptr_gc
+// #187: issue involving std::shared_ptr<> return value policy & garbage collection
+struct ElementBase {
+    virtual ~ElementBase() = default; /* Force creation of virtual table */
+    ElementBase() = default;
+    ElementBase(const ElementBase&) = delete;
+};
+
+struct ElementA : ElementBase {
+    ElementA(int v) : v(v) { }
+    int value() { return v; }
+    int v;
+};
+
+struct ElementList {
+    void add(std::shared_ptr<ElementBase> e) { l.push_back(e); }
+    std::vector<std::shared_ptr<ElementBase>> l;
+};
 
-    struct ElementList {
-        void add(std::shared_ptr<ElementBase> e) { l.push_back(e); }
-        std::vector<std::shared_ptr<ElementBase>> l;
-    };
 } // namespace
 
+// ref<T> is a wrapper for 'Object' which uses intrusive reference counting
+// It is always possible to construct a ref<T> from an Object* pointer without
+// possible inconsistencies, hence the 'true' argument at the end.
+// Make pybind11 aware of the non-standard getter member function
+namespace pybind11 { namespace detail {
+    template <typename T>
+    struct holder_helper<ref<T>> {
+        static const T *get(const ref<T> &p) { return p.get_ptr(); }
+    };
+} // namespace detail
+} // namespace pybind11
+
+// Make pybind aware of the ref-counted wrapper type (s):
+PYBIND11_DECLARE_HOLDER_TYPE(T, ref<T>, true);
+// The following is not required anymore for std::shared_ptr, but it should compile without error:
+PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>);
+PYBIND11_DECLARE_HOLDER_TYPE(T, huge_unique_ptr<T>);
+PYBIND11_DECLARE_HOLDER_TYPE(T, custom_unique_ptr<T>);
+PYBIND11_DECLARE_HOLDER_TYPE(T, shared_ptr_with_addressof_operator<T>);
+PYBIND11_DECLARE_HOLDER_TYPE(T, unique_ptr_with_addressof_operator<T>);
+
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(Object, ref<Object>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject1, ref<MyObject1>)
 PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(MyObject2, std::shared_ptr<MyObject2>)
@@ -295,8 +296,7 @@ PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(ElementList, std::shared_ptr<ElementL
 #ifdef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
 // To prevent triggering a static_assert in the smart_holder code.
 // This is a very special case, because the associated test exercises a holder mismatch.
-namespace pybind11 {
-namespace detail {
+namespace pybind11 { namespace detail {
 template <>
 class type_caster<std::shared_ptr<HeldByDefaultHolder>>
     : public copyable_holder_caster<HeldByDefaultHolder, std::shared_ptr<HeldByDefaultHolder>> {};

From 413c23b3543b4780ff029f0206eb827853a83df5 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 15 Feb 2021 13:01:17 -0800
Subject: [PATCH 184/206] Systematically adding SMART_HOLDER_WIP tag. Removing
 minor UNTESTED tags (only the throw are not actually exercised, investing
 time there has a high cost but very little benefit).

---
 include/pybind11/cast.h | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index ca69bde8ab..9a9c994147 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1244,7 +1244,7 @@ struct smart_holder_type_caster_load {
     }
 
     T *loaded_as_raw_ptr_unowned() const {
-        void *void_ptr = load_impl.unowned_void_ptr_from_direct_conversion; // UNTESTED.
+        void *void_ptr = load_impl.unowned_void_ptr_from_direct_conversion;
         if (void_ptr == nullptr) {
             if (have_holder()) {
                 throw_if_uninitialized_or_disowned_holder();
@@ -1266,7 +1266,7 @@ struct smart_holder_type_caster_load {
     std::shared_ptr<T> loaded_as_shared_ptr() const {
         if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
             throw cast_error("Unowned pointer from direct conversion cannot be converted to a"
-                             " std::shared_ptr."); // UNTESTED.
+                             " std::shared_ptr.");
         if (!have_holder()) return nullptr;
         throw_if_uninitialized_or_disowned_holder();
         std::shared_ptr<void> void_ptr = holder().template as_shared_ptr<void>();
@@ -1277,13 +1277,13 @@ struct smart_holder_type_caster_load {
     std::unique_ptr<T, D> loaded_as_unique_ptr(const char *context = "loaded_as_unique_ptr") {
         if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
             throw cast_error("Unowned pointer from direct conversion cannot be converted to a"
-                             " std::unique_ptr."); // UNTESTED.
+                             " std::unique_ptr.");
         if (!have_holder()) return nullptr;
         throw_if_uninitialized_or_disowned_holder();
         holder().template ensure_compatible_rtti_uqp_del<T, D>(context);
         holder().ensure_use_count_1(context);
         auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
-        // MISSING: Safety checks for type conversions
+        // SMART_HOLDER_WIP: MISSING: Safety checks for type conversions
         // (T must be polymorphic or meet certain other conditions).
         T *raw_type_ptr = convert_type(raw_void_ptr);
 
@@ -1332,7 +1332,7 @@ struct smart_holder_type_caster_load {
     }
 };
 
-// IMPROVABLE: Formally factor out of type_caster_base.
+// SMART_HOLDER_WIP: IMPROVABLE: Formally factor out of type_caster_base.
 struct make_constructor : private type_caster_base<int> { // Any type, nothing special about int.
     using type_caster_base<int>::Constructor;
     using type_caster_base<int>::make_copy_constructor;
@@ -1508,7 +1508,7 @@ struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_l
     static handle cast(const std::shared_ptr<T> &src, return_value_policy policy, handle parent) {
         if (policy != return_value_policy::automatic
             && policy != return_value_policy::reference_internal) {
-            // IMPROVABLE: Error message.
+            // SMART_HOLDER_WIP: IMPROVABLE: Error message.
             throw cast_error("Invalid return_value_policy for shared_ptr.");
         }
 
@@ -1520,8 +1520,8 @@ struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_l
         void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
         const detail::type_info *tinfo = st.second;
         if (handle existing_inst = find_registered_python_instance(src_raw_void_ptr, tinfo))
-            // MISSING: Enforcement of consistency with existing smart_holder.
-            // MISSING: keep_alive.
+            // SMART_HOLDER_WIP: MISSING: Enforcement of consistency with existing smart_holder.
+            // SMART_HOLDER_WIP: MISSING: keep_alive.
             return existing_inst;
 
         auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
@@ -1573,7 +1573,7 @@ struct smart_holder_type_caster<std::unique_ptr<T, D>> : smart_holder_type_caste
         if (policy != return_value_policy::automatic
             && policy != return_value_policy::reference_internal
             && policy != return_value_policy::move) {
-            // IMPROVABLE: Error message.
+            // SMART_HOLDER_WIP: IMPROVABLE: Error message.
             throw cast_error("Invalid return_value_policy for unique_ptr.");
         }
 

From b222aa40748abfe5fc12d745a38f16c2da85db35 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 15 Feb 2021 13:46:19 -0800
Subject: [PATCH 185/206] Splitting out smart_holder_type_casters again, into
 new detail/smart_holder_type_casters_inline_include.h.

---
 include/pybind11/cast.h                       | 692 +-----------------
 ...smart_holder_type_casters_inline_include.h | 688 +++++++++++++++++
 2 files changed, 698 insertions(+), 682 deletions(-)
 create mode 100644 include/pybind11/detail/smart_holder_type_casters_inline_include.h

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 9a9c994147..3aeefa3566 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -18,7 +18,6 @@
 #include "detail/common.h"
 #include "detail/descr.h"
 #include "detail/internals.h"
-#include "detail/smart_holder_poc.h"
 #include <array>
 #include <cstring>
 #include <functional>
@@ -49,9 +48,6 @@
 #endif
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-using pybindit::memory::smart_holder;
-
 PYBIND11_NAMESPACE_BEGIN(detail)
 
 /// A life support system for temporary objects created by `type_caster::load()`.
@@ -972,684 +968,16 @@ struct is_smart_holder_type_caster_base_tag {};
 template <typename T>
 struct is_smart_holder_type_caster;
 
-//DETAIL/SMART_HOLDER_TYPE_CASTERS_H/BEGIN/////////////////////////////////////////////////////////
-
-//FWD begin
-inline void register_instance(instance *self, void *valptr, const type_info *tinfo);
-inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo);
-//FWD end
-
-// The modified_type_caster_generic_load_impl could replace type_caster_generic::load_impl but not
-// vice versa. The main difference is that the original code only propagates a reference to the
-// held value, while the modified implementation propagates value_and_holder.
-// clang-format off
-class modified_type_caster_generic_load_impl {
-public:
-    PYBIND11_NOINLINE modified_type_caster_generic_load_impl(const std::type_info &type_info)
-        : typeinfo(get_type_info(type_info)), cpptype(&type_info) { }
-
-    explicit modified_type_caster_generic_load_impl(const type_info *typeinfo = nullptr)
-        : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { }
-
-    bool load(handle src, bool convert) {
-        return load_impl<modified_type_caster_generic_load_impl>(src, convert);
-    }
-
-    // Base methods for generic caster; there are overridden in copyable_holder_caster
-    void load_value_and_holder(value_and_holder &&v_h) {
-        if (!v_h.holder_constructed()) {
-            // This is needed for old-style __init__.
-            // type_caster_generic::load_value BEGIN
-            auto *&vptr = v_h.value_ptr();
-            // Lazy allocation for unallocated values:
-            if (vptr == nullptr) {
-                // Lazy allocation for unallocated values:
-                auto *type = v_h.type ? v_h.type : typeinfo;
-                if (type->operator_new) {
-                    vptr = type->operator_new(type->type_size);
-                } else {
-                    #if defined(__cpp_aligned_new) && (!defined(_MSC_VER) || _MSC_VER >= 1912)
-                        if (type->type_align > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
-                            vptr = ::operator new(type->type_size,
-                                                  std::align_val_t(type->type_align));
-                        else
-                    #endif
-                    vptr = ::operator new(type->type_size);
-                }
-            }
-            // type_caster_generic::load_value END
-        }
-        loaded_v_h = std::move(v_h);
-        loaded_v_h.type = typeinfo;
-    }
-
-    bool try_implicit_casts(handle src, bool convert) {
-        for (auto &cast : typeinfo->implicit_casts) {
-            modified_type_caster_generic_load_impl sub_caster(*cast.first);
-            if (sub_caster.load(src, convert)) {
-                if (loaded_v_h_cpptype != nullptr) {
-                    pybind11_fail("smart_holder_type_casters: try_implicit_casts failure.");
-                }
-                loaded_v_h = sub_caster.loaded_v_h;
-                loaded_v_h_cpptype = cast.first;
-                implicit_cast = cast.second;
-                return true;
-            }
-        }
-        return false;
-    }
-
-    bool try_direct_conversions(handle src) {
-        for (auto &converter : *typeinfo->direct_conversions) {
-            if (converter(src.ptr(), unowned_void_ptr_from_direct_conversion)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
-        std::unique_ptr<modified_type_caster_generic_load_impl> loader(
-            new modified_type_caster_generic_load_impl(ti));
-        if (loader->load(src, false)) {
-            // Trick to work with the existing pybind11 internals.
-            // The void pointer is immediately captured in a new unique_ptr in
-            // try_load_foreign_module_local. If this assumption is violated sanitizers
-            // will most likely flag a leak (verified to be the case with ASAN).
-            return static_cast<void *>(loader.release());
-        }
-        return nullptr;
-    }
-
-    /// Try to load with foreign typeinfo, if available. Used when there is no
-    /// native typeinfo, or when the native one wasn't able to produce a value.
-    PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) {
-        constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
-        const auto pytype = type::handle_of(src);
-        if (!hasattr(pytype, local_key))
-            return false;
-
-        type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key));
-        // Only consider this foreign loader if actually foreign and is a loader of the correct cpp type
-        if (foreign_typeinfo->module_local_load == &local_load
-            || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype)))
-            return false;
-
-        void* foreign_loader_void_ptr =
-            foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo);
-        if (foreign_loader_void_ptr != nullptr) {
-            auto foreign_loader = std::unique_ptr<modified_type_caster_generic_load_impl>(
-                static_cast<modified_type_caster_generic_load_impl *>(foreign_loader_void_ptr));
-            // Magic number intentionally hard-coded for simplicity and maximum robustness.
-            if (foreign_loader->local_load_safety_guard != 1887406645) {
-                pybind11_fail(
-                    "smart_holder_type_casters: Unexpected local_load_safety_guard,"
-                    " possibly due to py::class_ holder mixup.");
-            }
-            if (loaded_v_h_cpptype != nullptr) {
-                pybind11_fail("smart_holder_type_casters: try_load_foreign_module_local failure.");
-            }
-            loaded_v_h = foreign_loader->loaded_v_h;
-            loaded_v_h_cpptype = foreign_loader->loaded_v_h_cpptype;
-            implicit_cast = foreign_loader->implicit_cast;
-            return true;
-        }
-        return false;
-    }
-
-    // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
-    // bits of code between here and copyable_holder_caster where the two classes need different
-    // logic (without having to resort to virtual inheritance).
-    template <typename ThisT>
-    PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
-        if (!src) return false;
-        if (!typeinfo) return try_load_foreign_module_local(src);
-        if (src.is_none()) {
-            // Defer accepting None to other overloads (if we aren't in convert mode):
-            if (!convert) return false;
-            loaded_v_h = value_and_holder();
-            return true;
-        }
-
-        auto &this_ = static_cast<ThisT &>(*this);
-
-        PyTypeObject *srctype = Py_TYPE(src.ptr());
-
-        // Case 1: If src is an exact type match for the target type then we can reinterpret_cast
-        // the instance's value pointer to the target type:
-        if (srctype == typeinfo->type) {
-            this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
-            return true;
-        }
-        // Case 2: We have a derived class
-        else if (PyType_IsSubtype(srctype, typeinfo->type)) {
-            auto &bases = all_type_info(srctype); // subtype bases
-            bool no_cpp_mi = typeinfo->simple_type;
-
-            // Case 2a: the python type is a Python-inherited derived class that inherits from just
-            // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of
-            // the right type and we can use reinterpret_cast.
-            // (This is essentially the same as case 2b, but because not using multiple inheritance
-            // is extremely common, we handle it specially to avoid the loop iterator and type
-            // pointer lookup overhead)
-            if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
-                this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
-                loaded_v_h_cpptype = bases.front()->cpptype;
-                reinterpret_cast_deemed_ok = true;
-                return true;
-            }
-            // Case 2b: the python type inherits from multiple C++ bases.  Check the bases to see if
-            // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we
-            // can safely reinterpret_cast to the relevant pointer.
-            else if (bases.size() > 1) {
-                for (auto base : bases) {
-                    if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
-                        this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
-                        loaded_v_h_cpptype = base->cpptype;
-                        reinterpret_cast_deemed_ok = true;
-                        return true;
-                    }
-                }
-            }
-
-            // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match
-            // in the registered bases, above, so try implicit casting (needed for proper C++ casting
-            // when MI is involved).
-            if (this_.try_implicit_casts(src, convert)) {
-                return true;
-            }
-        }
-
-        // Perform an implicit conversion
-        if (convert) {
-            for (auto &converter : typeinfo->implicit_conversions) {
-                auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
-                if (load_impl<ThisT>(temp, false)) {
-                    loader_life_support::add_patient(temp);
-                    return true;
-                }
-            }
-            if (this_.try_direct_conversions(src))
-                return true;
-        }
-
-        // Failed to match local typeinfo. Try again with global.
-        if (typeinfo->module_local) {
-            if (auto gtype = get_global_type_info(*typeinfo->cpptype)) {
-                typeinfo = gtype;
-                return load(src, false);
-            }
-        }
-
-        // Global typeinfo has precedence over foreign module_local
-        return try_load_foreign_module_local(src);
-    }
-
-    const type_info *typeinfo = nullptr;
-    const std::type_info *cpptype = nullptr;
-    void *unowned_void_ptr_from_direct_conversion = nullptr;
-    const std::type_info *loaded_v_h_cpptype = nullptr;
-    void *(*implicit_cast)(void *) = nullptr;
-    value_and_holder loaded_v_h;
-    bool reinterpret_cast_deemed_ok = false;
-    // Magic number intentionally hard-coded, to guard against class_ holder mixups.
-    // Ideally type_caster_generic would have a similar guard, but this requires a change there.
-    std::size_t local_load_safety_guard = 1887406645; // 32-bit compatible value for portability.
-};
-// clang-format on
-
-struct smart_holder_type_caster_class_hooks : is_smart_holder_type_caster_base_tag {
-    static decltype(&modified_type_caster_generic_load_impl::local_load)
-    get_local_load_function_ptr() {
-        return &modified_type_caster_generic_load_impl::local_load;
-    }
-
-    template <typename T>
-    static void init_instance_for_type(detail::instance *inst, const void *holder_const_void_ptr) {
-        // Need for const_cast is a consequence of the type_info::init_instance type:
-        // void (*init_instance)(instance *, const void *);
-        auto holder_void_ptr = const_cast<void *>(holder_const_void_ptr);
-
-        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(T)));
-        if (!v_h.instance_registered()) {
-            register_instance(inst, v_h.value_ptr(), v_h.type);
-            v_h.set_instance_registered();
-        }
-        using holder_type = pybindit::memory::smart_holder;
-        if (holder_void_ptr) {
-            // Note: inst->owned ignored.
-            auto holder_ptr = static_cast<holder_type *>(holder_void_ptr);
-            new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*holder_ptr));
-        } else if (inst->owned) {
-            new (std::addressof(v_h.holder<holder_type>()))
-                holder_type(holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<T>()));
-        } else {
-            new (std::addressof(v_h.holder<holder_type>()))
-                holder_type(holder_type::from_raw_ptr_unowned(v_h.value_ptr<T>()));
-        }
-        v_h.set_holder_constructed();
-    }
-};
-
-template <typename T>
-struct smart_holder_type_caster_load {
-    using holder_type = pybindit::memory::smart_holder;
-
-    bool load(handle src, bool convert) {
-        static_assert(is_smart_holder_type_caster<T>::value, "Internal consistency error.");
-        load_impl = modified_type_caster_generic_load_impl(typeid(T));
-        if (!load_impl.load(src, convert))
-            return false;
-        return true;
-    }
-
-    T *loaded_as_raw_ptr_unowned() const {
-        void *void_ptr = load_impl.unowned_void_ptr_from_direct_conversion;
-        if (void_ptr == nullptr) {
-            if (have_holder()) {
-                throw_if_uninitialized_or_disowned_holder();
-                void_ptr = holder().template as_raw_ptr_unowned<void>();
-            } else if (load_impl.loaded_v_h.vh != nullptr)
-                void_ptr = load_impl.loaded_v_h.value_ptr();
-            if (void_ptr == nullptr)
-                return nullptr;
-        }
-        return convert_type(void_ptr);
-    }
-
-    T &loaded_as_lvalue_ref() const {
-        T *raw_ptr = loaded_as_raw_ptr_unowned();
-        if (raw_ptr == nullptr) throw reference_cast_error();
-        return *raw_ptr;
-    }
-
-    std::shared_ptr<T> loaded_as_shared_ptr() const {
-        if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
-            throw cast_error("Unowned pointer from direct conversion cannot be converted to a"
-                             " std::shared_ptr.");
-        if (!have_holder()) return nullptr;
-        throw_if_uninitialized_or_disowned_holder();
-        std::shared_ptr<void> void_ptr = holder().template as_shared_ptr<void>();
-        return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
-    }
-
-    template <typename D>
-    std::unique_ptr<T, D> loaded_as_unique_ptr(const char *context = "loaded_as_unique_ptr") {
-        if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
-            throw cast_error("Unowned pointer from direct conversion cannot be converted to a"
-                             " std::unique_ptr.");
-        if (!have_holder()) return nullptr;
-        throw_if_uninitialized_or_disowned_holder();
-        holder().template ensure_compatible_rtti_uqp_del<T, D>(context);
-        holder().ensure_use_count_1(context);
-        auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
-        // SMART_HOLDER_WIP: MISSING: Safety checks for type conversions
-        // (T must be polymorphic or meet certain other conditions).
-        T *raw_type_ptr = convert_type(raw_void_ptr);
-
-        // Critical transfer-of-ownership section. This must stay together.
-        holder().release_ownership();
-        auto result = std::unique_ptr<T, D>(raw_type_ptr);
-
-        void *value_void_ptr = load_impl.loaded_v_h.value_ptr();
-        if (value_void_ptr != raw_void_ptr) {
-            pybind11_fail("smart_holder_type_casters: loaded_as_unique_ptr failure:"
-                          " value_void_ptr != raw_void_ptr");
-        }
-        load_impl.loaded_v_h.value_ptr() = nullptr;
-        deregister_instance(load_impl.loaded_v_h.inst, value_void_ptr, load_impl.loaded_v_h.type);
-
-        return result;
-    }
-
-private:
-    modified_type_caster_generic_load_impl load_impl;
-
-    bool have_holder() const {
-        return load_impl.loaded_v_h.vh != nullptr && load_impl.loaded_v_h.holder_constructed();
-    }
-
-    holder_type &holder() const { return load_impl.loaded_v_h.holder<holder_type>(); }
-
-    // have_holder() must be true or this function will fail.
-    void throw_if_uninitialized_or_disowned_holder() const {
-        if (!holder().is_populated) {
-            pybind11_fail("Missing value for wrapped C++ type:"
-                          " Python instance is uninitialized.");
-        }
-        if (!holder().has_pointee()) {
-            throw cast_error("Missing value for wrapped C++ type:"
-                             " Python instance was disowned.");
-        }
-    }
-
-    T *convert_type(void *void_ptr) const {
-        if (void_ptr != nullptr && load_impl.loaded_v_h_cpptype != nullptr
-            && !load_impl.reinterpret_cast_deemed_ok && load_impl.implicit_cast != nullptr) {
-            void_ptr = load_impl.implicit_cast(void_ptr);
-        }
-        return static_cast<T *>(void_ptr);
-    }
-};
-
-// SMART_HOLDER_WIP: IMPROVABLE: Formally factor out of type_caster_base.
-struct make_constructor : private type_caster_base<int> { // Any type, nothing special about int.
-    using type_caster_base<int>::Constructor;
-    using type_caster_base<int>::make_copy_constructor;
-    using type_caster_base<int>::make_move_constructor;
-};
-
-template <typename T>
-struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
-                                  smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<T>();
-
-    // static handle cast(T, ...)
-    // is redundant (leads to ambiguous overloads).
-
-    static handle cast(T &&src, return_value_policy /*policy*/, handle parent) {
-        // type_caster_base BEGIN
-        // clang-format off
-        return cast(&src, return_value_policy::move, parent);
-        // clang-format on
-        // type_caster_base END
-    }
-
-    static handle cast(T const &src, return_value_policy policy, handle parent) {
-        // type_caster_base BEGIN
-        // clang-format off
-        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
-            policy = return_value_policy::copy;
-        return cast(&src, policy, parent);
-        // clang-format on
-        // type_caster_base END
-    }
-
-    static handle cast(T &src, return_value_policy policy, handle parent) {
-        return cast(const_cast<T const &>(src), policy, parent); // Mutbl2Const
-    }
-
-    static handle cast(T const *src, return_value_policy policy, handle parent) {
-        auto st = type_caster_base<T>::src_and_type(src);
-        return cast_const_raw_ptr( // Originally type_caster_generic::cast.
-            st.first,
-            policy,
-            parent,
-            st.second,
-            make_constructor::make_copy_constructor(src),
-            make_constructor::make_move_constructor(src));
-    }
-
-    static handle cast(T *src, return_value_policy policy, handle parent) {
-        return cast(const_cast<T const *>(src), policy, parent); // Mutbl2Const
-    }
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-    // Working around MSVC 2015 bug. const-correctness is lost.
-    // SMART_HOLDER_WIP: IMPROVABLE: make common code work with MSVC 2015.
-    template <typename T_>
-    using cast_op_type = detail::cast_op_type<T_>;
-#else
-    template <typename T_>
-    using cast_op_type = conditional_t<
-        std::is_same<remove_reference_t<T_>, T const *>::value,
-        T const *,
-        conditional_t<std::is_same<remove_reference_t<T_>, T *>::value,
-                      T *,
-                      conditional_t<std::is_same<T_, T const &>::value, T const &, T &>>>;
-#endif
-
-    // The const operators here prove that the existing type_caster mechanism already supports
-    // const-correctness. However, fully implementing const-correctness inside this type_caster
-    // is still a major project.
-    operator T const &() const {
-        return const_cast<smart_holder_type_caster *>(this)->loaded_as_lvalue_ref();
-    }
-    operator T const *() const {
-        return const_cast<smart_holder_type_caster *>(this)->loaded_as_raw_ptr_unowned();
-    }
-    operator T &() { return this->loaded_as_lvalue_ref(); }
-    operator T *() { return this->loaded_as_raw_ptr_unowned(); }
-
-    // Originally type_caster_generic::cast.
-    PYBIND11_NOINLINE static handle cast_const_raw_ptr(const void *_src,
-                                                       return_value_policy policy,
-                                                       handle parent,
-                                                       const detail::type_info *tinfo,
-                                                       void *(*copy_constructor)(const void *),
-                                                       void *(*move_constructor)(const void *),
-                                                       const void *existing_holder = nullptr) {
-        if (!tinfo) // no type info: error will be set already
-            return handle();
-
-        void *src = const_cast<void *>(_src);
-        if (src == nullptr)
-            return none().release();
-
-        if (handle existing_inst = find_registered_python_instance(src, tinfo))
-            return existing_inst;
-
-        auto inst       = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        auto wrapper    = reinterpret_cast<instance *>(inst.ptr());
-        wrapper->owned  = false;
-        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
-
-        switch (policy) {
-            case return_value_policy::automatic:
-            case return_value_policy::take_ownership:
-                valueptr       = src;
-                wrapper->owned = true;
-                break;
-
-            case return_value_policy::automatic_reference:
-            case return_value_policy::reference:
-                valueptr       = src;
-                wrapper->owned = false;
-                break;
-
-            case return_value_policy::copy:
-                if (copy_constructor)
-                    valueptr = copy_constructor(src);
-                else {
-#if defined(NDEBUG)
-                    throw cast_error("return_value_policy = copy, but type is "
-                                     "non-copyable! (compile in debug mode for details)");
-#else
-                    std::string type_name(tinfo->cpptype->name());
-                    detail::clean_type_id(type_name);
-                    throw cast_error("return_value_policy = copy, but type " + type_name
-                                     + " is non-copyable!");
-#endif
-                }
-                wrapper->owned = true;
-                break;
-
-            case return_value_policy::move:
-                if (move_constructor)
-                    valueptr = move_constructor(src);
-                else if (copy_constructor)
-                    valueptr = copy_constructor(src);
-                else {
-#if defined(NDEBUG)
-                    throw cast_error("return_value_policy = move, but type is neither "
-                                     "movable nor copyable! "
-                                     "(compile in debug mode for details)");
-#else
-                    std::string type_name(tinfo->cpptype->name());
-                    detail::clean_type_id(type_name);
-                    throw cast_error("return_value_policy = move, but type " + type_name
-                                     + " is neither movable nor copyable!");
-#endif
-                }
-                wrapper->owned = true;
-                break;
-
-            case return_value_policy::reference_internal:
-                valueptr       = src;
-                wrapper->owned = false;
-                keep_alive_impl(inst, parent);
-                break;
-
-            default:
-                throw cast_error("unhandled return_value_policy: should not happen!");
-        }
-
-        tinfo->init_instance(wrapper, existing_holder);
-
-        return inst.release();
-    }
-};
-
-template <typename T>
-struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_load<T>,
-                                                      smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<std::shared_ptr<T>>();
-
-    static handle cast(const std::shared_ptr<T> &src, return_value_policy policy, handle parent) {
-        if (policy != return_value_policy::automatic
-            && policy != return_value_policy::reference_internal) {
-            // SMART_HOLDER_WIP: IMPROVABLE: Error message.
-            throw cast_error("Invalid return_value_policy for shared_ptr.");
-        }
-
-        auto src_raw_ptr = src.get();
-        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
-        if (st.first == nullptr)
-            return none().release(); // PyErr was set already.
-
-        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
-        const detail::type_info *tinfo = st.second;
-        if (handle existing_inst = find_registered_python_instance(src_raw_void_ptr, tinfo))
-            // SMART_HOLDER_WIP: MISSING: Enforcement of consistency with existing smart_holder.
-            // SMART_HOLDER_WIP: MISSING: keep_alive.
-            return existing_inst;
-
-        auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
-        inst_raw_ptr->owned = true;
-        void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
-        valueptr            = src_raw_void_ptr;
-
-        auto smhldr = pybindit::memory::smart_holder::from_shared_ptr(src);
-        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
-
-        if (policy == return_value_policy::reference_internal)
-            keep_alive_impl(inst, parent);
-
-        return inst.release();
-    }
-
-    template <typename>
-    using cast_op_type = std::shared_ptr<T>;
-
-    operator std::shared_ptr<T>() { return this->loaded_as_shared_ptr(); }
-};
-
-template <typename T>
-struct smart_holder_type_caster<std::shared_ptr<T const>> : smart_holder_type_caster_load<T>,
-                                                            smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<std::shared_ptr<T const>>();
-
-    static handle
-    cast(const std::shared_ptr<T const> &src, return_value_policy policy, handle parent) {
-        return smart_holder_type_caster<std::shared_ptr<T>>::cast(
-            std::const_pointer_cast<T>(src), // Const2Mutbl
-            policy,
-            parent);
-    }
-
-    template <typename>
-    using cast_op_type = std::shared_ptr<T const>;
-
-    operator std::shared_ptr<T const>() { return this->loaded_as_shared_ptr(); } // Mutbl2Const
-};
-
-template <typename T, typename D>
-struct smart_holder_type_caster<std::unique_ptr<T, D>> : smart_holder_type_caster_load<T>,
-                                                         smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<std::unique_ptr<T, D>>();
-
-    static handle cast(std::unique_ptr<T, D> &&src, return_value_policy policy, handle parent) {
-        if (policy != return_value_policy::automatic
-            && policy != return_value_policy::reference_internal
-            && policy != return_value_policy::move) {
-            // SMART_HOLDER_WIP: IMPROVABLE: Error message.
-            throw cast_error("Invalid return_value_policy for unique_ptr.");
-        }
-
-        auto src_raw_ptr = src.get();
-        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
-        if (st.first == nullptr)
-            return none().release(); // PyErr was set already.
-
-        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
-        const detail::type_info *tinfo = st.second;
-        if (find_registered_python_instance(src_raw_void_ptr, tinfo))
-            throw cast_error("Invalid unique_ptr: another instance owns this pointer already.");
-
-        auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
-        inst_raw_ptr->owned = true;
-        void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
-        valueptr            = src_raw_void_ptr;
-
-        auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(src));
-        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
-
-        if (policy == return_value_policy::reference_internal)
-            keep_alive_impl(inst, parent);
-
-        return inst.release();
-    }
-
-    template <typename>
-    using cast_op_type = std::unique_ptr<T, D>;
-
-    operator std::unique_ptr<T, D>() { return this->template loaded_as_unique_ptr<D>(); }
-};
-
-template <typename T, typename D>
-struct smart_holder_type_caster<std::unique_ptr<T const, D>>
-    : smart_holder_type_caster_load<T>, smart_holder_type_caster_class_hooks {
-    static constexpr auto name = _<std::unique_ptr<T const, D>>();
-
-    static handle
-    cast(std::unique_ptr<T const, D> &&src, return_value_policy policy, handle parent) {
-        return smart_holder_type_caster<std::unique_ptr<T, D>>::cast(
-            std::unique_ptr<T, D>(const_cast<T *>(src.release())), // Const2Mutbl
-            policy,
-            parent);
-    }
-
-    template <typename>
-    using cast_op_type = std::unique_ptr<T const, D>;
-
-    operator std::unique_ptr<T const, D>() { return this->template loaded_as_unique_ptr<D>(); }
-};
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
 
-#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
-#define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                     \
-    namespace pybind11 {                                                                          \
-    namespace detail {                                                                            \
-    template <>                                                                                   \
-    class type_caster<T> : public smart_holder_type_caster<T> {};                                 \
-    template <>                                                                                   \
-    class type_caster<std::shared_ptr<T>> : public smart_holder_type_caster<std::shared_ptr<T>> { \
-    };                                                                                            \
-    template <>                                                                                   \
-    class type_caster<std::shared_ptr<T const>>                                                   \
-        : public smart_holder_type_caster<std::shared_ptr<T const>> {};                           \
-    template <typename D>                                                                         \
-    class type_caster<std::unique_ptr<T, D>>                                                      \
-        : public smart_holder_type_caster<std::unique_ptr<T, D>> {};                              \
-    template <typename D>                                                                         \
-    class type_caster<std::unique_ptr<T const, D>>                                                \
-        : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};                        \
-    }                                                                                             \
-    }
-#endif
+// SMART_HOLDER_WIP: Needs refactoring of existing pybind11 code.
+#define PYBIND11_CAST_H_SMART_HOLDER_TYPE_CASTERS_INLINE_INCLUDE_SAFETY_GUARD
+#include "detail/smart_holder_type_casters_inline_include.h"
+#undef PYBIND11_CAST_H_SMART_HOLDER_TYPE_CASTERS_INLINE_INCLUDE_SAFETY_GUARD
 
-//DETAIL/SMART_HOLDER_TYPE_CASTERS_H/END///////////////////////////////////////////////////////////
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
 
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
 
@@ -2475,8 +1803,8 @@ template <typename T> using move_never = none_of<move_always<T>, move_if_unrefer
 template <typename type> using cast_is_temporary_value_reference = bool_constant<
     (std::is_reference<type>::value || std::is_pointer<type>::value) &&
     !std::is_base_of<type_caster_generic, make_caster<type>>::value &&
-    !std::is_same<intrinsic_t<type>, void>::value &&
-    !is_smart_holder_type_caster<intrinsic_t<type>>::value
+    !is_smart_holder_type_caster<intrinsic_t<type>>::value &&
+    !std::is_same<intrinsic_t<type>, void>::value
 >;
 
 // When a value returned from a C++ function is being cast back to Python, we almost always want to
diff --git a/include/pybind11/detail/smart_holder_type_casters_inline_include.h b/include/pybind11/detail/smart_holder_type_casters_inline_include.h
new file mode 100644
index 0000000000..a834eabb1e
--- /dev/null
+++ b/include/pybind11/detail/smart_holder_type_casters_inline_include.h
@@ -0,0 +1,688 @@
+#ifndef PYBIND11_CAST_H_SMART_HOLDER_TYPE_CASTERS_INLINE_INCLUDE_SAFETY_GUARD
+#error "THIS FILE MUST ONLY BE INCLUDED FROM pybind11/cast.h"
+#endif
+
+#include "smart_holder_poc.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+using pybindit::memory::smart_holder;
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// SMART_HOLDER_WIP: Needs refactoring of existing pybind11 code.
+inline void register_instance(instance *self, void *valptr, const type_info *tinfo);
+inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo);
+
+// The modified_type_caster_generic_load_impl could replace type_caster_generic::load_impl but not
+// vice versa. The main difference is that the original code only propagates a reference to the
+// held value, while the modified implementation propagates value_and_holder.
+// clang-format off
+class modified_type_caster_generic_load_impl {
+public:
+    PYBIND11_NOINLINE modified_type_caster_generic_load_impl(const std::type_info &type_info)
+        : typeinfo(get_type_info(type_info)), cpptype(&type_info) { }
+
+    explicit modified_type_caster_generic_load_impl(const type_info *typeinfo = nullptr)
+        : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { }
+
+    bool load(handle src, bool convert) {
+        return load_impl<modified_type_caster_generic_load_impl>(src, convert);
+    }
+
+    // Base methods for generic caster; there are overridden in copyable_holder_caster
+    void load_value_and_holder(value_and_holder &&v_h) {
+        if (!v_h.holder_constructed()) {
+            // This is needed for old-style __init__.
+            // type_caster_generic::load_value BEGIN
+            auto *&vptr = v_h.value_ptr();
+            // Lazy allocation for unallocated values:
+            if (vptr == nullptr) {
+                // Lazy allocation for unallocated values:
+                auto *type = v_h.type ? v_h.type : typeinfo;
+                if (type->operator_new) {
+                    vptr = type->operator_new(type->type_size);
+                } else {
+                    #if defined(__cpp_aligned_new) && (!defined(_MSC_VER) || _MSC_VER >= 1912)
+                        if (type->type_align > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
+                            vptr = ::operator new(type->type_size,
+                                                  std::align_val_t(type->type_align));
+                        else
+                    #endif
+                    vptr = ::operator new(type->type_size);
+                }
+            }
+            // type_caster_generic::load_value END
+        }
+        loaded_v_h = std::move(v_h);
+        loaded_v_h.type = typeinfo;
+    }
+
+    bool try_implicit_casts(handle src, bool convert) {
+        for (auto &cast : typeinfo->implicit_casts) {
+            modified_type_caster_generic_load_impl sub_caster(*cast.first);
+            if (sub_caster.load(src, convert)) {
+                if (loaded_v_h_cpptype != nullptr) {
+                    pybind11_fail("smart_holder_type_casters: try_implicit_casts failure.");
+                }
+                loaded_v_h = sub_caster.loaded_v_h;
+                loaded_v_h_cpptype = cast.first;
+                implicit_cast = cast.second;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    bool try_direct_conversions(handle src) {
+        for (auto &converter : *typeinfo->direct_conversions) {
+            if (converter(src.ptr(), unowned_void_ptr_from_direct_conversion)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
+        std::unique_ptr<modified_type_caster_generic_load_impl> loader(
+            new modified_type_caster_generic_load_impl(ti));
+        if (loader->load(src, false)) {
+            // Trick to work with the existing pybind11 internals.
+            // The void pointer is immediately captured in a new unique_ptr in
+            // try_load_foreign_module_local. If this assumption is violated sanitizers
+            // will most likely flag a leak (verified to be the case with ASAN).
+            return static_cast<void *>(loader.release());
+        }
+        return nullptr;
+    }
+
+    /// Try to load with foreign typeinfo, if available. Used when there is no
+    /// native typeinfo, or when the native one wasn't able to produce a value.
+    PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) {
+        constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
+        const auto pytype = type::handle_of(src);
+        if (!hasattr(pytype, local_key))
+            return false;
+
+        type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key));
+        // Only consider this foreign loader if actually foreign and is a loader of the correct cpp type
+        if (foreign_typeinfo->module_local_load == &local_load
+            || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype)))
+            return false;
+
+        void* foreign_loader_void_ptr =
+            foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo);
+        if (foreign_loader_void_ptr != nullptr) {
+            auto foreign_loader = std::unique_ptr<modified_type_caster_generic_load_impl>(
+                static_cast<modified_type_caster_generic_load_impl *>(foreign_loader_void_ptr));
+            // Magic number intentionally hard-coded for simplicity and maximum robustness.
+            if (foreign_loader->local_load_safety_guard != 1887406645) {
+                pybind11_fail(
+                    "smart_holder_type_casters: Unexpected local_load_safety_guard,"
+                    " possibly due to py::class_ holder mixup.");
+            }
+            if (loaded_v_h_cpptype != nullptr) {
+                pybind11_fail("smart_holder_type_casters: try_load_foreign_module_local failure.");
+            }
+            loaded_v_h = foreign_loader->loaded_v_h;
+            loaded_v_h_cpptype = foreign_loader->loaded_v_h_cpptype;
+            implicit_cast = foreign_loader->implicit_cast;
+            return true;
+        }
+        return false;
+    }
+
+    // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
+    // bits of code between here and copyable_holder_caster where the two classes need different
+    // logic (without having to resort to virtual inheritance).
+    template <typename ThisT>
+    PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
+        if (!src) return false;
+        if (!typeinfo) return try_load_foreign_module_local(src);
+        if (src.is_none()) {
+            // Defer accepting None to other overloads (if we aren't in convert mode):
+            if (!convert) return false;
+            loaded_v_h = value_and_holder();
+            return true;
+        }
+
+        auto &this_ = static_cast<ThisT &>(*this);
+
+        PyTypeObject *srctype = Py_TYPE(src.ptr());
+
+        // Case 1: If src is an exact type match for the target type then we can reinterpret_cast
+        // the instance's value pointer to the target type:
+        if (srctype == typeinfo->type) {
+            this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
+            return true;
+        }
+        // Case 2: We have a derived class
+        else if (PyType_IsSubtype(srctype, typeinfo->type)) {
+            auto &bases = all_type_info(srctype); // subtype bases
+            bool no_cpp_mi = typeinfo->simple_type;
+
+            // Case 2a: the python type is a Python-inherited derived class that inherits from just
+            // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of
+            // the right type and we can use reinterpret_cast.
+            // (This is essentially the same as case 2b, but because not using multiple inheritance
+            // is extremely common, we handle it specially to avoid the loop iterator and type
+            // pointer lookup overhead)
+            if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
+                this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
+                loaded_v_h_cpptype = bases.front()->cpptype;
+                reinterpret_cast_deemed_ok = true;
+                return true;
+            }
+            // Case 2b: the python type inherits from multiple C++ bases.  Check the bases to see if
+            // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we
+            // can safely reinterpret_cast to the relevant pointer.
+            else if (bases.size() > 1) {
+                for (auto base : bases) {
+                    if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
+                        this_.load_value_and_holder(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
+                        loaded_v_h_cpptype = base->cpptype;
+                        reinterpret_cast_deemed_ok = true;
+                        return true;
+                    }
+                }
+            }
+
+            // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match
+            // in the registered bases, above, so try implicit casting (needed for proper C++ casting
+            // when MI is involved).
+            if (this_.try_implicit_casts(src, convert)) {
+                return true;
+            }
+        }
+
+        // Perform an implicit conversion
+        if (convert) {
+            for (auto &converter : typeinfo->implicit_conversions) {
+                auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
+                if (load_impl<ThisT>(temp, false)) {
+                    loader_life_support::add_patient(temp);
+                    return true;
+                }
+            }
+            if (this_.try_direct_conversions(src))
+                return true;
+        }
+
+        // Failed to match local typeinfo. Try again with global.
+        if (typeinfo->module_local) {
+            if (auto gtype = get_global_type_info(*typeinfo->cpptype)) {
+                typeinfo = gtype;
+                return load(src, false);
+            }
+        }
+
+        // Global typeinfo has precedence over foreign module_local
+        return try_load_foreign_module_local(src);
+    }
+
+    const type_info *typeinfo = nullptr;
+    const std::type_info *cpptype = nullptr;
+    void *unowned_void_ptr_from_direct_conversion = nullptr;
+    const std::type_info *loaded_v_h_cpptype = nullptr;
+    void *(*implicit_cast)(void *) = nullptr;
+    value_and_holder loaded_v_h;
+    bool reinterpret_cast_deemed_ok = false;
+    // Magic number intentionally hard-coded, to guard against class_ holder mixups.
+    // Ideally type_caster_generic would have a similar guard, but this requires a change there.
+    std::size_t local_load_safety_guard = 1887406645; // 32-bit compatible value for portability.
+};
+// clang-format on
+
+struct smart_holder_type_caster_class_hooks : is_smart_holder_type_caster_base_tag {
+    static decltype(&modified_type_caster_generic_load_impl::local_load)
+    get_local_load_function_ptr() {
+        return &modified_type_caster_generic_load_impl::local_load;
+    }
+
+    template <typename T>
+    static void init_instance_for_type(detail::instance *inst, const void *holder_const_void_ptr) {
+        // Need for const_cast is a consequence of the type_info::init_instance type:
+        // void (*init_instance)(instance *, const void *);
+        auto holder_void_ptr = const_cast<void *>(holder_const_void_ptr);
+
+        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(T)));
+        if (!v_h.instance_registered()) {
+            register_instance(inst, v_h.value_ptr(), v_h.type);
+            v_h.set_instance_registered();
+        }
+        using holder_type = pybindit::memory::smart_holder;
+        if (holder_void_ptr) {
+            // Note: inst->owned ignored.
+            auto holder_ptr = static_cast<holder_type *>(holder_void_ptr);
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*holder_ptr));
+        } else if (inst->owned) {
+            new (std::addressof(v_h.holder<holder_type>()))
+                holder_type(holder_type::from_raw_ptr_take_ownership(v_h.value_ptr<T>()));
+        } else {
+            new (std::addressof(v_h.holder<holder_type>()))
+                holder_type(holder_type::from_raw_ptr_unowned(v_h.value_ptr<T>()));
+        }
+        v_h.set_holder_constructed();
+    }
+};
+
+template <typename T>
+struct smart_holder_type_caster_load {
+    using holder_type = pybindit::memory::smart_holder;
+
+    bool load(handle src, bool convert) {
+        static_assert(is_smart_holder_type_caster<T>::value, "Internal consistency error.");
+        load_impl = modified_type_caster_generic_load_impl(typeid(T));
+        if (!load_impl.load(src, convert))
+            return false;
+        return true;
+    }
+
+    T *loaded_as_raw_ptr_unowned() const {
+        void *void_ptr = load_impl.unowned_void_ptr_from_direct_conversion;
+        if (void_ptr == nullptr) {
+            if (have_holder()) {
+                throw_if_uninitialized_or_disowned_holder();
+                void_ptr = holder().template as_raw_ptr_unowned<void>();
+            } else if (load_impl.loaded_v_h.vh != nullptr)
+                void_ptr = load_impl.loaded_v_h.value_ptr();
+            if (void_ptr == nullptr)
+                return nullptr;
+        }
+        return convert_type(void_ptr);
+    }
+
+    T &loaded_as_lvalue_ref() const {
+        T *raw_ptr = loaded_as_raw_ptr_unowned();
+        if (raw_ptr == nullptr) throw reference_cast_error();
+        return *raw_ptr;
+    }
+
+    std::shared_ptr<T> loaded_as_shared_ptr() const {
+        if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
+            throw cast_error("Unowned pointer from direct conversion cannot be converted to a"
+                             " std::shared_ptr.");
+        if (!have_holder()) return nullptr;
+        throw_if_uninitialized_or_disowned_holder();
+        std::shared_ptr<void> void_ptr = holder().template as_shared_ptr<void>();
+        return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
+    }
+
+    template <typename D>
+    std::unique_ptr<T, D> loaded_as_unique_ptr(const char *context = "loaded_as_unique_ptr") {
+        if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
+            throw cast_error("Unowned pointer from direct conversion cannot be converted to a"
+                             " std::unique_ptr.");
+        if (!have_holder()) return nullptr;
+        throw_if_uninitialized_or_disowned_holder();
+        holder().template ensure_compatible_rtti_uqp_del<T, D>(context);
+        holder().ensure_use_count_1(context);
+        auto raw_void_ptr = holder().template as_raw_ptr_unowned<void>();
+        // SMART_HOLDER_WIP: MISSING: Safety checks for type conversions
+        // (T must be polymorphic or meet certain other conditions).
+        T *raw_type_ptr = convert_type(raw_void_ptr);
+
+        // Critical transfer-of-ownership section. This must stay together.
+        holder().release_ownership();
+        auto result = std::unique_ptr<T, D>(raw_type_ptr);
+
+        void *value_void_ptr = load_impl.loaded_v_h.value_ptr();
+        if (value_void_ptr != raw_void_ptr) {
+            pybind11_fail("smart_holder_type_casters: loaded_as_unique_ptr failure:"
+                          " value_void_ptr != raw_void_ptr");
+        }
+        load_impl.loaded_v_h.value_ptr() = nullptr;
+        deregister_instance(load_impl.loaded_v_h.inst, value_void_ptr, load_impl.loaded_v_h.type);
+
+        return result;
+    }
+
+private:
+    modified_type_caster_generic_load_impl load_impl;
+
+    bool have_holder() const {
+        return load_impl.loaded_v_h.vh != nullptr && load_impl.loaded_v_h.holder_constructed();
+    }
+
+    holder_type &holder() const { return load_impl.loaded_v_h.holder<holder_type>(); }
+
+    // have_holder() must be true or this function will fail.
+    void throw_if_uninitialized_or_disowned_holder() const {
+        if (!holder().is_populated) {
+            pybind11_fail("Missing value for wrapped C++ type:"
+                          " Python instance is uninitialized.");
+        }
+        if (!holder().has_pointee()) {
+            throw cast_error("Missing value for wrapped C++ type:"
+                             " Python instance was disowned.");
+        }
+    }
+
+    T *convert_type(void *void_ptr) const {
+        if (void_ptr != nullptr && load_impl.loaded_v_h_cpptype != nullptr
+            && !load_impl.reinterpret_cast_deemed_ok && load_impl.implicit_cast != nullptr) {
+            void_ptr = load_impl.implicit_cast(void_ptr);
+        }
+        return static_cast<T *>(void_ptr);
+    }
+};
+
+// SMART_HOLDER_WIP: Needs refactoring of existing pybind11 code.
+struct make_constructor : private type_caster_base<int> { // Any type, nothing special about int.
+    using type_caster_base<int>::Constructor;
+    using type_caster_base<int>::make_copy_constructor;
+    using type_caster_base<int>::make_move_constructor;
+};
+
+template <typename T>
+struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
+                                  smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<T>();
+
+    // static handle cast(T, ...)
+    // is redundant (leads to ambiguous overloads).
+
+    static handle cast(T &&src, return_value_policy /*policy*/, handle parent) {
+        // type_caster_base BEGIN
+        // clang-format off
+        return cast(&src, return_value_policy::move, parent);
+        // clang-format on
+        // type_caster_base END
+    }
+
+    static handle cast(T const &src, return_value_policy policy, handle parent) {
+        // type_caster_base BEGIN
+        // clang-format off
+        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
+            policy = return_value_policy::copy;
+        return cast(&src, policy, parent);
+        // clang-format on
+        // type_caster_base END
+    }
+
+    static handle cast(T &src, return_value_policy policy, handle parent) {
+        return cast(const_cast<T const &>(src), policy, parent); // Mutbl2Const
+    }
+
+    static handle cast(T const *src, return_value_policy policy, handle parent) {
+        auto st = type_caster_base<T>::src_and_type(src);
+        return cast_const_raw_ptr( // Originally type_caster_generic::cast.
+            st.first,
+            policy,
+            parent,
+            st.second,
+            make_constructor::make_copy_constructor(src),
+            make_constructor::make_move_constructor(src));
+    }
+
+    static handle cast(T *src, return_value_policy policy, handle parent) {
+        return cast(const_cast<T const *>(src), policy, parent); // Mutbl2Const
+    }
+
+#if defined(_MSC_VER) && _MSC_VER < 1910
+    // Working around MSVC 2015 bug. const-correctness is lost.
+    // SMART_HOLDER_WIP: IMPROVABLE: make common code work with MSVC 2015.
+    template <typename T_>
+    using cast_op_type = detail::cast_op_type<T_>;
+#else
+    template <typename T_>
+    using cast_op_type = conditional_t<
+        std::is_same<remove_reference_t<T_>, T const *>::value,
+        T const *,
+        conditional_t<std::is_same<remove_reference_t<T_>, T *>::value,
+                      T *,
+                      conditional_t<std::is_same<T_, T const &>::value, T const &, T &>>>;
+#endif
+
+    // The const operators here prove that the existing type_caster mechanism already supports
+    // const-correctness. However, fully implementing const-correctness inside this type_caster
+    // is still a major project.
+    operator T const &() const {
+        return const_cast<smart_holder_type_caster *>(this)->loaded_as_lvalue_ref();
+    }
+    operator T const *() const {
+        return const_cast<smart_holder_type_caster *>(this)->loaded_as_raw_ptr_unowned();
+    }
+    operator T &() { return this->loaded_as_lvalue_ref(); }
+    operator T *() { return this->loaded_as_raw_ptr_unowned(); }
+
+    // Originally type_caster_generic::cast.
+    PYBIND11_NOINLINE static handle cast_const_raw_ptr(const void *_src,
+                                                       return_value_policy policy,
+                                                       handle parent,
+                                                       const detail::type_info *tinfo,
+                                                       void *(*copy_constructor)(const void *),
+                                                       void *(*move_constructor)(const void *),
+                                                       const void *existing_holder = nullptr) {
+        if (!tinfo) // no type info: error will be set already
+            return handle();
+
+        void *src = const_cast<void *>(_src);
+        if (src == nullptr)
+            return none().release();
+
+        if (handle existing_inst = find_registered_python_instance(src, tinfo))
+            return existing_inst;
+
+        auto inst       = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto wrapper    = reinterpret_cast<instance *>(inst.ptr());
+        wrapper->owned  = false;
+        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
+
+        switch (policy) {
+            case return_value_policy::automatic:
+            case return_value_policy::take_ownership:
+                valueptr       = src;
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::automatic_reference:
+            case return_value_policy::reference:
+                valueptr       = src;
+                wrapper->owned = false;
+                break;
+
+            case return_value_policy::copy:
+                if (copy_constructor)
+                    valueptr = copy_constructor(src);
+                else {
+#if defined(NDEBUG)
+                    throw cast_error("return_value_policy = copy, but type is "
+                                     "non-copyable! (compile in debug mode for details)");
+#else
+                    std::string type_name(tinfo->cpptype->name());
+                    detail::clean_type_id(type_name);
+                    throw cast_error("return_value_policy = copy, but type " + type_name
+                                     + " is non-copyable!");
+#endif
+                }
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::move:
+                if (move_constructor)
+                    valueptr = move_constructor(src);
+                else if (copy_constructor)
+                    valueptr = copy_constructor(src);
+                else {
+#if defined(NDEBUG)
+                    throw cast_error("return_value_policy = move, but type is neither "
+                                     "movable nor copyable! "
+                                     "(compile in debug mode for details)");
+#else
+                    std::string type_name(tinfo->cpptype->name());
+                    detail::clean_type_id(type_name);
+                    throw cast_error("return_value_policy = move, but type " + type_name
+                                     + " is neither movable nor copyable!");
+#endif
+                }
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::reference_internal:
+                valueptr       = src;
+                wrapper->owned = false;
+                keep_alive_impl(inst, parent);
+                break;
+
+            default:
+                throw cast_error("unhandled return_value_policy: should not happen!");
+        }
+
+        tinfo->init_instance(wrapper, existing_holder);
+
+        return inst.release();
+    }
+};
+
+template <typename T>
+struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_load<T>,
+                                                      smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<std::shared_ptr<T>>();
+
+    static handle cast(const std::shared_ptr<T> &src, return_value_policy policy, handle parent) {
+        if (policy != return_value_policy::automatic
+            && policy != return_value_policy::reference_internal) {
+            // SMART_HOLDER_WIP: IMPROVABLE: Error message.
+            throw cast_error("Invalid return_value_policy for shared_ptr.");
+        }
+
+        auto src_raw_ptr = src.get();
+        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
+        if (st.first == nullptr)
+            return none().release(); // PyErr was set already.
+
+        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
+        const detail::type_info *tinfo = st.second;
+        if (handle existing_inst = find_registered_python_instance(src_raw_void_ptr, tinfo))
+            // SMART_HOLDER_WIP: MISSING: Enforcement of consistency with existing smart_holder.
+            // SMART_HOLDER_WIP: MISSING: keep_alive.
+            return existing_inst;
+
+        auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
+        inst_raw_ptr->owned = true;
+        void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+        valueptr            = src_raw_void_ptr;
+
+        auto smhldr = pybindit::memory::smart_holder::from_shared_ptr(src);
+        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
+
+        if (policy == return_value_policy::reference_internal)
+            keep_alive_impl(inst, parent);
+
+        return inst.release();
+    }
+
+    template <typename>
+    using cast_op_type = std::shared_ptr<T>;
+
+    operator std::shared_ptr<T>() { return this->loaded_as_shared_ptr(); }
+};
+
+template <typename T>
+struct smart_holder_type_caster<std::shared_ptr<T const>> : smart_holder_type_caster_load<T>,
+                                                            smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<std::shared_ptr<T const>>();
+
+    static handle
+    cast(const std::shared_ptr<T const> &src, return_value_policy policy, handle parent) {
+        return smart_holder_type_caster<std::shared_ptr<T>>::cast(
+            std::const_pointer_cast<T>(src), // Const2Mutbl
+            policy,
+            parent);
+    }
+
+    template <typename>
+    using cast_op_type = std::shared_ptr<T const>;
+
+    operator std::shared_ptr<T const>() { return this->loaded_as_shared_ptr(); } // Mutbl2Const
+};
+
+template <typename T, typename D>
+struct smart_holder_type_caster<std::unique_ptr<T, D>> : smart_holder_type_caster_load<T>,
+                                                         smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<std::unique_ptr<T, D>>();
+
+    static handle cast(std::unique_ptr<T, D> &&src, return_value_policy policy, handle parent) {
+        if (policy != return_value_policy::automatic
+            && policy != return_value_policy::reference_internal
+            && policy != return_value_policy::move) {
+            // SMART_HOLDER_WIP: IMPROVABLE: Error message.
+            throw cast_error("Invalid return_value_policy for unique_ptr.");
+        }
+
+        auto src_raw_ptr = src.get();
+        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
+        if (st.first == nullptr)
+            return none().release(); // PyErr was set already.
+
+        void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
+        const detail::type_info *tinfo = st.second;
+        if (find_registered_python_instance(src_raw_void_ptr, tinfo))
+            throw cast_error("Invalid unique_ptr: another instance owns this pointer already.");
+
+        auto inst           = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto *inst_raw_ptr  = reinterpret_cast<instance *>(inst.ptr());
+        inst_raw_ptr->owned = true;
+        void *&valueptr     = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+        valueptr            = src_raw_void_ptr;
+
+        auto smhldr = pybindit::memory::smart_holder::from_unique_ptr(std::move(src));
+        tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
+
+        if (policy == return_value_policy::reference_internal)
+            keep_alive_impl(inst, parent);
+
+        return inst.release();
+    }
+
+    template <typename>
+    using cast_op_type = std::unique_ptr<T, D>;
+
+    operator std::unique_ptr<T, D>() { return this->template loaded_as_unique_ptr<D>(); }
+};
+
+template <typename T, typename D>
+struct smart_holder_type_caster<std::unique_ptr<T const, D>>
+    : smart_holder_type_caster_load<T>, smart_holder_type_caster_class_hooks {
+    static constexpr auto name = _<std::unique_ptr<T const, D>>();
+
+    static handle
+    cast(std::unique_ptr<T const, D> &&src, return_value_policy policy, handle parent) {
+        return smart_holder_type_caster<std::unique_ptr<T, D>>::cast(
+            std::unique_ptr<T, D>(const_cast<T *>(src.release())), // Const2Mutbl
+            policy,
+            parent);
+    }
+
+    template <typename>
+    using cast_op_type = std::unique_ptr<T const, D>;
+
+    operator std::unique_ptr<T const, D>() { return this->template loaded_as_unique_ptr<D>(); }
+};
+
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+#define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                     \
+    namespace pybind11 {                                                                          \
+    namespace detail {                                                                            \
+    template <>                                                                                   \
+    class type_caster<T> : public smart_holder_type_caster<T> {};                                 \
+    template <>                                                                                   \
+    class type_caster<std::shared_ptr<T>> : public smart_holder_type_caster<std::shared_ptr<T>> { \
+    };                                                                                            \
+    template <>                                                                                   \
+    class type_caster<std::shared_ptr<T const>>                                                   \
+        : public smart_holder_type_caster<std::shared_ptr<T const>> {};                           \
+    template <typename D>                                                                         \
+    class type_caster<std::unique_ptr<T, D>>                                                      \
+        : public smart_holder_type_caster<std::unique_ptr<T, D>> {};                              \
+    template <typename D>                                                                         \
+    class type_caster<std::unique_ptr<T const, D>>                                                \
+        : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};                        \
+    }                                                                                             \
+    }
+#endif
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

From 348d893baf01d988575eb0e84c6b184cb964c67c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 15 Feb 2021 13:57:00 -0800
Subject: [PATCH 186/206] Splitting out smart_holder_init_inline_include.h.

---
 include/pybind11/detail/init.h                | 53 ++-----------------
 .../detail/smart_holder_init_inline_include.h | 49 +++++++++++++++++
 2 files changed, 53 insertions(+), 49 deletions(-)
 create mode 100644 include/pybind11/detail/smart_holder_init_inline_include.h

diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index 44d652f290..816a1764d9 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -169,55 +169,10 @@ void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
     v_h.value_ptr() = new Alias<Class>(std::move(result));
 }
 
-//DETAIL/SMART_HOLDER_INIT_H/BEGIN/////////////////////////////////////////////////////////////////
-
-template <typename Class, typename D = std::default_delete<Cpp<Class>>,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
-    auto *ptr = unq_ptr.get();
-    no_nullptr(ptr);
-    if (Class::has_alias && need_alias)
-        throw type_error("pybind11::init(): construction failed: returned std::unique_ptr pointee "
-                         "is not an alias instance");
-    auto smhldr = smart_holder::from_unique_ptr(std::move(unq_ptr));
-    v_h.value_ptr() = ptr;
-    v_h.type->init_instance(v_h.inst, &smhldr);
-}
-
-template <typename Class, typename D = std::default_delete<Alias<Class>>,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h, std::unique_ptr<Alias<Class>, D> &&unq_ptr, bool /*need_alias*/) {
-    auto *ptr = unq_ptr.get();
-    no_nullptr(ptr);
-    auto smhldr = smart_holder::from_unique_ptr(std::move(unq_ptr));
-    v_h.value_ptr() = ptr;
-    v_h.type->init_instance(v_h.inst, &smhldr);
-}
-
-template <typename Class,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, bool need_alias) {
-    auto *ptr = shd_ptr.get();
-    no_nullptr(ptr);
-    if (Class::has_alias && need_alias)
-        throw type_error("pybind11::init(): construction failed: returned std::shared_ptr pointee "
-                         "is not an alias instance");
-    auto smhldr = smart_holder::from_shared_ptr(std::move(shd_ptr));
-    v_h.value_ptr() = ptr;
-    v_h.type->init_instance(v_h.inst, &smhldr);
-}
-
-template <typename Class,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h, std::shared_ptr<Alias<Class>> &&shd_ptr, bool /*need_alias*/) {
-    auto *ptr = shd_ptr.get();
-    no_nullptr(ptr);
-    auto smhldr = smart_holder::from_shared_ptr(std::move(shd_ptr));
-    v_h.value_ptr() = ptr;
-    v_h.type->init_instance(v_h.inst, &smhldr);
-}
-
-//DETAIL/SMART_HOLDER_INIT_H/END///////////////////////////////////////////////////////////////////
+// SMART_HOLDER_WIP: Needs refactoring of existing pybind11 code.
+#define PYBIND11_DETAIL_INIT_H_SMART_HOLDER_INIT_INLINE_INCLUDE_SAFETY_GUARD
+#include "smart_holder_init_inline_include.h"
+#undef PYBIND11_DETAIL_INIT_H_SMART_HOLDER_INIT_INLINE_INCLUDE_SAFETY_GUARD
 
 // Implementing class for py::init<...>()
 template <typename... Args>
diff --git a/include/pybind11/detail/smart_holder_init_inline_include.h b/include/pybind11/detail/smart_holder_init_inline_include.h
new file mode 100644
index 0000000000..652dcdf628
--- /dev/null
+++ b/include/pybind11/detail/smart_holder_init_inline_include.h
@@ -0,0 +1,49 @@
+#ifndef PYBIND11_DETAIL_INIT_H_SMART_HOLDER_INIT_INLINE_INCLUDE_SAFETY_GUARD
+#error "THIS FILE MUST ONLY BE INCLUDED FROM pybind11/detail/init.h"
+#endif
+
+template <typename Class, typename D = std::default_delete<Cpp<Class>>,
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
+    auto *ptr = unq_ptr.get();
+    no_nullptr(ptr);
+    if (Class::has_alias && need_alias)
+        throw type_error("pybind11::init(): construction failed: returned std::unique_ptr pointee "
+                         "is not an alias instance");
+    auto smhldr = smart_holder::from_unique_ptr(std::move(unq_ptr));
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+
+template <typename Class, typename D = std::default_delete<Alias<Class>>,
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, std::unique_ptr<Alias<Class>, D> &&unq_ptr, bool /*need_alias*/) {
+    auto *ptr = unq_ptr.get();
+    no_nullptr(ptr);
+    auto smhldr = smart_holder::from_unique_ptr(std::move(unq_ptr));
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+
+template <typename Class,
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, bool need_alias) {
+    auto *ptr = shd_ptr.get();
+    no_nullptr(ptr);
+    if (Class::has_alias && need_alias)
+        throw type_error("pybind11::init(): construction failed: returned std::shared_ptr pointee "
+                         "is not an alias instance");
+    auto smhldr = smart_holder::from_shared_ptr(std::move(shd_ptr));
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+
+template <typename Class,
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, std::shared_ptr<Alias<Class>> &&shd_ptr, bool /*need_alias*/) {
+    auto *ptr = shd_ptr.get();
+    no_nullptr(ptr);
+    auto smhldr = smart_holder::from_shared_ptr(std::move(shd_ptr));
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}

From 8cac3e031e940048657cb849fdd4906bbb4050ba Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 15 Feb 2021 14:02:18 -0800
Subject: [PATCH 187/206] Adding additional new include files to
 CMakeLists.txt, tests/extra_python_package/test_files.py.

---
 CMakeLists.txt                           | 2 ++
 tests/extra_python_package/test_files.py | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5daba8f9e7..140948a2b2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -105,7 +105,9 @@ set(PYBIND11_HEADERS
     include/pybind11/detail/descr.h
     include/pybind11/detail/init.h
     include/pybind11/detail/internals.h
+    include/pybind11/detail/smart_holder_init_inline_include.h
     include/pybind11/detail/smart_holder_poc.h
+    include/pybind11/detail/smart_holder_type_casters_inline_include.h
     include/pybind11/detail/typeid.h
     include/pybind11/attr.h
     include/pybind11/buffer_info.h
diff --git a/tests/extra_python_package/test_files.py b/tests/extra_python_package/test_files.py
index 2b8f2ebf34..cf550549b9 100644
--- a/tests/extra_python_package/test_files.py
+++ b/tests/extra_python_package/test_files.py
@@ -43,7 +43,9 @@
     "include/pybind11/detail/descr.h",
     "include/pybind11/detail/init.h",
     "include/pybind11/detail/internals.h",
+    "include/pybind11/detail/smart_holder_init_inline_include.h",
     "include/pybind11/detail/smart_holder_poc.h",
+    "include/pybind11/detail/smart_holder_type_casters_inline_include.h",
     "include/pybind11/detail/typeid.h",
 }
 

From 4ffa561268d67dad3aad0e7bdd09687c559eb958 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 15 Feb 2021 14:32:38 -0800
Subject: [PATCH 188/206] clang-format cleanup of most smart_holder code.

---
 include/pybind11/cast.h                       | 45 ++++++++-------
 .../detail/smart_holder_init_inline_include.h | 24 +++++---
 ...smart_holder_type_casters_inline_include.h | 49 +++++++++--------
 include/pybind11/pybind11.h                   | 55 ++++++++++++-------
 4 files changed, 101 insertions(+), 72 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 3aeefa3566..1284170e44 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -1,3 +1,4 @@
+// clang-format off
 /*
     pybind11/cast.h: Partial template specializations to cast between
     C++ and Python types
@@ -962,6 +963,7 @@ template <typename type> class type_caster_base : public type_caster_generic {
     static Constructor make_move_constructor(...) { return nullptr; }
 };
 
+// clang-format on
 // Tag to be used as base class, inspected by is_smart_holder_type_caster<T> test.
 struct is_smart_holder_type_caster_base_tag {};
 
@@ -981,26 +983,29 @@ PYBIND11_NAMESPACE_BEGIN(detail)
 
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
 
-#define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, ...)
+#    define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, ...)
 
-template <typename T> class type_caster_for_class_ : public type_caster_base<T> {};
+template <typename T>
+class type_caster_for_class_ : public type_caster_base<T> {};
 
 #else
 
-#define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, ...)                                        \
-    namespace pybind11 {                                                                          \
-    namespace detail {                                                                            \
-    template <>                                                                                   \
-    class type_caster<T> : public type_caster_base<T> {};                                         \
-    template <>                                                                                   \
-    class type_caster<__VA_ARGS__> : public type_caster_holder<T, __VA_ARGS__> {};                \
-    }                                                                                             \
-    }
+#    define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, ...)                                    \
+        namespace pybind11 {                                                                      \
+        namespace detail {                                                                        \
+        template <>                                                                               \
+        class type_caster<T> : public type_caster_base<T> {};                                     \
+        template <>                                                                               \
+        class type_caster<__VA_ARGS__> : public type_caster_holder<T, __VA_ARGS__> {};            \
+        }                                                                                         \
+        }
 
-template <typename T> class type_caster_for_class_ : public smart_holder_type_caster<T> {};
+template <typename T>
+class type_caster_for_class_ : public smart_holder_type_caster<T> {};
 
 template <typename T>
-class type_caster_for_class_<std::shared_ptr<T>> : public smart_holder_type_caster<std::shared_ptr<T>> {};
+class type_caster_for_class_<std::shared_ptr<T>>
+    : public smart_holder_type_caster<std::shared_ptr<T>> {};
 
 template <typename T>
 class type_caster_for_class_<std::shared_ptr<T const>>
@@ -1014,20 +1019,22 @@ template <typename T, typename D>
 class type_caster_for_class_<std::unique_ptr<T const, D>>
     : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};
 
-#define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)
+#    define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)
 
 #endif
 
-template <typename type, typename SFINAE = void> class type_caster : public type_caster_for_class_<type> { };
+template <typename type, typename SFINAE = void>
+class type_caster : public type_caster_for_class_<type> {};
 
-template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
+template <typename type>
+using make_caster = type_caster<intrinsic_t<type>>;
 
 template <typename T>
 struct is_smart_holder_type_caster {
-    static constexpr bool value = std::is_base_of<
-        is_smart_holder_type_caster_base_tag,
-        make_caster<T>>::value;
+    static constexpr bool value
+        = std::is_base_of<is_smart_holder_type_caster_base_tag, make_caster<T>>::value;
 };
+// clang-format off
 
 // Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T
 template <typename T> typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &caster) {
diff --git a/include/pybind11/detail/smart_holder_init_inline_include.h b/include/pybind11/detail/smart_holder_init_inline_include.h
index 652dcdf628..b604848b6a 100644
--- a/include/pybind11/detail/smart_holder_init_inline_include.h
+++ b/include/pybind11/detail/smart_holder_init_inline_include.h
@@ -1,8 +1,9 @@
 #ifndef PYBIND11_DETAIL_INIT_H_SMART_HOLDER_INIT_INLINE_INCLUDE_SAFETY_GUARD
-#error "THIS FILE MUST ONLY BE INCLUDED FROM pybind11/detail/init.h"
+#    error "THIS FILE MUST ONLY BE INCLUDED FROM pybind11/detail/init.h"
 #endif
 
-template <typename Class, typename D = std::default_delete<Cpp<Class>>,
+template <typename Class,
+          typename D = std::default_delete<Cpp<Class>>,
           detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
     auto *ptr = unq_ptr.get();
@@ -10,17 +11,20 @@ void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr,
     if (Class::has_alias && need_alias)
         throw type_error("pybind11::init(): construction failed: returned std::unique_ptr pointee "
                          "is not an alias instance");
-    auto smhldr = smart_holder::from_unique_ptr(std::move(unq_ptr));
+    auto smhldr     = smart_holder::from_unique_ptr(std::move(unq_ptr));
     v_h.value_ptr() = ptr;
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
 
-template <typename Class, typename D = std::default_delete<Alias<Class>>,
+template <typename Class,
+          typename D = std::default_delete<Alias<Class>>,
           detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h, std::unique_ptr<Alias<Class>, D> &&unq_ptr, bool /*need_alias*/) {
+void construct(value_and_holder &v_h,
+               std::unique_ptr<Alias<Class>, D> &&unq_ptr,
+               bool /*need_alias*/) {
     auto *ptr = unq_ptr.get();
     no_nullptr(ptr);
-    auto smhldr = smart_holder::from_unique_ptr(std::move(unq_ptr));
+    auto smhldr     = smart_holder::from_unique_ptr(std::move(unq_ptr));
     v_h.value_ptr() = ptr;
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
@@ -33,17 +37,19 @@ void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, boo
     if (Class::has_alias && need_alias)
         throw type_error("pybind11::init(): construction failed: returned std::shared_ptr pointee "
                          "is not an alias instance");
-    auto smhldr = smart_holder::from_shared_ptr(std::move(shd_ptr));
+    auto smhldr     = smart_holder::from_shared_ptr(std::move(shd_ptr));
     v_h.value_ptr() = ptr;
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
 
 template <typename Class,
           detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h, std::shared_ptr<Alias<Class>> &&shd_ptr, bool /*need_alias*/) {
+void construct(value_and_holder &v_h,
+               std::shared_ptr<Alias<Class>> &&shd_ptr,
+               bool /*need_alias*/) {
     auto *ptr = shd_ptr.get();
     no_nullptr(ptr);
-    auto smhldr = smart_holder::from_shared_ptr(std::move(shd_ptr));
+    auto smhldr     = smart_holder::from_shared_ptr(std::move(shd_ptr));
     v_h.value_ptr() = ptr;
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
diff --git a/include/pybind11/detail/smart_holder_type_casters_inline_include.h b/include/pybind11/detail/smart_holder_type_casters_inline_include.h
index a834eabb1e..ef87b1a62f 100644
--- a/include/pybind11/detail/smart_holder_type_casters_inline_include.h
+++ b/include/pybind11/detail/smart_holder_type_casters_inline_include.h
@@ -1,5 +1,5 @@
 #ifndef PYBIND11_CAST_H_SMART_HOLDER_TYPE_CASTERS_INLINE_INCLUDE_SAFETY_GUARD
-#error "THIS FILE MUST ONLY BE INCLUDED FROM pybind11/cast.h"
+#    error "THIS FILE MUST ONLY BE INCLUDED FROM pybind11/cast.h"
 #endif
 
 #include "smart_holder_poc.h"
@@ -294,7 +294,8 @@ struct smart_holder_type_caster_load {
 
     T &loaded_as_lvalue_ref() const {
         T *raw_ptr = loaded_as_raw_ptr_unowned();
-        if (raw_ptr == nullptr) throw reference_cast_error();
+        if (raw_ptr == nullptr)
+            throw reference_cast_error();
         return *raw_ptr;
     }
 
@@ -302,7 +303,8 @@ struct smart_holder_type_caster_load {
         if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
             throw cast_error("Unowned pointer from direct conversion cannot be converted to a"
                              " std::shared_ptr.");
-        if (!have_holder()) return nullptr;
+        if (!have_holder())
+            return nullptr;
         throw_if_uninitialized_or_disowned_holder();
         std::shared_ptr<void> void_ptr = holder().template as_shared_ptr<void>();
         return std::shared_ptr<T>(void_ptr, convert_type(void_ptr.get()));
@@ -313,7 +315,8 @@ struct smart_holder_type_caster_load {
         if (load_impl.unowned_void_ptr_from_direct_conversion != nullptr)
             throw cast_error("Unowned pointer from direct conversion cannot be converted to a"
                              " std::unique_ptr.");
-        if (!have_holder()) return nullptr;
+        if (!have_holder())
+            return nullptr;
         throw_if_uninitialized_or_disowned_holder();
         holder().template ensure_compatible_rtti_uqp_del<T, D>(context);
         holder().ensure_use_count_1(context);
@@ -663,25 +666,25 @@ struct smart_holder_type_caster<std::unique_ptr<T const, D>>
 };
 
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
-#define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                     \
-    namespace pybind11 {                                                                          \
-    namespace detail {                                                                            \
-    template <>                                                                                   \
-    class type_caster<T> : public smart_holder_type_caster<T> {};                                 \
-    template <>                                                                                   \
-    class type_caster<std::shared_ptr<T>> : public smart_holder_type_caster<std::shared_ptr<T>> { \
-    };                                                                                            \
-    template <>                                                                                   \
-    class type_caster<std::shared_ptr<T const>>                                                   \
-        : public smart_holder_type_caster<std::shared_ptr<T const>> {};                           \
-    template <typename D>                                                                         \
-    class type_caster<std::unique_ptr<T, D>>                                                      \
-        : public smart_holder_type_caster<std::unique_ptr<T, D>> {};                              \
-    template <typename D>                                                                         \
-    class type_caster<std::unique_ptr<T const, D>>                                                \
-        : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};                        \
-    }                                                                                             \
-    }
+#    define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                 \
+        namespace pybind11 {                                                                      \
+        namespace detail {                                                                        \
+        template <>                                                                               \
+        class type_caster<T> : public smart_holder_type_caster<T> {};                             \
+        template <>                                                                               \
+        class type_caster<std::shared_ptr<T>>                                                     \
+            : public smart_holder_type_caster<std::shared_ptr<T>> {};                             \
+        template <>                                                                               \
+        class type_caster<std::shared_ptr<T const>>                                               \
+            : public smart_holder_type_caster<std::shared_ptr<T const>> {};                       \
+        template <typename D>                                                                     \
+        class type_caster<std::unique_ptr<T, D>>                                                  \
+            : public smart_holder_type_caster<std::unique_ptr<T, D>> {};                          \
+        template <typename D>                                                                     \
+        class type_caster<std::unique_ptr<T const, D>>                                            \
+            : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};                    \
+        }                                                                                         \
+        }
 #endif
 
 PYBIND11_NAMESPACE_END(detail)
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index ee6f4134ba..eabc3d520f 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1,3 +1,4 @@
+// clang-format off
 /*
     pybind11/pybind11.h: Main header file of the C++11 python
     binding generator library
@@ -1241,22 +1242,26 @@ auto method_adaptor(Return (Class::*pmf)(Args...) const) -> Return (Derived::*)(
     return pmf;
 }
 
+// clang-format on
 template <typename T>
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
 using default_holder_type = std::unique_ptr<T>;
 #else
 using default_holder_type = smart_holder;
 #endif
+// clang-format off
 
 template <typename type_, typename... options>
 class class_ : public detail::generic_type {
     template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>;
     template <typename T> using is_base = detail::is_strict_base_of<T, type_>;
     template <typename T>
+    // clang-format on
     using is_holder = detail::any_of<detail::is_holder_type<type_, T>,
                                      detail::all_of<detail::negation<is_base<T>>,
                                                     detail::negation<is_subtype<T>>,
                                                     detail::is_smart_holder_type_caster<type_>>>;
+    // clang-format off
     // struct instead of using here to help MSVC:
     template <typename T> struct is_valid_class_option :
         detail::any_of<is_holder<T>, is_subtype<T>, is_base<T>> {};
@@ -1287,18 +1292,24 @@ class class_ : public detail::generic_type {
                 none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
             "Error: multiple inheritance bases must be specified via class_ template options");
 
-        static constexpr bool holder_is_smart_holder = std::is_same<holder_type, smart_holder>::value;
-        static constexpr bool type_caster_type_is_smart_holder_type_caster = detail::is_smart_holder_type_caster<type>::value;
-        static constexpr bool type_caster_type_is_type_caster_base_subtype = std::is_base_of<detail::type_caster_base<type>, detail::type_caster<type>>::value;
+        // clang-format on
+        static constexpr bool holder_is_smart_holder
+            = std::is_same<holder_type, smart_holder>::value;
+        static constexpr bool type_caster_type_is_smart_holder_type_caster
+            = detail::is_smart_holder_type_caster<type>::value;
+        static constexpr bool type_caster_type_is_type_caster_base_subtype
+            = std::is_base_of<detail::type_caster_base<type>, detail::type_caster<type>>::value;
         // Necessary conditions, but not strict.
-        static_assert(!(detail::is_instantiation<std::unique_ptr, holder_type>::value &&
-                        type_caster_type_is_smart_holder_type_caster),
-                      "py::class_ holder vs type_caster mismatch:"
-                      " missing PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, std::unique_ptr<T>)?");
-        static_assert(!(detail::is_instantiation<std::shared_ptr, holder_type>::value &&
-                        type_caster_type_is_smart_holder_type_caster),
-                      "py::class_ holder vs type_caster mismatch:"
-                      " missing PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, std::shared_ptr<T>)?");
+        static_assert(
+            !(detail::is_instantiation<std::unique_ptr, holder_type>::value
+              && type_caster_type_is_smart_holder_type_caster),
+            "py::class_ holder vs type_caster mismatch:"
+            " missing PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, std::unique_ptr<T>)?");
+        static_assert(
+            !(detail::is_instantiation<std::shared_ptr, holder_type>::value
+              && type_caster_type_is_smart_holder_type_caster),
+            "py::class_ holder vs type_caster mismatch:"
+            " missing PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, std::shared_ptr<T>)?");
         static_assert(!(holder_is_smart_holder && type_caster_type_is_type_caster_base_subtype),
                       "py::class_ holder vs type_caster mismatch:"
                       " missing PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)?");
@@ -1313,6 +1324,7 @@ class class_ : public detail::generic_type {
                       " missing PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, ...)"
                       " or collision with custom py::detail::type_caster<T>?");
 #endif
+        // clang-format off
         type_record record;
         record.scope = scope;
         record.name = name;
@@ -1323,7 +1335,7 @@ class class_ : public detail::generic_type {
         record.init_instance = init_instance;
         record.dealloc = dealloc;
 
-        // A better name would be uses_unique_ptr_holder.
+        // A more fitting name would be uses_unique_ptr_holder.
         record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
 
         set_operator_new<type>(&record);
@@ -1542,19 +1554,19 @@ class class_ : public detail::generic_type {
     }
 
 private:
-    template <
-        typename T = type,
-        detail::enable_if_t<!detail::is_smart_holder_type_caster<T>::value, int> = 0>
+    // clang-format on
+    template <typename T                                                               = type,
+              detail::enable_if_t<!detail::is_smart_holder_type_caster<T>::value, int> = 0>
     void generic_type_initialize(const detail::type_record &record) {
         generic_type::initialize(record, &detail::type_caster_generic::local_load);
     }
 
-    template <
-        typename T = type,
-        detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
+    template <typename T                                                              = type,
+              detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
     void generic_type_initialize(const detail::type_record &record) {
         generic_type::initialize(record, detail::type_caster<T>::get_local_load_function_ptr());
     }
+    // clang-format off
 
     /// Initialize holder object, variant 1: object derives from enable_shared_from_this
     template <typename T>
@@ -1612,12 +1624,13 @@ class class_ : public detail::generic_type {
         init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
     }
 
-    template <
-        typename T = type,
-        detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
+    // clang-format on
+    template <typename T                                                              = type,
+              detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
         detail::type_caster<T>::template init_instance_for_type<type>(inst, holder_ptr);
     }
+    // clang-format off
 
     /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.
     static void dealloc(detail::value_and_holder &v_h) {

From 81cd3cc1d585bee4707fec52fb34dd420f56dfe8 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Wed, 17 Feb 2021 20:02:49 -0800
Subject: [PATCH 189/206] Adding source code comments in response to review.

---
 include/pybind11/cast.h                                    | 7 +++++++
 include/pybind11/detail/smart_holder_poc.h                 | 1 +
 .../detail/smart_holder_type_casters_inline_include.h      | 2 ++
 3 files changed, 10 insertions(+)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 1284170e44..2eb91d3849 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -11,9 +11,16 @@
 
 #pragma once
 
+// clang-format on
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
 // #define PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+// Currently the main purpose of this switch is to enable non-intrusive comprehensive testing. If
+// and when `smart_holder` will actually become the released default is currently open. In the
+// meantime, the full functionality is easily available by using `py::classh`, which is just a
+// handy shortcut for `py::class_<T, py::smart_holder>` (see `pybind11/smart_holder.h`). Classes
+// wrapped in this way are fully compatible with everything existing.
 #endif
+// clang-format off
 
 #include "pytypes.h"
 #include "detail/common.h"
diff --git a/include/pybind11/detail/smart_holder_poc.h b/include/pybind11/detail/smart_holder_poc.h
index 5e3fcfaf28..f6aaae2d0a 100644
--- a/include/pybind11/detail/smart_holder_poc.h
+++ b/include/pybind11/detail/smart_holder_poc.h
@@ -154,6 +154,7 @@ struct smart_holder {
         // race conditions, but in the context of Python it is a bug (elsewhere)
         // if the Global Interpreter Lock (GIL) is not being held when this code
         // is reached.
+        // SMART_HOLDER_WIP: IMPROVABLE: assert(GIL is held).
         if (vptr.use_count() != 1) {
             throw std::runtime_error(std::string("Cannot disown use_count != 1 (") + context
                                      + ").");
diff --git a/include/pybind11/detail/smart_holder_type_casters_inline_include.h b/include/pybind11/detail/smart_holder_type_casters_inline_include.h
index ef87b1a62f..1076585591 100644
--- a/include/pybind11/detail/smart_holder_type_casters_inline_include.h
+++ b/include/pybind11/detail/smart_holder_type_casters_inline_include.h
@@ -229,6 +229,8 @@ class modified_type_caster_generic_load_impl {
     bool reinterpret_cast_deemed_ok = false;
     // Magic number intentionally hard-coded, to guard against class_ holder mixups.
     // Ideally type_caster_generic would have a similar guard, but this requires a change there.
+    // SMART_HOLDER_WIP: If it is decided that this guard is useful long term, potentially
+    // set/reset this value in ctor/dtor, mark volatile.
     std::size_t local_load_safety_guard = 1887406645; // 32-bit compatible value for portability.
 };
 // clang-format on

From baf51b4e2855780d41ee86d64a96cd20f8ffed01 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Fri, 19 Feb 2021 17:22:58 -0800
Subject: [PATCH 190/206] Simple micro-benchmark ("ubench") comparing runtime
 performance for several holders.

Tested using github.com/rwgk/pybind11_scons and Google-internal build system.
Sorry, no cmake support at the moment.

First results: https://docs.google.com/spreadsheets/d/1InapCYws2Gt-stmFf_Bwl33eOMo3aLE_gc9adveY7RU/edit#gid=0
---
 ubench/holder_comparison.cpp |  95 +++++++++++++++++++++++++++
 ubench/holder_comparison.py  | 121 +++++++++++++++++++++++++++++++++++
 2 files changed, 216 insertions(+)
 create mode 100644 ubench/holder_comparison.cpp
 create mode 100644 ubench/holder_comparison.py

diff --git a/ubench/holder_comparison.cpp b/ubench/holder_comparison.cpp
new file mode 100644
index 0000000000..5a16089e51
--- /dev/null
+++ b/ubench/holder_comparison.cpp
@@ -0,0 +1,95 @@
+#include <pybind11/smart_holder.h>
+
+#include <cstddef>
+#include <memory>
+#include <vector>
+
+namespace hc { // holder comparison
+
+template <int Serial>
+struct number_bucket {
+    std::vector<double> data;
+
+    explicit number_bucket(std::size_t data_size = 0) : data(data_size, 1.0) {}
+
+    double sum() const {
+        std::size_t n   = 0;
+        double s        = 0;
+        const double *a = &*data.begin();
+        const double *e = &*data.end();
+        while (a != e) {
+            s += *a++;
+            n++;
+        }
+        if (n != data.size()) {
+            throw std::runtime_error("Internal consistency failure (sum).");
+        }
+        return s;
+    }
+
+    std::size_t add(const number_bucket &other) {
+        if (other.data.size() != data.size()) {
+            throw std::runtime_error("Incompatible data sizes.");
+        }
+        std::size_t n   = 0;
+        double *a       = &*data.begin();
+        const double *e = &*data.end();
+        const double *b = &*other.data.begin();
+        while (a != e) {
+            *a++ += *b++;
+            n++;
+        }
+        return n;
+    }
+
+private:
+    number_bucket(const number_bucket &) = delete;
+    number_bucket(number_bucket &&)      = delete;
+    number_bucket &operator=(const number_bucket &) = delete;
+    number_bucket &operator=(number_bucket &&) = delete;
+};
+
+namespace py = pybind11;
+
+template <typename WrappedType, typename HolderType>
+void wrap_number_bucket(py::module m, const char *class_name) {
+    py::class_<WrappedType, HolderType>(m, class_name)
+        .def(py::init<std::size_t>(), py::arg("data_size") = 0)
+        .def("sum", &WrappedType::sum)
+        .def("add", &WrappedType::add, py::arg("other"));
+}
+
+template <typename T>
+class padded_unique_ptr {
+    std::unique_ptr<T> ptr;
+    char padding[sizeof(py::smart_holder) - sizeof(std::unique_ptr<T>)];
+
+public:
+    padded_unique_ptr(T *p) : ptr(p) {}
+    T *get() { return ptr.get(); }
+};
+
+using nb_up = number_bucket<0>;
+using nb_sp = number_bucket<1>;
+using nb_pu = number_bucket<2>;
+using nb_sh = number_bucket<3>;
+
+static_assert(sizeof(padded_unique_ptr<nb_pu>) == sizeof(py::smart_holder),
+              "Unexpected sizeof mismatch.");
+
+} // namespace hc
+
+PYBIND11_DECLARE_HOLDER_TYPE(T, hc::padded_unique_ptr<T>);
+
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(hc::nb_up, std::unique_ptr<hc::nb_up>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(hc::nb_sp, std::shared_ptr<hc::nb_sp>)
+PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(hc::nb_pu, hc::padded_unique_ptr<hc::nb_pu>)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(hc::nb_sh)
+
+PYBIND11_MODULE(pybind11_ubench_holder_comparison, m) {
+    using namespace hc;
+    wrap_number_bucket<nb_up, std::unique_ptr<nb_up>>(m, "number_bucket_up");
+    wrap_number_bucket<nb_sp, std::shared_ptr<nb_sp>>(m, "number_bucket_sp");
+    wrap_number_bucket<nb_pu, padded_unique_ptr<nb_pu>>(m, "number_bucket_pu");
+    wrap_number_bucket<nb_sh, py::smart_holder>(m, "number_bucket_sh");
+}
diff --git a/ubench/holder_comparison.py b/ubench/holder_comparison.py
new file mode 100644
index 0000000000..9df28239e8
--- /dev/null
+++ b/ubench/holder_comparison.py
@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+"""Simple comparison of holder performances, relative to unique_ptr holder."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import pybind11_ubench_holder_comparison as m
+
+import collections
+import sys
+import time
+
+
+def pflush(*args, **kwargs):
+    result = print(*args, **kwargs)
+    # Using "file" here because it is the name of the built-in keyword argument.
+    file = kwargs.get("file", sys.stdout)  # pylint: disable=redefined-builtin
+    file.flush()  # file object must have a flush method.
+    return result
+
+
+def run(args):
+    if not args:
+        size_exponent_min = 0
+        size_exponent_max = 16
+        size_exponent_step = 4
+        call_repetitions_first_pass = 100
+        call_repetitions_target_elapsed_secs = 0.1
+        num_samples = 10
+        selected_holder_type = "*"
+    else:
+        assert len(args) == 7, (
+            "size_exponent_min size_exponent_max size_exponent_step"
+            " call_repetitions_first_pass call_repetitions_target_elapsed_secs"
+            " num_samples selected_holder_type"
+        )
+        size_exponent_min = int(args[0])
+        size_exponent_max = int(args[1])
+        size_exponent_step = int(args[2])
+        call_repetitions_first_pass = int(args[3])
+        call_repetitions_target_elapsed_secs = float(args[4])
+        num_samples = int(args[5])
+        selected_holder_type = args[6]
+    pflush(
+        "command-line arguments:",
+        size_exponent_min,
+        size_exponent_max,
+        size_exponent_step,
+        call_repetitions_first_pass,
+        "%.3f" % call_repetitions_target_elapsed_secs,
+        num_samples,
+        selected_holder_type,
+    )
+
+    for size_exponent in range(
+        size_exponent_min, size_exponent_max + 1, size_exponent_step
+    ):
+        data_size = 2 ** size_exponent
+        pflush(data_size, "data_size")
+        ratios = collections.defaultdict(list)
+        call_repetitions_dynamic = None
+        for _ in range(num_samples):
+            row_0 = None
+            for nb_label, nb_type in [
+                ("up", m.number_bucket_up),
+                ("sp", m.number_bucket_sp),
+                ("pu", m.number_bucket_pu),
+                ("sh", m.number_bucket_sh),
+            ]:
+                if selected_holder_type != "*" and nb_label != selected_holder_type:
+                    continue
+                nb1 = nb_type(data_size)
+                nb2 = nb_type(data_size)
+                if call_repetitions_dynamic is None:
+                    assert int(round(nb1.sum())) == data_size
+                    t0 = time.time()
+                    for _ in range(call_repetitions_first_pass):
+                        nb1.sum()
+                    td_sum = time.time() - t0
+                    call_repetitions_dynamic = max(
+                        call_repetitions_first_pass,
+                        int(
+                            call_repetitions_target_elapsed_secs
+                            * call_repetitions_first_pass
+                            / max(td_sum, 1.0e-6)
+                        )
+                        + 1,
+                    )
+                    pflush(call_repetitions_dynamic, "call_repetitions_dynamic")
+                assert int(round(nb1.sum())) == data_size
+                t0 = time.time()
+                for _ in range(call_repetitions_dynamic):
+                    nb1.sum()
+                td_sum = time.time() - t0
+                assert nb1.add(nb2) == data_size
+                t0 = time.time()
+                for _ in range(call_repetitions_dynamic):
+                    nb1.add(nb2)
+                td_add = time.time() - t0
+                row = [td_sum, td_add]
+                if row_0 is None:
+                    pflush("     Sum   Add  ratS  ratA")
+                    row_0 = row
+                else:
+                    for curr, prev in zip(row, row_0):
+                        if prev:
+                            rat = curr / prev
+                        else:
+                            rat = -1
+                        row.append(curr / prev)
+                    ratios[nb_label + "_ratS"].append(row[-2])
+                    ratios[nb_label + "_ratA"].append(row[-1])
+                pflush(nb_label, " ".join(["%.3f" % v for v in row]))
+        pflush("          Min  Mean   Max")
+        for key, rat in ratios.items():
+            print(key, "%5.3f %5.3f %5.3f" % (min(rat), sum(rat) / len(rat), max(rat)))
+
+
+if __name__ == "__main__":
+    run(args=sys.argv[1:])

From 096441969d2b6967c797dee9dac05306827c18d5 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 20 Feb 2021 23:34:30 -0800
Subject: [PATCH 191/206] Breaking out number_bucket.h, adding hook for also
 collecting performance data for PyCLIF.

---
 ubench/holder_comparison.cpp | 54 ++++-------------------------------
 ubench/holder_comparison.py  |  9 ++++--
 ubench/number_bucket.h       | 55 ++++++++++++++++++++++++++++++++++++
 3 files changed, 68 insertions(+), 50 deletions(-)
 create mode 100644 ubench/number_bucket.h

diff --git a/ubench/holder_comparison.cpp b/ubench/holder_comparison.cpp
index 5a16089e51..edff7cb6c8 100644
--- a/ubench/holder_comparison.cpp
+++ b/ubench/holder_comparison.cpp
@@ -1,53 +1,16 @@
 #include <pybind11/smart_holder.h>
 
+#include "number_bucket.h"
+
 #include <cstddef>
 #include <memory>
-#include <vector>
 
 namespace hc { // holder comparison
 
-template <int Serial>
-struct number_bucket {
-    std::vector<double> data;
-
-    explicit number_bucket(std::size_t data_size = 0) : data(data_size, 1.0) {}
-
-    double sum() const {
-        std::size_t n   = 0;
-        double s        = 0;
-        const double *a = &*data.begin();
-        const double *e = &*data.end();
-        while (a != e) {
-            s += *a++;
-            n++;
-        }
-        if (n != data.size()) {
-            throw std::runtime_error("Internal consistency failure (sum).");
-        }
-        return s;
-    }
-
-    std::size_t add(const number_bucket &other) {
-        if (other.data.size() != data.size()) {
-            throw std::runtime_error("Incompatible data sizes.");
-        }
-        std::size_t n   = 0;
-        double *a       = &*data.begin();
-        const double *e = &*data.end();
-        const double *b = &*other.data.begin();
-        while (a != e) {
-            *a++ += *b++;
-            n++;
-        }
-        return n;
-    }
-
-private:
-    number_bucket(const number_bucket &) = delete;
-    number_bucket(number_bucket &&)      = delete;
-    number_bucket &operator=(const number_bucket &) = delete;
-    number_bucket &operator=(number_bucket &&) = delete;
-};
+using nb_up = pybind11_ubench::number_bucket<1>;
+using nb_sp = pybind11_ubench::number_bucket<2>;
+using nb_pu = pybind11_ubench::number_bucket<3>;
+using nb_sh = pybind11_ubench::number_bucket<4>;
 
 namespace py = pybind11;
 
@@ -69,11 +32,6 @@ class padded_unique_ptr {
     T *get() { return ptr.get(); }
 };
 
-using nb_up = number_bucket<0>;
-using nb_sp = number_bucket<1>;
-using nb_pu = number_bucket<2>;
-using nb_sh = number_bucket<3>;
-
 static_assert(sizeof(padded_unique_ptr<nb_pu>) == sizeof(py::smart_holder),
               "Unexpected sizeof mismatch.");
 
diff --git a/ubench/holder_comparison.py b/ubench/holder_comparison.py
index 9df28239e8..b864f0ef3f 100644
--- a/ubench/holder_comparison.py
+++ b/ubench/holder_comparison.py
@@ -11,6 +11,8 @@
 import sys
 import time
 
+number_bucket_pc = None
+
 
 def pflush(*args, **kwargs):
     result = print(*args, **kwargs)
@@ -28,7 +30,7 @@ def run(args):
         call_repetitions_first_pass = 100
         call_repetitions_target_elapsed_secs = 0.1
         num_samples = 10
-        selected_holder_type = "*"
+        selected_holder_type = "all"
     else:
         assert len(args) == 7, (
             "size_exponent_min size_exponent_max size_exponent_step"
@@ -67,8 +69,11 @@ def run(args):
                 ("sp", m.number_bucket_sp),
                 ("pu", m.number_bucket_pu),
                 ("sh", m.number_bucket_sh),
+                ("pc", number_bucket_pc),
             ]:
-                if selected_holder_type != "*" and nb_label != selected_holder_type:
+                if nb_label == "pc" and nb_type is None:
+                    continue
+                if selected_holder_type != "all" and nb_label != selected_holder_type:
                     continue
                 nb1 = nb_type(data_size)
                 nb2 = nb_type(data_size)
diff --git a/ubench/number_bucket.h b/ubench/number_bucket.h
new file mode 100644
index 0000000000..75523cb605
--- /dev/null
+++ b/ubench/number_bucket.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#include <cstddef>
+#include <exception>
+#include <iostream>
+#include <vector>
+
+namespace pybind11_ubench {
+
+template <int Serial>
+struct number_bucket {
+    std::vector<double> data;
+
+    explicit number_bucket(std::size_t data_size = 0) : data(data_size, 1.0) {}
+
+    double sum() const {
+        std::size_t n   = 0;
+        double s        = 0;
+        const double *a = &*data.begin();
+        const double *e = &*data.end();
+        while (a != e) {
+            s += *a++;
+            n++;
+        }
+        if (n != data.size()) {
+            std::cerr << "Internal consistency failure (sum)." << std::endl;
+            std::terminate();
+        }
+        return s;
+    }
+
+    std::size_t add(const number_bucket &other) {
+        if (other.data.size() != data.size()) {
+            std::cerr << "Incompatible data sizes (add)." << std::endl;
+            std::terminate();
+        }
+        std::size_t n   = 0;
+        double *a       = &*data.begin();
+        const double *e = &*data.end();
+        const double *b = &*other.data.begin();
+        while (a != e) {
+            *a++ += *b++;
+            n++;
+        }
+        return n;
+    }
+
+private:
+    number_bucket(const number_bucket &) = delete;
+    number_bucket(number_bucket &&)      = delete;
+    number_bucket &operator=(const number_bucket &) = delete;
+    number_bucket &operator=(number_bucket &&) = delete;
+};
+
+} // namespace pybind11_ubench

From 1e8fe108629ef1cebac79678a4f0e8cb3ae6ebae Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sat, 20 Feb 2021 23:41:36 -0800
Subject: [PATCH 192/206] Accounting for ubench in MANIFEST.in (simply prune,
 for now).

---
 MANIFEST.in | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MANIFEST.in b/MANIFEST.in
index aed183e874..dc39f97229 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -4,3 +4,4 @@ recursive-include pybind11 py.typed
 recursive-include pybind11 *.pyi
 include pybind11/share/cmake/pybind11/*.cmake
 include LICENSE README.rst pyproject.toml setup.py setup.cfg
+prune ubench

From 227de408303297c240197088ddd0c9c6fb8d5312 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 21 Feb 2021 11:51:12 -0800
Subject: [PATCH 193/206] Smarter determination of call_repetitions.

[skip ci]
---
 ubench/holder_comparison.cpp                  |  1 +
 ubench/holder_comparison.py                   | 62 ++++++++++++-------
 .../holder_comparison_extract_sheet_data.py   | 53 ++++++++++++++++
 3 files changed, 92 insertions(+), 24 deletions(-)
 create mode 100644 ubench/holder_comparison_extract_sheet_data.py

diff --git a/ubench/holder_comparison.cpp b/ubench/holder_comparison.cpp
index edff7cb6c8..720464a91b 100644
--- a/ubench/holder_comparison.cpp
+++ b/ubench/holder_comparison.cpp
@@ -46,6 +46,7 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(hc::nb_sh)
 
 PYBIND11_MODULE(pybind11_ubench_holder_comparison, m) {
     using namespace hc;
+    m.def("sizeof_smart_holder", []() { return sizeof(py::smart_holder); });
     wrap_number_bucket<nb_up, std::unique_ptr<nb_up>>(m, "number_bucket_up");
     wrap_number_bucket<nb_sp, std::shared_ptr<nb_sp>>(m, "number_bucket_sp");
     wrap_number_bucket<nb_pu, padded_unique_ptr<nb_pu>>(m, "number_bucket_pu");
diff --git a/ubench/holder_comparison.py b/ubench/holder_comparison.py
index b864f0ef3f..f6277a8439 100644
--- a/ubench/holder_comparison.py
+++ b/ubench/holder_comparison.py
@@ -54,6 +54,25 @@ def run(args):
         num_samples,
         selected_holder_type,
     )
+    pflush("sizeof_smart_holder:", m.sizeof_smart_holder())
+
+    def find_call_repetitions(
+        callable,
+        time_delta_floor=1.0e-6,
+        target_elapsed_secs_multiplier=1.05,  # Empirical.
+        target_elapsed_secs_tolerance=0.05,
+        max_iterations=100,
+    ):
+        td_target = (
+            call_repetitions_target_elapsed_secs * target_elapsed_secs_multiplier
+        )
+        crd = call_repetitions_first_pass
+        for _ in range(max_iterations):
+            td = callable(crd)
+            crd = max(1, int(td_target * crd / max(td, time_delta_floor)))
+            if abs(td - td_target) / td_target < target_elapsed_secs_tolerance:
+                return crd
+        raise RuntimeError("find_call_repetitions failure: max_iterations exceeded.")
 
     for size_exponent in range(
         size_exponent_min, size_exponent_max + 1, size_exponent_step
@@ -61,7 +80,7 @@ def run(args):
         data_size = 2 ** size_exponent
         pflush(data_size, "data_size")
         ratios = collections.defaultdict(list)
-        call_repetitions_dynamic = None
+        call_repetitions = None
         for _ in range(num_samples):
             row_0 = None
             for nb_label, nb_type in [
@@ -77,32 +96,27 @@ def run(args):
                     continue
                 nb1 = nb_type(data_size)
                 nb2 = nb_type(data_size)
-                if call_repetitions_dynamic is None:
+
+                def many_sum(call_repetitions):
                     assert int(round(nb1.sum())) == data_size
                     t0 = time.time()
-                    for _ in range(call_repetitions_first_pass):
+                    for _ in range(call_repetitions):
                         nb1.sum()
-                    td_sum = time.time() - t0
-                    call_repetitions_dynamic = max(
-                        call_repetitions_first_pass,
-                        int(
-                            call_repetitions_target_elapsed_secs
-                            * call_repetitions_first_pass
-                            / max(td_sum, 1.0e-6)
-                        )
-                        + 1,
-                    )
-                    pflush(call_repetitions_dynamic, "call_repetitions_dynamic")
-                assert int(round(nb1.sum())) == data_size
-                t0 = time.time()
-                for _ in range(call_repetitions_dynamic):
-                    nb1.sum()
-                td_sum = time.time() - t0
-                assert nb1.add(nb2) == data_size
-                t0 = time.time()
-                for _ in range(call_repetitions_dynamic):
-                    nb1.add(nb2)
-                td_add = time.time() - t0
+                    return time.time() - t0
+
+                def many_add(call_repetitions):
+                    assert nb1.add(nb2) == data_size
+                    t0 = time.time()
+                    for _ in range(call_repetitions):
+                        nb1.add(nb2)
+                    return time.time() - t0
+
+                if call_repetitions is None:
+                    call_repetitions = find_call_repetitions(many_sum)
+                    pflush(call_repetitions, "call_repetitions")
+
+                td_sum = many_sum(call_repetitions)
+                td_add = many_add(call_repetitions)
                 row = [td_sum, td_add]
                 if row_0 is None:
                     pflush("     Sum   Add  ratS  ratA")
diff --git a/ubench/holder_comparison_extract_sheet_data.py b/ubench/holder_comparison_extract_sheet_data.py
new file mode 100644
index 0000000000..f552ea5738
--- /dev/null
+++ b/ubench/holder_comparison_extract_sheet_data.py
@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+"""Extract mean ratios from holder_comparison.py output."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import sys
+
+
+def run(args):
+    assert len(args) == 1, "log_holder_comparison.txt"
+
+    log_lines = open(args[0]).read().splitlines()
+
+    for ratx in ("_ratS ", "_ratA "):
+        print(ratx)
+        header = None
+        header_row = None
+        data_row = None
+
+        def show():
+            if header_row:
+                if header is None:
+                    print(",".join(header_row))
+                else:
+                    assert header == header_row
+            if data_row is not None:
+                print(",".join(data_row))
+            return header_row
+
+        for line in log_lines:
+            if line.endswith(" data_size"):
+                header = show()
+                flds = line.split()
+                assert len(flds) == 2
+                header_row = ["data_size"]
+                data_row = [flds[0]]
+            elif line.endswith(" call_repetitions"):
+                flds = line.split()
+                assert len(flds) == 2
+                header_row.append("calls")
+                data_row.append(flds[0])
+            elif line[2:].startswith(ratx):
+                flds = line.split()
+                assert len(flds) == 4
+                header_row.append(line[:2])
+                data_row.append(flds[2])
+        show()
+
+
+if __name__ == "__main__":
+    run(args=sys.argv[1:])

From fb505c053243878865c18ba3b316401a6437d07c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Sun, 21 Feb 2021 20:58:55 -0800
Subject: [PATCH 194/206] Also scaling performance data to PyCLIF.

[skip ci]
---
 ubench/holder_comparison_extract_sheet_data.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/ubench/holder_comparison_extract_sheet_data.py b/ubench/holder_comparison_extract_sheet_data.py
index f552ea5738..64ee27fc48 100644
--- a/ubench/holder_comparison_extract_sheet_data.py
+++ b/ubench/holder_comparison_extract_sheet_data.py
@@ -18,6 +18,7 @@ def run(args):
         header = None
         header_row = None
         data_row = None
+        data_row_buffer = []
 
         def show():
             if header_row:
@@ -27,6 +28,7 @@ def show():
                     assert header == header_row
             if data_row is not None:
                 print(",".join(data_row))
+                data_row_buffer.append(data_row)
             return header_row
 
         for line in log_lines:
@@ -41,6 +43,8 @@ def show():
                 assert len(flds) == 2
                 header_row.append("calls")
                 data_row.append(flds[0])
+                header_row.append("up")
+                data_row.append("1.000")
             elif line[2:].startswith(ratx):
                 flds = line.split()
                 assert len(flds) == 4
@@ -48,6 +52,15 @@ def show():
                 data_row.append(flds[2])
         show()
 
+        print("Scaled to last column:")
+        print(",".join(header_row))
+        for data_row in data_row_buffer:
+            data_row_rescaled = data_row[:2]
+            unit = float(data_row[-1])
+            for fld in data_row[2:]:
+                data_row_rescaled.append("%.3f" % (float(fld) / unit))
+            print(",".join(data_row_rescaled))
+
 
 if __name__ == "__main__":
     run(args=sys.argv[1:])

From a886a567a3bf9b8648b5346e07094432af6b5153 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Mon, 22 Feb 2021 06:06:28 -0800
Subject: [PATCH 195/206] Adding ubench/python/number_bucket.clif here for
 general visibility.

---
 ubench/python/number_bucket.clif | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 ubench/python/number_bucket.clif

diff --git a/ubench/python/number_bucket.clif b/ubench/python/number_bucket.clif
new file mode 100644
index 0000000000..ef704c0905
--- /dev/null
+++ b/ubench/python/number_bucket.clif
@@ -0,0 +1,6 @@
+from "pybind11/ubench/number_bucket.h":
+  namespace `pybind11_ubench`:
+    class `number_bucket<0>` as number_bucket_pc:
+      def __init__(self, data_size: int = default)
+      def sum(self) -> float
+      def add(self, other: number_bucket_pc) -> int

From 044056a1d65d04ca3498751505f97b2258cc6585 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 23 Feb 2021 13:01:16 -0800
Subject: [PATCH 196/206] Fix after rebase

---
 CMakeLists.txt                                |   2 +-
 include/pybind11/cast.h                       | 985 +-----------------
 .../detail/is_smart_holder_type_caster.h      |  29 +
 .../detail/smart_holder_init_inline_include.h |  10 +-
 ..._include.h => smart_holder_type_casters.h} |  44 +-
 include/pybind11/pybind11.h                   |  20 +-
 include/pybind11/smart_holder.h               |   1 +
 tests/class_sh_module_local_0.cpp             |   1 -
 tests/class_sh_module_local_1.cpp             |   1 -
 tests/class_sh_module_local_2.cpp             |   1 -
 tests/extra_python_package/test_files.py      |   2 +-
 11 files changed, 105 insertions(+), 991 deletions(-)
 create mode 100644 include/pybind11/detail/is_smart_holder_type_caster.h
 rename include/pybind11/detail/{smart_holder_type_casters_inline_include.h => smart_holder_type_casters.h} (95%)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 140948a2b2..7baa8a3b2c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -107,7 +107,7 @@ set(PYBIND11_HEADERS
     include/pybind11/detail/internals.h
     include/pybind11/detail/smart_holder_init_inline_include.h
     include/pybind11/detail/smart_holder_poc.h
-    include/pybind11/detail/smart_holder_type_casters_inline_include.h
+    include/pybind11/detail/smart_holder_type_casters.h
     include/pybind11/detail/typeid.h
     include/pybind11/attr.h
     include/pybind11/buffer_info.h
diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 2eb91d3849..babb672fe5 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -11,21 +11,12 @@
 
 #pragma once
 
-// clang-format on
-#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
-// #define PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
-// Currently the main purpose of this switch is to enable non-intrusive comprehensive testing. If
-// and when `smart_holder` will actually become the released default is currently open. In the
-// meantime, the full functionality is easily available by using `py::classh`, which is just a
-// handy shortcut for `py::class_<T, py::smart_holder>` (see `pybind11/smart_holder.h`). Classes
-// wrapped in this way are fully compatible with everything existing.
-#endif
-// clang-format off
-
 #include "pytypes.h"
 #include "detail/common.h"
 #include "detail/descr.h"
-#include "detail/internals.h"
+#include "detail/is_smart_holder_type_caster.h"
+#include "detail/type_caster_base.h"
+#include "detail/typeid.h"
 #include <array>
 #include <cstring>
 #include <functional>
@@ -38,6 +29,10 @@
 #include <utility>
 #include <vector>
 
+#ifdef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+#include "detail/smart_holder_type_casters.h"
+#endif
+
 #if defined(PYBIND11_CPP17)
 #  if defined(__has_include)
 #    if __has_include(<string_view>)
@@ -58,976 +53,10 @@
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 PYBIND11_NAMESPACE_BEGIN(detail)
 
-/// A life support system for temporary objects created by `type_caster::load()`.
-/// Adding a patient will keep it alive up until the enclosing function returns.
-class loader_life_support {
-public:
-    /// A new patient frame is created when a function is entered
-    loader_life_support() {
-        get_internals().loader_patient_stack.push_back(nullptr);
-    }
-
-    /// ... and destroyed after it returns
-    ~loader_life_support() {
-        auto &stack = get_internals().loader_patient_stack;
-        if (stack.empty())
-            pybind11_fail("loader_life_support: internal error");
-
-        auto ptr = stack.back();
-        stack.pop_back();
-        Py_CLEAR(ptr);
-
-        // A heuristic to reduce the stack's capacity (e.g. after long recursive calls)
-        if (stack.capacity() > 16 && !stack.empty() && stack.capacity() / stack.size() > 2)
-            stack.shrink_to_fit();
-    }
-
-    /// 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) {
-        auto &stack = get_internals().loader_patient_stack;
-        if (stack.empty())
-            throw cast_error("When called outside a bound function, py::cast() cannot "
-                             "do Python -> C++ conversions which require the creation "
-                             "of temporary values");
-
-        auto &list_ptr = stack.back();
-        if (list_ptr == nullptr) {
-            list_ptr = PyList_New(1);
-            if (!list_ptr)
-                pybind11_fail("loader_life_support: error allocating list");
-            PyList_SET_ITEM(list_ptr, 0, h.inc_ref().ptr());
-        } else {
-            auto result = PyList_Append(list_ptr, h.ptr());
-            if (result == -1)
-                pybind11_fail("loader_life_support: error adding patient");
-        }
-    }
-};
-
-// Gets the cache entry for the given type, creating it if necessary.  The return value is the pair
-// returned by emplace, i.e. an iterator for the entry and a bool set to `true` if the entry was
-// just created.
-inline std::pair<decltype(internals::registered_types_py)::iterator, bool> all_type_info_get_cache(PyTypeObject *type);
-
-// Populates a just-created cache entry.
-PYBIND11_NOINLINE inline void all_type_info_populate(PyTypeObject *t, std::vector<type_info *> &bases) {
-    std::vector<PyTypeObject *> check;
-    for (handle parent : reinterpret_borrow<tuple>(t->tp_bases))
-        check.push_back((PyTypeObject *) parent.ptr());
-
-    auto const &type_dict = get_internals().registered_types_py;
-    for (size_t i = 0; i < check.size(); i++) {
-        auto type = check[i];
-        // Ignore Python2 old-style class super type:
-        if (!PyType_Check((PyObject *) type)) continue;
-
-        // Check `type` in the current set of registered python types:
-        auto it = type_dict.find(type);
-        if (it != type_dict.end()) {
-            // We found a cache entry for it, so it's either pybind-registered or has pre-computed
-            // pybind bases, but we have to make sure we haven't already seen the type(s) before: we
-            // want to follow Python/virtual C++ rules that there should only be one instance of a
-            // common base.
-            for (auto *tinfo : it->second) {
-                // NB: Could use a second set here, rather than doing a linear search, but since
-                // having a large number of immediate pybind11-registered types seems fairly
-                // unlikely, that probably isn't worthwhile.
-                bool found = false;
-                for (auto *known : bases) {
-                    if (known == tinfo) { found = true; break; }
-                }
-                if (!found) bases.push_back(tinfo);
-            }
-        }
-        else if (type->tp_bases) {
-            // It's some python type, so keep follow its bases classes to look for one or more
-            // registered types
-            if (i + 1 == check.size()) {
-                // When we're at the end, we can pop off the current element to avoid growing
-                // `check` when adding just one base (which is typical--i.e. when there is no
-                // multiple inheritance)
-                check.pop_back();
-                i--;
-            }
-            for (handle parent : reinterpret_borrow<tuple>(type->tp_bases))
-                check.push_back((PyTypeObject *) parent.ptr());
-        }
-    }
-}
-
-/**
- * Extracts vector of type_info pointers of pybind-registered roots of the given Python type.  Will
- * be just 1 pybind type for the Python type of a pybind-registered class, or for any Python-side
- * derived class that uses single inheritance.  Will contain as many types as required for a Python
- * class that uses multiple inheritance to inherit (directly or indirectly) from multiple
- * pybind-registered classes.  Will be empty if neither the type nor any base classes are
- * pybind-registered.
- *
- * The value is cached for the lifetime of the Python type.
- */
-inline const std::vector<detail::type_info *> &all_type_info(PyTypeObject *type) {
-    auto ins = all_type_info_get_cache(type);
-    if (ins.second)
-        // New cache entry: populate it
-        all_type_info_populate(type, ins.first->second);
-
-    return ins.first->second;
-}
-
-/**
- * Gets a single pybind11 type info for a python type.  Returns nullptr if neither the type nor any
- * ancestors are pybind11-registered.  Throws an exception if there are multiple bases--use
- * `all_type_info` instead if you want to support multiple bases.
- */
-PYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type) {
-    auto &bases = all_type_info(type);
-    if (bases.empty())
-        return nullptr;
-    if (bases.size() > 1)
-        pybind11_fail("pybind11::detail::get_type_info: type has multiple pybind11-registered bases");
-    return bases.front();
-}
-
-inline detail::type_info *get_local_type_info(const std::type_index &tp) {
-    auto &locals = registered_local_types_cpp();
-    auto it = locals.find(tp);
-    if (it != locals.end())
-        return it->second;
-    return nullptr;
-}
-
-inline detail::type_info *get_global_type_info(const std::type_index &tp) {
-    auto &types = get_internals().registered_types_cpp;
-    auto it = types.find(tp);
-    if (it != types.end())
-        return it->second;
-    return nullptr;
-}
-
-/// Return the type info for a given C++ type; on lookup failure can either throw or return nullptr.
-PYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_index &tp,
-                                                          bool throw_if_missing = false) {
-    if (auto ltype = get_local_type_info(tp))
-        return ltype;
-    if (auto gtype = get_global_type_info(tp))
-        return gtype;
-
-    if (throw_if_missing) {
-        std::string tname = tp.name();
-        detail::clean_type_id(tname);
-        pybind11_fail("pybind11::detail::get_type_info: unable to find type info for \"" + tname + "\"");
-    }
-    return nullptr;
-}
-
-PYBIND11_NOINLINE inline handle get_type_handle(const std::type_info &tp, bool throw_if_missing) {
-    detail::type_info *type_info = get_type_info(tp, throw_if_missing);
-    return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
-}
-
-// Searches the inheritance graph for a registered Python instance, using all_type_info().
-PYBIND11_NOINLINE inline handle find_registered_python_instance(void *src,
-                                                                const detail::type_info *tinfo) {
-    auto it_instances = get_internals().registered_instances.equal_range(src);
-    for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
-        for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
-            if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
-                return handle((PyObject *) it_i->second).inc_ref();
-        }
-    }
-    return handle();
-}
-
-struct value_and_holder {
-    instance *inst = nullptr;
-    size_t index = 0u;
-    const detail::type_info *type = nullptr;
-    void **vh = nullptr;
-
-    // Main constructor for a found value/holder:
-    value_and_holder(instance *i, const detail::type_info *type, size_t vpos, size_t index) :
-        inst{i}, index{index}, type{type},
-        vh{inst->simple_layout ? inst->simple_value_holder : &inst->nonsimple.values_and_holders[vpos]}
-    {}
-
-    // Default constructor (used to signal a value-and-holder not found by get_value_and_holder())
-    value_and_holder() = default;
-
-    // Used for past-the-end iterator
-    value_and_holder(size_t index) : index{index} {}
-
-    template <typename V = void> V *&value_ptr() const {
-        return reinterpret_cast<V *&>(vh[0]);
-    }
-    // True if this `value_and_holder` has a non-null value pointer
-    explicit operator bool() const { return value_ptr(); }
-
-    template <typename H> H &holder() const {
-        return reinterpret_cast<H &>(vh[1]);
-    }
-    bool holder_constructed() const {
-        return inst->simple_layout
-            ? inst->simple_holder_constructed
-            : inst->nonsimple.status[index] & instance::status_holder_constructed;
-    }
-    void set_holder_constructed(bool v = true) {
-        if (inst->simple_layout)
-            inst->simple_holder_constructed = v;
-        else if (v)
-            inst->nonsimple.status[index] |= instance::status_holder_constructed;
-        else
-            inst->nonsimple.status[index] &= (uint8_t) ~instance::status_holder_constructed;
-    }
-    bool instance_registered() const {
-        return inst->simple_layout
-            ? inst->simple_instance_registered
-            : inst->nonsimple.status[index] & instance::status_instance_registered;
-    }
-    void set_instance_registered(bool v = true) {
-        if (inst->simple_layout)
-            inst->simple_instance_registered = v;
-        else if (v)
-            inst->nonsimple.status[index] |= instance::status_instance_registered;
-        else
-            inst->nonsimple.status[index] &= (uint8_t) ~instance::status_instance_registered;
-    }
-};
-
-// Container for accessing and iterating over an instance's values/holders
-struct values_and_holders {
-private:
-    instance *inst;
-    using type_vec = std::vector<detail::type_info *>;
-    const type_vec &tinfo;
-
-public:
-    values_and_holders(instance *inst) : inst{inst}, tinfo(all_type_info(Py_TYPE(inst))) {}
-
-    struct iterator {
-    private:
-        instance *inst = nullptr;
-        const type_vec *types = nullptr;
-        value_and_holder curr;
-        friend struct values_and_holders;
-        iterator(instance *inst, const type_vec *tinfo)
-            : inst{inst}, types{tinfo},
-            curr(inst /* instance */,
-                 types->empty() ? nullptr : (*types)[0] /* type info */,
-                 0, /* vpos: (non-simple types only): the first vptr comes first */
-                 0 /* index */)
-        {}
-        // Past-the-end iterator:
-        iterator(size_t end) : curr(end) {}
-    public:
-        bool operator==(const iterator &other) const { return curr.index == other.curr.index; }
-        bool operator!=(const iterator &other) const { return curr.index != other.curr.index; }
-        iterator &operator++() {
-            if (!inst->simple_layout)
-                curr.vh += 1 + (*types)[curr.index]->holder_size_in_ptrs;
-            ++curr.index;
-            curr.type = curr.index < types->size() ? (*types)[curr.index] : nullptr;
-            return *this;
-        }
-        value_and_holder &operator*() { return curr; }
-        value_and_holder *operator->() { return &curr; }
-    };
-
-    iterator begin() { return iterator(inst, &tinfo); }
-    iterator end() { return iterator(tinfo.size()); }
-
-    iterator find(const type_info *find_type) {
-        auto it = begin(), endit = end();
-        while (it != endit && it->type != find_type) ++it;
-        return it;
-    }
-
-    size_t size() { return tinfo.size(); }
-};
-
-/**
- * Extracts C++ value and holder pointer references from an instance (which may contain multiple
- * values/holders for python-side multiple inheritance) that match the given type.  Throws an error
- * if the given type (or ValueType, if omitted) is not a pybind11 base of the given instance.  If
- * `find_type` is omitted (or explicitly specified as nullptr) the first value/holder are returned,
- * regardless of type (and the resulting .type will be nullptr).
- *
- * The returned object should be short-lived: in particular, it must not outlive the called-upon
- * instance.
- */
-PYBIND11_NOINLINE inline value_and_holder instance::get_value_and_holder(const type_info *find_type /*= nullptr default in common.h*/, bool throw_if_missing /*= true in common.h*/) {
-    // Optimize common case:
-    if (!find_type || Py_TYPE(this) == find_type->type)
-        return value_and_holder(this, find_type, 0, 0);
-
-    detail::values_and_holders vhs(this);
-    auto it = vhs.find(find_type);
-    if (it != vhs.end())
-        return *it;
-
-    if (!throw_if_missing)
-        return value_and_holder();
-
-#if defined(NDEBUG)
-    pybind11_fail("pybind11::detail::instance::get_value_and_holder: "
-            "type is not a pybind11 base of the given instance "
-            "(compile in debug mode for type details)");
-#else
-    pybind11_fail("pybind11::detail::instance::get_value_and_holder: `" +
-            get_fully_qualified_tp_name(find_type->type) + "' is not a pybind11 base of the given `" +
-            get_fully_qualified_tp_name(Py_TYPE(this)) + "' instance");
-#endif
-}
-
-PYBIND11_NOINLINE inline void instance::allocate_layout() {
-    auto &tinfo = all_type_info(Py_TYPE(this));
-
-    const size_t n_types = tinfo.size();
-
-    if (n_types == 0)
-        pybind11_fail("instance allocation failed: new instance has no pybind11-registered base types");
-
-    simple_layout =
-        n_types == 1 && tinfo.front()->holder_size_in_ptrs <= instance_simple_holder_in_ptrs();
-
-    // Simple path: no python-side multiple inheritance, and a small-enough holder
-    if (simple_layout) {
-        simple_value_holder[0] = nullptr;
-        simple_holder_constructed = false;
-        simple_instance_registered = false;
-    }
-    else { // multiple base types or a too-large holder
-        // Allocate space to hold: [v1*][h1][v2*][h2]...[bb...] where [vN*] is a value pointer,
-        // [hN] is the (uninitialized) holder instance for value N, and [bb...] is a set of bool
-        // values that tracks whether each associated holder has been initialized.  Each [block] is
-        // padded, if necessary, to an integer multiple of sizeof(void *).
-        size_t space = 0;
-        for (auto t : tinfo) {
-            space += 1; // value pointer
-            space += t->holder_size_in_ptrs; // holder instance
-        }
-        size_t flags_at = space;
-        space += size_in_ptrs(n_types); // status bytes (holder_constructed and instance_registered)
-
-        // Allocate space for flags, values, and holders, and initialize it to 0 (flags and values,
-        // in particular, need to be 0).  Use Python's memory allocation functions: in Python 3.6
-        // they default to using pymalloc, which is designed to be efficient for small allocations
-        // like the one we're doing here; in earlier versions (and for larger allocations) they are
-        // just wrappers around malloc.
-#if PY_VERSION_HEX >= 0x03050000
-        nonsimple.values_and_holders = (void **) PyMem_Calloc(space, sizeof(void *));
-        if (!nonsimple.values_and_holders) throw std::bad_alloc();
-#else
-        nonsimple.values_and_holders = (void **) PyMem_New(void *, space);
-        if (!nonsimple.values_and_holders) throw std::bad_alloc();
-        std::memset(nonsimple.values_and_holders, 0, space * sizeof(void *));
-#endif
-        nonsimple.status = reinterpret_cast<uint8_t *>(&nonsimple.values_and_holders[flags_at]);
-    }
-    owned = true;
-}
-
-PYBIND11_NOINLINE inline void instance::deallocate_layout() {
-    if (!simple_layout)
-        PyMem_Free(nonsimple.values_and_holders);
-}
-
-PYBIND11_NOINLINE inline bool isinstance_generic(handle obj, const std::type_info &tp) {
-    handle type = detail::get_type_handle(tp, false);
-    if (!type)
-        return false;
-    return isinstance(obj, type);
-}
-
-PYBIND11_NOINLINE inline std::string error_string() {
-    if (!PyErr_Occurred()) {
-        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);
-
-#if PY_MAJOR_VERSION >= 3
-    if (scope.trace != nullptr)
-        PyException_SetTraceback(scope.value, scope.trace);
-#endif
-
-#if !defined(PYPY_VERSION)
-    if (scope.trace) {
-        auto *trace = (PyTracebackObject *) scope.trace;
-
-        /* Get the deepest trace possible */
-        while (trace->tb_next)
-            trace = trace->tb_next;
-
-        PyFrameObject *frame = trace->tb_frame;
-        errorString += "\n\nAt:\n";
-        while (frame) {
-            int lineno = PyFrame_GetLineNumber(frame);
-            errorString +=
-                "  " + handle(frame->f_code->co_filename).cast<std::string>() +
-                "(" + std::to_string(lineno) + "): " +
-                handle(frame->f_code->co_name).cast<std::string>() + "\n";
-            frame = frame->f_back;
-        }
-    }
-#endif
-
-    return errorString;
-}
-
-PYBIND11_NOINLINE inline handle get_object_handle(const void *ptr, const detail::type_info *type ) {
-    auto &instances = get_internals().registered_instances;
-    auto range = instances.equal_range(ptr);
-    for (auto it = range.first; it != range.second; ++it) {
-        for (const auto &vh : values_and_holders(it->second)) {
-            if (vh.type == type)
-                return handle((PyObject *) it->second);
-        }
-    }
-    return handle();
-}
-
-inline PyThreadState *get_thread_state_unchecked() {
-#if defined(PYPY_VERSION)
-    return PyThreadState_GET();
-#elif PY_VERSION_HEX < 0x03000000
-    return _PyThreadState_Current;
-#elif PY_VERSION_HEX < 0x03050000
-    return (PyThreadState*) _Py_atomic_load_relaxed(&_PyThreadState_Current);
-#elif PY_VERSION_HEX < 0x03050200
-    return (PyThreadState*) _PyThreadState_Current.value;
-#else
-    return _PyThreadState_UncheckedGet();
-#endif
-}
-
-// Forward declarations
-inline void keep_alive_impl(handle nurse, handle patient);
-inline PyObject *make_new_instance(PyTypeObject *type);
-
-class type_caster_generic {
-public:
-    PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info)
-        : typeinfo(get_type_info(type_info)), cpptype(&type_info) { }
-
-    type_caster_generic(const type_info *typeinfo)
-        : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { }
-
-    bool load(handle src, bool convert) {
-        return load_impl<type_caster_generic>(src, convert);
-    }
-
-    PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
-                                         const detail::type_info *tinfo,
-                                         void *(*copy_constructor)(const void *),
-                                         void *(*move_constructor)(const void *),
-                                         const void *existing_holder = nullptr) {
-        if (!tinfo) // no type info: error will be set already
-            return handle();
-
-        void *src = const_cast<void *>(_src);
-        if (src == nullptr)
-            return none().release();
-
-        if (handle registered_inst = find_registered_python_instance(src, tinfo))
-            return registered_inst;
-
-        auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type));
-        auto wrapper = reinterpret_cast<instance *>(inst.ptr());
-        wrapper->owned = false;
-        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
-
-        switch (policy) {
-            case return_value_policy::automatic:
-            case return_value_policy::take_ownership:
-                valueptr = src;
-                wrapper->owned = true;
-                break;
-
-            case return_value_policy::automatic_reference:
-            case return_value_policy::reference:
-                valueptr = src;
-                wrapper->owned = false;
-                break;
-
-            case return_value_policy::copy:
-                if (copy_constructor)
-                    valueptr = copy_constructor(src);
-                else {
-#if defined(NDEBUG)
-                    throw cast_error("return_value_policy = copy, but type is "
-                                     "non-copyable! (compile in debug mode for details)");
-#else
-                    std::string type_name(tinfo->cpptype->name());
-                    detail::clean_type_id(type_name);
-                    throw cast_error("return_value_policy = copy, but type " +
-                                     type_name + " is non-copyable!");
-#endif
-                }
-                wrapper->owned = true;
-                break;
-
-            case return_value_policy::move:
-                if (move_constructor)
-                    valueptr = move_constructor(src);
-                else if (copy_constructor)
-                    valueptr = copy_constructor(src);
-                else {
-#if defined(NDEBUG)
-                    throw cast_error("return_value_policy = move, but type is neither "
-                                     "movable nor copyable! "
-                                     "(compile in debug mode for details)");
-#else
-                    std::string type_name(tinfo->cpptype->name());
-                    detail::clean_type_id(type_name);
-                    throw cast_error("return_value_policy = move, but type " +
-                                     type_name + " is neither movable nor copyable!");
-#endif
-                }
-                wrapper->owned = true;
-                break;
-
-            case return_value_policy::reference_internal:
-                valueptr = src;
-                wrapper->owned = false;
-                keep_alive_impl(inst, parent);
-                break;
-
-            default:
-                throw cast_error("unhandled return_value_policy: should not happen!");
-        }
-
-        tinfo->init_instance(wrapper, existing_holder);
-
-        return inst.release();
-    }
-
-    // Base methods for generic caster; there are overridden in copyable_holder_caster
-    void load_value(value_and_holder &&v_h) {
-        auto *&vptr = v_h.value_ptr();
-        // Lazy allocation for unallocated values:
-        if (vptr == nullptr) {
-            auto *type = v_h.type ? v_h.type : typeinfo;
-            if (type->operator_new) {
-                vptr = type->operator_new(type->type_size);
-            } else {
-                #if defined(__cpp_aligned_new) && (!defined(_MSC_VER) || _MSC_VER >= 1912)
-                    if (type->type_align > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
-                        vptr = ::operator new(type->type_size,
-                                              std::align_val_t(type->type_align));
-                    else
-                #endif
-                vptr = ::operator new(type->type_size);
-            }
-        }
-        value = vptr;
-    }
-    bool try_implicit_casts(handle src, bool convert) {
-        for (auto &cast : typeinfo->implicit_casts) {
-            type_caster_generic sub_caster(*cast.first);
-            if (sub_caster.load(src, convert)) {
-                value = cast.second(sub_caster.value);
-                return true;
-            }
-        }
-        return false;
-    }
-    bool try_direct_conversions(handle src) {
-        for (auto &converter : *typeinfo->direct_conversions) {
-            if (converter(src.ptr(), value))
-                return true;
-        }
-        return false;
-    }
-    void check_holder_compat() {}
-
-    PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
-        auto caster = type_caster_generic(ti);
-        if (caster.load(src, false))
-            return caster.value;
-        return nullptr;
-    }
-
-    /// Try to load with foreign typeinfo, if available. Used when there is no
-    /// native typeinfo, or when the native one wasn't able to produce a value.
-    PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) {
-        constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
-        const auto pytype = type::handle_of(src);
-        if (!hasattr(pytype, local_key))
-            return false;
-
-        type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key));
-        // Only consider this foreign loader if actually foreign and is a loader of the correct cpp type
-        if (foreign_typeinfo->module_local_load == &local_load
-            || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype)))
-            return false;
-
-        if (auto result = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo)) {
-            value = result;
-            return true;
-        }
-        return false;
-    }
-
-    // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
-    // bits of code between here and copyable_holder_caster where the two classes need different
-    // logic (without having to resort to virtual inheritance).
-    template <typename ThisT>
-    PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
-        if (!src) return false;
-        if (!typeinfo) return try_load_foreign_module_local(src);
-        if (src.is_none()) {
-            // Defer accepting None to other overloads (if we aren't in convert mode):
-            if (!convert) return false;
-            value = nullptr;
-            return true;
-        }
-
-        auto &this_ = static_cast<ThisT &>(*this);
-        this_.check_holder_compat();
-
-        PyTypeObject *srctype = Py_TYPE(src.ptr());
-
-        // Case 1: If src is an exact type match for the target type then we can reinterpret_cast
-        // the instance's value pointer to the target type:
-        if (srctype == typeinfo->type) {
-            this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
-            return true;
-        }
-        // Case 2: We have a derived class
-        else if (PyType_IsSubtype(srctype, typeinfo->type)) {
-            auto &bases = all_type_info(srctype);
-            bool no_cpp_mi = typeinfo->simple_type;
-
-            // Case 2a: the python type is a Python-inherited derived class that inherits from just
-            // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of
-            // the right type and we can use reinterpret_cast.
-            // (This is essentially the same as case 2b, but because not using multiple inheritance
-            // is extremely common, we handle it specially to avoid the loop iterator and type
-            // pointer lookup overhead)
-            if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
-                this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
-                return true;
-            }
-            // Case 2b: the python type inherits from multiple C++ bases.  Check the bases to see if
-            // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we
-            // can safely reinterpret_cast to the relevant pointer.
-            else if (bases.size() > 1) {
-                for (auto base : bases) {
-                    if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
-                        this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
-                        return true;
-                    }
-                }
-            }
-
-            // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match
-            // in the registered bases, above, so try implicit casting (needed for proper C++ casting
-            // when MI is involved).
-            if (this_.try_implicit_casts(src, convert))
-                return true;
-        }
-
-        // Perform an implicit conversion
-        if (convert) {
-            for (auto &converter : typeinfo->implicit_conversions) {
-                auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
-                if (load_impl<ThisT>(temp, false)) {
-                    loader_life_support::add_patient(temp);
-                    return true;
-                }
-            }
-            if (this_.try_direct_conversions(src))
-                return true;
-        }
-
-        // Failed to match local typeinfo. Try again with global.
-        if (typeinfo->module_local) {
-            if (auto gtype = get_global_type_info(*typeinfo->cpptype)) {
-                typeinfo = gtype;
-                return load(src, false);
-            }
-        }
-
-        // Global typeinfo has precedence over foreign module_local
-        return try_load_foreign_module_local(src);
-    }
-
-
-    // Called to do type lookup and wrap the pointer and type in a pair when a dynamic_cast
-    // isn't needed or can't be used.  If the type is unknown, sets the error and returns a pair
-    // with .second = nullptr.  (p.first = nullptr is not an error: it becomes None).
-    PYBIND11_NOINLINE static std::pair<const void *, const type_info *> src_and_type(
-            const void *src, const std::type_info &cast_type, const std::type_info *rtti_type = nullptr) {
-        if (auto *tpi = get_type_info(cast_type))
-            return {src, const_cast<const type_info *>(tpi)};
-
-        // Not found, set error:
-        std::string tname = rtti_type ? rtti_type->name() : cast_type.name();
-        detail::clean_type_id(tname);
-        std::string msg = "Unregistered type : " + tname;
-        PyErr_SetString(PyExc_TypeError, msg.c_str());
-        return {nullptr, nullptr};
-    }
-
-    const type_info *typeinfo = nullptr;
-    const std::type_info *cpptype = nullptr;
-    void *value = nullptr;
-};
-
-/**
- * Determine suitable casting operator for pointer-or-lvalue-casting type casters.  The type caster
- * needs to provide `operator T*()` and `operator T&()` operators.
- *
- * If the type supports moving the value away via an `operator T&&() &&` method, it should use
- * `movable_cast_op_type` instead.
- */
-template <typename T>
-using cast_op_type =
-    conditional_t<std::is_pointer<remove_reference_t<T>>::value,
-        typename std::add_pointer<intrinsic_t<T>>::type,
-        typename std::add_lvalue_reference<intrinsic_t<T>>::type>;
-
-/**
- * Determine suitable casting operator for a type caster with a movable value.  Such a type caster
- * needs to provide `operator T*()`, `operator T&()`, and `operator T&&() &&`.  The latter will be
- * called in appropriate contexts where the value can be moved rather than copied.
- *
- * These operator are automatically provided when using the PYBIND11_TYPE_CASTER macro.
- */
-template <typename T>
-using movable_cast_op_type =
-    conditional_t<std::is_pointer<typename std::remove_reference<T>::type>::value,
-        typename std::add_pointer<intrinsic_t<T>>::type,
-    conditional_t<std::is_rvalue_reference<T>::value,
-        typename std::add_rvalue_reference<intrinsic_t<T>>::type,
-        typename std::add_lvalue_reference<intrinsic_t<T>>::type>>;
-
-// std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when
-// T is non-copyable, but code containing such a copy constructor fails to actually compile.
-template <typename T, typename SFINAE = void> struct is_copy_constructible : std::is_copy_constructible<T> {};
-
-// Specialization for types that appear to be copy constructible but also look like stl containers
-// (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
-// so, copy constructability depends on whether the value_type is copy constructible.
-template <typename Container> struct is_copy_constructible<Container, enable_if_t<all_of<
-        std::is_copy_constructible<Container>,
-        std::is_same<typename Container::value_type &, typename Container::reference>,
-        // Avoid infinite recursion
-        negation<std::is_same<Container, typename Container::value_type>>
-    >::value>> : is_copy_constructible<typename Container::value_type> {};
-
-// Likewise for std::pair
-// (after C++17 it is mandatory that the copy constructor not exist when the two types aren't themselves
-// copy constructible, but this can not be relied upon when T1 or T2 are themselves containers).
-template <typename T1, typename T2> struct is_copy_constructible<std::pair<T1, T2>>
-    : all_of<is_copy_constructible<T1>, is_copy_constructible<T2>> {};
-
-// The same problems arise with std::is_copy_assignable, so we use the same workaround.
-template <typename T, typename SFINAE = void> struct is_copy_assignable : std::is_copy_assignable<T> {};
-template <typename Container> struct is_copy_assignable<Container, enable_if_t<all_of<
-        std::is_copy_assignable<Container>,
-        std::is_same<typename Container::value_type &, typename Container::reference>
-    >::value>> : is_copy_assignable<typename Container::value_type> {};
-template <typename T1, typename T2> struct is_copy_assignable<std::pair<T1, T2>>
-    : all_of<is_copy_assignable<T1>, is_copy_assignable<T2>> {};
-
-PYBIND11_NAMESPACE_END(detail)
-
-// polymorphic_type_hook<itype>::get(src, tinfo) determines whether the object pointed
-// to by `src` actually is an instance of some class derived from `itype`.
-// If so, it sets `tinfo` to point to the std::type_info representing that derived
-// type, and returns a pointer to the start of the most-derived object of that type
-// (in which `src` is a subobject; this will be the same address as `src` in most
-// single inheritance cases). If not, or if `src` is nullptr, it simply returns `src`
-// and leaves `tinfo` at its default value of nullptr.
-//
-// The default polymorphic_type_hook just returns src. A specialization for polymorphic
-// types determines the runtime type of the passed object and adjusts the this-pointer
-// appropriately via dynamic_cast<void*>. This is what enables a C++ Animal* to appear
-// to Python as a Dog (if Dog inherits from Animal, Animal is polymorphic, Dog is
-// registered with pybind11, and this Animal is in fact a Dog).
-//
-// You may specialize polymorphic_type_hook yourself for types that want to appear
-// polymorphic to Python but do not use C++ RTTI. (This is a not uncommon pattern
-// in performance-sensitive applications, used most notably in LLVM.)
-//
-// polymorphic_type_hook_base allows users to specialize polymorphic_type_hook with
-// std::enable_if. User provided specializations will always have higher priority than
-// the default implementation and specialization provided in polymorphic_type_hook_base.
-template <typename itype, typename SFINAE = void>
-struct polymorphic_type_hook_base
-{
-    static const void *get(const itype *src, const std::type_info*&) { return src; }
-};
-template <typename itype>
-struct polymorphic_type_hook_base<itype, detail::enable_if_t<std::is_polymorphic<itype>::value>>
-{
-    static const void *get(const itype *src, const std::type_info*& type) {
-        type = src ? &typeid(*src) : nullptr;
-        return dynamic_cast<const void*>(src);
-    }
-};
-template <typename itype, typename SFINAE = void>
-struct polymorphic_type_hook : public polymorphic_type_hook_base<itype> {};
-
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-/// Generic type caster for objects stored on the heap
-template <typename type> class type_caster_base : public type_caster_generic {
-    using itype = intrinsic_t<type>;
-
-public:
-    static constexpr auto name = _<type>();
-
-    type_caster_base() : type_caster_base(typeid(type)) { }
-    explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) { }
-
-    static handle cast(const itype &src, return_value_policy policy, handle parent) {
-        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
-            policy = return_value_policy::copy;
-        return cast(&src, policy, parent);
-    }
-
-    static handle cast(itype &&src, return_value_policy, handle parent) {
-        return cast(&src, return_value_policy::move, parent);
-    }
-
-    // Returns a (pointer, type_info) pair taking care of necessary type lookup for a
-    // polymorphic type (using RTTI by default, but can be overridden by specializing
-    // polymorphic_type_hook). If the instance isn't derived, returns the base version.
-    static std::pair<const void *, const type_info *> src_and_type(const itype *src) {
-        auto &cast_type = typeid(itype);
-        const std::type_info *instance_type = nullptr;
-        const void *vsrc = polymorphic_type_hook<itype>::get(src, instance_type);
-        if (instance_type && !same_type(cast_type, *instance_type)) {
-            // This is a base pointer to a derived type. If the derived type is registered
-            // with pybind11, we want to make the full derived object available.
-            // In the typical case where itype is polymorphic, we get the correct
-            // derived pointer (which may be != base pointer) by a dynamic_cast to
-            // most derived type. If itype is not polymorphic, we won't get here
-            // except via a user-provided specialization of polymorphic_type_hook,
-            // and the user has promised that no this-pointer adjustment is
-            // required in that case, so it's OK to use static_cast.
-            if (const auto *tpi = get_type_info(*instance_type))
-                return {vsrc, tpi};
-        }
-        // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer, so
-        // don't do a cast
-        return type_caster_generic::src_and_type(src, cast_type, instance_type);
-    }
-
-    static handle cast(const itype *src, return_value_policy policy, handle parent) {
-        auto st = src_and_type(src);
-        return type_caster_generic::cast(
-            st.first, policy, parent, st.second,
-            make_copy_constructor(src), make_move_constructor(src));
-    }
-
-    static handle cast_holder(const itype *src, const void *holder) {
-        auto st = src_and_type(src);
-        return type_caster_generic::cast(
-            st.first, return_value_policy::take_ownership, {}, st.second,
-            nullptr, nullptr, holder);
-    }
-
-    template <typename T> using cast_op_type = detail::cast_op_type<T>;
-
-    operator itype*() { return (type *) value; }
-    operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
-
-protected:
-    using Constructor = void *(*)(const void *);
-
-    /* Only enabled when the types are {copy,move}-constructible *and* when the type
-       does not have a private operator new implementation. */
-    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
-    static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
-        return [](const void *arg) -> void * {
-            return new T(*reinterpret_cast<const T *>(arg));
-        };
-    }
-
-    template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
-    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
-        return [](const void *arg) -> void * {
-            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
-        };
-    }
-
-    static Constructor make_copy_constructor(...) { return nullptr; }
-    static Constructor make_move_constructor(...) { return nullptr; }
-};
-
 // clang-format on
-// Tag to be used as base class, inspected by is_smart_holder_type_caster<T> test.
-struct is_smart_holder_type_caster_base_tag {};
-
-template <typename T>
-struct is_smart_holder_type_caster;
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
-
-// SMART_HOLDER_WIP: Needs refactoring of existing pybind11 code.
-#define PYBIND11_CAST_H_SMART_HOLDER_TYPE_CASTERS_INLINE_INCLUDE_SAFETY_GUARD
-#include "detail/smart_holder_type_casters_inline_include.h"
-#undef PYBIND11_CAST_H_SMART_HOLDER_TYPE_CASTERS_INLINE_INCLUDE_SAFETY_GUARD
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
-
-#    define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, ...)
-
 template <typename T>
 class type_caster_for_class_ : public type_caster_base<T> {};
-
-#else
-
-#    define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, ...)                                    \
-        namespace pybind11 {                                                                      \
-        namespace detail {                                                                        \
-        template <>                                                                               \
-        class type_caster<T> : public type_caster_base<T> {};                                     \
-        template <>                                                                               \
-        class type_caster<__VA_ARGS__> : public type_caster_holder<T, __VA_ARGS__> {};            \
-        }                                                                                         \
-        }
-
-template <typename T>
-class type_caster_for_class_ : public smart_holder_type_caster<T> {};
-
-template <typename T>
-class type_caster_for_class_<std::shared_ptr<T>>
-    : public smart_holder_type_caster<std::shared_ptr<T>> {};
-
-template <typename T>
-class type_caster_for_class_<std::shared_ptr<T const>>
-    : public smart_holder_type_caster<std::shared_ptr<T const>> {};
-
-template <typename T, typename D>
-class type_caster_for_class_<std::unique_ptr<T, D>>
-    : public smart_holder_type_caster<std::unique_ptr<T, D>> {};
-
-template <typename T, typename D>
-class type_caster_for_class_<std::unique_ptr<T const, D>>
-    : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};
-
-#    define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)
-
 #endif
 
 template <typename type, typename SFINAE = void>
diff --git a/include/pybind11/detail/is_smart_holder_type_caster.h b/include/pybind11/detail/is_smart_holder_type_caster.h
new file mode 100644
index 0000000000..6dcea62da5
--- /dev/null
+++ b/include/pybind11/detail/is_smart_holder_type_caster.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "common.h"
+
+#include <type_traits>
+
+#ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+// #define PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+// Currently the main purpose of this switch is to enable non-intrusive comprehensive testing. If
+// and when `smart_holder` will actually become the released default is currently open. In the
+// meantime, the full functionality is easily available by using `py::classh`, which is just a
+// handy shortcut for `py::class_<T, py::smart_holder>` (see `pybind11/smart_holder.h`). Classes
+// wrapped in this way are fully compatible with everything existing.
+#endif
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <typename T>
+struct is_smart_holder_type : std::false_type {};
+
+// Tag to be used as base class, inspected by is_smart_holder_type_caster<T> test.
+struct is_smart_holder_type_caster_base_tag {};
+
+template <typename T>
+struct is_smart_holder_type_caster;
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/include/pybind11/detail/smart_holder_init_inline_include.h b/include/pybind11/detail/smart_holder_init_inline_include.h
index b604848b6a..a4d17649ea 100644
--- a/include/pybind11/detail/smart_holder_init_inline_include.h
+++ b/include/pybind11/detail/smart_holder_init_inline_include.h
@@ -11,7 +11,8 @@ void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr,
     if (Class::has_alias && need_alias)
         throw type_error("pybind11::init(): construction failed: returned std::unique_ptr pointee "
                          "is not an alias instance");
-    auto smhldr     = smart_holder::from_unique_ptr(std::move(unq_ptr));
+    auto smhldr
+        = type_caster<Cpp<Class>>::template smart_holder_from_unique_ptr(std::move(unq_ptr));
     v_h.value_ptr() = ptr;
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
@@ -24,7 +25,8 @@ void construct(value_and_holder &v_h,
                bool /*need_alias*/) {
     auto *ptr = unq_ptr.get();
     no_nullptr(ptr);
-    auto smhldr     = smart_holder::from_unique_ptr(std::move(unq_ptr));
+    auto smhldr
+        = type_caster<Alias<Class>>::template smart_holder_from_unique_ptr(std::move(unq_ptr));
     v_h.value_ptr() = ptr;
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
@@ -37,7 +39,7 @@ void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, boo
     if (Class::has_alias && need_alias)
         throw type_error("pybind11::init(): construction failed: returned std::shared_ptr pointee "
                          "is not an alias instance");
-    auto smhldr     = smart_holder::from_shared_ptr(std::move(shd_ptr));
+    auto smhldr     = type_caster<Cpp<Class>>::template smart_holder_from_shared_ptr(shd_ptr);
     v_h.value_ptr() = ptr;
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
@@ -49,7 +51,7 @@ void construct(value_and_holder &v_h,
                bool /*need_alias*/) {
     auto *ptr = shd_ptr.get();
     no_nullptr(ptr);
-    auto smhldr     = smart_holder::from_shared_ptr(std::move(shd_ptr));
+    auto smhldr     = type_caster<Alias<Class>>::template smart_holder_from_shared_ptr(shd_ptr);
     v_h.value_ptr() = ptr;
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
diff --git a/include/pybind11/detail/smart_holder_type_casters_inline_include.h b/include/pybind11/detail/smart_holder_type_casters.h
similarity index 95%
rename from include/pybind11/detail/smart_holder_type_casters_inline_include.h
rename to include/pybind11/detail/smart_holder_type_casters.h
index 1076585591..750323a9b8 100644
--- a/include/pybind11/detail/smart_holder_type_casters_inline_include.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -1,8 +1,9 @@
-#ifndef PYBIND11_CAST_H_SMART_HOLDER_TYPE_CASTERS_INLINE_INCLUDE_SAFETY_GUARD
-#    error "THIS FILE MUST ONLY BE INCLUDED FROM pybind11/cast.h"
-#endif
+#pragma once
+#define PYBIND11_SMART_HOLDER_TYPE_CASTERS_H_IS_INCLUDED
 
+#include "is_smart_holder_type_caster.h"
 #include "smart_holder_poc.h"
+#include "type_caster_base.h"
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 
@@ -10,6 +11,9 @@ using pybindit::memory::smart_holder;
 
 PYBIND11_NAMESPACE_BEGIN(detail)
 
+template <>
+struct is_smart_holder_type<smart_holder> : std::true_type {};
+
 // SMART_HOLDER_WIP: Needs refactoring of existing pybind11 code.
 inline void register_instance(instance *self, void *valptr, const type_info *tinfo);
 inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo);
@@ -266,6 +270,16 @@ struct smart_holder_type_caster_class_hooks : is_smart_holder_type_caster_base_t
         }
         v_h.set_holder_constructed();
     }
+
+    template <typename T, typename D>
+    static smart_holder smart_holder_from_unique_ptr(std::unique_ptr<T, D> &&unq_ptr) {
+        return pybindit::memory::smart_holder::from_unique_ptr(std::move(unq_ptr));
+    }
+
+    template <typename T>
+    static smart_holder smart_holder_from_shared_ptr(std::shared_ptr<T> shd_ptr) {
+        return pybindit::memory::smart_holder::from_shared_ptr(shd_ptr);
+    }
 };
 
 template <typename T>
@@ -668,6 +682,7 @@ struct smart_holder_type_caster<std::unique_ptr<T const, D>>
 };
 
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+
 #    define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)                                                 \
         namespace pybind11 {                                                                      \
         namespace detail {                                                                        \
@@ -687,6 +702,29 @@ struct smart_holder_type_caster<std::unique_ptr<T const, D>>
             : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};                    \
         }                                                                                         \
         }
+#else
+
+#    define PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)
+
+template <typename T>
+class type_caster_for_class_ : public smart_holder_type_caster<T> {};
+
+template <typename T>
+class type_caster_for_class_<std::shared_ptr<T>>
+    : public smart_holder_type_caster<std::shared_ptr<T>> {};
+
+template <typename T>
+class type_caster_for_class_<std::shared_ptr<T const>>
+    : public smart_holder_type_caster<std::shared_ptr<T const>> {};
+
+template <typename T, typename D>
+class type_caster_for_class_<std::unique_ptr<T, D>>
+    : public smart_holder_type_caster<std::unique_ptr<T, D>> {};
+
+template <typename T, typename D>
+class type_caster_for_class_<std::unique_ptr<T const, D>>
+    : public smart_holder_type_caster<std::unique_ptr<T const, D>> {};
+
 #endif
 
 PYBIND11_NAMESPACE_END(detail)
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index eabc3d520f..de26d68738 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1245,9 +1245,27 @@ auto method_adaptor(Return (Class::*pmf)(Args...) const) -> Return (Derived::*)(
 // clang-format on
 template <typename T>
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
+
 using default_holder_type = std::unique_ptr<T>;
+
+#    define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, ...)
+
 #else
+
 using default_holder_type = smart_holder;
+
+// This define could be hidden away inside detail/smart_holder_type_casters.h, but is kept here
+// for clarity.
+#    define PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, ...)                                    \
+        namespace pybind11 {                                                                      \
+        namespace detail {                                                                        \
+        template <>                                                                               \
+        class type_caster<T> : public type_caster_base<T> {};                                     \
+        template <>                                                                               \
+        class type_caster<__VA_ARGS__> : public type_caster_holder<T, __VA_ARGS__> {};            \
+        }                                                                                         \
+        }
+
 #endif
 // clang-format off
 
@@ -1294,7 +1312,7 @@ class class_ : public detail::generic_type {
 
         // clang-format on
         static constexpr bool holder_is_smart_holder
-            = std::is_same<holder_type, smart_holder>::value;
+            = detail::is_smart_holder_type<holder_type>::value;
         static constexpr bool type_caster_type_is_smart_holder_type_caster
             = detail::is_smart_holder_type_caster<type>::value;
         static constexpr bool type_caster_type_is_type_caster_base_subtype
diff --git a/include/pybind11/smart_holder.h b/include/pybind11/smart_holder.h
index 470d445a3a..25f0e6b526 100644
--- a/include/pybind11/smart_holder.h
+++ b/include/pybind11/smart_holder.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "detail/smart_holder_type_casters.h"
 #include "pybind11.h"
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
diff --git a/tests/class_sh_module_local_0.cpp b/tests/class_sh_module_local_0.cpp
index 8e007fd0e3..bb1f46d5cd 100644
--- a/tests/class_sh_module_local_0.cpp
+++ b/tests/class_sh_module_local_0.cpp
@@ -1,4 +1,3 @@
-#include <pybind11/pybind11.h>
 #include <pybind11/smart_holder.h>
 
 #include <string>
diff --git a/tests/class_sh_module_local_1.cpp b/tests/class_sh_module_local_1.cpp
index b8fd9591f3..66bc955163 100644
--- a/tests/class_sh_module_local_1.cpp
+++ b/tests/class_sh_module_local_1.cpp
@@ -1,5 +1,4 @@
 // Identical to class_sh_module_local_2.cpp, except 2 replaced with 1.
-#include <pybind11/pybind11.h>
 #include <pybind11/smart_holder.h>
 
 #include <string>
diff --git a/tests/class_sh_module_local_2.cpp b/tests/class_sh_module_local_2.cpp
index dd72cdcac0..bef105aade 100644
--- a/tests/class_sh_module_local_2.cpp
+++ b/tests/class_sh_module_local_2.cpp
@@ -1,5 +1,4 @@
 // Identical to class_sh_module_local_1.cpp, except 1 replaced with 2.
-#include <pybind11/pybind11.h>
 #include <pybind11/smart_holder.h>
 
 #include <string>
diff --git a/tests/extra_python_package/test_files.py b/tests/extra_python_package/test_files.py
index cf550549b9..44cf54f000 100644
--- a/tests/extra_python_package/test_files.py
+++ b/tests/extra_python_package/test_files.py
@@ -45,7 +45,7 @@
     "include/pybind11/detail/internals.h",
     "include/pybind11/detail/smart_holder_init_inline_include.h",
     "include/pybind11/detail/smart_holder_poc.h",
-    "include/pybind11/detail/smart_holder_type_casters_inline_include.h",
+    "include/pybind11/detail/smart_holder_type_casters.h",
     "include/pybind11/detail/typeid.h",
 }
 

From 3d31698f1b87b74104491820277e966b42da2a2b Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 23 Feb 2021 13:22:32 -0800
Subject: [PATCH 197/206] Merging detail/smart_holder_init_inline_include.h
 into detail/init.h.

---
 CMakeLists.txt                                |  1 -
 include/pybind11/detail/init.h                | 60 +++++++++++++++++--
 .../detail/smart_holder_init_inline_include.h | 57 ------------------
 tests/extra_python_package/test_files.py      |  1 -
 4 files changed, 56 insertions(+), 63 deletions(-)
 delete mode 100644 include/pybind11/detail/smart_holder_init_inline_include.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7baa8a3b2c..3b1f22b4f5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -105,7 +105,6 @@ set(PYBIND11_HEADERS
     include/pybind11/detail/descr.h
     include/pybind11/detail/init.h
     include/pybind11/detail/internals.h
-    include/pybind11/detail/smart_holder_init_inline_include.h
     include/pybind11/detail/smart_holder_poc.h
     include/pybind11/detail/smart_holder_type_casters.h
     include/pybind11/detail/typeid.h
diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index 816a1764d9..561f37f633 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -1,3 +1,4 @@
+// clang-format off
 /*
     pybind11/detail/init.h: init factory function implementation and support code.
 
@@ -169,10 +170,61 @@ void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
     v_h.value_ptr() = new Alias<Class>(std::move(result));
 }
 
-// SMART_HOLDER_WIP: Needs refactoring of existing pybind11 code.
-#define PYBIND11_DETAIL_INIT_H_SMART_HOLDER_INIT_INLINE_INCLUDE_SAFETY_GUARD
-#include "smart_holder_init_inline_include.h"
-#undef PYBIND11_DETAIL_INIT_H_SMART_HOLDER_INIT_INLINE_INCLUDE_SAFETY_GUARD
+// clang-format on
+template <typename Class,
+          typename D = std::default_delete<Cpp<Class>>,
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
+    auto *ptr = unq_ptr.get();
+    no_nullptr(ptr);
+    if (Class::has_alias && need_alias)
+        throw type_error("pybind11::init(): construction failed: returned std::unique_ptr pointee "
+                         "is not an alias instance");
+    auto smhldr
+        = type_caster<Cpp<Class>>::template smart_holder_from_unique_ptr(std::move(unq_ptr));
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+
+template <typename Class,
+          typename D = std::default_delete<Alias<Class>>,
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h,
+               std::unique_ptr<Alias<Class>, D> &&unq_ptr,
+               bool /*need_alias*/) {
+    auto *ptr = unq_ptr.get();
+    no_nullptr(ptr);
+    auto smhldr
+        = type_caster<Alias<Class>>::template smart_holder_from_unique_ptr(std::move(unq_ptr));
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+
+template <typename Class,
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, bool need_alias) {
+    auto *ptr = shd_ptr.get();
+    no_nullptr(ptr);
+    if (Class::has_alias && need_alias)
+        throw type_error("pybind11::init(): construction failed: returned std::shared_ptr pointee "
+                         "is not an alias instance");
+    auto smhldr     = type_caster<Cpp<Class>>::template smart_holder_from_shared_ptr(shd_ptr);
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+
+template <typename Class,
+          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h,
+               std::shared_ptr<Alias<Class>> &&shd_ptr,
+               bool /*need_alias*/) {
+    auto *ptr = shd_ptr.get();
+    no_nullptr(ptr);
+    auto smhldr     = type_caster<Alias<Class>>::template smart_holder_from_shared_ptr(shd_ptr);
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+// clang-format off
 
 // Implementing class for py::init<...>()
 template <typename... Args>
diff --git a/include/pybind11/detail/smart_holder_init_inline_include.h b/include/pybind11/detail/smart_holder_init_inline_include.h
deleted file mode 100644
index a4d17649ea..0000000000
--- a/include/pybind11/detail/smart_holder_init_inline_include.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef PYBIND11_DETAIL_INIT_H_SMART_HOLDER_INIT_INLINE_INCLUDE_SAFETY_GUARD
-#    error "THIS FILE MUST ONLY BE INCLUDED FROM pybind11/detail/init.h"
-#endif
-
-template <typename Class,
-          typename D = std::default_delete<Cpp<Class>>,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
-    auto *ptr = unq_ptr.get();
-    no_nullptr(ptr);
-    if (Class::has_alias && need_alias)
-        throw type_error("pybind11::init(): construction failed: returned std::unique_ptr pointee "
-                         "is not an alias instance");
-    auto smhldr
-        = type_caster<Cpp<Class>>::template smart_holder_from_unique_ptr(std::move(unq_ptr));
-    v_h.value_ptr() = ptr;
-    v_h.type->init_instance(v_h.inst, &smhldr);
-}
-
-template <typename Class,
-          typename D = std::default_delete<Alias<Class>>,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h,
-               std::unique_ptr<Alias<Class>, D> &&unq_ptr,
-               bool /*need_alias*/) {
-    auto *ptr = unq_ptr.get();
-    no_nullptr(ptr);
-    auto smhldr
-        = type_caster<Alias<Class>>::template smart_holder_from_unique_ptr(std::move(unq_ptr));
-    v_h.value_ptr() = ptr;
-    v_h.type->init_instance(v_h.inst, &smhldr);
-}
-
-template <typename Class,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, bool need_alias) {
-    auto *ptr = shd_ptr.get();
-    no_nullptr(ptr);
-    if (Class::has_alias && need_alias)
-        throw type_error("pybind11::init(): construction failed: returned std::shared_ptr pointee "
-                         "is not an alias instance");
-    auto smhldr     = type_caster<Cpp<Class>>::template smart_holder_from_shared_ptr(shd_ptr);
-    v_h.value_ptr() = ptr;
-    v_h.type->init_instance(v_h.inst, &smhldr);
-}
-
-template <typename Class,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h,
-               std::shared_ptr<Alias<Class>> &&shd_ptr,
-               bool /*need_alias*/) {
-    auto *ptr = shd_ptr.get();
-    no_nullptr(ptr);
-    auto smhldr     = type_caster<Alias<Class>>::template smart_holder_from_shared_ptr(shd_ptr);
-    v_h.value_ptr() = ptr;
-    v_h.type->init_instance(v_h.inst, &smhldr);
-}
diff --git a/tests/extra_python_package/test_files.py b/tests/extra_python_package/test_files.py
index 44cf54f000..a5e47eeb76 100644
--- a/tests/extra_python_package/test_files.py
+++ b/tests/extra_python_package/test_files.py
@@ -43,7 +43,6 @@
     "include/pybind11/detail/descr.h",
     "include/pybind11/detail/init.h",
     "include/pybind11/detail/internals.h",
-    "include/pybind11/detail/smart_holder_init_inline_include.h",
     "include/pybind11/detail/smart_holder_poc.h",
     "include/pybind11/detail/smart_holder_type_casters.h",
     "include/pybind11/detail/typeid.h",

From 658cf3ba39ae3a2e37f91dcd1b34a8994ca43003 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 23 Feb 2021 13:34:15 -0800
Subject: [PATCH 198/206] Renaming detail/is_smart_holder_type_caster.h ->
 detail/smart_holder_sfinae_hooks_only.h.

---
 include/pybind11/cast.h                                         | 2 +-
 ...rt_holder_type_caster.h => smart_holder_sfinae_hooks_only.h} | 0
 include/pybind11/detail/smart_holder_type_casters.h             | 2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)
 rename include/pybind11/detail/{is_smart_holder_type_caster.h => smart_holder_sfinae_hooks_only.h} (100%)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index babb672fe5..d384b9d694 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -14,7 +14,7 @@
 #include "pytypes.h"
 #include "detail/common.h"
 #include "detail/descr.h"
-#include "detail/is_smart_holder_type_caster.h"
+#include "detail/smart_holder_sfinae_hooks_only.h"
 #include "detail/type_caster_base.h"
 #include "detail/typeid.h"
 #include <array>
diff --git a/include/pybind11/detail/is_smart_holder_type_caster.h b/include/pybind11/detail/smart_holder_sfinae_hooks_only.h
similarity index 100%
rename from include/pybind11/detail/is_smart_holder_type_caster.h
rename to include/pybind11/detail/smart_holder_sfinae_hooks_only.h
diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index 750323a9b8..d549efe031 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -1,8 +1,8 @@
 #pragma once
 #define PYBIND11_SMART_HOLDER_TYPE_CASTERS_H_IS_INCLUDED
 
-#include "is_smart_holder_type_caster.h"
 #include "smart_holder_poc.h"
+#include "smart_holder_sfinae_hooks_only.h"
 #include "type_caster_base.h"
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)

From 3a303ee2f2703258adbaca77c9b6ad9b4a797028 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 23 Feb 2021 13:45:03 -0800
Subject: [PATCH 199/206] Renaming is_smart_holder_type_caster ->
 type_uses_smart_holder_type_caster for clarity.

---
 include/pybind11/cast.h                       |  6 ++---
 include/pybind11/detail/init.h                | 26 +++++++++++--------
 .../detail/smart_holder_sfinae_hooks_only.h   |  4 +--
 .../detail/smart_holder_type_casters.h        |  2 +-
 include/pybind11/pybind11.h                   | 25 +++++++++---------
 5 files changed, 34 insertions(+), 29 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index d384b9d694..25b41148ba 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -66,7 +66,7 @@ template <typename type>
 using make_caster = type_caster<intrinsic_t<type>>;
 
 template <typename T>
-struct is_smart_holder_type_caster {
+struct type_uses_smart_holder_type_caster {
     static constexpr bool value
         = std::is_base_of<is_smart_holder_type_caster_base_tag, make_caster<T>>::value;
 };
@@ -846,7 +846,7 @@ template <typename T> using move_never = none_of<move_always<T>, move_if_unrefer
 template <typename type> using cast_is_temporary_value_reference = bool_constant<
     (std::is_reference<type>::value || std::is_pointer<type>::value) &&
     !std::is_base_of<type_caster_generic, make_caster<type>>::value &&
-    !is_smart_holder_type_caster<intrinsic_t<type>>::value &&
+    !type_uses_smart_holder_type_caster<intrinsic_t<type>>::value &&
     !std::is_same<intrinsic_t<type>, void>::value
 >;
 
@@ -1391,7 +1391,7 @@ template<typename T>
 handle type::handle_of() {
     static_assert(
         detail::any_of<std::is_base_of<detail::type_caster_generic, detail::make_caster<T>>,
-                       detail::is_smart_holder_type_caster<T>>::value,
+                       detail::type_uses_smart_holder_type_caster<T>>::value,
         "py::type::of<T> only supports the case where T is a registered C++ types.");
 
     return detail::get_type_handle(typeid(T), true);
diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index 561f37f633..29b792260d 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -133,7 +133,7 @@ void construct(value_and_holder &v_h, Alias<Class> *alias_ptr, bool) {
 // holder.  This also handles types like std::shared_ptr<T> and std::unique_ptr<T> where T is a
 // derived type (through those holder's implicit conversion from derived class holder constructors).
 template <typename Class,
-          detail::enable_if_t<!detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+          detail::enable_if_t<!detail::type_uses_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h, Holder<Class> holder, bool need_alias) {
     auto *ptr = holder_helper<Holder<Class>>::get(holder);
     no_nullptr(ptr);
@@ -171,9 +171,10 @@ void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
 }
 
 // clang-format on
-template <typename Class,
-          typename D = std::default_delete<Cpp<Class>>,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+template <
+    typename Class,
+    typename D = std::default_delete<Cpp<Class>>,
+    detail::enable_if_t<detail::type_uses_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
     auto *ptr = unq_ptr.get();
     no_nullptr(ptr);
@@ -186,9 +187,10 @@ void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr,
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
 
-template <typename Class,
-          typename D = std::default_delete<Alias<Class>>,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
+template <
+    typename Class,
+    typename D = std::default_delete<Alias<Class>>,
+    detail::enable_if_t<detail::type_uses_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h,
                std::unique_ptr<Alias<Class>, D> &&unq_ptr,
                bool /*need_alias*/) {
@@ -200,8 +202,9 @@ void construct(value_and_holder &v_h,
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
 
-template <typename Class,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+template <
+    typename Class,
+    detail::enable_if_t<detail::type_uses_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, bool need_alias) {
     auto *ptr = shd_ptr.get();
     no_nullptr(ptr);
@@ -213,8 +216,9 @@ void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, boo
     v_h.type->init_instance(v_h.inst, &smhldr);
 }
 
-template <typename Class,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
+template <
+    typename Class,
+    detail::enable_if_t<detail::type_uses_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h,
                std::shared_ptr<Alias<Class>> &&shd_ptr,
                bool /*need_alias*/) {
diff --git a/include/pybind11/detail/smart_holder_sfinae_hooks_only.h b/include/pybind11/detail/smart_holder_sfinae_hooks_only.h
index 6dcea62da5..563117b260 100644
--- a/include/pybind11/detail/smart_holder_sfinae_hooks_only.h
+++ b/include/pybind11/detail/smart_holder_sfinae_hooks_only.h
@@ -19,11 +19,11 @@ PYBIND11_NAMESPACE_BEGIN(detail)
 template <typename T>
 struct is_smart_holder_type : std::false_type {};
 
-// Tag to be used as base class, inspected by is_smart_holder_type_caster<T> test.
+// Tag to be used as base class, inspected by type_uses_smart_holder_type_caster<T> test.
 struct is_smart_holder_type_caster_base_tag {};
 
 template <typename T>
-struct is_smart_holder_type_caster;
+struct type_uses_smart_holder_type_caster;
 
 PYBIND11_NAMESPACE_END(detail)
 PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index d549efe031..7f47f122c1 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -287,7 +287,7 @@ struct smart_holder_type_caster_load {
     using holder_type = pybindit::memory::smart_holder;
 
     bool load(handle src, bool convert) {
-        static_assert(is_smart_holder_type_caster<T>::value, "Internal consistency error.");
+        static_assert(type_uses_smart_holder_type_caster<T>::value, "Internal consistency error.");
         load_impl = modified_type_caster_generic_load_impl(typeid(T));
         if (!load_impl.load(src, convert))
             return false;
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index de26d68738..7c7b026de4 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1275,10 +1275,11 @@ class class_ : public detail::generic_type {
     template <typename T> using is_base = detail::is_strict_base_of<T, type_>;
     template <typename T>
     // clang-format on
-    using is_holder = detail::any_of<detail::is_holder_type<type_, T>,
-                                     detail::all_of<detail::negation<is_base<T>>,
-                                                    detail::negation<is_subtype<T>>,
-                                                    detail::is_smart_holder_type_caster<type_>>>;
+    using is_holder
+        = detail::any_of<detail::is_holder_type<type_, T>,
+                         detail::all_of<detail::negation<is_base<T>>,
+                                        detail::negation<is_subtype<T>>,
+                                        detail::type_uses_smart_holder_type_caster<type_>>>;
     // clang-format off
     // struct instead of using here to help MSVC:
     template <typename T> struct is_valid_class_option :
@@ -1314,7 +1315,7 @@ class class_ : public detail::generic_type {
         static constexpr bool holder_is_smart_holder
             = detail::is_smart_holder_type<holder_type>::value;
         static constexpr bool type_caster_type_is_smart_holder_type_caster
-            = detail::is_smart_holder_type_caster<type>::value;
+            = detail::type_uses_smart_holder_type_caster<type>::value;
         static constexpr bool type_caster_type_is_type_caster_base_subtype
             = std::is_base_of<detail::type_caster_base<type>, detail::type_caster<type>>::value;
         // Necessary conditions, but not strict.
@@ -1573,14 +1574,14 @@ class class_ : public detail::generic_type {
 
 private:
     // clang-format on
-    template <typename T                                                               = type,
-              detail::enable_if_t<!detail::is_smart_holder_type_caster<T>::value, int> = 0>
+    template <typename T = type,
+              detail::enable_if_t<!detail::type_uses_smart_holder_type_caster<T>::value, int> = 0>
     void generic_type_initialize(const detail::type_record &record) {
         generic_type::initialize(record, &detail::type_caster_generic::local_load);
     }
 
-    template <typename T                                                              = type,
-              detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
+    template <typename T = type,
+              detail::enable_if_t<detail::type_uses_smart_holder_type_caster<T>::value, int> = 0>
     void generic_type_initialize(const detail::type_record &record) {
         generic_type::initialize(record, detail::type_caster<T>::get_local_load_function_ptr());
     }
@@ -1632,7 +1633,7 @@ class class_ : public detail::generic_type {
     /// `.owned`, a new holder will be constructed to manage the value pointer.
     template <
         typename T = type,
-        detail::enable_if_t<!detail::is_smart_holder_type_caster<T>::value, int> = 0>
+        detail::enable_if_t<!detail::type_uses_smart_holder_type_caster<T>::value, int> = 0>
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
         auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
         if (!v_h.instance_registered()) {
@@ -1643,8 +1644,8 @@ class class_ : public detail::generic_type {
     }
 
     // clang-format on
-    template <typename T                                                              = type,
-              detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
+    template <typename T = type,
+              detail::enable_if_t<detail::type_uses_smart_holder_type_caster<T>::value, int> = 0>
     static void init_instance(detail::instance *inst, const void *holder_ptr) {
         detail::type_caster<T>::template init_instance_for_type<type>(inst, holder_ptr);
     }

From ce40fb6f4c8d5ec5eb7e8f088dd104e615eccc7b Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 23 Feb 2021 13:49:23 -0800
Subject: [PATCH 200/206] Renaming type_caster_type_is_smart_holder_type_caster
 -> wrapped_type_uses_smart_holder_type_caster for clarity.

---
 include/pybind11/pybind11.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 7c7b026de4..3d709f6167 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1314,19 +1314,19 @@ class class_ : public detail::generic_type {
         // clang-format on
         static constexpr bool holder_is_smart_holder
             = detail::is_smart_holder_type<holder_type>::value;
-        static constexpr bool type_caster_type_is_smart_holder_type_caster
+        static constexpr bool wrapped_type_uses_smart_holder_type_caster
             = detail::type_uses_smart_holder_type_caster<type>::value;
         static constexpr bool type_caster_type_is_type_caster_base_subtype
             = std::is_base_of<detail::type_caster_base<type>, detail::type_caster<type>>::value;
         // Necessary conditions, but not strict.
         static_assert(
             !(detail::is_instantiation<std::unique_ptr, holder_type>::value
-              && type_caster_type_is_smart_holder_type_caster),
+              && wrapped_type_uses_smart_holder_type_caster),
             "py::class_ holder vs type_caster mismatch:"
             " missing PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, std::unique_ptr<T>)?");
         static_assert(
             !(detail::is_instantiation<std::shared_ptr, holder_type>::value
-              && type_caster_type_is_smart_holder_type_caster),
+              && wrapped_type_uses_smart_holder_type_caster),
             "py::class_ holder vs type_caster mismatch:"
             " missing PYBIND11_SMART_POINTER_HOLDER_TYPE_CASTERS(T, std::shared_ptr<T>)?");
         static_assert(!(holder_is_smart_holder && type_caster_type_is_type_caster_base_subtype),
@@ -1334,7 +1334,7 @@ class class_ : public detail::generic_type {
                       " missing PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)?");
 #ifdef PYBIND11_STRICT_ASSERTS_CLASS_HOLDER_VS_TYPE_CASTER_MIX
         // Strict conditions cannot be enforced universally at the moment (PR #2836).
-        static_assert(holder_is_smart_holder == type_caster_type_is_smart_holder_type_caster,
+        static_assert(holder_is_smart_holder == wrapped_type_uses_smart_holder_type_caster,
                       "py::class_ holder vs type_caster mismatch:"
                       " missing PYBIND11_SMART_HOLDER_TYPE_CASTERS(T)"
                       " or collision with custom py::detail::type_caster<T>?");

From c56bd3ac9c5aeebc01a68ab907e473f3b4129076 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 23 Feb 2021 13:53:26 -0800
Subject: [PATCH 201/206] Renaming is_smart_holder_type_caster_base_tag ->
 smart_holder_type_caster_base_tag for simplicity.

---
 include/pybind11/cast.h                                  | 2 +-
 include/pybind11/detail/smart_holder_sfinae_hooks_only.h | 2 +-
 include/pybind11/detail/smart_holder_type_casters.h      | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 25b41148ba..fd8f9a6668 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -68,7 +68,7 @@ using make_caster = type_caster<intrinsic_t<type>>;
 template <typename T>
 struct type_uses_smart_holder_type_caster {
     static constexpr bool value
-        = std::is_base_of<is_smart_holder_type_caster_base_tag, make_caster<T>>::value;
+        = std::is_base_of<smart_holder_type_caster_base_tag, make_caster<T>>::value;
 };
 // clang-format off
 
diff --git a/include/pybind11/detail/smart_holder_sfinae_hooks_only.h b/include/pybind11/detail/smart_holder_sfinae_hooks_only.h
index 563117b260..0359addf4f 100644
--- a/include/pybind11/detail/smart_holder_sfinae_hooks_only.h
+++ b/include/pybind11/detail/smart_holder_sfinae_hooks_only.h
@@ -20,7 +20,7 @@ template <typename T>
 struct is_smart_holder_type : std::false_type {};
 
 // Tag to be used as base class, inspected by type_uses_smart_holder_type_caster<T> test.
-struct is_smart_holder_type_caster_base_tag {};
+struct smart_holder_type_caster_base_tag {};
 
 template <typename T>
 struct type_uses_smart_holder_type_caster;
diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index 7f47f122c1..3e31c191c7 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -239,7 +239,7 @@ class modified_type_caster_generic_load_impl {
 };
 // clang-format on
 
-struct smart_holder_type_caster_class_hooks : is_smart_holder_type_caster_base_tag {
+struct smart_holder_type_caster_class_hooks : smart_holder_type_caster_base_tag {
     static decltype(&modified_type_caster_generic_load_impl::local_load)
     get_local_load_function_ptr() {
         return &modified_type_caster_generic_load_impl::local_load;

From 62afdc04cea79b8eb5a70d9dff74a66601138ff5 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 23 Feb 2021 14:22:26 -0800
Subject: [PATCH 202/206] Adding copyright notices and minor colateral cleanup.

---
 CMakeLists.txt                                           | 1 +
 include/pybind11/detail/smart_holder_sfinae_hooks_only.h | 4 ++++
 include/pybind11/detail/smart_holder_type_casters.h      | 5 ++++-
 tests/extra_python_package/test_files.py                 | 1 +
 4 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3b1f22b4f5..0cf93be853 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -106,6 +106,7 @@ set(PYBIND11_HEADERS
     include/pybind11/detail/init.h
     include/pybind11/detail/internals.h
     include/pybind11/detail/smart_holder_poc.h
+    include/pybind11/detail/smart_holder_sfinae_hooks_only.h
     include/pybind11/detail/smart_holder_type_casters.h
     include/pybind11/detail/typeid.h
     include/pybind11/attr.h
diff --git a/include/pybind11/detail/smart_holder_sfinae_hooks_only.h b/include/pybind11/detail/smart_holder_sfinae_hooks_only.h
index 0359addf4f..f324854751 100644
--- a/include/pybind11/detail/smart_holder_sfinae_hooks_only.h
+++ b/include/pybind11/detail/smart_holder_sfinae_hooks_only.h
@@ -1,3 +1,7 @@
+// Copyright (c) 2021 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
 #pragma once
 
 #include "common.h"
diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index 3e31c191c7..2a6149600b 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -1,5 +1,8 @@
+// Copyright (c) 2021 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
 #pragma once
-#define PYBIND11_SMART_HOLDER_TYPE_CASTERS_H_IS_INCLUDED
 
 #include "smart_holder_poc.h"
 #include "smart_holder_sfinae_hooks_only.h"
diff --git a/tests/extra_python_package/test_files.py b/tests/extra_python_package/test_files.py
index a5e47eeb76..05294744c9 100644
--- a/tests/extra_python_package/test_files.py
+++ b/tests/extra_python_package/test_files.py
@@ -44,6 +44,7 @@
     "include/pybind11/detail/init.h",
     "include/pybind11/detail/internals.h",
     "include/pybind11/detail/smart_holder_poc.h",
+    "include/pybind11/detail/smart_holder_sfinae_hooks_only.h",
     "include/pybind11/detail/smart_holder_type_casters.h",
     "include/pybind11/detail/typeid.h",
 }

From 4f5f4419e9430fd6bd4a43f2d832b5f8df76e797 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 23 Feb 2021 16:15:45 -0800
Subject: [PATCH 203/206] iwyu cleanup (comprehensive only for cast.h and
 smart_holder*.h files).

---
 include/pybind11/detail/init.h                      |  1 +
 include/pybind11/detail/smart_holder_type_casters.h | 13 +++++++++++++
 include/pybind11/pybind11.h                         |  1 +
 include/pybind11/smart_holder.h                     |  1 +
 4 files changed, 16 insertions(+)

diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index 29b792260d..2c1c77ae95 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -11,6 +11,7 @@
 #pragma once
 
 #include "class.h"
+#include "smart_holder_sfinae_hooks_only.h"
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 PYBIND11_NAMESPACE_BEGIN(detail)
diff --git a/include/pybind11/detail/smart_holder_type_casters.h b/include/pybind11/detail/smart_holder_type_casters.h
index 2a6149600b..3865ece255 100644
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -4,9 +4,22 @@
 
 #pragma once
 
+#include "../pytypes.h"
+#include "common.h"
+#include "descr.h"
+#include "internals.h"
 #include "smart_holder_poc.h"
 #include "smart_holder_sfinae_hooks_only.h"
 #include "type_caster_base.h"
+#include "typeid.h"
+
+#include <cstddef>
+#include <memory>
+#include <new>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 3d709f6167..b9ab8bbe86 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -48,6 +48,7 @@
 #include "options.h"
 #include "detail/class.h"
 #include "detail/init.h"
+#include "detail/smart_holder_sfinae_hooks_only.h"
 
 #include <memory>
 #include <vector>
diff --git a/include/pybind11/smart_holder.h b/include/pybind11/smart_holder.h
index 25f0e6b526..7a185f7692 100644
--- a/include/pybind11/smart_holder.h
+++ b/include/pybind11/smart_holder.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "detail/common.h"
 #include "detail/smart_holder_type_casters.h"
 #include "pybind11.h"
 

From f5dadd4876b4dd354fe616220419a63351efe8bb Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 23 Feb 2021 16:54:58 -0800
Subject: [PATCH 204/206] Fixing `git rebase master` accident.

---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0cf93be853..39800c3e9c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -108,6 +108,7 @@ set(PYBIND11_HEADERS
     include/pybind11/detail/smart_holder_poc.h
     include/pybind11/detail/smart_holder_sfinae_hooks_only.h
     include/pybind11/detail/smart_holder_type_casters.h
+    include/pybind11/detail/type_caster_base.h
     include/pybind11/detail/typeid.h
     include/pybind11/attr.h
     include/pybind11/buffer_info.h

From 4bae719587b8ed3bcd6b218a87b479e579e54fc2 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 23 Feb 2021 20:03:57 -0800
Subject: [PATCH 205/206] Moving large `pragma warning` block from pybind11.h
 to detail/common.h.

---
 include/pybind11/detail/common.h | 32 ++++++++++++++++++++++++++++++++
 include/pybind11/pybind11.h      | 32 --------------------------------
 2 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/include/pybind11/detail/common.h b/include/pybind11/detail/common.h
index 5560198a05..17021978a1 100644
--- a/include/pybind11/detail/common.h
+++ b/include/pybind11/detail/common.h
@@ -13,6 +13,38 @@
 #define PYBIND11_VERSION_MINOR 6
 #define PYBIND11_VERSION_PATCH 3.dev1
 
+#if defined(__INTEL_COMPILER)
+#  pragma warning push
+#  pragma warning disable 68    // integer conversion resulted in a change of sign
+#  pragma warning disable 186   // pointless comparison of unsigned integer with zero
+#  pragma warning disable 878   // incompatible exception specifications
+#  pragma warning disable 1334  // the "template" keyword used for syntactic disambiguation may only be used within a template
+#  pragma warning disable 1682  // implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
+#  pragma warning disable 1786  // function "strdup" was declared deprecated
+#  pragma warning disable 1875  // offsetof applied to non-POD (Plain Old Data) types is nonstandard
+#  pragma warning disable 2196  // warning #2196: routine is both "inline" and "noinline"
+#elif defined(_MSC_VER)
+#  pragma warning(push)
+#  pragma warning(disable: 4100) // warning C4100: Unreferenced formal parameter
+#  pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
+#  pragma warning(disable: 4512) // warning C4512: Assignment operator was implicitly defined as deleted
+#  pragma warning(disable: 4800) // warning C4800: 'int': forcing value to bool 'true' or 'false' (performance warning)
+#  pragma warning(disable: 4996) // warning C4996: The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name
+#  pragma warning(disable: 4702) // warning C4702: unreachable code
+#  pragma warning(disable: 4522) // warning C4522: multiple assignment operators specified
+#  pragma warning(disable: 4505) // warning C4505: 'PySlice_GetIndicesEx': unreferenced local function has been removed (PyPy only)
+#elif defined(__GNUG__) && !defined(__clang__)
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wunused-but-set-parameter"
+#  pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#  pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#  pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#  pragma GCC diagnostic ignored "-Wattributes"
+#  if __GNUC__ >= 7
+#    pragma GCC diagnostic ignored "-Wnoexcept-type"
+#  endif
+#endif
+
 #define PYBIND11_NAMESPACE_BEGIN(name) namespace name {
 #define PYBIND11_NAMESPACE_END(name) }
 
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index b9ab8bbe86..e3dd4c8226 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -11,38 +11,6 @@
 
 #pragma once
 
-#if defined(__INTEL_COMPILER)
-#  pragma warning push
-#  pragma warning disable 68    // integer conversion resulted in a change of sign
-#  pragma warning disable 186   // pointless comparison of unsigned integer with zero
-#  pragma warning disable 878   // incompatible exception specifications
-#  pragma warning disable 1334  // the "template" keyword used for syntactic disambiguation may only be used within a template
-#  pragma warning disable 1682  // implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
-#  pragma warning disable 1786  // function "strdup" was declared deprecated
-#  pragma warning disable 1875  // offsetof applied to non-POD (Plain Old Data) types is nonstandard
-#  pragma warning disable 2196  // warning #2196: routine is both "inline" and "noinline"
-#elif defined(_MSC_VER)
-#  pragma warning(push)
-#  pragma warning(disable: 4100) // warning C4100: Unreferenced formal parameter
-#  pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
-#  pragma warning(disable: 4512) // warning C4512: Assignment operator was implicitly defined as deleted
-#  pragma warning(disable: 4800) // warning C4800: 'int': forcing value to bool 'true' or 'false' (performance warning)
-#  pragma warning(disable: 4996) // warning C4996: The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name
-#  pragma warning(disable: 4702) // warning C4702: unreachable code
-#  pragma warning(disable: 4522) // warning C4522: multiple assignment operators specified
-#  pragma warning(disable: 4505) // warning C4505: 'PySlice_GetIndicesEx': unreferenced local function has been removed (PyPy only)
-#elif defined(__GNUG__) && !defined(__clang__)
-#  pragma GCC diagnostic push
-#  pragma GCC diagnostic ignored "-Wunused-but-set-parameter"
-#  pragma GCC diagnostic ignored "-Wunused-but-set-variable"
-#  pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#  pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#  pragma GCC diagnostic ignored "-Wattributes"
-#  if __GNUC__ >= 7
-#    pragma GCC diagnostic ignored "-Wnoexcept-type"
-#  endif
-#endif
-
 #include "attr.h"
 #include "gil.h"
 #include "options.h"

From 4255d6cf4418f0a776ced93a09dcc4a1ccc58ad1 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
Date: Tue, 23 Feb 2021 20:18:27 -0800
Subject: [PATCH 206/206] Fixing another `git rebase master` accident.

---
 tests/extra_python_package/test_files.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/extra_python_package/test_files.py b/tests/extra_python_package/test_files.py
index 05294744c9..12d14e45ad 100644
--- a/tests/extra_python_package/test_files.py
+++ b/tests/extra_python_package/test_files.py
@@ -46,6 +46,7 @@
     "include/pybind11/detail/smart_holder_poc.h",
     "include/pybind11/detail/smart_holder_sfinae_hooks_only.h",
     "include/pybind11/detail/smart_holder_type_casters.h",
+    "include/pybind11/detail/type_caster_base.h",
     "include/pybind11/detail/typeid.h",
 }