PyO3 · davidhewitt · Nov 20, 2021 · Nov 19, 2021
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -14,6 +14,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Update `indoc` optional dependency to 1.0. [#2004](https://github.com/PyO3/pyo3/pull/2004)
 - Update `paste` optional dependency to 1.0. [#2004](https://github.com/PyO3/pyo3/pull/2004)
 
+## Removed
+
+- Remove all functionality deprecated in PyO3 0.14. [#2007](https://github.com/PyO3/pyo3/pull/2007)
+
 ## [0.15.1] - 2021-11-19
 
 ### Added

diff --git a/guide/src/class.md b/guide/src/class.md
@@ -865,7 +865,6 @@ impl pyo3::class::impl_::PyClassImpl for MyClass {
         visitor(collector.py_class_descriptors());
         visitor(collector.object_protocol_methods());
         visitor(collector.async_protocol_methods());
-        visitor(collector.context_protocol_methods());
         visitor(collector.descr_protocol_methods());
         visitor(collector.mapping_protocol_methods());
         visitor(collector.number_protocol_methods());

diff --git a/pyo3-macros-backend/src/attributes.rs b/pyo3-macros-backend/src/attributes.rs
@@ -1,13 +1,10 @@
 use syn::{
     parse::{Parse, ParseStream},
     punctuated::Punctuated,
-    spanned::Spanned,
     token::Comma,
     Attribute, ExprPath, Ident, LitStr, Result, Token,
 };
 
-use crate::deprecations::{Deprecation, Deprecations};
-
 pub mod kw {
     syn::custom_keyword!(annotation);
     syn::custom_keyword!(attribute);
@@ -113,66 +110,3 @@ pub fn take_pyo3_options<T: Parse>(attrs: &mut Vec<syn::Attribute>) -> Result<Ve
     })?;
     Ok(out)
 }
-
-pub fn get_deprecated_name_attribute(
-    attr: &syn::Attribute,
-    deprecations: &mut Deprecations,
-) -> syn::Result<Option<NameAttribute>> {
-    match attr.parse_meta() {
-        Ok(syn::Meta::NameValue(syn::MetaNameValue {
-            path,
-            lit: syn::Lit::Str(s),
-            ..
-        })) if path.is_ident("name") => {
-            deprecations.push(Deprecation::NameAttribute, attr.span());
-            Ok(Some(NameAttribute(s.parse()?)))
-        }
-        _ => Ok(None),
-    }
-}
-
-pub fn get_deprecated_text_signature_attribute(
-    attr: &syn::Attribute,
-    deprecations: &mut Deprecations,
-) -> syn::Result<Option<TextSignatureAttribute>> {
-    match attr.parse_meta() {
-        Ok(syn::Meta::NameValue(syn::MetaNameValue {
-            path,
-            lit: syn::Lit::Str(lit),
-            ..
-        })) if path.is_ident("text_signature") => {
-            let text_signature = TextSignatureAttribute {
-                kw: syn::parse_quote!(text_signature),
-                eq_token: syn::parse_quote!(=),
-                lit,
-            };
-            deprecations.push(
-                crate::deprecations::Deprecation::TextSignatureAttribute,
-                attr.span(),
-            );
-            Ok(Some(text_signature))
-        }
-        _ => Ok(None),
-    }
-}
-
-pub fn take_deprecated_text_signature_attribute(
-    attrs: &mut Vec<syn::Attribute>,
-    deprecations: &mut Deprecations,
-) -> syn::Result<Option<TextSignatureAttribute>> {
-    let mut text_signature = None;
-    let mut attrs_out = Vec::with_capacity(attrs.len());
-    for attr in attrs.drain(..) {
-        if let Some(value) = get_deprecated_text_signature_attribute(&attr, deprecations)? {
-            ensure_spanned!(
-                text_signature.is_none(),
-                attr.span() => "text_signature attribute already specified previously"
-            );
-            text_signature = Some(value);
-        } else {
-            attrs_out.push(attr);
-        }
-    }
-    *attrs = attrs_out;
-    Ok(text_signature)
-}
diff --git a/pyo3-macros-backend/src/defs.rs b/pyo3-macros-backend/src/defs.rs
@@ -107,13 +107,6 @@ impl PyMethod {
             can_coexist: true,
         }
     }
-    const fn new(name: &'static str, proto: &'static str) -> Self {
-        PyMethod {
-            name,
-            proto,
-            can_coexist: false,
-        }
-    }
 }
 
 /// Represents a slot definition.
