[Python] Raise a TypeError if C++ nullptr is compared with None

C++ nullptr comparisons with None were deprecated in ROOT 6.38 and will
now raise a TypeError.

Also adapt the tests, and delete a duplicate test in `roottest/python`.

Author: guitargeek

README/ReleaseNotes/v640/index.md

@@ -35,6 +35,7 @@ The following people have contributed to this new version:
 * The `TH1K` class was removed. `TMath::KNNDensity` can be used in its stead.
 
 * The `TObject` equality operator pythonization (`TObject.__eq__`) that was deprecated in ROOT 6.38 and scheduled for removal in ROOT 6.40 is removed
+* Comparing C++ `nullptr` objects with `None` in Python now raises a `TypeError`, as announced in the ROOT 6.38 release notes. Use truth-value checks like `if not x` or `x is None` instead.
 
 ## Build System
 

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

@@ -574,20 +574,16 @@ static PyObject* op_richcompare(CPPInstance* self, PyObject* other, int op)
     // special case for None to compare True to a null-pointer
         if ((PyObject*)other == Py_None && !self->fObject) {
             const char *msg =
-                "\nComparison of C++ nullptr objects with `None` is deprecated and will raise a TypeError starting from ROOT 6.40."
-                "\n\nThis currently treats `None` as equivalent to a null C++ pointer, which may lead to confusing results."
-                "\nFor example, `x == None` may return True even though `x is None` is False."
+                "\nComparison of C++ nullptr objects with `None` is no longer supported."
+                "\n\nPreviously, `None` was treated as equivalent to a null C++ pointer, "
+                "but this led to confusing behavior where `x == None` could be True even though `x is None` was False."
                 "\n\nTo test whether a C++ object is null or not, check its truth value instead:"
                 "\n    if not x: ..."
                 "\nor use `x is None` to explicitly check for Python None."
                 "\n";
 
-            // Equivalent to: warnings.warn(msg, FutureWarning, stacklevel=0)
-            if (PyErr_WarnEx(PyExc_FutureWarning, msg, 0) < 0) {
-                return NULL;  // Propagate the error if warning turned into an exception
-            }
-            if (op == Py_EQ) { Py_RETURN_TRUE; }
-            Py_RETURN_FALSE;
+            PyErr_SetString(PyExc_TypeError, msg);
+            return NULL;  // stop execution, raise TypeError
         }
 
     // use C++-side operators if available

bindings/pyroot/cppyy/cppyy/test/test_datatypes.py

@@ -989,17 +989,15 @@ def test19_object_and_pointer_comparisons(self):
         gbl = cppyy.gbl
 
         c1 = cppyy.bind_object(0, gbl.CppyyTestData)
-        assert c1 == None
-        assert None == c1
+        assert not c1
 
         c2 = cppyy.bind_object(0, gbl.CppyyTestData)
         assert c1 == c2
         assert c2 == c1
 
         # FourVector overrides operator==
         l1 = cppyy.bind_object(0, gbl.FourVector)
-        assert l1 == None
-        assert None == l1
+        assert not l1
 
         assert c1 != l1
         assert l1 != c1
@@ -1014,10 +1012,9 @@ def test19_object_and_pointer_comparisons(self):
         assert l3 == l4
         assert l4 == l3
 
-        assert l3 != None                 # like this to ensure __ne__ is called
-        assert None != l3                 # id.
-        assert l3 != l5
-        assert l5 != l3
+        assert l3
+        assert l3 != l5                   # like this to ensure __ne__ is called
+        assert l5 != l3                   # id.
 
     def test20_object_comparisons_with_cpp__eq__(self):
         """Comparisons with C++ providing __eq__/__ne__"""
@@ -1364,7 +1361,7 @@ def voidf(i):
             retval = i
 
         assert retval is None
-        assert fv(voidf, 5) == None
+        assert not fv(voidf, 5)
         assert retval == 5
 
         # call of function with reference argument
@@ -1438,7 +1435,7 @@ def voidf(i):
             retval = i
 
         assert retval is None
-        assert fv(voidf, 5) == None
+        assert not fv(voidf, 5)
         assert retval == 5
 
         # call of function with reference argument

bindings/pyroot/pythonizations/test/tobject_comparisonops.py

@@ -39,6 +39,22 @@ def test_ne(self):
         # Test comparison with None
         self.assertTrue(o != None)
 
+    def test_nullptr_eq_none_raises(self):
+        import cppyy
+
+        x = cppyy.bind_object(cppyy.nullptr, "TObject")
+
+        # Comparing a nullptr to None must raise TypeError in ROOT >= 6.40
+        # This is important to check, because if we don't raise an error, the
+        # result might not be equivalent to the confusing behavior in previous
+        # ROOT versions, which would be a silent behavior change.
+        # See https://github.com/root-project/root/issues/20283
+        with self.assertRaises(TypeError):
+            _ = x == None
+
+        with self.assertRaises(TypeError):
+            _ = x != None
+
     def test_lt(self):
         a = TUrl("a")
         b = TUrl("b")

roottest/python/basic/PyROOT_datatypetest.py

@@ -820,43 +820,6 @@ def test17_respect_privacy(self):
 
         c.__destruct__()
 
-    def test18_object_and_pointer_comparisons(self):
-        """Object and pointer comparisons"""
-
-        import cppyy
-        gbl = cppyy.gbl
-
-        c1 = cppyy.bind_object(0, gbl.CppyyTestData)
-        assert c1 == None
-        assert None == c1
-
-        c2 = cppyy.bind_object(0, gbl.CppyyTestData)
-        assert c1 == c2
-        assert c2 == c1
-
-        # FourVector overrides operator==
-        l1 = cppyy.bind_object(0, gbl.FourVector)
-        assert l1 == None
-        assert None == l1
-
-        assert c1 != l1
-        assert l1 != c1
-
-        l2 = cppyy.bind_object(0, gbl.FourVector)
-        assert l1 == l2
-        assert l2 == l1
-
-        l3 = gbl.FourVector(1, 2, 3, 4)
-        l4 = gbl.FourVector(1, 2, 3, 4)
-        l5 = gbl.FourVector(4, 3, 2, 1)
-        assert l3 == l4
-        assert l4 == l3
-
-        assert l3 != None                 # like this to ensure __ne__ is called
-        assert None != l3                 # id.
-        assert l3 != l5
-        assert l5 != l3
-
     def test19_object_validity(self):
         """Object validity checking"""
 

roottest/python/cpp/PyROOT_cpptests.py

@@ -292,17 +292,15 @@ def test15ObjectAndPointerComparisons( self ):
       """Verify object and pointer comparisons"""
 
       c1 = MakeNullPointer( TCanvas )
-      self.assertEqual( c1, None )
-      self.assertEqual( None, c1 )
+      self.assertFalse( c1 )
 
       c2 = MakeNullPointer( TCanvas )
       self.assertEqual( c1, c2 )
       self.assertEqual( c2, c1 )
 
     # TLorentzVector overrides operator==
       l1 = MakeNullPointer( TLorentzVector )
-      self.assertEqual( l1, None )
-      self.assertEqual( None, l1 )
+      self.assertFalse( l1 )
 
       self.assertNotEqual( c1, l1 )
       self.assertNotEqual( l1, c1 )