Add is_none method for efficient None test

Rather than contructing `py.None()` just to compare against (which
increments and then decrements the refcount on `None`), add a method
on `PyObject` that tests whether the object is the `None` instance.

Use this more widely to reduce the number of `unsafe` blocks.

Author: markbt

src/argparse.rs

@@ -463,7 +463,7 @@ macro_rules! py_argparse_extract {
         // second unwrap() asserts the parameter was not missing (which fn parse_args already checked for).
         let v = $iter.next().unwrap().as_ref().unwrap();
         let mut c = |$pname: $ptype| $crate::py_argparse_extract!($py, $iter, $body, [$($tail)*]);
-        let r = if v.as_ptr() == unsafe { $crate::_detail::ffi::Py_None() } {
+        let r = if v.is_none($py) {
             Ok(c(None))
         } else {
             <$rtype as $crate::RefFromPyObject>::with_extracted($py, v, |r: &$rtype| c(Some(r)))
@@ -537,7 +537,7 @@ where
 {
     match obj {
         Some(obj) => {
-            if obj.as_ptr() == unsafe { crate::ffi::Py_None() } {
+            if obj.is_none(py) {
                 f(None)
             } else {
                 match P::with_extracted(py, obj, |p| f(Some(p))) {

src/conversion.rs

@@ -224,7 +224,7 @@ where
     T: FromPyObject<'s>,
 {
     fn extract(py: Python, obj: &'s PyObject) -> PyResult<Self> {
-        if obj.as_ptr() == unsafe { ffi::Py_None() } {
+        if obj.is_none(py) {
             Ok(None)
         } else {
             match T::extract(py, obj) {
@@ -242,7 +242,7 @@ where T: ExtractPyObject<'prepared>
     type Prepared = Option<T::Prepared>;
 
     fn prepare_extract(py: Python, obj: &PyObject) -> PyResult<Self::Prepared> {
-        if obj.as_ptr() == unsafe { ffi::Py_None() } {
+        if obj.is_none(py) {
             Ok(None)
         } else {
             Ok(Some(T::prepare_extract(py, obj)?))

src/objects/object.rs

@@ -259,6 +259,12 @@ impl PyObject {
     {
         crate::conversion::FromPyObject::extract(py, self)
     }
+
+    /// True if this is None in Python.
+    #[inline]
+    pub fn is_none(&self, _py: Python) -> bool {
+        self.as_ptr() == unsafe { ffi::Py_None() }
+    }
 }
 
 /// PyObject implements the `==` operator using reference equality:

src/py_class/slots.rs

@@ -266,7 +266,7 @@ macro_rules! py_class_call_slot_impl_with_ref {
         $arg_if_some:expr
         $(, $extra_arg:ident)*
     ) => {{
-        if $arg.as_ptr() == unsafe { $crate::_detail::ffi::Py_None() } {
+        if $arg.is_none($py) {
             Ok($slf.$f($py, $arg_if_none $(, $extra_arg)*))
         } else {
             <$arg_type as $crate::RefFromPyObject>::with_extracted(

src/serde/de.rs

@@ -85,7 +85,7 @@ impl<'gil> Deserializer<'gil> {
 
     /// Test whether `self.obj` is `None` in Python.
     fn is_none(&self) -> bool {
-        self.obj == self.py.None()
+        self.obj.is_none(self.py)
     }
 }