From e009a8736c082d6ad3a5a99b9c36893605ef0eb2 Mon Sep 17 00:00:00 2001
From: Axel Huebl <axel.huebl@plasma.ninja>
Date: Mon, 20 Mar 2023 13:39:15 -0700
Subject: [PATCH 1/6] Test: Default Alias in Base Class

This tests that template type aliases for base class templates are
resolved to the same registered types.
---
 tests/CMakeLists.txt               |  1 +
 tests/test_template_alias_base.cpp | 24 ++++++++++++++++++++++++
 tests/test_template_alias_base.py  | 11 +++++++++++
 3 files changed, 36 insertions(+)
 create mode 100644 tests/test_template_alias_base.cpp
 create mode 100644 tests/test_template_alias_base.py

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index b1cb222b4a..edb5f0eb30 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -153,6 +153,7 @@ set(PYBIND11_TEST_FILES
     test_stl
     test_stl_binders
     test_tagbased_polymorphic
+    test_template_alias_base
     test_thread
     test_union
     test_virtual_functions)
diff --git a/tests/test_template_alias_base.cpp b/tests/test_template_alias_base.cpp
new file mode 100644
index 0000000000..822a89a25b
--- /dev/null
+++ b/tests/test_template_alias_base.cpp
@@ -0,0 +1,24 @@
+#include "pybind11_tests.h"
+
+#include <memory>
+
+template <class T>
+using DefaultAllocator = std::allocator<T>;
+
+template <template <class> class Allocator = DefaultAllocator>
+struct Base {};
+
+template <template <class> class Allocator = DefaultAllocator>
+struct S : public Base<Allocator> {};
+
+// this returns S<DefaultAllocator> even though we register
+// the type S<std::allocator>
+// MSVC and Clang on Windows failed here to detect the registered type
+S<> make_S() { return S<>{}; }
+
+TEST_SUBMODULE(template_alias_base, m) {
+    py::class_<Base<std::allocator>>(m, "B_std").def(py::init());
+    py::class_<S<std::allocator>, Base<std::allocator>>(m, "S_std").def(py::init());
+
+    m.def("make_S", &make_S);
+}
diff --git a/tests/test_template_alias_base.py b/tests/test_template_alias_base.py
new file mode 100644
index 0000000000..2cae121d62
--- /dev/null
+++ b/tests/test_template_alias_base.py
@@ -0,0 +1,11 @@
+from pybind11_tests import template_alias_base as m
+
+
+def test_can_create_variable():
+    v = m.S_std()
+    print(v)
+
+
+def test_can_return_variable():
+    v = m.make_S()
+    print(v)

From e7f58dafad32c666891aa6668a4ecb5c25f8c2d5 Mon Sep 17 00:00:00 2001
From: Axel Huebl <axel.huebl@plasma.ninja>
Date: Tue, 21 Mar 2023 17:07:23 -0700
Subject: [PATCH 2/6] Patch: `internals.h` for `same_type`

Co-authored-by: "Ralf W. Grosse-Kunstleve" <rwgk@google.com>
---
 include/pybind11/detail/internals.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/pybind11/detail/internals.h b/include/pybind11/detail/internals.h
index 05e36ad18b..9bccc82ffe 100644
--- a/include/pybind11/detail/internals.h
+++ b/include/pybind11/detail/internals.h
@@ -34,7 +34,7 @@
 /// further ABI-incompatible changes may be made before the ABI is officially
 /// changed to the new version.
 #ifndef PYBIND11_INTERNALS_VERSION
