[smart_holder] Simple experiment related to PR #4022

CMakeLists.txt

@@ -115,6 +115,7 @@ set(PYBIND11_HEADERS
     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/type_caster_odr_guard.h
     include/pybind11/detail/typeid.h
     include/pybind11/attr.h
     include/pybind11/buffer_info.h

include/pybind11/cast.h

@@ -14,6 +14,7 @@
 #include "detail/descr.h"
 #include "detail/smart_holder_sfinae_hooks_only.h"
 #include "detail/type_caster_base.h"
+#include "detail/type_caster_odr_guard.h"
 #include "detail/typeid.h"
 #include "pytypes.h"
 
@@ -44,9 +45,18 @@ class type_caster_for_class_ : public type_caster_base<T> {};
 template <typename type, typename SFINAE = void>
 class type_caster : public type_caster_for_class_<type> {};
 
+#ifdef PYBIND11_TYPE_CASTER_ODR_GUARD_ON
+
+template <typename type>
+using make_caster = type_caster_odr_guard<intrinsic_t<type>, type_caster<intrinsic_t<type>>>;
+
+#else
+
 template <typename type>
 using make_caster = type_caster<intrinsic_t<type>>;
 
+#endif
+
 template <typename T>
 struct type_uses_smart_holder_type_caster {
     static constexpr bool value
@@ -56,11 +66,13 @@ struct type_uses_smart_holder_type_caster {
 // 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) {
+    PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(T)
     return caster.operator typename make_caster<T>::template cast_op_type<T>();
 }
 template <typename T>
 typename make_caster<T>::template cast_op_type<typename std::add_rvalue_reference<T>::type>
 cast_op(make_caster<T> &&caster) {
+    PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(T)
     return std::move(caster).operator typename make_caster<T>::
         template cast_op_type<typename std::add_rvalue_reference<T>::type>();
 }
@@ -80,10 +92,15 @@ class type_caster<std::reference_wrapper<type>> {
         "`operator T &()` or `operator const T &()`");
 
 public:
-    bool load(handle src, bool convert) { return subcaster.load(src, convert); }
+    bool load(handle src, bool convert) {
+        PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(type)
+        return subcaster.load(src, convert);
+    }
     static constexpr auto name = caster_t::name;
+    PYBIND11_TYPE_CASTER_SOURCE_FILE_LINE
     static handle
     cast(const std::reference_wrapper<type> &src, return_value_policy policy, handle parent) {
+        PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(type)
         // It is definitely wrong to take ownership of this pointer, so mask that rvp
         if (policy == return_value_policy::take_ownership
             || policy == return_value_policy::automatic) {
@@ -96,12 +113,13 @@ class type_caster<std::reference_wrapper<type>> {
     explicit operator std::reference_wrapper<type>() { return cast_op<type &>(subcaster); }
 };
 
-#define PYBIND11_TYPE_CASTER(type, py_name)                                                       \
+#define PYBIND11_DETAIL_TYPE_CASTER_HEAD(type, py_name)                                           \
 protected:                                                                                        \
     type value;                                                                                   \
                                                                                                   \
 public:                                                                                           \
-    static constexpr auto name = py_name;                                                         \
+    static constexpr auto name = py_name;
+#define PYBIND11_DETAIL_TYPE_CASTER_TAIL(type)                                                    \
     template <typename T_,                                                                        \
               ::pybind11::detail::enable_if_t<                                                    \
                   std::is_same<type, ::pybind11::detail::remove_cv_t<T_>>::value,                 \
@@ -123,6 +141,22 @@ public:
     template <typename T_>                                                                        \
     using cast_op_type = ::pybind11::detail::movable_cast_op_type<T_>
 
+#ifdef PYBIND11_TYPE_CASTER_ODR_GUARD_ON
+
+#    define PYBIND11_TYPE_CASTER(type, py_name)                                                   \
+        PYBIND11_DETAIL_TYPE_CASTER_HEAD(type, py_name)                                           \
+        static constexpr auto source_file_line                                                    \
+            = ::pybind11::detail::tu_local_const_name(__FILE__ ":" PYBIND11_TOSTRING(__LINE__));  \
+        PYBIND11_DETAIL_TYPE_CASTER_TAIL(type)
+
+#else
+
+#    define PYBIND11_TYPE_CASTER(type, py_name)                                                   \
+        PYBIND11_DETAIL_TYPE_CASTER_HEAD(type, py_name)                                           \
+        PYBIND11_DETAIL_TYPE_CASTER_TAIL(type)
+
+#endif
+
 template <typename CharT>
 using is_std_char_type = any_of<std::is_same<CharT, char>, /* std::string */
 #if defined(PYBIND11_HAS_U8STRING)
@@ -315,6 +349,7 @@ class type_caster<void> : public type_caster<void_type> {
     using cast_op_type = void *&;
     explicit operator void *&() { return value; }
     static constexpr auto name = const_name("capsule");
+    PYBIND11_TYPE_CASTER_SOURCE_FILE_LINE
 
 private:
     void *value = nullptr;
@@ -542,6 +577,7 @@ struct type_caster<CharT, enable_if_t<is_std_char_type<CharT>::value>> {
 
 public:
     bool load(handle src, bool convert) {
+        PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(StringType)
         if (!src) {
             return false;
         }
@@ -557,13 +593,15 @@ struct type_caster<CharT, enable_if_t<is_std_char_type<CharT>::value>> {
     }
 
     static handle cast(const CharT *src, return_value_policy policy, handle parent) {
+        PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(StringType)
         if (src == nullptr) {
             return pybind11::none().inc_ref();
         }
         return StringCaster::cast(StringType(src), policy, parent);
     }
 
     static handle cast(CharT src, return_value_policy policy, handle parent) {
+        PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(StringType)
         if (std::is_same<char, CharT>::value) {
             handle s = PyUnicode_DecodeLatin1((const char *) &src, 1, nullptr);
             if (!s) {
@@ -635,6 +673,7 @@ struct type_caster<CharT, enable_if_t<is_std_char_type<CharT>::value>> {
     }
 
     static constexpr auto name = const_name(PYBIND11_STRING_NAME);
+    PYBIND11_TYPE_CASTER_SOURCE_FILE_LINE
     template <typename _T>
     using cast_op_type = pybind11::detail::cast_op_type<_T>;
 };
@@ -679,6 +718,7 @@ class tuple_caster {
 
     static constexpr auto name
         = const_name("Tuple[") + concat(make_caster<Ts>::name...) + const_name("]");
+    PYBIND11_TYPE_CASTER_SOURCE_FILE_LINE
 
     template <typename T>
     using cast_op_type = type;
@@ -851,6 +891,7 @@ struct move_only_holder_caster {
         return type_caster_base<type>::cast_holder(ptr, std::addressof(src));
     }
     static constexpr auto name = type_caster_base<type>::name;
+    PYBIND11_TYPE_CASTER_SOURCE_FILE_LINE
 };
 
 #ifndef PYBIND11_USE_SMART_HOLDER_AS_DEFAULT
@@ -1035,8 +1076,8 @@ struct return_value_policy_override<
 };
 
 // Basic python -> C++ casting; throws if casting fails
-template <typename T, typename SFINAE>
-type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
+template <typename T>
+make_caster<T> &load_type(make_caster<T> &conv, const handle &handle) {
     static_assert(!detail::is_pyobject<T>::value,
                   "Internal error: type_caster should only be used for C++ types");
     if (!conv.load(handle, true)) {
@@ -1054,8 +1095,9 @@ type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &ha
 // Wrapper around the above that also constructs and returns a type_caster
 template <typename T>
 make_caster<T> load_type(const handle &handle) {
+    PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(T)
     make_caster<T> conv;
-    load_type(conv, handle);
+    load_type<T>(conv, handle);
     return conv;
 }
 
@@ -1091,6 +1133,7 @@ object cast(T &&value,
                  : std::is_lvalue_reference<T>::value ? return_value_policy::copy
                                                       : return_value_policy::move;
     }
+    PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(T)
     return reinterpret_steal<object>(
         detail::make_caster<T>::cast(std::forward<T>(value), policy, parent));
 }
@@ -1191,7 +1234,8 @@ using override_caster_t = conditional_t<cast_is_temporary_value_reference<ret_ty
 template <typename T>
 enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&o,
                                                                      make_caster<T> &caster) {
-    return cast_op<T>(load_type(caster, o));
+    PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(T)
+    return cast_op<T>(load_type<T>(caster, o));
 }
 template <typename T>
 enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&,
@@ -1302,6 +1346,7 @@ struct arg_v : arg {
           type(type_id<T>())
 #endif
     {
+        PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(T)
         // Workaround! See:
         // https://github.com/pybind/pybind11/issues/2336
         // https://github.com/pybind/pybind11/pull/2685#issuecomment-731286700
@@ -1532,6 +1577,7 @@ class unpacking_collector {
 private:
     template <typename T>
     void process(list &args_list, T &&x) {
+        PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(T)
         auto o = reinterpret_steal<object>(
             detail::make_caster<T>::cast(std::forward<T>(x), policy, {}));
         if (!o) {
@@ -1676,6 +1722,7 @@ handle type::handle_of() {
                        detail::type_uses_smart_holder_type_caster<T>>::value,
         "py::type::of<T> only supports the case where T is a registered C++ types.");
 
+    PYBIND11_DETAIL_TYPE_CASTER_ACCESS_TRANSLATION_UNIT_LOCAL(T)
     return detail::get_type_handle(typeid(T), true);
 }
 

include/pybind11/detail/init.h

@@ -27,6 +27,7 @@ class type_caster<value_and_holder> {
     using cast_op_type = value_and_holder &;
     explicit operator value_and_holder &() { return *value; }
     static constexpr auto name = const_name<value_and_holder>();
+    PYBIND11_TYPE_CASTER_SOURCE_FILE_LINE
 
 private:
     value_and_holder *value = nullptr;

include/pybind11/detail/smart_holder_type_casters.h

@@ -616,6 +616,7 @@ template <typename T>
 struct smart_holder_type_caster : smart_holder_type_caster_load<T>,
                                   smart_holder_type_caster_class_hooks {
     static constexpr auto name = const_name<T>();
+    PYBIND11_TYPE_CASTER_SOURCE_FILE_LINE
 
     // static handle cast(T, ...)
     // is redundant (leads to ambiguous overloads).
@@ -777,6 +778,7 @@ 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 = const_name<T>();
+    PYBIND11_TYPE_CASTER_SOURCE_FILE_LINE
 
     static handle cast(const std::shared_ptr<T> &src, return_value_policy policy, handle parent) {
         switch (policy) {
@@ -841,6 +843,7 @@ 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 = const_name<T>();
+    PYBIND11_TYPE_CASTER_SOURCE_FILE_LINE
 
     static handle
     cast(const std::shared_ptr<T const> &src, return_value_policy policy, handle parent) {
@@ -861,6 +864,7 @@ 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 = const_name<T>();
+    PYBIND11_TYPE_CASTER_SOURCE_FILE_LINE
 
     static handle cast(std::unique_ptr<T, D> &&src, return_value_policy policy, handle parent) {
         if (policy != return_value_policy::automatic
@@ -944,6 +948,7 @@ 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 = const_name<T>();
+    PYBIND11_TYPE_CASTER_SOURCE_FILE_LINE
 
     static handle
     cast(std::unique_ptr<T const, D> &&src, return_value_policy policy, handle parent) {

include/pybind11/detail/type_caster_base.h

@@ -13,6 +13,7 @@
 #include "common.h"
 #include "descr.h"
 #include "internals.h"
+#include "type_caster_odr_guard.h"
 #include "typeid.h"
 
 #include <cstdint>
@@ -911,6 +912,7 @@ class type_caster_base : public type_caster_generic {
 
 public:
     static constexpr auto name = const_name<type>();
+    PYBIND11_TYPE_CASTER_SOURCE_FILE_LINE
 
     type_caster_base() : type_caster_base(typeid(type)) {}
     explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) {}