diff --git a/guide/src/class/protocols.md b/guide/src/class/protocols.md
index 4bdcaa471ce..57be0c70546 100644
--- a/guide/src/class/protocols.md
+++ b/guide/src/class/protocols.md
@@ -288,7 +288,7 @@ This trait also has support the augmented arithmetic assignments (`+=`, `-=`,
   * `fn __itruediv__(&'p mut self, other: impl FromPyObject) -> PyResult<()>`
   * `fn __ifloordiv__(&'p mut self, other: impl FromPyObject) -> PyResult<()>`
   * `fn __imod__(&'p mut self, other: impl FromPyObject) -> PyResult<()>`
-  * `fn __ipow__(&'p mut self, other: impl FromPyObject) -> PyResult<()>`
+  * `fn __ipow__(&'p mut self, other: impl FromPyObject, _modulo: impl FromPyObject) -> PyResult<()>`
   * `fn __ilshift__(&'p mut self, other: impl FromPyObject) -> PyResult<()>`
   * `fn __irshift__(&'p mut self, other: impl FromPyObject) -> PyResult<()>`
   * `fn __iand__(&'p mut self, other: impl FromPyObject) -> PyResult<()>`
diff --git a/pyo3-macros-backend/Cargo.toml b/pyo3-macros-backend/Cargo.toml
index 5abd99afdd1..8ed07db286c 100644
--- a/pyo3-macros-backend/Cargo.toml
+++ b/pyo3-macros-backend/Cargo.toml
@@ -18,6 +18,9 @@ quote = { version = "1", default-features = false }
 proc-macro2 = { version = "1", default-features = false }
 pyo3-build-config = { path = "../pyo3-build-config", version = "0.15.1", features = ["resolve-config"] }
 
+[build-dependencies]
+pyo3-build-config = { path = "../pyo3-build-config", version = "0.15.1", features = ["resolve-config"] }
+
 [dependencies.syn]
 version = "1"
 default-features = false
diff --git a/pyo3-macros-backend/build.rs b/pyo3-macros-backend/build.rs
new file mode 100644
index 00000000000..afcf26de3ca
--- /dev/null
+++ b/pyo3-macros-backend/build.rs
@@ -0,0 +1,14 @@
+use pyo3_build_config::pyo3_build_script_impl::{errors::Result, resolve_interpreter_config};
+
+fn configure_pyo3() -> Result<()> {
+    let interpreter_config = resolve_interpreter_config()?;
+    interpreter_config.emit_pyo3_cfgs();
+    Ok(())
+}
+
+fn main() {
+    if let Err(e) = configure_pyo3() {
+        eprintln!("error: {}", e.report());
+        std::process::exit(1)
+    }
+}
diff --git a/pyo3-macros-backend/src/defs.rs b/pyo3-macros-backend/src/defs.rs
index be90f137974..938a91c51f1 100644
--- a/pyo3-macros-backend/src/defs.rs
+++ b/pyo3-macros-backend/src/defs.rs
@@ -420,6 +420,12 @@ pub const NUM: Proto = Proto {
         MethodProto::new("__imod__", "PyNumberIModProtocol")
             .args(&["Other"])
             .has_self(),
+        // See https://bugs.python.org/issue36379
+        #[cfg(Py_3_8)]
+        MethodProto::new("__ipow__", "PyNumberIPowProtocol")
+            .args(&["Other", "Modulo"])
+            .has_self(),
+        #[cfg(not(Py_3_8))]
         MethodProto::new("__ipow__", "PyNumberIPowProtocol")
             .args(&["Other"])
             .has_self(),
diff --git a/pyo3-macros-backend/src/pymethod.rs b/pyo3-macros-backend/src/pymethod.rs
index c8b4d607e5b..8c52369cdd8 100644
--- a/pyo3-macros-backend/src/pymethod.rs
+++ b/pyo3-macros-backend/src/pymethod.rs
@@ -532,10 +532,16 @@ const __IMOD__: SlotDef = SlotDef::new("Py_nb_inplace_remainder", "binaryfunc")
     .arguments(&[Ty::Object])
     .extract_error_mode(ExtractErrorMode::NotImplemented)
     .return_self();
+#[cfg(Py_3_8)]
 const __IPOW__: SlotDef = SlotDef::new("Py_nb_inplace_power", "ternaryfunc")
     .arguments(&[Ty::Object, Ty::Object])
     .extract_error_mode(ExtractErrorMode::NotImplemented)
     .return_self();
+#[cfg(not(Py_3_8))]
+const __IPOW__: SlotDef = SlotDef::new("Py_nb_inplace_power", "binaryfunc")
+    .arguments(&[Ty::Object])
+    .extract_error_mode(ExtractErrorMode::NotImplemented)
+    .return_self();
 const __ILSHIFT__: SlotDef = SlotDef::new("Py_nb_inplace_lshift", "binaryfunc")
     .arguments(&[Ty::Object])
     .extract_error_mode(ExtractErrorMode::NotImplemented)
@@ -856,8 +862,11 @@ fn generate_method_body(
 ) -> Result<TokenStream> {
     let self_conversion = spec.tp.self_conversion(Some(cls), extract_error_mode);
     let rust_name = spec.name;
-    let (arg_idents, conversions) =
+    let (arg_idents, arg_count, conversions) =
         extract_proto_arguments(cls, py, &spec.args, arguments, extract_error_mode)?;
+    if arg_count != arguments.len() {
+        bail_spanned!(spec.name.span() => format!("Expected {} arguments, got {}", arguments.len(), arg_count));
+    }
     let call = quote! { _pyo3::callback::convert(#py, #cls::#rust_name(_slf, #(#arg_idents),*)) };
     let body = if let Some(return_mode) = return_mode {
         return_mode.return_call_output(py, call)
@@ -1026,7 +1035,7 @@ fn extract_proto_arguments(
     method_args: &[FnArg],
     proto_args: &[Ty],
     extract_error_mode: ExtractErrorMode,
-) -> Result<(Vec<Ident>, TokenStream)> {
+) -> Result<(Vec<Ident>, usize, TokenStream)> {
     let mut arg_idents = Vec::with_capacity(method_args.len());
     let mut non_python_args = 0;
 
@@ -1045,9 +1054,8 @@ fn extract_proto_arguments(
             arg_idents.push(ident);
         }
     }
-
     let conversions = quote!(#(#args_conversions)*);
-    Ok((arg_idents, conversions))
+    Ok((arg_idents, non_python_args, conversions))
 }
 
 struct StaticIdent(&'static str);
diff --git a/src/class/number.rs b/src/class/number.rs
index 2b0c2ade799..2dbe5403793 100644
--- a/src/class/number.rs
+++ b/src/class/number.rs
@@ -221,6 +221,14 @@ pub trait PyNumberProtocol<'p>: PyClass {
     {
         unimplemented!()
     }
+    #[cfg(Py_3_8)]
+    fn __ipow__(&'p mut self, other: Self::Other, modulo: Option<Self::Modulo>) -> Self::Result
+    where
+        Self: PyNumberIPowProtocol<'p>,
+    {
+        unimplemented!()
+    }
+    #[cfg(not(Py_3_8))]
     fn __ipow__(&'p mut self, other: Self::Other) -> Self::Result
     where
         Self: PyNumberIPowProtocol<'p>,
@@ -504,6 +512,8 @@ pub trait PyNumberIDivmodProtocol<'p>: PyNumberProtocol<'p> {
 pub trait PyNumberIPowProtocol<'p>: PyNumberProtocol<'p> {
     type Other: FromPyObject<'p>;
     type Result: IntoPyCallbackOutput<()>;
+    #[cfg(Py_3_8)]
+    type Modulo: FromPyObject<'p>;
 }
 
 #[allow(clippy::upper_case_acronyms)]
@@ -714,11 +724,13 @@ py_binary_self_func!(isub, PyNumberISubProtocol, T::__isub__);
 py_binary_self_func!(imul, PyNumberIMulProtocol, T::__imul__);
 py_binary_self_func!(imod, PyNumberIModProtocol, T::__imod__);
 
+// See https://bugs.python.org/issue36379
 #[doc(hidden)]
+#[cfg(Py_3_8)]
 pub unsafe extern "C" fn ipow<T>(
     slf: *mut ffi::PyObject,
     other: *mut ffi::PyObject,
-    _modulo: *mut ffi::PyObject,
+    modulo: *mut ffi::PyObject,
 ) -> *mut ffi::PyObject
 where
     T: for<'p> PyNumberIPowProtocol<'p>,
@@ -728,7 +740,35 @@ where
     crate::callback_body!(py, {
         let slf_cell = py.from_borrowed_ptr::<crate::PyCell<T>>(slf);
         let other = py.from_borrowed_ptr::<crate::PyAny>(other);
-        call_operator_mut!(py, slf_cell, __ipow__, other).convert(py)?;
+        let modulo = py.from_borrowed_ptr::<crate::PyAny>(modulo);
+        slf_cell
+            .try_borrow_mut()?
+            .__ipow__(
+                extract_or_return_not_implemented!(other),
+                extract_or_return_not_implemented!(modulo),
+            )
+            .convert(py)?;
+        ffi::Py_INCREF(slf);
+        Ok::<_, PyErr>(slf)
+    })
+}
+
+#[doc(hidden)]
+#[cfg(not(Py_3_8))]
+pub unsafe extern "C" fn ipow<T>(
+    slf: *mut ffi::PyObject,
+    other: *mut ffi::PyObject,
+) -> *mut ffi::PyObject
+where
+    T: for<'p> PyNumberIPowProtocol<'p>,
+{
+    crate::callback_body!(py, {
+        let slf_cell = py.from_borrowed_ptr::<crate::PyCell<T>>(slf);
+        let other = py.from_borrowed_ptr::<crate::PyAny>(other);
+        slf_cell
+            .try_borrow_mut()?
+            .__ipow__(extract_or_return_not_implemented!(other))
+            .convert(py)?;
         ffi::Py_INCREF(slf);
         Ok::<_, PyErr>(slf)
     })
diff --git a/src/test_hygiene/pymethods.rs b/src/test_hygiene/pymethods.rs
index 832e72396d3..fdd2f2b8223 100644
--- a/src/test_hygiene/pymethods.rs
+++ b/src/test_hygiene/pymethods.rs
@@ -9,6 +9,7 @@ pub struct Dummy;
 #[pyo3(crate = "crate")]
 pub struct DummyIter;
 
+#[cfg(Py_3_8)]
 #[crate::pymethods]
 #[pyo3(crate = "crate")]
 impl Dummy {
@@ -401,3 +402,396 @@ impl Dummy {
     // PyGcProtocol
     // Buffer protocol?
 }
+
+#[cfg(not(Py_3_8))]
+#[crate::pymethods]
+#[pyo3(crate = "crate")]
+impl Dummy {
+    //////////////////////
+    // Basic customization
+    //////////////////////
+    fn __repr__(&self) -> &'static str {
+        "Dummy"
+    }
+
+    fn __str__(&self) -> &'static str {
+        "Dummy"
+    }
+
+    fn __bytes__<'py>(&self, py: crate::Python<'py>) -> &'py crate::types::PyBytes {
+        crate::types::PyBytes::new(py, &[0])
+    }
+
+    fn __format__(&self, format_spec: ::std::string::String) -> ::std::string::String {
+        ::std::panic!("unimplemented isn't hygienic before 1.50")
+    }
+
+    fn __lt__(&self, other: &Self) -> bool {
+        false
+    }
+
+    fn __le__(&self, other: &Self) -> bool {
+        false
+    }
+    fn __eq__(&self, other: &Self) -> bool {
+        false
+    }
+    fn __ne__(&self, other: &Self) -> bool {
+        false
+    }
+    fn __gt__(&self, other: &Self) -> bool {
+        false
+    }
+    fn __ge__(&self, other: &Self) -> bool {
+        false
+    }
+
+    fn __hash__(&self) -> u64 {
+        42
+    }
+
+    fn __bool__(&self) -> bool {
+        true
+    }
+
+    //////////////////////
+    // Customizing attribute access
+    //////////////////////
+
+    fn __getattr__(&self, name: ::std::string::String) -> &crate::PyAny {
+        ::std::panic!("unimplemented isn't hygienic before 1.50")
+    }
+
+    fn __getattribute__(&self, name: ::std::string::String) -> &crate::PyAny {
+        ::std::panic!("unimplemented isn't hygienic before 1.50")
+    }
+
+    fn __setattr__(&mut self, name: ::std::string::String, value: ::std::string::String) {}
+
+    fn __delattr__(&mut self, name: ::std::string::String) {}
+
+    fn __dir__<'py>(&self, py: crate::Python<'py>) -> &'py crate::types::PyList {
+        crate::types::PyList::new(py, ::std::vec![0_u8])
+    }
+
+    //////////////////////
+    // Implementing Descriptors
+    //////////////////////
+
+    fn __get__(
+        &self,
+        instance: &crate::PyAny,
+        owner: &crate::PyAny,
+    ) -> crate::PyResult<&crate::PyAny> {
+        ::std::panic!("unimplemented isn't hygienic before 1.50")
+    }
+
+    fn __set__(&self, instance: &crate::PyAny, owner: &crate::PyAny) {}
+
+    fn __delete__(&self, instance: &crate::PyAny) {}
+
+    fn __set_name__(&self, owner: &crate::PyAny, name: &crate::PyAny) {}
+
+    //////////////////////
+    // Implementing Descriptors
+    //////////////////////
+
+    fn __len__(&self) -> usize {
+        0
+    }
+
+    fn __getitem__(&self, key: u32) -> crate::PyResult<u32> {
+        ::std::result::Result::Err(crate::exceptions::PyKeyError::new_err("boo"))
+    }
+
+    fn __setitem__(&self, key: u32, value: u32) {}
+
+    fn __delitem__(&self, key: u32) {}
+
+    fn __iter__(_: crate::pycell::PyRef<Self>, py: crate::Python) -> crate::Py<DummyIter> {
+        crate::Py::new(py, DummyIter {}).unwrap()
+    }
+
+    fn __next__(&mut self) -> ::std::option::Option<()> {
+        ::std::option::Option::None
+    }
+
+    fn __reversed__(slf: crate::pycell::PyRef<Self>, py: crate::Python) -> crate::Py<DummyIter> {
+        crate::Py::new(py, DummyIter {}).unwrap()
+    }
+
+    fn __contains__(&self, item: u32) -> bool {
+        false
+    }
+
+    //////////////////////
+    // Emulating numeric types
+    //////////////////////
+
+    fn __add__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __sub__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __mul__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __truediv__(&self, _other: &Self) -> crate::PyResult<()> {
+        ::std::result::Result::Err(crate::exceptions::PyZeroDivisionError::new_err("boo"))
+    }
+
+    fn __floordiv__(&self, _other: &Self) -> crate::PyResult<()> {
+        ::std::result::Result::Err(crate::exceptions::PyZeroDivisionError::new_err("boo"))
+    }
+
+    fn __mod__(&self, _other: &Self) -> u32 {
+        0
+    }
+
+    fn __divmod__(&self, _other: &Self) -> (u32, u32) {
+        (0, 0)
+    }
+
+    fn __pow__(&self, _other: &Self, modulo: ::std::option::Option<i32>) -> Dummy {
+        Dummy {}
+    }
+
+    fn __lshift__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __rshift__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __and__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __xor__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __or__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __radd__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __rrsub__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __rmul__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __rtruediv__(&self, _other: &Self) -> crate::PyResult<()> {
+        ::std::result::Result::Err(crate::exceptions::PyZeroDivisionError::new_err("boo"))
+    }
+
+    fn __rfloordiv__(&self, _other: &Self) -> crate::PyResult<()> {
+        ::std::result::Result::Err(crate::exceptions::PyZeroDivisionError::new_err("boo"))
+    }
+
+    fn __rmod__(&self, _other: &Self) -> u32 {
+        0
+    }
+
+    fn __rdivmod__(&self, _other: &Self) -> (u32, u32) {
+        (0, 0)
+    }
+
+    fn __rpow__(&self, _other: &Self, modulo: ::std::option::Option<i32>) -> Dummy {
+        Dummy {}
+    }
+
+    fn __rlshift__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __rrshift__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __rand__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __rxor__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __ror__(&self, other: &Self) -> Dummy {
+        Dummy {}
+    }
+
+    fn __iadd__(&mut self, other: &Self) {}
+
+    fn __irsub__(&mut self, other: &Self) {}
+
+    fn __imul__(&mut self, other: &Self) {}
+
+    fn __itruediv__(&mut self, _other: &Self) {}
+
+    fn __ifloordiv__(&mut self, _other: &Self) {}
+
+    fn __imod__(&mut self, _other: &Self) {}
+
+    fn __ipow__(&mut self, _other: &Self) {}
+    fn __ilshift__(&mut self, other: &Self) {}
+
+    fn __irshift__(&mut self, other: &Self) {}
+
+    fn __iand__(&mut self, other: &Self) {}
+
+    fn __ixor__(&mut self, other: &Self) {}
+
+    fn __ior__(&mut self, other: &Self) {}
+
+    fn __neg__(slf: crate::pycell::PyRef<Self>) -> crate::pycell::PyRef<Self> {
+        slf
+    }
+
+    fn __pos__(slf: crate::pycell::PyRef<Self>) -> crate::pycell::PyRef<Self> {
+        slf
+    }
+
+    fn __abs__(slf: crate::pycell::PyRef<Self>) -> crate::pycell::PyRef<Self> {
+        slf
+    }
+
+    fn __invert__(slf: crate::pycell::PyRef<Self>) -> crate::pycell::PyRef<Self> {
+        slf
+    }
+
+    fn __complex__<'py>(&self, py: crate::Python<'py>) -> &'py crate::types::PyComplex {
+        crate::types::PyComplex::from_doubles(py, 0.0, 0.0)
+    }
+
+    fn __int__(&self) -> u32 {
+        0
+    }
+
+    fn __float__(&self) -> f64 {
+        0.0
+    }
+
+    fn __index__(&self) -> u32 {
+        0
+    }
+
+    fn __round__(&self, ndigits: ::std::option::Option<u32>) -> u32 {
+        0
+    }
+
+    fn __trunc__(&self) -> u32 {
+        0
+    }
+
+    fn __floor__(&self) -> u32 {
+        0
+    }
+
+    fn __ceil__(&self) -> u32 {
+        0
+    }
+
+    //////////////////////
+    // With Statement Context Managers
+    //////////////////////
+
+    fn __enter__(&mut self) {}
+
+    fn __exit__(
+        &mut self,
+        exc_type: &crate::PyAny,
+        exc_value: &crate::PyAny,
+        traceback: &crate::PyAny,
+    ) {
+    }
+
+    //////////////////////
+    // Awaitable Objects
+    //////////////////////
+
+    fn __await__(slf: crate::pycell::PyRef<Self>) -> crate::pycell::PyRef<Self> {
+        slf
+    }
+
+    //////////////////////
+
+    // Asynchronous Iterators
+    //////////////////////
+
+    fn __aiter__(slf: crate::pycell::PyRef<Self>, py: crate::Python) -> crate::Py<DummyIter> {
+        crate::Py::new(py, DummyIter {}).unwrap()
+    }
+
+    fn __anext__(&mut self) -> ::std::option::Option<()> {
+        ::std::option::Option::None
+    }
+
+    //////////////////////
+    // Asynchronous Context Managers
+    //////////////////////
+
+    fn __aenter__(&mut self) {}
+
+    fn __aexit__(
+        &mut self,
+        exc_type: &crate::PyAny,
+        exc_value: &crate::PyAny,
+        traceback: &crate::PyAny,
+    ) {
+    }
+
+    // Things with attributes
+
+    #[args(x = "1", "*", _z = "2")]
+    fn test(&self, _y: &Dummy, _z: i32) {}
+    #[staticmethod]
+    fn staticmethod() {}
+    #[classmethod]
+    fn clsmethod(_: &crate::types::PyType) {}
+    #[args(args = "*", kwds = "**")]
+    fn __call__(
+        &self,
+        _args: &crate::types::PyTuple,
+        _kwds: ::std::option::Option<&crate::types::PyDict>,
+    ) -> crate::PyResult<i32> {
+        ::std::panic!("unimplemented isn't hygienic before 1.50")
+    }
+    #[new]
+    fn new(a: u8) -> Self {
+        Dummy {}
+    }
+    #[getter]
+    fn get(&self) -> i32 {
+        0
+    }
+    #[setter]
+    fn set(&mut self, _v: i32) {}
+    #[classattr]
+    fn class_attr() -> i32 {
+        0
+    }
+
+    // Dunder methods invented for protocols
+
+    fn __richcmp__(
+        &self,
+        other: &Self,
+        op: crate::class::basic::CompareOp,
+    ) -> crate::PyResult<bool> {
+        ::std::result::Result::Ok(false)
+    }
+    // PyGcProtocol
+    // Buffer protocol?
+}
diff --git a/tests/test_arithmetics.rs b/tests/test_arithmetics.rs
index 5d9e2b1a316..7f317407a64 100644
--- a/tests/test_arithmetics.rs
+++ b/tests/test_arithmetics.rs
@@ -57,6 +57,51 @@ struct InPlaceOperations {
     value: u32,
 }
 
+#[cfg(Py_3_8)]
+#[pymethods]
+impl InPlaceOperations {
+    fn __repr__(&self) -> String {
+        format!("IPO({:?})", self.value)
+    }
+
+    fn __iadd__(&mut self, other: u32) {
+        self.value += other;
+    }
+
+    fn __isub__(&mut self, other: u32) {
+        self.value -= other;
+    }
+
+    fn __imul__(&mut self, other: u32) {
+        self.value *= other;
+    }
+
+    fn __ilshift__(&mut self, other: u32) {
+        self.value <<= other;
+    }
+
+    fn __irshift__(&mut self, other: u32) {
+        self.value >>= other;
+    }
+
+    fn __iand__(&mut self, other: u32) {
+        self.value &= other;
+    }
+
+    fn __ixor__(&mut self, other: u32) {
+        self.value ^= other;
+    }
+
+    fn __ior__(&mut self, other: u32) {
+        self.value |= other;
+    }
+
+    fn __ipow__(&mut self, other: u32, _modulo: Option<u32>) {
+        self.value = self.value.pow(other);
+    }
+}
+
+#[cfg(not(Py_3_8))]
 #[pymethods]
 impl InPlaceOperations {
     fn __repr__(&self) -> String {
@@ -505,6 +550,77 @@ mod return_not_implemented {
     #[pyclass]
     struct RichComparisonToSelf {}
 
+    #[cfg(Py_3_8)]
+    #[pymethods]
+    impl RichComparisonToSelf {
+        fn __repr__(&self) -> &'static str {
+            "RC_Self"
+        }
+
+        fn __richcmp__(&self, other: PyRef<Self>, _op: CompareOp) -> PyObject {
+            other.py().None()
+        }
+
+        fn __add__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+        fn __sub__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+        fn __mul__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+        fn __matmul__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+        fn __truediv__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+        fn __floordiv__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+        fn __mod__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+        fn __pow__(slf: PyRef<Self>, _other: u8, _modulo: Option<u8>) -> PyRef<Self> {
+            slf
+        }
+        fn __lshift__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+        fn __rshift__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+        fn __divmod__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+        fn __and__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+        fn __or__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+        fn __xor__<'p>(slf: PyRef<'p, Self>, _other: PyRef<'p, Self>) -> PyRef<'p, Self> {
+            slf
+        }
+
+        // Inplace assignments
+        fn __iadd__(&mut self, _other: PyRef<Self>) {}
+        fn __isub__(&mut self, _other: PyRef<Self>) {}
+        fn __imul__(&mut self, _other: PyRef<Self>) {}
+        fn __imatmul__(&mut self, _other: PyRef<Self>) {}
+        fn __itruediv__(&mut self, _other: PyRef<Self>) {}
+        fn __ifloordiv__(&mut self, _other: PyRef<Self>) {}
+        fn __imod__(&mut self, _other: PyRef<Self>) {}
+        fn __ilshift__(&mut self, _other: PyRef<Self>) {}
+        fn __irshift__(&mut self, _other: PyRef<Self>) {}
+        fn __iand__(&mut self, _other: PyRef<Self>) {}
+        fn __ior__(&mut self, _other: PyRef<Self>) {}
+        fn __ixor__(&mut self, _other: PyRef<Self>) {}
+        fn __ipow__(&mut self, _other: PyRef<Self>, _modulo: Option<u8>) {}
+    }
+
+    #[cfg(not(Py_3_8))]
     #[pymethods]
     impl RichComparisonToSelf {
         fn __repr__(&self) -> &'static str {
@@ -566,12 +682,12 @@ mod return_not_implemented {
         fn __itruediv__(&mut self, _other: PyRef<Self>) {}
         fn __ifloordiv__(&mut self, _other: PyRef<Self>) {}
         fn __imod__(&mut self, _other: PyRef<Self>) {}
-        fn __ipow__(&mut self, _other: PyRef<Self>) {}
         fn __ilshift__(&mut self, _other: PyRef<Self>) {}
         fn __irshift__(&mut self, _other: PyRef<Self>) {}
         fn __iand__(&mut self, _other: PyRef<Self>) {}
         fn __ior__(&mut self, _other: PyRef<Self>) {}
         fn __ixor__(&mut self, _other: PyRef<Self>) {}
+        fn __ipow__(&mut self, _other: PyRef<Self>) {}
     }
 
     fn _test_binary_dunder(dunder: &str) {
diff --git a/tests/test_arithmetics_protos.rs b/tests/test_arithmetics_protos.rs
index b57c5f49268..02ff0173516 100644
--- a/tests/test_arithmetics_protos.rs
+++ b/tests/test_arithmetics_protos.rs
@@ -74,6 +74,7 @@ impl PyObjectProtocol for InPlaceOperations {
     }
 }
 
+#[cfg(not(Py_3_8))]
 #[pyproto]
 impl PyNumberProtocol for InPlaceOperations {
     fn __iadd__(&mut self, other: u32) {
@@ -113,6 +114,45 @@ impl PyNumberProtocol for InPlaceOperations {
     }
 }
 
+#[cfg(Py_3_8)]
+#[pyproto]
+impl PyNumberProtocol for InPlaceOperations {
+    fn __iadd__(&mut self, other: u32) {
+        self.value += other;
+    }
+
+    fn __isub__(&mut self, other: u32) {
+        self.value -= other;
+    }
+
+    fn __imul__(&mut self, other: u32) {
+        self.value *= other;
+    }
+
+    fn __ilshift__(&mut self, other: u32) {
+        self.value <<= other;
+    }
+
+    fn __irshift__(&mut self, other: u32) {
+        self.value >>= other;
+    }
+
+    fn __iand__(&mut self, other: u32) {
+        self.value &= other;
+    }
+
+    fn __ixor__(&mut self, other: u32) {
+        self.value ^= other;
+    }
+
+    fn __ior__(&mut self, other: u32) {
+        self.value |= other;
+    }
+
+    fn __ipow__(&mut self, other: u32, _modulo: Option<u32>) {
+        self.value = self.value.pow(other);
+    }
+}
 #[test]
 fn inplace_operations() {
     let gil = Python::acquire_gil();
@@ -536,6 +576,69 @@ mod return_not_implemented {
         }
     }
 
+    #[cfg(Py_3_8)]
+    #[pyproto]
+    impl<'p> PyNumberProtocol<'p> for RichComparisonToSelf {
+        fn __add__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+        fn __sub__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+        fn __mul__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+        fn __matmul__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+        fn __truediv__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+        fn __floordiv__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+        fn __mod__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+        fn __pow__(lhs: &'p PyAny, _other: u8, _modulo: Option<u8>) -> &'p PyAny {
+            lhs
+        }
+        fn __lshift__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+        fn __rshift__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+        fn __divmod__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+        fn __and__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+        fn __or__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+        fn __xor__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
+            lhs
+        }
+
+        // Inplace assignments
+        fn __iadd__(&'p mut self, _other: PyRef<'p, Self>) {}
+        fn __isub__(&'p mut self, _other: PyRef<'p, Self>) {}
+        fn __imul__(&'p mut self, _other: PyRef<'p, Self>) {}
+        fn __imatmul__(&'p mut self, _other: PyRef<'p, Self>) {}
+        fn __itruediv__(&'p mut self, _other: PyRef<'p, Self>) {}
+        fn __ifloordiv__(&'p mut self, _other: PyRef<'p, Self>) {}
+        fn __imod__(&'p mut self, _other: PyRef<'p, Self>) {}
+        fn __ipow__(&'p mut self, _other: PyRef<'p, Self>, _modulo: Option<u8>) {}
+        fn __ilshift__(&'p mut self, _other: PyRef<'p, Self>) {}
+        fn __irshift__(&'p mut self, _other: PyRef<'p, Self>) {}
+        fn __iand__(&'p mut self, _other: PyRef<'p, Self>) {}
+        fn __ior__(&'p mut self, _other: PyRef<'p, Self>) {}
+        fn __ixor__(&'p mut self, _other: PyRef<'p, Self>) {}
+    }
+
+    #[cfg(not(Py_3_8))]
     #[pyproto]
     impl<'p> PyNumberProtocol<'p> for RichComparisonToSelf {
         fn __add__(lhs: &'p PyAny, _other: PyRef<'p, Self>) -> &'p PyAny {
diff --git a/tests/test_compile_error.rs b/tests/test_compile_error.rs
index daade52d8c6..9801f97a1a3 100644
--- a/tests/test_compile_error.rs
+++ b/tests/test_compile_error.rs
@@ -30,6 +30,7 @@ fn _test_compile_errors() {
     t.compile_fail("tests/ui/missing_clone.rs");
     t.compile_fail("tests/ui/reject_generics.rs");
     t.compile_fail("tests/ui/not_send.rs");
+    t.compile_fail("tests/ui/invalid_pymethod_proto_args.rs");
 
     tests_rust_1_49(&t);
     tests_rust_1_55(&t);
diff --git a/tests/ui/invalid_pymethod_proto_args.rs b/tests/ui/invalid_pymethod_proto_args.rs
new file mode 100644
index 00000000000..3c3e96ab3b6
--- /dev/null
+++ b/tests/ui/invalid_pymethod_proto_args.rs
@@ -0,0 +1,13 @@
+use pyo3::prelude::*;
+
+#[pyclass]
+struct MyClass {}
+
+#[pymethods]
+impl MyClass {
+    fn __truediv__(&self) -> PyResult<()> {
+        Ok(())
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_pymethod_proto_args.stderr b/tests/ui/invalid_pymethod_proto_args.stderr
new file mode 100644
index 00000000000..04d77c76308
--- /dev/null
+++ b/tests/ui/invalid_pymethod_proto_args.stderr
@@ -0,0 +1,5 @@
+error: Expected 1 arguments, got 0
+ --> tests/ui/invalid_pymethod_proto_args.rs:8:8
+  |
+8 |     fn __truediv__(&self) -> PyResult<()> {
+  |        ^^^^^^^^^^^