-#    define PYBIND11_INTERNALS_VERSION 4
+#    define PYBIND11_INTERNALS_VERSION 5
 #endif
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
@@ -114,7 +114,7 @@ inline void tls_replace_value(PYBIND11_TLS_KEY_REF key, void *value) {
 // libstdc++, this doesn't happen: equality and the type_index hash are based on the type name,
 // which works.  If not under a known-good stl, provide our own name-based hash and equality
 // functions that use the type name.
-#if defined(__GLIBCXX__)
+#if !defined(_LIBCPP_VERSION)
 inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { return lhs == rhs; }
 using type_hash = std::hash<std::type_index>;
 using type_equal_to = std::equal_to<std::type_index>;

From 073a76bfa812b08245100399a5c306d2232ec7b1 Mon Sep 17 00:00:00 2001
From: Axel Huebl <axel.huebl@plasma.ninja>
Date: Tue, 21 Mar 2023 17:30:40 -0700
Subject: [PATCH 3/6] More Defensive `libstdc++` Test

---
 include/pybind11/detail/internals.h | 26 +++++++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/include/pybind11/detail/internals.h b/include/pybind11/detail/internals.h
index 9bccc82ffe..bd9bef6313 100644
--- a/include/pybind11/detail/internals.h
+++ b/include/pybind11/detail/internals.h
@@ -19,6 +19,30 @@
 
 #include <exception>
 
+/// Other includes, e.g., from system Python libs, tend to clutter and polute std defines
+/// depending on include order. Do a clean check.
+// GNU libstdc++
+#ifdef __GLIBCXX__
+#    undef __GLIBCXX__
+#endif
+// LLVM libc++
+#ifdef _LIBCPP_VERSION
+#    undef _LIBCPP_VERSION
+#endif
+// MS VS 2017 15.5+
+#ifdef _MSVC_STL_UPDATE
+#    undef _MSVC_STL_UPDATE
+#endif
+// MS Visual Studio (legacy)
+#ifdef _CPPLIB_VER
+#    undef _CPPLIB_VER
+#endif
+#if __cplusplus >= 202002
+#    include <ciso646>  // __GLIBCXX__ or _LIBCPP_VERSION, etc.
+#else
+#    include <version>
+#endif
+
 /// Tracks the `internals` and `type_info` ABI version independent of the main library version.
 ///
 /// Some portions of the code use an ABI that is conditional depending on this
@@ -114,7 +138,7 @@ inline void tls_replace_value(PYBIND11_TLS_KEY_REF key, void *value) {
 // libstdc++, this doesn't happen: equality and the type_index hash are based on the type name,
 // which works.  If not under a known-good stl, provide our own name-based hash and equality
 // functions that use the type name.
-#if !defined(_LIBCPP_VERSION)
+#if defined(__GLIBCXX__) && !defined(_LIBCPP_VERSION) && !defined(_MSVC_STL_UPDATE) && !defined(_CPPLIB_VER)
 inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { return lhs == rhs; }
 using type_hash = std::hash<std::type_index>;
 using type_equal_to = std::equal_to<std::type_index>;

From af929fe7960589fd2602f37db843559f3007add3 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 22 Mar 2023 00:34:12 +0000
Subject: [PATCH 4/6] style: pre-commit fixes

---
 include/pybind11/detail/internals.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/include/pybind11/detail/internals.h b/include/pybind11/detail/internals.h
index bd9bef6313..aa4cc49ae6 100644
--- a/include/pybind11/detail/internals.h
+++ b/include/pybind11/detail/internals.h
@@ -38,7 +38,7 @@
 #    undef _CPPLIB_VER
 #endif
 #if __cplusplus >= 202002
-#    include <ciso646>  // __GLIBCXX__ or _LIBCPP_VERSION, etc.
+#    include <ciso646> // __GLIBCXX__ or _LIBCPP_VERSION, etc.
 #else
 #    include <version>
 #endif
@@ -138,7 +138,8 @@ inline void tls_replace_value(PYBIND11_TLS_KEY_REF key, void *value) {
 // libstdc++, this doesn't happen: equality and the type_index hash are based on the type name,
 // which works.  If not under a known-good stl, provide our own name-based hash and equality
 // functions that use the type name.
-#if defined(__GLIBCXX__) && !defined(_LIBCPP_VERSION) && !defined(_MSVC_STL_UPDATE) && !defined(_CPPLIB_VER)
+#if defined(__GLIBCXX__) && !defined(_LIBCPP_VERSION) && !defined(_MSVC_STL_UPDATE)               \
+    && !defined(_CPPLIB_VER)
 inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { return lhs == rhs; }
 using type_hash = std::hash<std::type_index>;
 using type_equal_to = std::equal_to<std::type_index>;

From 9d1d0bd3118193e2989ea4268720f42b03b1f266 Mon Sep 17 00:00:00 2001
From: Axel Huebl <axel.huebl@plasma.ninja>
Date: Wed, 22 Mar 2023 13:33:54 -0700
Subject: [PATCH 5/6] Always use custom hash

---
 include/pybind11/detail/internals.h | 29 ++---------------------------
 1 file changed, 2 insertions(+), 27 deletions(-)

diff --git a/include/pybind11/detail/internals.h b/include/pybind11/detail/internals.h
index aa4cc49ae6..8ca2f0cec7 100644
--- a/include/pybind11/detail/internals.h
+++ b/include/pybind11/detail/internals.h
@@ -19,30 +19,6 @@
 
 #include <exception>
 
-/// Other includes, e.g., from system Python libs, tend to clutter and polute std defines
-/// depending on include order. Do a clean check.
-// GNU libstdc++
-#ifdef __GLIBCXX__
-#    undef __GLIBCXX__
-#endif
-// LLVM libc++
-#ifdef _LIBCPP_VERSION
-#    undef _LIBCPP_VERSION
-#endif
-// MS VS 2017 15.5+
-#ifdef _MSVC_STL_UPDATE
-#    undef _MSVC_STL_UPDATE
-#endif
-// MS Visual Studio (legacy)
-#ifdef _CPPLIB_VER
-#    undef _CPPLIB_VER
-#endif
-#if __cplusplus >= 202002
-#    include <ciso646> // __GLIBCXX__ or _LIBCPP_VERSION, etc.
-#else
-#    include <version>
-#endif
-
 /// Tracks the `internals` and `type_info` ABI version independent of the main library version.
 ///
 /// Some portions of the code use an ABI that is conditional depending on this
@@ -58,7 +34,7 @@
 /// further ABI-incompatible changes may be made before the ABI is officially
 /// changed to the new version.
 #ifndef PYBIND11_INTERNALS_VERSION
-#    define PYBIND11_INTERNALS_VERSION 5
+#    define PYBIND11_INTERNALS_VERSION 4
 #endif
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
@@ -138,8 +114,7 @@ inline void tls_replace_value(PYBIND11_TLS_KEY_REF key, void *value) {
 // libstdc++, this doesn't happen: equality and the type_index hash are based on the type name,
 // which works.  If not under a known-good stl, provide our own name-based hash and equality
 // functions that use the type name.
-#if defined(__GLIBCXX__) && !defined(_LIBCPP_VERSION) && !defined(_MSVC_STL_UPDATE)               \
-    && !defined(_CPPLIB_VER)
+#if 0
 inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { return lhs == rhs; }
 using type_hash = std::hash<std::type_index>;
 using type_equal_to = std::equal_to<std::type_index>;

From 4f576727eb6af61dc2053b8d991062bf794a9ed1 Mon Sep 17 00:00:00 2001
From: Axel Huebl <axel.huebl@plasma.ninja>
Date: Thu, 23 Mar 2023 10:53:51 -0700
Subject: [PATCH 6/6] printf debugging of caster

---
 include/pybind11/pybind11.h        | 43 +++++++++++++++++++++++++++---
 tests/CMakeLists.txt               |  4 +--
 tests/test_template_alias_base.cpp |  6 ++++-
 3 files changed, 47 insertions(+), 6 deletions(-)

diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index 6205effd61..fb8a75c02f 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -18,6 +18,7 @@
 
 #include <cstdlib>
 #include <cstring>
+#include <iostream>
 #include <memory>
 #include <new>
 #include <string>
@@ -221,10 +222,12 @@ class cpp_function : public function {
 
         /* Dispatch code which converts function arguments and performs the actual function call */
         rec->impl = [](function_call &call) -> handle {
+            std::cout << "in rec->impl" << std::endl;
             cast_in args_converter;
 
             /* Try to cast the function arguments into the C++ domain */
             if (!args_converter.load_args(call)) {
+                std::cout << ".. returning PYBIND11_TRY_NEXT_OVERLOAD" << std::endl;
                 return PYBIND11_TRY_NEXT_OVERLOAD;
             }
 
@@ -247,11 +250,18 @@ class cpp_function : public function {
             handle result
                 = cast_out::cast(std::move(args_converter).template call<Return, Guard>(cap->f),
                                  policy,
-                                 call.parent);
+                                 call.parent); // FIXME this seems to fail to detect identical
+                                               // return types with all compilers but GCC
+
+            std::cout << ".. after cast_out::cast - result=" << result.ptr() << " "
+                      << (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) << std::endl;
 
             /* Invoke call policy post-call hook */
             process_attributes<Extra...>::postcall(call, result);
 
+            std::cout << ".. after postcall - result=" << result.ptr() << " "
+                      << (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) << std::endl;
+
             return result;
         };
 
@@ -705,6 +715,7 @@ class cpp_function : public function {
         }
 
         try {
+            std::cout << "Starting two-pass matching..." << std::endl;
             // We do this in two passes: in the first pass, we load arguments with `convert=false`;
             // in the second, we allow conversion (except for arguments with an explicit
             // py::arg().noconvert()).  This lets us prefer calls without conversion, with
@@ -761,6 +772,7 @@ class cpp_function : public function {
                 size_t args_copied = 0;
 
                 // 0. Inject new-style `self` argument
+                std::cout << "0. Inject new-style `self` argument" << std::endl;
                 if (func.is_new_style_constructor) {
                     // The `value` may have been preallocated by an old-style `__init__`
                     // if it was a preceding candidate for overload resolution.
@@ -775,6 +787,7 @@ class cpp_function : public function {
                 }
 
                 // 1. Copy any position arguments given.
+                std::cout << "1. Copy any position arguments given." << std::endl;
                 bool bad_arg = false;
                 for (; args_copied < args_to_copy; ++args_copied) {
                     const argument_record *arg_rec
@@ -805,6 +818,8 @@ class cpp_function : public function {
                 dict kwargs = reinterpret_borrow<dict>(kwargs_in);
 
                 // 1.5. Fill in any missing pos_only args from defaults if they exist
+                std::cout << "1.5. Fill in any missing pos_only args from defaults if they exist"
+                          << std::endl;
                 if (args_copied < func.nargs_pos_only) {
                     for (; args_copied < func.nargs_pos_only; ++args_copied) {
                         const auto &arg_rec = func.args[args_copied];
@@ -827,6 +842,9 @@ class cpp_function : public function {
                 }
 
                 // 2. Check kwargs and, failing that, defaults that may help complete the list
+                std::cout << "2. Check kwargs and, failing that, defaults that may help complete "
+                             "the list"
+                          << std::endl;
                 if (args_copied < num_args) {
                     bool copied_kwargs = false;
 
@@ -876,11 +894,16 @@ class cpp_function : public function {
                 }
 
                 // 3. Check everything was consumed (unless we have a kwargs arg)
+                std::cout << "3. Check everything was consumed (unless we have a kwargs arg)"
+                          << std::endl;
                 if (kwargs && !kwargs.empty() && !func.has_kwargs) {
                     continue; // Unconsumed kwargs, but no py::kwargs argument to accept them
                 }
 
                 // 4a. If we have a py::args argument, create a new tuple with leftovers
+                std::cout
+                    << "4a. If we have a py::args argument, create a new tuple with leftovers"
+                    << std::endl;
                 if (func.has_args) {
                     tuple extra_args;
                     if (args_to_copy == 0) {
@@ -906,6 +929,8 @@ class cpp_function : public function {
                 }
 
                 // 4b. If we have a py::kwargs, pass on any remaining kwargs
+                std::cout << "4b. If we have a py::kwargs, pass on any remaining kwargs"
+                          << std::endl;
                 if (func.has_kwargs) {
                     if (!kwargs.ptr()) {
                         kwargs = dict(); // If we didn't get one, send an empty one
@@ -917,7 +942,10 @@ class cpp_function : public function {
 
 // 5. Put everything in a vector.  Not technically step 5, we've been building it
 // in `call.args` all along.
-#if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+#if 1
+                std::cout << "5. Put everything in a vector.  Not technically step 5, we've been "
+                             "building it in `call.args` all along."
+                          << std::endl;
                 if (call.args.size() != func.nargs || call.args_convert.size() != func.nargs) {
                     pybind11_fail("Internal error: function call dispatcher inserted wrong number "
                                   "of arguments!");
@@ -934,18 +962,24 @@ class cpp_function : public function {
                 }
 
                 // 6. Call the function.
+                std::cout << "6. Call the function." << std::endl;
                 try {
                     loader_life_support guard{};
-                    result = func.impl(call);
+                    result = func.impl(
+                        call); // FIXME looks like this fails to match identical return types
                 } catch (reference_cast_error &) {
+                    std::cout << ".. catch (reference_cast_error &)" << std::endl;
                     result = PYBIND11_TRY_NEXT_OVERLOAD;
                 }
 
                 if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD) {
+                    std::cout << ".. result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD -> break"
+                              << std::endl;
                     break;
                 }
 
                 if (overloaded) {
+                    std::cout << ".. overloaded" << std::endl;
                     // The (overloaded) call failed; if the call has at least one argument that
                     // permits conversion (i.e. it hasn't been explicitly specified `.noconvert()`)
                     // then add this call to the list of second pass overloads to try.
@@ -964,6 +998,9 @@ class cpp_function : public function {
             if (overloaded && !second_pass.empty() && result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
                 // The no-conversion pass finished without success, try again with conversion
                 // allowed
+                std::cout << "The no-conversion pass finished without success, try again with "
+                             "conversion allowed"
+                          << std::endl;
                 for (auto &call : second_pass) {
                     try {
                         loader_life_support guard{};
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index edb5f0eb30..bf8b165560 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -522,8 +522,8 @@ set(PYBIND11_TEST_PREFIX_COMMAND
 # A single command to compile and run the tests
 add_custom_target(
   pytest
-  COMMAND ${PYBIND11_TEST_PREFIX_COMMAND} ${PYTHON_EXECUTABLE} -m pytest
-          ${PYBIND11_ABS_PYTEST_FILES}
+  COMMAND ${PYBIND11_TEST_PREFIX_COMMAND} ${PYTHON_EXECUTABLE} -m pytest -s -vvvv
+          "${CMAKE_CURRENT_SOURCE_DIR}/test_template_alias_base.py"
   DEPENDS ${test_targets}
   WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
   USES_TERMINAL)
diff --git a/tests/test_template_alias_base.cpp b/tests/test_template_alias_base.cpp
index 822a89a25b..f5d48f9d02 100644
--- a/tests/test_template_alias_base.cpp
+++ b/tests/test_template_alias_base.cpp
@@ -1,5 +1,6 @@
 #include "pybind11_tests.h"
 
+#include <iostream>
 #include <memory>
 
 template <class T>
@@ -14,7 +15,10 @@ struct S : public Base<Allocator> {};
 // this returns S<DefaultAllocator> even though we register
 // the type S<std::allocator>
 // MSVC and Clang on Windows failed here to detect the registered type
-S<> make_S() { return S<>{}; }
+S<> make_S() {
+    std::cout << "in make_S()" << std::endl;
+    return S<>{};
+}
 
 TEST_SUBMODULE(template_alias_base, m) {
     py::class_<Base<std::allocator>>(m, "B_std").def(py::init());