[CPyCppyy] Add back the (U)Long64_t converters and executors

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

@@ -3618,6 +3618,19 @@ static struct InitConvFactories_t {
         gf[CCOMPLEX_F " ptr"] =             gf["std::complex<float> ptr"];
         gf[CCOMPLEX_D " ptr"] =             gf["std::complex<double> ptr"];
 
+        // We always need these converters when cppyy is based on an unpatched
+        // ROOT, because the "long long" types are always converted to Long64_t
+        // and ULong64_t already at the ROOT Meta level.
+        // See https://github.com/root-project/root/issues/15872#issuecomment-2174092763
+        gf["Long64_t"] =                    gf["long long"];
+        gf["Long64_t ptr"] =                gf["long long ptr"];
+        gf["Long64_t&"] =                   gf["long long&"];
+        gf["const Long64_t&"] =             gf["const long long&"];
+        gf["ULong64_t"] =                   gf["unsigned long long"];
+        gf["ULong64_t ptr"] =               gf["unsigned long long ptr"];
+        gf["ULong64_t&"] =                  gf["unsigned long long&"];
+        gf["const ULong64_t&"] =            gf["const unsigned long long&"];
+
     // factories for special cases
         gf["nullptr_t"] =                   (cf_t)+[](cdims_t) { static NullptrConverter c{};        return &c;};
         gf["const char*"] =                 (cf_t)+[](cdims_t) { return new CStringConverter{}; };

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

@@ -1069,6 +1069,17 @@ struct InitExecFactories_t {
         gf[CCOMPLEX_F " ptr"] =             gf["std::complex<float> ptr"];
         gf[CCOMPLEX_D " ptr"] =             gf["std::complex<double> ptr"];
 
+        // We always need these executors when cppyy is based on an unpatched
+        // ROOT, because the "long long" types are always converted to Long64_t
+        // and ULong64_t already at the ROOT Meta level.
+        // See https://github.com/root-project/root/issues/15872#issuecomment-2174092763
+        gf["Long64_t"] =                    gf["long long"];
+        gf["Long64_t&"] =                   gf["long long&"];
+        gf["Long64_t ptr"] =                gf["long long ptr"];
+        gf["ULong64_t"] =                   gf["unsigned long long"];
+        gf["ULong64_t&"] =                  gf["unsigned long long&"];
+        gf["ULong64_t ptr"] =               gf["unsigned long long ptr"];
+
     // factories for special cases
         gf["const char*"] =                 (ef_t)+[](cdims_t) { static CStringExecutor e{};     return &e; };
         gf["char*"] =                       gf["const char*"];

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

@@ -323,12 +323,7 @@ static bool FillVector(PyObject* vecin, PyObject* args, ItemGetter* getter)
 // reserve memory as applicable
     if (0 < sz) {
         PyObject* res = PyObject_CallMethod(vecin, (char*)"reserve", (char*)"n", sz);
-        // TODO: Actually this "res" should never be nullptr, but somehow this
-        // call can fail on Windows 64 bit, resulting in "res" being a nullptr.
-        // This needs to be fixed, and then we can use again Py_DECREF(res),
-        // which doesn't do the nullptr check. Alternatively, there should be a
-        // proper error if calling reserve() fails.
-        Py_XDECREF(res);
+        Py_DECREF(res);
     } else   // i.e. sz == 0, so empty container: done
         return true;
 

bindings/pyroot/cppyy/cppyy/test/test_numba.py

@@ -1,4 +1,4 @@
 import os, pytest
 import math, time
 from pytest import mark, raises
 from support import setup_make, IS_MAC, IS_WINDOWS
@@ -13,7 +13,7 @@
 class TestREFLEX:
     def setup_class(cls):
         import cppyy
         import cppyy.reflex
 
     def test01_instance_box_unbox(self):
         """Access to box/unbox methods"""
@@ -69,16 +69,16 @@
         assert ns.MyData_d1.__dict__['m_int'].__cpp_reflex__(r.TYPE)    == 'int'
         assert ns.MyData_d1.__dict__['m_double'].__cpp_reflex__(r.TYPE) == 'double'
 
         d = ns.MyData_d1(); daddr = cppyy.addressof(d)
         assert ns.MyData_d1.__dict__['m_int'].__cpp_reflex__(r.OFFSET)    == 0
         assert ns.MyData_d1.__dict__['m_double'].__cpp_reflex__(r.OFFSET) == cppyy.addressof(d, 'm_double') - daddr
 
 
 @mark.skipif(has_numba == False, reason="numba not found")
 class TestNUMBA:
     def setup_class(cls):
         import cppyy
         import cppyy.numba_ext
 
     def compare(self, go_slow, go_fast, N, *args):
         t0 = time.time()
@@ -309,8 +309,8 @@
                 val = getattr(nl[ntype], m)()
                 assert access_field(getattr(ns, 'M%d'%i)(val)) == val
 
-    @mark.xfail(reason = "Numba tests comparing execution times are sensitive and fail sporadically. \
-                Fails on OS X")
+    @mark.xfail(run=False, reason = "Numba tests comparing execution times are sensitive and fail sporadically. \
+                Fails on OS X and Windows 64 bit")
     def test08_object_returns(self):
         """Numba-JITing of a function that returns an object"""
 
@@ -372,9 +372,9 @@
 
     @mark.xfail(condition=IS_MAC | IS_WINDOWS, reason="Fails on macOS and Windows")
     def test10_returning_a_reference(self):
         import cppyy
         import numpy as np
         import numba
 
         cppyy.cppdef("""
         int64_t& ref_add(int64_t x, int64_t y) {

bindings/pyroot/cppyy/cppyy/test/test_stltypes.py

@@ -327,7 +327,7 @@ def test04_vector_iteration(self):
 
         v.__destruct__()
 
-    @mark.xfail(run=False, condition=WINDOWS_BITS == 64, reason="Fails on Windows 64 bit")
+    @mark.xfail(condition=WINDOWS_BITS == 64, reason="Fails on Windows 64 bit")
     def test05_push_back_iterables_with_iadd(self):
         """Test usage of += of iterable on push_back-able container"""
 
@@ -447,7 +447,7 @@ def test09_vector_of_string(self):
 
         raises(TypeError, cppyy.gbl.std.vector["std::string"], "abc")
 
-    @mark.xfail(run=False, condition=WINDOWS_BITS == 64, reason="Fails on Windows 64 bit")
+    @mark.xfail(condition=WINDOWS_BITS == 64, reason="Fails on Windows 64 bit")
     def test10_vector_std_distance(self):
         """Use of std::distance with vector"""
 
@@ -459,7 +459,7 @@ def test10_vector_std_distance(self):
         assert std.distance(v.begin(), v.end()) == v.size()
         assert std.distance[type(v).iterator](v.begin(), v.end()) == v.size()
 
-    @mark.xfail(run=False, condition=WINDOWS_BITS == 64, reason="Fails on Windows 64 bit")
+    @mark.xfail(condition=WINDOWS_BITS == 64, reason="Fails on Windows 64 bit")
     def test11_vector_of_pair(self):
         """Use of std::vector<std::pair>"""
 
@@ -570,7 +570,7 @@ def test13_vector_smartptr_iteration(self):
             i += 1
         assert i == len(result)
 
-    @mark.xfail(run=False, condition=WINDOWS_BITS == 64, reason="Fails on Windows 64 bit")
+    @mark.xfail(condition=WINDOWS_BITS == 64, reason="Fails on Windows 64 bit")
     def test14_vector_of_vector_of_(self):
         """Nested vectors"""
 
@@ -586,7 +586,7 @@ def test14_vector_of_vector_of_(self):
         assert vv[1][0] == 3
         assert vv[1][1] == 4
 
-    @mark.xfail(run=False, condition=WINDOWS_BITS == 64, reason="Fails on Windows 64 bit")
+    @mark.xfail(condition=WINDOWS_BITS == 64, reason="Fails on Windows 64 bit")
     def test15_vector_slicing(self):
         """Advanced test of vector slicing"""
 

bindings/pyroot/pythonizations/python/ROOT/_facade.py

@@ -142,14 +142,6 @@ def _fallback_getattr(self, name):
     def _register_converters_and_executors(self):
 
         converter_aliases = {
-            "Long64_t": "long long",
-            "Long64_t ptr": "long long ptr",
-            "Long64_t&": "long long&",
-            "const Long64_t&": "const long long&",
-            "ULong64_t": "unsigned long long",
-            "ULong64_t ptr": "unsigned long long ptr",
-            "ULong64_t&": "unsigned long long&",
-            "const ULong64_t&": "const unsigned long long&",
             "Float16_t": "float",
             "const Float16_t&": "const float&",
             "Double32_t": "double",
@@ -158,12 +150,6 @@ def _register_converters_and_executors(self):
         }
 
         executor_aliases = {
-            "Long64_t": "long long",
-            "Long64_t&": "long long&",
-            "Long64_t ptr": "long long ptr",
-            "ULong64_t": "unsigned long long",
-            "ULong64_t&": "unsigned long long&",
-            "ULong64_t ptr": "unsigned long long ptr",
             "Float16_t": "float",
             "Float16_t&": "float&",
             "Double32_t": "double",