Revert "[cppyy] Fix hash collision in TemplateProxy dispatch for CPPOverload objects"

This reverts commit 87380b5.

Author: guitargeek

bindings/pyroot/cppyy/CPyCppyy/src/CPPOverload.cxx

@@ -17,63 +17,16 @@
 #include "CPPInstance.h"
 #include "CallContext.h"
 #include "PyStrings.h"
-#include "TemplateProxy.h"
 #include "Utility.h"
 
 // Standard
 #include <algorithm>
-#include <functional>
 #include <sstream>
 #include <vector>
 
 
 namespace CPyCppyy {
 
-//----------------------------------------------------------------------------
-// Combine name hash and method count for stable identity
-
-namespace {
-constexpr uint64_t kGoldenRatioHash = 0x9e3779b9ULL;
-
-inline void hash_combine(uint64_t &seed, uint64_t value)
-{
-   seed ^= value + kGoldenRatioHash + (seed << 6) + (seed >> 2);
-}
-} // anonymous namespace
-
-uint64_t HashSignature(CPyCppyy_PyArgs_t args, size_t nargsf)
-{
-   uint64_t hash = 0;
-   std::hash<std::string> str_hash;
-
-   Py_ssize_t nargs = CPyCppyy_PyArgs_GET_SIZE(args, nargsf);
-   for (Py_ssize_t i = 0; i < nargs; ++i) {
-      PyObject *pyobj = CPyCppyy_PyArgs_GET_ITEM(args, i);
-
-      if (CPPOverload_Check(pyobj)) {
-         // Hash the method name and overload count for uniqueness
-         // All O(1) access - no RTTI, no string construction
-         auto *ol = static_cast<CPPOverload *>(pyobj);
-         hash_combine(hash, str_hash(ol->fMethodInfo->fName));
-         hash_combine(hash, static_cast<uint64_t>(ol->fMethodInfo->fMethods.size()));
-      } else if (TemplateProxy_Check(pyobj)) {
-         // Hash the stable template name (fCppName includes scope for templates)
-         auto *tp = static_cast<TemplateProxy *>(pyobj);
-         hash_combine(hash, str_hash(tp->fTI->fCppName));
-      } else {
-         // Standard type-based hashing for other objects
-         hash_combine(hash, reinterpret_cast<uint64_t>(Py_TYPE(pyobj)));
-#if PY_VERSION_HEX >= 0x030e0000
-         hash_combine(hash, PyUnstable_Object_IsUniqueReferencedTemporary(pyobj) ? 1ULL : 0ULL);
-#else
-         hash_combine(hash, Py_REFCNT(pyobj) == 1 ? 1ULL : 0ULL);
-#endif
-      }
-   }
-
-   return hash;
-}
-
 namespace {
 
 // from CPython's instancemethod: Free list for method objects to safe malloc/free overhead

bindings/pyroot/cppyy/CPyCppyy/src/CPPOverload.h

@@ -5,7 +5,6 @@
 #include "PyCallable.h"
 
 // Standard
-#include <cstdint>
 #include <map>
 #include <string>
 #include <utility>
@@ -14,8 +13,30 @@
 
 namespace CPyCppyy {
 
-// Signature hashing for memoization (implementation in CPPOverload.cxx)
-uint64_t HashSignature(CPyCppyy_PyArgs_t args, size_t nargsf);
+// signature hashes are also used by TemplateProxy
+inline uint64_t HashSignature(CPyCppyy_PyArgs_t args, size_t nargsf)
+{
+// Build a hash from the types of the given python function arguments.
+    uint64_t hash = 0;
+
+    Py_ssize_t nargs = CPyCppyy_PyArgs_GET_SIZE(args, nargsf);
+    for (Py_ssize_t i = 0; i < nargs; ++i) {
+    // TODO: hashing in the ref-count is for moves; resolve this together with the
+    // improved overloads for implicit conversions
+        PyObject* pyobj = CPyCppyy_PyArgs_GET_ITEM(args, i);
+        hash += (uint64_t)Py_TYPE(pyobj);
+#if PY_VERSION_HEX >= 0x030e0000
+        hash += (uint64_t)(PyUnstable_Object_IsUniqueReferencedTemporary(pyobj) ? 1 : 0);
+#else
+        hash += (uint64_t)(Py_REFCNT(pyobj) == 1 ? 1 : 0);
+#endif
+        hash += (hash << 10); hash ^= (hash >> 6);
+    }
+
+    hash += (hash << 3); hash ^= (hash >> 11); hash += (hash << 15);
+
+    return hash;
+}
 
 class CPPOverload {
 public:

bindings/pyroot/cppyy/cppyy/test/test_templates.py

@@ -1159,28 +1159,6 @@ def test34_cstring_template_argument(self):
         assert ns.stringify["const char*"]("Aap")                    == "Aap "
         assert ns.stringify(ctypes.c_char_p(bytes("Noot", "ascii"))) == "Noot "
 
-    def test35_issue_20526_hash_collision(self):
-        """Fix #20526: Ensure distinct global functions have distinct hashes"""
-
-        import cppyy
-
-        cppyy.cppdef("""
-            namespace Issue20526 {
-                int funcA() { return 101; }
-                int funcB() { return 202; }
-                template<typename T> int call_it(T f) { return f(); }
-            }
-        """)
-
-        ns = cppyy.gbl.Issue20526
-
-        # If hashes collide, the cache returns the wrong instantiation
-        resA = ns.call_it(ns.funcA)
-        resB = ns.call_it(ns.funcB)
-
-        assert resA == 101
-        assert resB == 202
-
 
 class TestTEMPLATED_TYPEDEFS:
     def setup_class(cls):