Introspection: simplify code by leveraging that building type hint for containers now work

Author: Tpt

pyo3-macros-backend/src/introspection.rs

@@ -332,34 +332,12 @@ fn argument_introspection_data<'a>(
         params.insert("annotation", IntrospectionNode::String(annotation.into()));
     } else if desc.from_py_with.is_none() {
         // If from_py_with is set we don't know anything on the input type
-        if let Some(ty) = desc.option_wrapped_type {
-            // Special case to properly generate a `T | None` annotation
-            let mut ty = ty.clone();
-            if let Some(class_type) = class_type {
-                replace_self(&mut ty, class_type);
-            }
-            elide_lifetimes(&mut ty);
-            params.insert(
-                "annotation",
-                IntrospectionNode::InputType {
-                    rust_type: ty,
-                    nullable: true,
-                },
-            );
-        } else {
-            let mut ty = desc.ty.clone();
-            if let Some(class_type) = class_type {
-                replace_self(&mut ty, class_type);
-            }
-            elide_lifetimes(&mut ty);
-            params.insert(
-                "annotation",
-                IntrospectionNode::InputType {
-                    rust_type: ty,
-                    nullable: false,
-                },
-            );
+        let mut ty = desc.ty.clone();
+        if let Some(class_type) = class_type {
+            replace_self(&mut ty, class_type);
         }
+        elide_lifetimes(&mut ty);
+        params.insert("annotation", IntrospectionNode::InputType(ty));
     }
     IntrospectionNode::Map(params).into()
 }
@@ -368,7 +346,7 @@ enum IntrospectionNode<'a> {
     String(Cow<'a, str>),
     Bool(bool),
     IntrospectionId(Option<Cow<'a, Type>>),
-    InputType { rust_type: Type, nullable: bool },
+    InputType(Type),
     OutputType { rust_type: Type, is_final: bool },
     ConstantType(PythonIdentifier),
     Map(HashMap<&'static str, IntrospectionNode<'a>>),
@@ -404,11 +382,8 @@ impl IntrospectionNode<'_> {
                 });
                 content.push_str("\"");
             }
-            Self::InputType {
-                rust_type,
-                nullable,
-            } => {
-                let mut annotation = quote! {
+            Self::InputType(rust_type) => {
+                let annotation = quote! {
                     <#rust_type as #pyo3_crate_path::impl_::extract_argument::PyFunctionArgument<
                         {
                             #[allow(unused_imports, reason = "`Probe` trait used on negative case only")]
@@ -417,9 +392,6 @@ impl IntrospectionNode<'_> {
                         }
                     >>::INPUT_TYPE
                 };
-                if nullable {
-                    annotation = quote! { #pyo3_crate_path::inspect::TypeHint::union(&[#annotation, #pyo3_crate_path::inspect::TypeHint::builtin("None")]) };
-                }
                 content.push_tokens(serialize_type_hint(annotation, pyo3_crate_path));
             }
             Self::OutputType {

src/conversions/std/option.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
 use crate::{
     conversion::IntoPyObject, types::any::PyAnyMethods, BoundObject, FromPyObject, PyAny, Python,
 };
@@ -10,6 +12,8 @@ where
     type Target = PyAny;
     type Output = Bound<'py, Self::Target>;
     type Error = T::Error;
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = TypeHint::union(&[T::OUTPUT_TYPE, TypeHint::builtin("None")]);
 
     fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         self.map_or_else(
@@ -30,6 +34,8 @@ where
     type Target = PyAny;
     type Output = Bound<'py, Self::Target>;
     type Error = <&'a T as IntoPyObject<'py>>::Error;
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = <Option<&T> as IntoPyObject<'_>>::OUTPUT_TYPE;
 
     #[inline]
     fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
@@ -42,6 +48,8 @@ where
     T: FromPyObject<'a, 'py>,
 {
     type Error = T::Error;
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = TypeHint::union(&[T::INPUT_TYPE, TypeHint::builtin("None")]);
 
     fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
         if obj.is_none() {

src/impl_/extract_argument.rs

@@ -108,10 +108,7 @@ where
     type Error = T::Error;
 
     #[cfg(feature = "experimental-inspect")]
-    const INPUT_TYPE: TypeHint = TypeHint::union(&[
-        TypeHint::module_attr("typing", "Any"),
-        TypeHint::builtin("None"),
-    ]);
+    const INPUT_TYPE: TypeHint = TypeHint::union(&[T::INPUT_TYPE, TypeHint::builtin("None")]);
 
     #[inline]
     fn extract(