@@ -156,20 +149,13 @@ pub const OBJECT: Proto = Proto {
             .has_self(),
         MethodProto::new("__str__", "PyObjectStrProtocol").has_self(),
         MethodProto::new("__repr__", "PyObjectReprProtocol").has_self(),
-        MethodProto::new("__format__", "PyObjectFormatProtocol")
-            .args(&["Format"])
-            .has_self(),
         MethodProto::new("__hash__", "PyObjectHashProtocol").has_self(),
-        MethodProto::new("__bytes__", "PyObjectBytesProtocol").has_self(),
         MethodProto::new("__richcmp__", "PyObjectRichcmpProtocol")
             .args(&["Other"])
             .has_self(),
         MethodProto::new("__bool__", "PyObjectBoolProtocol").has_self(),
     ],
-    py_methods: &[
-        PyMethod::new("__format__", "FormatProtocolImpl"),
-        PyMethod::new("__bytes__", "BytesProtocolImpl"),
-    ],
+    py_methods: &[],
     slot_defs: &[
         SlotDef::new(&["__str__"], "Py_tp_str", "str"),
         SlotDef::new(&["__repr__"], "Py_tp_repr", "repr"),
@@ -194,15 +180,8 @@ pub const ASYNC: Proto = Proto {
         MethodProto::new("__await__", "PyAsyncAwaitProtocol").args(&["Receiver"]),
         MethodProto::new("__aiter__", "PyAsyncAiterProtocol").args(&["Receiver"]),
         MethodProto::new("__anext__", "PyAsyncAnextProtocol").args(&["Receiver"]),
-        MethodProto::new("__aenter__", "PyAsyncAenterProtocol").has_self(),
-        MethodProto::new("__aexit__", "PyAsyncAexitProtocol")
-            .args(&["ExcType", "ExcValue", "Traceback"])
-            .has_self(),
-    ],
-    py_methods: &[
-        PyMethod::new("__aenter__", "PyAsyncAenterProtocolImpl"),
-        PyMethod::new("__aexit__", "PyAsyncAexitProtocolImpl"),
     ],
+    py_methods: &[],
     slot_defs: &[
         SlotDef::new(&["__await__"], "Py_am_await", "await_"),
         SlotDef::new(&["__aiter__"], "Py_am_aiter", "aiter"),
@@ -228,22 +207,6 @@ pub const BUFFER: Proto = Proto {
     ],
 };
 
-pub const CONTEXT: Proto = Proto {
-    name: "Context",
-    module: "::pyo3::class::context",
-    methods: &[
-        MethodProto::new("__enter__", "PyContextEnterProtocol").has_self(),
-        MethodProto::new("__exit__", "PyContextExitProtocol")
-            .args(&["ExcType", "ExcValue", "Traceback"])
-            .has_self(),
-    ],
-    py_methods: &[
-        PyMethod::new("__enter__", "PyContextEnterProtocolImpl"),
-        PyMethod::new("__exit__", "PyContextExitProtocolImpl"),
-    ],
-    slot_defs: &[],
-};
-
 pub const GC: Proto = Proto {
     name: "GC",
     module: "::pyo3::class::gc",
@@ -268,17 +231,8 @@ pub const DESCR: Proto = Proto {
     methods: &[
         MethodProto::new("__get__", "PyDescrGetProtocol").args(&["Receiver", "Inst", "Owner"]),
         MethodProto::new("__set__", "PyDescrSetProtocol").args(&["Receiver", "Inst", "Value"]),
-        MethodProto::new("__delete__", "PyDescrDelProtocol")
-            .args(&["Inst"])
-            .has_self(),
-        MethodProto::new("__set_name__", "PyDescrSetNameProtocol")
-            .args(&["Inst"])
-            .has_self(),
-    ],
-    py_methods: &[
-        PyMethod::new("__delete__", "PyDescrDelProtocolImpl"),
-        PyMethod::new("__set_name__", "PyDescrNameProtocolImpl"),
     ],
+    py_methods: &[],
     slot_defs: &[
         SlotDef::new(&["__get__"], "Py_tp_descr_get", "descr_get"),
         SlotDef::new(&["__set__"], "Py_tp_descr_set", "descr_set"),
@@ -313,12 +267,8 @@ pub const MAPPING: Proto = Proto {
         MethodProto::new("__delitem__", "PyMappingDelItemProtocol")
             .args(&["Key"])
             .has_self(),
-        MethodProto::new("__reversed__", "PyMappingReversedProtocol").has_self(),
     ],
-    py_methods: &[PyMethod::new(
-        "__reversed__",
-        "PyMappingReversedProtocolImpl",
-    )],
+    py_methods: &[],
     slot_defs: &[
         SlotDef::new(&["__len__"], "Py_mp_length", "len"),
         SlotDef::new(&["__getitem__"], "Py_mp_subscript", "getitem"),
@@ -492,13 +442,9 @@ pub const NUM: Proto = Proto {
         MethodProto::new("__pos__", "PyNumberPosProtocol").has_self(),
         MethodProto::new("__abs__", "PyNumberAbsProtocol").has_self(),
         MethodProto::new("__invert__", "PyNumberInvertProtocol").has_self(),
-        MethodProto::new("__complex__", "PyNumberComplexProtocol").has_self(),
         MethodProto::new("__int__", "PyNumberIntProtocol").has_self(),
         MethodProto::new("__float__", "PyNumberFloatProtocol").has_self(),
         MethodProto::new("__index__", "PyNumberIndexProtocol").has_self(),
-        MethodProto::new("__round__", "PyNumberRoundProtocol")
-            .args(&["NDigits"])
-            .has_self(),
     ],
     py_methods: &[
         PyMethod::coexist("__radd__", "PyNumberRAddProtocolImpl"),
@@ -515,8 +461,6 @@ pub const NUM: Proto = Proto {
         PyMethod::coexist("__rand__", "PyNumberRAndProtocolImpl"),
         PyMethod::coexist("__rxor__", "PyNumberRXorProtocolImpl"),
         PyMethod::coexist("__ror__", "PyNumberROrProtocolImpl"),
-        PyMethod::new("__complex__", "PyNumberComplexProtocolImpl"),
-        PyMethod::new("__round__", "PyNumberRoundProtocolImpl"),
     ],
     slot_defs: &[
         SlotDef::new(&["__add__", "__radd__"], "Py_nb_add", "add_radd"),

diff --git a/pyo3-macros-backend/src/deprecations.rs b/pyo3-macros-backend/src/deprecations.rs
@@ -2,20 +2,12 @@ use proc_macro2::{Span, TokenStream};
 use quote::{quote_spanned, ToTokens};
 
 pub enum Deprecation {
-    NameAttribute,
-    PyfnNameArgument,
-    PyModuleNameArgument,
-    TextSignatureAttribute,
     CallAttribute,
 }
 
 impl Deprecation {
     fn ident(&self, span: Span) -> syn::Ident {
         let string = match self {
-            Deprecation::NameAttribute => "NAME_ATTRIBUTE",
-            Deprecation::PyfnNameArgument => "PYFN_NAME_ARGUMENT",
-            Deprecation::PyModuleNameArgument => "PYMODULE_NAME_ARGUMENT",
-            Deprecation::TextSignatureAttribute => "TEXT_SIGNATURE_ATTRIBUTE",
             Deprecation::CallAttribute => "CALL_ATTRIBUTE",
         };
         syn::Ident::new(string, span)

diff --git a/pyo3-macros-backend/src/konst.rs b/pyo3-macros-backend/src/konst.rs
@@ -1,10 +1,7 @@
 use std::borrow::Cow;
 
 use crate::{
-    attributes::{
-        self, get_deprecated_name_attribute, get_pyo3_options, is_attribute_ident, take_attributes,
-        NameAttribute,
-    },
+    attributes::{self, get_pyo3_options, is_attribute_ident, take_attributes, NameAttribute},
     deprecations::Deprecations,
 };
 use proc_macro2::{Ident, TokenStream};
@@ -81,11 +78,6 @@ impl ConstAttributes {
                     }
                 }
                 Ok(true)
-            } else if let Some(name) =
-                get_deprecated_name_attribute(attr, &mut attributes.deprecations)?
-            {
-                attributes.set_name(name)?;
-                Ok(true)
             } else {
                 Ok(false)
             }

diff --git a/pyo3-macros-backend/src/module.rs b/pyo3-macros-backend/src/module.rs
@@ -2,15 +2,10 @@
 //! Code generation for the function that initializes a python module and adds classes and function.
 
 use crate::{
-    attributes::{self, take_pyo3_options},
-    deprecations::Deprecations,
+    attributes::{self, is_attribute_ident, take_attributes, take_pyo3_options, NameAttribute},
     pyfunction::{impl_wrap_pyfunction, PyFunctionOptions},
     utils::PythonDoc,
 };
-use crate::{
-    attributes::{is_attribute_ident, take_attributes, NameAttribute},
-    deprecations::Deprecation,
-};
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{
@@ -23,23 +18,11 @@ use syn::{
 
 pub struct PyModuleOptions {
     name: Option<syn::Ident>,
-    deprecations: Deprecations,
 }
 
 impl PyModuleOptions {
-    pub fn from_pymodule_arg_and_attrs(
-        deprecated_pymodule_name_arg: Option<syn::Ident>,
-        attrs: &mut Vec<syn::Attribute>,
-    ) -> Result<Self> {
-        let mut deprecations = Deprecations::new();
-        if let Some(name) = &deprecated_pymodule_name_arg {
-            deprecations.push(Deprecation::PyModuleNameArgument, name.span());
-        }
-
-        let mut options: PyModuleOptions = PyModuleOptions {
-            name: deprecated_pymodule_name_arg,
-            deprecations,
-        };
+    pub fn from_attrs(attrs: &mut Vec<syn::Attribute>) -> Result<Self> {
+        let mut options: PyModuleOptions = PyModuleOptions { name: None };
 
         for option in take_pyo3_options(attrs)? {
             match option {
@@ -65,7 +48,6 @@ impl PyModuleOptions {
 /// module
 pub fn py_init(fnname: &Ident, options: PyModuleOptions, doc: PythonDoc) -> TokenStream {
     let name = options.name.unwrap_or_else(|| fnname.unraw());
-    let deprecations = options.deprecations;
     let cb_name = Ident::new(&format!("PyInit_{}", name), Span::call_site());
 
     quote! {
@@ -79,8 +61,6 @@ pub fn py_init(fnname: &Ident, options: PyModuleOptions, doc: PythonDoc) -> Toke
             static DOC: &str = #doc;
             static MODULE_DEF: ModuleDef = unsafe { ModuleDef::new(NAME, DOC) };
 
-            #deprecations
-
             ::pyo3::callback::handle_panic(|_py| { MODULE_DEF.make_module(_py, #fnname) })
         }
     }
@@ -129,23 +109,10 @@ impl Parse for PyFnArgs {
 
         let _: Comma = input.parse()?;
 
-        let mut deprecated_name_argument = None;
-        if let Ok(lit_str) = input.parse::<syn::LitStr>() {
-            deprecated_name_argument = Some(lit_str);
-            if !input.is_empty() {
-                let _: Comma = input.parse()?;
-            }
-        }
-
-        let mut options: PyFunctionOptions = input.parse()?;
-        if let Some(lit_str) = deprecated_name_argument {
-            options.set_name(NameAttribute(lit_str.parse()?))?;
-            options
-                .deprecations
-                .push(Deprecation::PyfnNameArgument, lit_str.span());
-        }
-
-        Ok(Self { modname, options })
+        Ok(Self {
+            modname,
+            options: input.parse()?,
+        })
     }
 }
 
@@ -167,7 +134,9 @@ fn get_pyfn_attr(attrs: &mut Vec<syn::Attribute>) -> syn::Result<Option<PyFnArgs
     })?;
 
     if let Some(pyfn_args) = &mut pyfn_args {
-        pyfn_args.options.take_pyo3_options(attrs)?;
+        pyfn_args
+            .options
+            .add_attributes(take_pyo3_options(attrs)?)?;
     }
 
     Ok(pyfn_args)