Add PyNone to represent Python None

Add a new zero-sized struct `PyNone`, that represents Python's `None`.  This is
similar to `NoArgs` for the empty tuple, and is useful for defining functions
or methods that return None in Python.

Author: markbt

src/objects/mod.rs

@@ -31,6 +31,7 @@ pub use self::capsule::PyCapsule;
 pub use self::dict::PyDict;
 pub use self::iterator::PyIterator;
 pub use self::list::PyList;
+pub use self::none::PyNone;
 #[cfg(feature = "python27-sys")]
 pub use self::num::PyInt;
 #[cfg(feature = "python3-sys")]
@@ -139,6 +140,7 @@ pub mod exc;
 mod iterator;
 mod list;
 mod module;
+mod none;
 mod num;
 mod object;
 mod sequence;

src/objects/none.rs

@@ -0,0 +1,62 @@
+// Copyright (c) 2021 Mark Juggurnauth-Thomas
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+use super::exc;
+use super::object::PyObject;
+use crate::conversion::{FromPyObject, ToPyObject};
+use crate::err::{PyErr, PyResult};
+use crate::python::{Python, PythonObject};
+
+/// An empty struct that represents `None` in Python.
+///
+/// This can be used as a function return type for functions that should return
+/// `None` in Python.
+///
+/// # Example
+/// ```
+/// use cpython::{Python, PyResult, PyNone};
+///
+/// fn example(py: Python) -> PyResult<PyNone> {
+///    Ok(PyNone)
+/// }
+/// ```
+#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Default, Hash, Ord)]
+pub struct PyNone;
+
+impl ToPyObject for PyNone {
+    type ObjectType = PyObject;
+
+    #[inline]
+    fn to_py_object(&self, py: Python) -> PyObject {
+        py.None()
+    }
+}
+
+impl FromPyObject<'_> for PyNone {
+    fn extract(py: Python, obj: &PyObject) -> PyResult<Self> {
+        if *obj == py.None() {
+            Ok(PyNone)
+        } else {
+            let msg = format!("Expected None but received {}", obj.get_type(py).name(py));
+            Err(PyErr::new_lazy_init(
+                py.get_type::<exc::TypeError>(),
+                Some(msg.to_py_object(py).into_object()),
+            ))
+        }
+    }
+}

tests/test_class.rs

@@ -3,7 +3,7 @@
 use cpython::_detail::ffi;
 use cpython::*;
 use std::cell::{Cell, RefCell};
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::{isize, iter, mem};
 
@@ -189,6 +189,34 @@ fn instance_method() {
     py.run("assert obj.method() == 42", None, Some(&d)).unwrap();
 }
 
+py_class!(class InstanceMethodReturnsNone |py| {
+    data member: AtomicUsize;
+
+    def value(&self) -> PyResult<usize> {
+        Ok(self.member(py).load(Ordering::Relaxed))
+    }
+
+    def incr(&self) -> PyResult<PyNone> {
+        self.member(py).fetch_add(1, Ordering::Relaxed);
+        Ok(PyNone)
+    }
+});
+
+#[test]
+fn instance_method_returns_none() {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+
+    let obj = InstanceMethodReturnsNone::create_instance(py, AtomicUsize::new(0)).unwrap();
+    assert!(obj.incr(py).unwrap() == PyNone);
+    assert!(obj.value(py).unwrap() == 1);
+    let d = PyDict::new(py);
+    d.set_item(py, "obj", obj).unwrap();
+    py.run("assert obj.value() == 1", None, Some(&d)).unwrap();
+    py.run("assert obj.incr() is None", None, Some(&d)).unwrap();
+    py.run("assert obj.value() == 2", None, Some(&d)).unwrap();
+}
+
 py_class!(class InstanceMethodWithArgs |py| {
     data member: i32;
 

tests/test_function.rs

@@ -1,4 +1,4 @@
-use cpython::{py_fn, NoArgs, ObjectProtocol, PyDict, PyResult, Python};
+use cpython::{py_fn, NoArgs, ObjectProtocol, PyDict, PyNone, PyResult, Python};
 use std::sync::atomic;
 use std::sync::atomic::Ordering::Relaxed;
 
@@ -157,6 +157,30 @@ fn opt_args() {
     );
 }
 
+#[test]
+fn none_return() {
+    static CALL_COUNT: atomic::AtomicUsize = atomic::AtomicUsize::new(0);
+
+    fn f(_py: Python) -> PyResult<PyNone> {
+        CALL_COUNT.fetch_add(1, Relaxed);
+        Ok(PyNone)
+    }
+
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    let obj = py_fn!(py, f());
+
+    assert_eq!(CALL_COUNT.load(Relaxed), 0);
+    assert_eq!(
+        obj.call(py, NoArgs, None)
+            .unwrap()
+            .extract::<PyNone>(py)
+            .unwrap(),
+        PyNone,
+    );
+    assert_eq!(CALL_COUNT.load(Relaxed), 1);
+}
+
 /* TODO: reimplement flexible sig support
 #[test]
 fn flexible_sig() {