From b81273e9bc48d04f910619f3379041cee1b9f22e Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Mon, 22 May 2023 23:55:39 +0900
Subject: [PATCH 1/2] to_pyo3_ast to return &'py

---
 ast/asdl_rs.py         |   84 +-
 ast/src/gen/to_pyo3.rs | 2374 +++++++++++++++++++---------------------
 ast/src/pyo3.rs        |  129 ++-
 3 files changed, 1294 insertions(+), 1293 deletions(-)

diff --git a/ast/asdl_rs.py b/ast/asdl_rs.py
index 7f0edd26..c61a553e 100755
--- a/ast/asdl_rs.py
+++ b/ast/asdl_rs.py
@@ -300,10 +300,13 @@ def emit_range(self, has_attributes, depth):
 
     def visitModule(self, mod):
         self.emit_attrs(0)
-        self.emit("""
+        self.emit(
+            """
         #[derive(is_macro::Is)]
         pub enum Ast<R=TextRange> {
-        """, 0)
+        """,
+            0,
+        )
         for dfn in mod.dfns:
             rust_name = rust_type_name(dfn.name)
             generics = "" if self.type_info[dfn.name].is_simple else "<R>"
@@ -315,23 +318,29 @@ def visitModule(self, mod):
                 # "ast_" prefix to everywhere seems less useful.
                 self.emit('#[is(name = "module")]', 1)
             self.emit(f"{rust_name}({rust_name}{generics}),", 1)
-        self.emit("""
-        }
-        impl<R> Node for Ast<R> {
-            const NAME: &'static str = "AST";
-            const FIELD_NAMES: &'static [&'static str] = &[];
-        }
-        """, 0)
+        self.emit(
+            """
+            }
+            impl<R> Node for Ast<R> {
+                const NAME: &'static str = "AST";
+                const FIELD_NAMES: &'static [&'static str] = &[];
+            }
+            """,
+            0,
+        )
         for dfn in mod.dfns:
             rust_name = rust_type_name(dfn.name)
             generics = "" if self.type_info[dfn.name].is_simple else "<R>"
-            self.emit(f"""
+            self.emit(
+                f"""
             impl<R> From<{rust_name}{generics}> for Ast<R> {{
                 fn from(node: {rust_name}{generics}) -> Self {{
                     Ast::{rust_name}(node)
                 }}
             }}
-            """, 0)
+            """,
+                0,
+            )
 
         for dfn in mod.dfns:
             self.visit(dfn)
@@ -663,9 +672,7 @@ def visitConstructor(self, cons, type, depth):
 
         cons_type_name = f"{enum_name}{cons.name}"
 
-        self.emit(
-            f"impl<T, U> Foldable<T, U> for {cons_type_name}{apply_t} {{", depth
-        )
+        self.emit(f"impl<T, U> Foldable<T, U> for {cons_type_name}{apply_t} {{", depth)
         self.emit(f"type Mapped = {cons_type_name}{apply_u};", depth + 1)
         self.emit(
             "fn fold<F: Fold<T, TargetU = U> + ?Sized>(self, folder: &mut F) -> Result<Self::Mapped, F::Error> {",
@@ -1097,7 +1104,7 @@ def visitSum(self, sum, type):
             f"""
             impl ToPyo3Ast for crate::generic::{rust_name}{self.generics} {{
                 #[inline]
-                fn to_pyo3_ast(&self, {"_" if simple else ""}py: Python) -> PyResult<Py<PyAny>> {{
+                fn to_pyo3_ast<'py>(&self, {"_" if simple else ""}py: Python<'py>) -> PyResult<&'py PyAny> {{
                     let instance = match &self {{
             """,
             0,
@@ -1130,7 +1137,7 @@ def emit_to_pyo3_with_fields(self, cons, type, name):
             f"""
             impl ToPyo3Ast for crate::{name}{self.generics} {{
                 #[inline]
-                    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {{
+                    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {{
                         let cache = Self::py_type_cache().get().unwrap();
             """,
             0,
@@ -1144,10 +1151,37 @@ def emit_to_pyo3_with_fields(self, cons, type, name):
                 1,
             )
             self.emit(
-                "let instance = cache.0.call1(py, (",
+                """
+                let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+                """,
                 1,
             )
             for field in cons.fields:
+                if field.type == "constant":
+                    self.emit(
+                        f"{rust_field(field.name)}.to_object(py),",
+                        3,
+                    )
+                    continue
+                if field.type == "int":
+                    if field.name == "level":
+                        assert field.opt
+                        self.emit(
+                            f"{rust_field(field.name)}.map_or_else(|| py.None(), |level| level.to_u32().to_object(py)),",
+                            3,
+                        )
+                        continue
+                    if field.name in (
+                        "lineno",
+                        "col_offset",
+                        "end_lineno",
+                        "end_col_offset",
+                    ):
+                        self.emit(
+                            f"{rust_field(field.name)}.to_u32().to_object(py),",
+                            3,
+                        )
+                        continue
                 self.emit(
                     f"{rust_field(field.name)}.to_pyo3_ast(py)?,",
                     3,
@@ -1158,7 +1192,7 @@ def emit_to_pyo3_with_fields(self, cons, type, name):
             )
         else:
             self.emit(
-                "let instance = cache.0.call0(py)?;",
+                "let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;",
                 1,
             )
             self.emit(
@@ -1168,12 +1202,12 @@ def emit_to_pyo3_with_fields(self, cons, type, name):
         if type.value.attributes and self.namespace == "located":
             self.emit(
                 """
-                let cache = ast_key_cache().get().unwrap();
-                instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-                instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+                let cache = ast_cache();
+                instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+                instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
                 if let Some(end) = _range.end {
-                    instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-                    instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+                    instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+                    instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
                 }
                 """,
                 1,
@@ -1858,7 +1892,7 @@ def write_to_pyo3_simple(type_info, f):
             f"""
             impl ToPyo3Ast for crate::generic::{rust_name} {{
                 #[inline]
-                fn to_pyo3_ast(&self, _py: Python) -> PyResult<Py<PyAny>> {{
+                fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {{
                     let cell = match &self {{
             """,
         )
@@ -1869,7 +1903,7 @@ def write_to_pyo3_simple(type_info, f):
         f.write(
             """
                     };
-                    Ok(cell.get().unwrap().1.clone())
+                    Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
                 }
             }
             """,
diff --git a/ast/src/gen/to_pyo3.rs b/ast/src/gen/to_pyo3.rs
index c8a7478f..07c4bb06 100644
--- a/ast/src/gen/to_pyo3.rs
+++ b/ast/src/gen/to_pyo3.rs
@@ -946,30 +946,30 @@ impl<R> Pyo3Node for crate::generic::TypeIgnoreTypeIgnore<R> {
 
 impl ToPyo3Ast for crate::generic::ExprContext {
     #[inline]
-    fn to_pyo3_ast(&self, _py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cell = match &self {
             crate::ExprContext::Load => crate::ExprContextLoad::py_type_cache(),
             crate::ExprContext::Store => crate::ExprContextStore::py_type_cache(),
             crate::ExprContext::Del => crate::ExprContextDel::py_type_cache(),
         };
-        Ok(cell.get().unwrap().1.clone())
+        Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
     }
 }
 
 impl ToPyo3Ast for crate::generic::Boolop {
     #[inline]
-    fn to_pyo3_ast(&self, _py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cell = match &self {
             crate::Boolop::And => crate::BoolopAnd::py_type_cache(),
             crate::Boolop::Or => crate::BoolopOr::py_type_cache(),
         };
-        Ok(cell.get().unwrap().1.clone())
+        Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
     }
 }
 
 impl ToPyo3Ast for crate::generic::Operator {
     #[inline]
-    fn to_pyo3_ast(&self, _py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cell = match &self {
             crate::Operator::Add => crate::OperatorAdd::py_type_cache(),
             crate::Operator::Sub => crate::OperatorSub::py_type_cache(),
@@ -985,26 +985,26 @@ impl ToPyo3Ast for crate::generic::Operator {
             crate::Operator::BitAnd => crate::OperatorBitAnd::py_type_cache(),
             crate::Operator::FloorDiv => crate::OperatorFloorDiv::py_type_cache(),
         };
-        Ok(cell.get().unwrap().1.clone())
+        Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
     }
 }
 
 impl ToPyo3Ast for crate::generic::Unaryop {
     #[inline]
-    fn to_pyo3_ast(&self, _py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cell = match &self {
             crate::Unaryop::Invert => crate::UnaryopInvert::py_type_cache(),
             crate::Unaryop::Not => crate::UnaryopNot::py_type_cache(),
             crate::Unaryop::UAdd => crate::UnaryopUAdd::py_type_cache(),
             crate::Unaryop::USub => crate::UnaryopUSub::py_type_cache(),
         };
-        Ok(cell.get().unwrap().1.clone())
+        Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
     }
 }
 
 impl ToPyo3Ast for crate::generic::Cmpop {
     #[inline]
-    fn to_pyo3_ast(&self, _py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cell = match &self {
             crate::Cmpop::Eq => crate::CmpopEq::py_type_cache(),
             crate::Cmpop::NotEq => crate::CmpopNotEq::py_type_cache(),
@@ -1017,13 +1017,13 @@ impl ToPyo3Ast for crate::generic::Cmpop {
             crate::Cmpop::In => crate::CmpopIn::py_type_cache(),
             crate::Cmpop::NotIn => crate::CmpopNotIn::py_type_cache(),
         };
-        Ok(cell.get().unwrap().1.clone())
+        Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
     }
 }
 
 impl ToPyo3Ast for crate::generic::Mod<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
             crate::Mod::Module(cons) => cons.to_pyo3_ast(py)?,
             crate::Mod::Interactive(cons) => cons.to_pyo3_ast(py)?,
@@ -1036,7 +1036,7 @@ impl ToPyo3Ast for crate::generic::Mod<TextRange> {
 
 impl ToPyo3Ast for crate::ModModule<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1044,9 +1044,9 @@ impl ToPyo3Ast for crate::ModModule<TextRange> {
             type_ignores,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (body.to_pyo3_ast(py)?, type_ignores.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((body.to_pyo3_ast(py)?, type_ignores.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1054,14 +1054,15 @@ impl ToPyo3Ast for crate::ModModule<TextRange> {
 
 impl ToPyo3Ast for crate::ModInteractive<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             body,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (body.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -1069,14 +1070,15 @@ impl ToPyo3Ast for crate::ModInteractive<TextRange> {
 
 impl ToPyo3Ast for crate::ModExpression<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             body,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (body.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -1084,7 +1086,7 @@ impl ToPyo3Ast for crate::ModExpression<TextRange> {
 
 impl ToPyo3Ast for crate::ModFunctionType<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1092,9 +1094,9 @@ impl ToPyo3Ast for crate::ModFunctionType<TextRange> {
             returns,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (argtypes.to_pyo3_ast(py)?, returns.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((argtypes.to_pyo3_ast(py)?, returns.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1102,7 +1104,7 @@ impl ToPyo3Ast for crate::ModFunctionType<TextRange> {
 
 impl ToPyo3Ast for crate::generic::Stmt<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
             crate::Stmt::FunctionDef(cons) => cons.to_pyo3_ast(py)?,
             crate::Stmt::AsyncFunctionDef(cons) => cons.to_pyo3_ast(py)?,
@@ -1138,7 +1140,7 @@ impl ToPyo3Ast for crate::generic::Stmt<TextRange> {
 
 impl ToPyo3Ast for crate::StmtFunctionDef<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1150,17 +1152,15 @@ impl ToPyo3Ast for crate::StmtFunctionDef<TextRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                name.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                decorator_list.to_pyo3_ast(py)?,
-                returns.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_pyo3_ast(py)?,
+            args.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            decorator_list.to_pyo3_ast(py)?,
+            returns.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1168,7 +1168,7 @@ impl ToPyo3Ast for crate::StmtFunctionDef<TextRange> {
 
 impl ToPyo3Ast for crate::StmtAsyncFunctionDef<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1180,17 +1180,15 @@ impl ToPyo3Ast for crate::StmtAsyncFunctionDef<TextRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                name.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                decorator_list.to_pyo3_ast(py)?,
-                returns.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_pyo3_ast(py)?,
+            args.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            decorator_list.to_pyo3_ast(py)?,
+            returns.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1198,7 +1196,7 @@ impl ToPyo3Ast for crate::StmtAsyncFunctionDef<TextRange> {
 
 impl ToPyo3Ast for crate::StmtClassDef<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1209,16 +1207,14 @@ impl ToPyo3Ast for crate::StmtClassDef<TextRange> {
             decorator_list,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                name.to_pyo3_ast(py)?,
-                bases.to_pyo3_ast(py)?,
-                keywords.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                decorator_list.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_pyo3_ast(py)?,
+            bases.to_pyo3_ast(py)?,
+            keywords.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            decorator_list.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1226,14 +1222,15 @@ impl ToPyo3Ast for crate::StmtClassDef<TextRange> {
 
 impl ToPyo3Ast for crate::StmtReturn<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -1241,14 +1238,15 @@ impl ToPyo3Ast for crate::StmtReturn<TextRange> {
 
 impl ToPyo3Ast for crate::StmtDelete<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             targets,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (targets.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((targets.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -1256,7 +1254,7 @@ impl ToPyo3Ast for crate::StmtDelete<TextRange> {
 
 impl ToPyo3Ast for crate::StmtAssign<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1265,14 +1263,12 @@ impl ToPyo3Ast for crate::StmtAssign<TextRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                targets.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            targets.to_pyo3_ast(py)?,
+            value.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1280,7 +1276,7 @@ impl ToPyo3Ast for crate::StmtAssign<TextRange> {
 
 impl ToPyo3Ast for crate::StmtAugAssign<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1289,14 +1285,12 @@ impl ToPyo3Ast for crate::StmtAugAssign<TextRange> {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                op.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_pyo3_ast(py)?,
+            op.to_pyo3_ast(py)?,
+            value.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1304,7 +1298,7 @@ impl ToPyo3Ast for crate::StmtAugAssign<TextRange> {
 
 impl ToPyo3Ast for crate::StmtAnnAssign<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1314,15 +1308,13 @@ impl ToPyo3Ast for crate::StmtAnnAssign<TextRange> {
             simple,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                annotation.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-                simple.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_pyo3_ast(py)?,
+            annotation.to_pyo3_ast(py)?,
+            value.to_pyo3_ast(py)?,
+            simple.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1330,7 +1322,7 @@ impl ToPyo3Ast for crate::StmtAnnAssign<TextRange> {
 
 impl ToPyo3Ast for crate::StmtFor<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1341,16 +1333,14 @@ impl ToPyo3Ast for crate::StmtFor<TextRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                iter.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_pyo3_ast(py)?,
+            iter.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1358,7 +1348,7 @@ impl ToPyo3Ast for crate::StmtFor<TextRange> {
 
 impl ToPyo3Ast for crate::StmtAsyncFor<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1369,16 +1359,14 @@ impl ToPyo3Ast for crate::StmtAsyncFor<TextRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                iter.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_pyo3_ast(py)?,
+            iter.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1386,7 +1374,7 @@ impl ToPyo3Ast for crate::StmtAsyncFor<TextRange> {
 
 impl ToPyo3Ast for crate::StmtWhile<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1395,14 +1383,12 @@ impl ToPyo3Ast for crate::StmtWhile<TextRange> {
             orelse,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                test.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            test.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1410,7 +1396,7 @@ impl ToPyo3Ast for crate::StmtWhile<TextRange> {
 
 impl ToPyo3Ast for crate::StmtIf<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1419,14 +1405,12 @@ impl ToPyo3Ast for crate::StmtIf<TextRange> {
             orelse,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                test.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            test.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1434,7 +1418,7 @@ impl ToPyo3Ast for crate::StmtIf<TextRange> {
 
 impl ToPyo3Ast for crate::StmtWith<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1443,14 +1427,12 @@ impl ToPyo3Ast for crate::StmtWith<TextRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                items.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            items.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1458,7 +1440,7 @@ impl ToPyo3Ast for crate::StmtWith<TextRange> {
 
 impl ToPyo3Ast for crate::StmtAsyncWith<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1467,14 +1449,12 @@ impl ToPyo3Ast for crate::StmtAsyncWith<TextRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                items.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            items.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1482,7 +1462,7 @@ impl ToPyo3Ast for crate::StmtAsyncWith<TextRange> {
 
 impl ToPyo3Ast for crate::StmtMatch<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1490,9 +1470,9 @@ impl ToPyo3Ast for crate::StmtMatch<TextRange> {
             cases,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (subject.to_pyo3_ast(py)?, cases.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((subject.to_pyo3_ast(py)?, cases.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1500,7 +1480,7 @@ impl ToPyo3Ast for crate::StmtMatch<TextRange> {
 
 impl ToPyo3Ast for crate::StmtRaise<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1508,9 +1488,9 @@ impl ToPyo3Ast for crate::StmtRaise<TextRange> {
             cause,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (exc.to_pyo3_ast(py)?, cause.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((exc.to_pyo3_ast(py)?, cause.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1518,7 +1498,7 @@ impl ToPyo3Ast for crate::StmtRaise<TextRange> {
 
 impl ToPyo3Ast for crate::StmtTry<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1528,15 +1508,13 @@ impl ToPyo3Ast for crate::StmtTry<TextRange> {
             finalbody,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                body.to_pyo3_ast(py)?,
-                handlers.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                finalbody.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            body.to_pyo3_ast(py)?,
+            handlers.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+            finalbody.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1544,7 +1522,7 @@ impl ToPyo3Ast for crate::StmtTry<TextRange> {
 
 impl ToPyo3Ast for crate::StmtTryStar<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1554,15 +1532,13 @@ impl ToPyo3Ast for crate::StmtTryStar<TextRange> {
             finalbody,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                body.to_pyo3_ast(py)?,
-                handlers.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                finalbody.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            body.to_pyo3_ast(py)?,
+            handlers.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+            finalbody.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1570,7 +1546,7 @@ impl ToPyo3Ast for crate::StmtTryStar<TextRange> {
 
 impl ToPyo3Ast for crate::StmtAssert<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1578,9 +1554,9 @@ impl ToPyo3Ast for crate::StmtAssert<TextRange> {
             msg,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (test.to_pyo3_ast(py)?, msg.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((test.to_pyo3_ast(py)?, msg.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1588,14 +1564,15 @@ impl ToPyo3Ast for crate::StmtAssert<TextRange> {
 
 impl ToPyo3Ast for crate::StmtImport<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             names,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (names.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -1603,7 +1580,7 @@ impl ToPyo3Ast for crate::StmtImport<TextRange> {
 
 impl ToPyo3Ast for crate::StmtImportFrom<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1612,14 +1589,12 @@ impl ToPyo3Ast for crate::StmtImportFrom<TextRange> {
             level,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                module.to_pyo3_ast(py)?,
-                names.to_pyo3_ast(py)?,
-                level.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            module.to_pyo3_ast(py)?,
+            names.to_pyo3_ast(py)?,
+            level.map_or_else(|| py.None(), |level| level.to_u32().to_object(py)),
+        ))?;
 
         Ok(instance)
     }
@@ -1627,14 +1602,15 @@ impl ToPyo3Ast for crate::StmtImportFrom<TextRange> {
 
 impl ToPyo3Ast for crate::StmtGlobal<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             names,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (names.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -1642,14 +1618,15 @@ impl ToPyo3Ast for crate::StmtGlobal<TextRange> {
 
 impl ToPyo3Ast for crate::StmtNonlocal<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             names,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (names.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -1657,14 +1634,15 @@ impl ToPyo3Ast for crate::StmtNonlocal<TextRange> {
 
 impl ToPyo3Ast for crate::StmtExpr<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -1672,10 +1650,10 @@ impl ToPyo3Ast for crate::StmtExpr<TextRange> {
 
 impl ToPyo3Ast for crate::StmtPass<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
-        let instance = cache.0.call0(py)?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
         let Self { range: _range } = self;
 
         Ok(instance)
@@ -1684,10 +1662,10 @@ impl ToPyo3Ast for crate::StmtPass<TextRange> {
 
 impl ToPyo3Ast for crate::StmtBreak<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
-        let instance = cache.0.call0(py)?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
         let Self { range: _range } = self;
 
         Ok(instance)
@@ -1696,10 +1674,10 @@ impl ToPyo3Ast for crate::StmtBreak<TextRange> {
 
 impl ToPyo3Ast for crate::StmtContinue<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
-        let instance = cache.0.call0(py)?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
         let Self { range: _range } = self;
 
         Ok(instance)
@@ -1708,7 +1686,7 @@ impl ToPyo3Ast for crate::StmtContinue<TextRange> {
 
 impl ToPyo3Ast for crate::generic::Expr<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
             crate::Expr::BoolOp(cons) => cons.to_pyo3_ast(py)?,
             crate::Expr::NamedExpr(cons) => cons.to_pyo3_ast(py)?,
@@ -1744,7 +1722,7 @@ impl ToPyo3Ast for crate::generic::Expr<TextRange> {
 
 impl ToPyo3Ast for crate::ExprBoolOp<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1752,9 +1730,9 @@ impl ToPyo3Ast for crate::ExprBoolOp<TextRange> {
             values,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (op.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((op.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1762,7 +1740,7 @@ impl ToPyo3Ast for crate::ExprBoolOp<TextRange> {
 
 impl ToPyo3Ast for crate::ExprNamedExpr<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1770,9 +1748,9 @@ impl ToPyo3Ast for crate::ExprNamedExpr<TextRange> {
             value,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (target.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((target.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1780,7 +1758,7 @@ impl ToPyo3Ast for crate::ExprNamedExpr<TextRange> {
 
 impl ToPyo3Ast for crate::ExprBinOp<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1789,14 +1767,12 @@ impl ToPyo3Ast for crate::ExprBinOp<TextRange> {
             right,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                left.to_pyo3_ast(py)?,
-                op.to_pyo3_ast(py)?,
-                right.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            left.to_pyo3_ast(py)?,
+            op.to_pyo3_ast(py)?,
+            right.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1804,7 +1780,7 @@ impl ToPyo3Ast for crate::ExprBinOp<TextRange> {
 
 impl ToPyo3Ast for crate::ExprUnaryOp<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1812,9 +1788,9 @@ impl ToPyo3Ast for crate::ExprUnaryOp<TextRange> {
             operand,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (op.to_pyo3_ast(py)?, operand.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((op.to_pyo3_ast(py)?, operand.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1822,7 +1798,7 @@ impl ToPyo3Ast for crate::ExprUnaryOp<TextRange> {
 
 impl ToPyo3Ast for crate::ExprLambda<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1830,9 +1806,9 @@ impl ToPyo3Ast for crate::ExprLambda<TextRange> {
             body,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (args.to_pyo3_ast(py)?, body.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((args.to_pyo3_ast(py)?, body.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1840,7 +1816,7 @@ impl ToPyo3Ast for crate::ExprLambda<TextRange> {
 
 impl ToPyo3Ast for crate::ExprIfExp<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1849,14 +1825,12 @@ impl ToPyo3Ast for crate::ExprIfExp<TextRange> {
             orelse,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                test.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            test.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1864,7 +1838,7 @@ impl ToPyo3Ast for crate::ExprIfExp<TextRange> {
 
 impl ToPyo3Ast for crate::ExprDict<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1872,9 +1846,9 @@ impl ToPyo3Ast for crate::ExprDict<TextRange> {
             values,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (keys.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((keys.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1882,14 +1856,15 @@ impl ToPyo3Ast for crate::ExprDict<TextRange> {
 
 impl ToPyo3Ast for crate::ExprSet<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             elts,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (elts.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -1897,7 +1872,7 @@ impl ToPyo3Ast for crate::ExprSet<TextRange> {
 
 impl ToPyo3Ast for crate::ExprListComp<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1905,9 +1880,9 @@ impl ToPyo3Ast for crate::ExprListComp<TextRange> {
             generators,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1915,7 +1890,7 @@ impl ToPyo3Ast for crate::ExprListComp<TextRange> {
 
 impl ToPyo3Ast for crate::ExprSetComp<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1923,9 +1898,9 @@ impl ToPyo3Ast for crate::ExprSetComp<TextRange> {
             generators,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1933,7 +1908,7 @@ impl ToPyo3Ast for crate::ExprSetComp<TextRange> {
 
 impl ToPyo3Ast for crate::ExprDictComp<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1942,14 +1917,12 @@ impl ToPyo3Ast for crate::ExprDictComp<TextRange> {
             generators,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                key.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-                generators.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            key.to_pyo3_ast(py)?,
+            value.to_pyo3_ast(py)?,
+            generators.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -1957,7 +1930,7 @@ impl ToPyo3Ast for crate::ExprDictComp<TextRange> {
 
 impl ToPyo3Ast for crate::ExprGeneratorExp<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1965,9 +1938,9 @@ impl ToPyo3Ast for crate::ExprGeneratorExp<TextRange> {
             generators,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -1975,14 +1948,15 @@ impl ToPyo3Ast for crate::ExprGeneratorExp<TextRange> {
 
 impl ToPyo3Ast for crate::ExprAwait<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -1990,14 +1964,15 @@ impl ToPyo3Ast for crate::ExprAwait<TextRange> {
 
 impl ToPyo3Ast for crate::ExprYield<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -2005,14 +1980,15 @@ impl ToPyo3Ast for crate::ExprYield<TextRange> {
 
 impl ToPyo3Ast for crate::ExprYieldFrom<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -2020,7 +1996,7 @@ impl ToPyo3Ast for crate::ExprYieldFrom<TextRange> {
 
 impl ToPyo3Ast for crate::ExprCompare<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2029,14 +2005,12 @@ impl ToPyo3Ast for crate::ExprCompare<TextRange> {
             comparators,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                left.to_pyo3_ast(py)?,
-                ops.to_pyo3_ast(py)?,
-                comparators.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            left.to_pyo3_ast(py)?,
+            ops.to_pyo3_ast(py)?,
+            comparators.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2044,7 +2018,7 @@ impl ToPyo3Ast for crate::ExprCompare<TextRange> {
 
 impl ToPyo3Ast for crate::ExprCall<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2053,14 +2027,12 @@ impl ToPyo3Ast for crate::ExprCall<TextRange> {
             keywords,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                func.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                keywords.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            func.to_pyo3_ast(py)?,
+            args.to_pyo3_ast(py)?,
+            keywords.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2068,7 +2040,7 @@ impl ToPyo3Ast for crate::ExprCall<TextRange> {
 
 impl ToPyo3Ast for crate::ExprFormattedValue<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2077,14 +2049,12 @@ impl ToPyo3Ast for crate::ExprFormattedValue<TextRange> {
             format_spec,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                value.to_pyo3_ast(py)?,
-                conversion.to_pyo3_ast(py)?,
-                format_spec.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            value.to_pyo3_ast(py)?,
+            conversion.to_pyo3_ast(py)?,
+            format_spec.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2092,14 +2062,15 @@ impl ToPyo3Ast for crate::ExprFormattedValue<TextRange> {
 
 impl ToPyo3Ast for crate::ExprJoinedStr<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             values,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (values.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((values.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -2107,7 +2078,7 @@ impl ToPyo3Ast for crate::ExprJoinedStr<TextRange> {
 
 impl ToPyo3Ast for crate::ExprConstant<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2115,9 +2086,9 @@ impl ToPyo3Ast for crate::ExprConstant<TextRange> {
             kind,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (value.to_pyo3_ast(py)?, kind.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((value.to_object(py), kind.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -2125,7 +2096,7 @@ impl ToPyo3Ast for crate::ExprConstant<TextRange> {
 
 impl ToPyo3Ast for crate::ExprAttribute<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2134,14 +2105,12 @@ impl ToPyo3Ast for crate::ExprAttribute<TextRange> {
             ctx,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                value.to_pyo3_ast(py)?,
-                attr.to_pyo3_ast(py)?,
-                ctx.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            value.to_pyo3_ast(py)?,
+            attr.to_pyo3_ast(py)?,
+            ctx.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2149,7 +2118,7 @@ impl ToPyo3Ast for crate::ExprAttribute<TextRange> {
 
 impl ToPyo3Ast for crate::ExprSubscript<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2158,14 +2127,12 @@ impl ToPyo3Ast for crate::ExprSubscript<TextRange> {
             ctx,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                value.to_pyo3_ast(py)?,
-                slice.to_pyo3_ast(py)?,
-                ctx.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            value.to_pyo3_ast(py)?,
+            slice.to_pyo3_ast(py)?,
+            ctx.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2173,7 +2140,7 @@ impl ToPyo3Ast for crate::ExprSubscript<TextRange> {
 
 impl ToPyo3Ast for crate::ExprStarred<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2181,9 +2148,9 @@ impl ToPyo3Ast for crate::ExprStarred<TextRange> {
             ctx,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (value.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((value.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -2191,7 +2158,7 @@ impl ToPyo3Ast for crate::ExprStarred<TextRange> {
 
 impl ToPyo3Ast for crate::ExprName<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2199,9 +2166,9 @@ impl ToPyo3Ast for crate::ExprName<TextRange> {
             ctx,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (id.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((id.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -2209,7 +2176,7 @@ impl ToPyo3Ast for crate::ExprName<TextRange> {
 
 impl ToPyo3Ast for crate::ExprList<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2217,9 +2184,9 @@ impl ToPyo3Ast for crate::ExprList<TextRange> {
             ctx,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -2227,7 +2194,7 @@ impl ToPyo3Ast for crate::ExprList<TextRange> {
 
 impl ToPyo3Ast for crate::ExprTuple<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2235,9 +2202,9 @@ impl ToPyo3Ast for crate::ExprTuple<TextRange> {
             ctx,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -2245,7 +2212,7 @@ impl ToPyo3Ast for crate::ExprTuple<TextRange> {
 
 impl ToPyo3Ast for crate::ExprSlice<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2254,14 +2221,12 @@ impl ToPyo3Ast for crate::ExprSlice<TextRange> {
             step,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                lower.to_pyo3_ast(py)?,
-                upper.to_pyo3_ast(py)?,
-                step.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            lower.to_pyo3_ast(py)?,
+            upper.to_pyo3_ast(py)?,
+            step.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2269,7 +2234,7 @@ impl ToPyo3Ast for crate::ExprSlice<TextRange> {
 
 impl ToPyo3Ast for crate::Comprehension<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2279,15 +2244,13 @@ impl ToPyo3Ast for crate::Comprehension<TextRange> {
             is_async,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                iter.to_pyo3_ast(py)?,
-                ifs.to_pyo3_ast(py)?,
-                is_async.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_pyo3_ast(py)?,
+            iter.to_pyo3_ast(py)?,
+            ifs.to_pyo3_ast(py)?,
+            is_async.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2295,7 +2258,7 @@ impl ToPyo3Ast for crate::Comprehension<TextRange> {
 
 impl ToPyo3Ast for crate::generic::Excepthandler<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
             crate::Excepthandler::ExceptHandler(cons) => cons.to_pyo3_ast(py)?,
         };
@@ -2305,7 +2268,7 @@ impl ToPyo3Ast for crate::generic::Excepthandler<TextRange> {
 
 impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2314,14 +2277,12 @@ impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<TextRange> {
             body,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                type_.to_pyo3_ast(py)?,
-                name.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            type_.to_pyo3_ast(py)?,
+            name.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2329,7 +2290,7 @@ impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<TextRange> {
 
 impl ToPyo3Ast for crate::Arguments<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2342,18 +2303,16 @@ impl ToPyo3Ast for crate::Arguments<TextRange> {
             defaults,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                posonlyargs.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                vararg.to_pyo3_ast(py)?,
-                kwonlyargs.to_pyo3_ast(py)?,
-                kw_defaults.to_pyo3_ast(py)?,
-                kwarg.to_pyo3_ast(py)?,
-                defaults.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            posonlyargs.to_pyo3_ast(py)?,
+            args.to_pyo3_ast(py)?,
+            vararg.to_pyo3_ast(py)?,
+            kwonlyargs.to_pyo3_ast(py)?,
+            kw_defaults.to_pyo3_ast(py)?,
+            kwarg.to_pyo3_ast(py)?,
+            defaults.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2361,7 +2320,7 @@ impl ToPyo3Ast for crate::Arguments<TextRange> {
 
 impl ToPyo3Ast for crate::Arg<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2370,14 +2329,12 @@ impl ToPyo3Ast for crate::Arg<TextRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                arg.to_pyo3_ast(py)?,
-                annotation.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            arg.to_pyo3_ast(py)?,
+            annotation.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2385,7 +2342,7 @@ impl ToPyo3Ast for crate::Arg<TextRange> {
 
 impl ToPyo3Ast for crate::Keyword<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2393,9 +2350,9 @@ impl ToPyo3Ast for crate::Keyword<TextRange> {
             value,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (arg.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((arg.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -2403,7 +2360,7 @@ impl ToPyo3Ast for crate::Keyword<TextRange> {
 
 impl ToPyo3Ast for crate::Alias<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2411,9 +2368,9 @@ impl ToPyo3Ast for crate::Alias<TextRange> {
             asname,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (name.to_pyo3_ast(py)?, asname.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((name.to_pyo3_ast(py)?, asname.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -2421,7 +2378,7 @@ impl ToPyo3Ast for crate::Alias<TextRange> {
 
 impl ToPyo3Ast for crate::Withitem<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2429,13 +2386,11 @@ impl ToPyo3Ast for crate::Withitem<TextRange> {
             optional_vars,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                context_expr.to_pyo3_ast(py)?,
-                optional_vars.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            context_expr.to_pyo3_ast(py)?,
+            optional_vars.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2443,7 +2398,7 @@ impl ToPyo3Ast for crate::Withitem<TextRange> {
 
 impl ToPyo3Ast for crate::MatchCase<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2452,14 +2407,12 @@ impl ToPyo3Ast for crate::MatchCase<TextRange> {
             body,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                pattern.to_pyo3_ast(py)?,
-                guard.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            pattern.to_pyo3_ast(py)?,
+            guard.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2467,7 +2420,7 @@ impl ToPyo3Ast for crate::MatchCase<TextRange> {
 
 impl ToPyo3Ast for crate::generic::Pattern<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
             crate::Pattern::MatchValue(cons) => cons.to_pyo3_ast(py)?,
             crate::Pattern::MatchSingleton(cons) => cons.to_pyo3_ast(py)?,
@@ -2484,14 +2437,15 @@ impl ToPyo3Ast for crate::generic::Pattern<TextRange> {
 
 impl ToPyo3Ast for crate::PatternMatchValue<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -2499,14 +2453,15 @@ impl ToPyo3Ast for crate::PatternMatchValue<TextRange> {
 
 impl ToPyo3Ast for crate::PatternMatchSingleton<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_object(py),))?;
 
         Ok(instance)
     }
@@ -2514,14 +2469,15 @@ impl ToPyo3Ast for crate::PatternMatchSingleton<TextRange> {
 
 impl ToPyo3Ast for crate::PatternMatchSequence<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             patterns,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (patterns.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -2529,7 +2485,7 @@ impl ToPyo3Ast for crate::PatternMatchSequence<TextRange> {
 
 impl ToPyo3Ast for crate::PatternMatchMapping<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2538,14 +2494,12 @@ impl ToPyo3Ast for crate::PatternMatchMapping<TextRange> {
             rest,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                keys.to_pyo3_ast(py)?,
-                patterns.to_pyo3_ast(py)?,
-                rest.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            keys.to_pyo3_ast(py)?,
+            patterns.to_pyo3_ast(py)?,
+            rest.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2553,7 +2507,7 @@ impl ToPyo3Ast for crate::PatternMatchMapping<TextRange> {
 
 impl ToPyo3Ast for crate::PatternMatchClass<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2563,15 +2517,13 @@ impl ToPyo3Ast for crate::PatternMatchClass<TextRange> {
             kwd_patterns,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                cls.to_pyo3_ast(py)?,
-                patterns.to_pyo3_ast(py)?,
-                kwd_attrs.to_pyo3_ast(py)?,
-                kwd_patterns.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            cls.to_pyo3_ast(py)?,
+            patterns.to_pyo3_ast(py)?,
+            kwd_attrs.to_pyo3_ast(py)?,
+            kwd_patterns.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -2579,14 +2531,15 @@ impl ToPyo3Ast for crate::PatternMatchClass<TextRange> {
 
 impl ToPyo3Ast for crate::PatternMatchStar<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             name,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (name.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -2594,7 +2547,7 @@ impl ToPyo3Ast for crate::PatternMatchStar<TextRange> {
 
 impl ToPyo3Ast for crate::PatternMatchAs<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2602,9 +2555,9 @@ impl ToPyo3Ast for crate::PatternMatchAs<TextRange> {
             name,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (pattern.to_pyo3_ast(py)?, name.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((pattern.to_pyo3_ast(py)?, name.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -2612,14 +2565,15 @@ impl ToPyo3Ast for crate::PatternMatchAs<TextRange> {
 
 impl ToPyo3Ast for crate::PatternMatchOr<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             patterns,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (patterns.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -2627,7 +2581,7 @@ impl ToPyo3Ast for crate::PatternMatchOr<TextRange> {
 
 impl ToPyo3Ast for crate::generic::TypeIgnore<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
             crate::TypeIgnore::TypeIgnore(cons) => cons.to_pyo3_ast(py)?,
         };
@@ -2637,7 +2591,7 @@ impl ToPyo3Ast for crate::generic::TypeIgnore<TextRange> {
 
 impl ToPyo3Ast for crate::TypeIgnoreTypeIgnore<TextRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2645,9 +2599,9 @@ impl ToPyo3Ast for crate::TypeIgnoreTypeIgnore<TextRange> {
             tag,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (lineno.to_pyo3_ast(py)?, tag.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((lineno.to_u32().to_object(py), tag.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -2655,7 +2609,7 @@ impl ToPyo3Ast for crate::TypeIgnoreTypeIgnore<TextRange> {
 
 impl ToPyo3Ast for crate::generic::Mod<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
             crate::Mod::Module(cons) => cons.to_pyo3_ast(py)?,
             crate::Mod::Interactive(cons) => cons.to_pyo3_ast(py)?,
@@ -2668,7 +2622,7 @@ impl ToPyo3Ast for crate::generic::Mod<SourceRange> {
 
 impl ToPyo3Ast for crate::ModModule<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2676,9 +2630,9 @@ impl ToPyo3Ast for crate::ModModule<SourceRange> {
             type_ignores,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (body.to_pyo3_ast(py)?, type_ignores.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((body.to_pyo3_ast(py)?, type_ignores.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -2686,14 +2640,15 @@ impl ToPyo3Ast for crate::ModModule<SourceRange> {
 
 impl ToPyo3Ast for crate::ModInteractive<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             body,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (body.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -2701,14 +2656,15 @@ impl ToPyo3Ast for crate::ModInteractive<SourceRange> {
 
 impl ToPyo3Ast for crate::ModExpression<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             body,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (body.to_pyo3_ast(py)?,))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_pyo3_ast(py)?,))?;
 
         Ok(instance)
     }
@@ -2716,7 +2672,7 @@ impl ToPyo3Ast for crate::ModExpression<SourceRange> {
 
 impl ToPyo3Ast for crate::ModFunctionType<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2724,9 +2680,9 @@ impl ToPyo3Ast for crate::ModFunctionType<SourceRange> {
             returns,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (argtypes.to_pyo3_ast(py)?, returns.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((argtypes.to_pyo3_ast(py)?, returns.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
@@ -2734,7 +2690,7 @@ impl ToPyo3Ast for crate::ModFunctionType<SourceRange> {
 
 impl ToPyo3Ast for crate::generic::Stmt<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
             crate::Stmt::FunctionDef(cons) => cons.to_pyo3_ast(py)?,
             crate::Stmt::AsyncFunctionDef(cons) => cons.to_pyo3_ast(py)?,
@@ -2770,7 +2726,7 @@ impl ToPyo3Ast for crate::generic::Stmt<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtFunctionDef<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2782,24 +2738,22 @@ impl ToPyo3Ast for crate::StmtFunctionDef<SourceRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                name.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                decorator_list.to_pyo3_ast(py)?,
-                returns.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_pyo3_ast(py)?,
+            args.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            decorator_list.to_pyo3_ast(py)?,
+            returns.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -2808,7 +2762,7 @@ impl ToPyo3Ast for crate::StmtFunctionDef<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtAsyncFunctionDef<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2820,24 +2774,22 @@ impl ToPyo3Ast for crate::StmtAsyncFunctionDef<SourceRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                name.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                decorator_list.to_pyo3_ast(py)?,
-                returns.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_pyo3_ast(py)?,
+            args.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            decorator_list.to_pyo3_ast(py)?,
+            returns.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -2846,7 +2798,7 @@ impl ToPyo3Ast for crate::StmtAsyncFunctionDef<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtClassDef<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2857,23 +2809,21 @@ impl ToPyo3Ast for crate::StmtClassDef<SourceRange> {
             decorator_list,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                name.to_pyo3_ast(py)?,
-                bases.to_pyo3_ast(py)?,
-                keywords.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                decorator_list.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_pyo3_ast(py)?,
+            bases.to_pyo3_ast(py)?,
+            keywords.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            decorator_list.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -2882,21 +2832,22 @@ impl ToPyo3Ast for crate::StmtClassDef<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtReturn<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -2905,21 +2856,22 @@ impl ToPyo3Ast for crate::StmtReturn<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtDelete<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             targets,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (targets.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((targets.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -2928,7 +2880,7 @@ impl ToPyo3Ast for crate::StmtDelete<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtAssign<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2937,21 +2889,19 @@ impl ToPyo3Ast for crate::StmtAssign<SourceRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                targets.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            targets.to_pyo3_ast(py)?,
+            value.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -2960,7 +2910,7 @@ impl ToPyo3Ast for crate::StmtAssign<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtAugAssign<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2969,21 +2919,19 @@ impl ToPyo3Ast for crate::StmtAugAssign<SourceRange> {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                op.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_pyo3_ast(py)?,
+            op.to_pyo3_ast(py)?,
+            value.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -2992,7 +2940,7 @@ impl ToPyo3Ast for crate::StmtAugAssign<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtAnnAssign<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3002,22 +2950,20 @@ impl ToPyo3Ast for crate::StmtAnnAssign<SourceRange> {
             simple,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                annotation.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-                simple.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_pyo3_ast(py)?,
+            annotation.to_pyo3_ast(py)?,
+            value.to_pyo3_ast(py)?,
+            simple.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3026,7 +2972,7 @@ impl ToPyo3Ast for crate::StmtAnnAssign<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtFor<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3037,23 +2983,21 @@ impl ToPyo3Ast for crate::StmtFor<SourceRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                iter.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_pyo3_ast(py)?,
+            iter.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3062,7 +3006,7 @@ impl ToPyo3Ast for crate::StmtFor<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtAsyncFor<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3073,23 +3017,21 @@ impl ToPyo3Ast for crate::StmtAsyncFor<SourceRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                iter.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_pyo3_ast(py)?,
+            iter.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3098,7 +3040,7 @@ impl ToPyo3Ast for crate::StmtAsyncFor<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtWhile<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3107,21 +3049,19 @@ impl ToPyo3Ast for crate::StmtWhile<SourceRange> {
             orelse,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                test.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            test.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3130,7 +3070,7 @@ impl ToPyo3Ast for crate::StmtWhile<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtIf<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3139,21 +3079,19 @@ impl ToPyo3Ast for crate::StmtIf<SourceRange> {
             orelse,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                test.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            test.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3162,7 +3100,7 @@ impl ToPyo3Ast for crate::StmtIf<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtWith<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3171,21 +3109,19 @@ impl ToPyo3Ast for crate::StmtWith<SourceRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                items.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            items.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3194,7 +3130,7 @@ impl ToPyo3Ast for crate::StmtWith<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtAsyncWith<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3203,21 +3139,19 @@ impl ToPyo3Ast for crate::StmtAsyncWith<SourceRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                items.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            items.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3226,7 +3160,7 @@ impl ToPyo3Ast for crate::StmtAsyncWith<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtMatch<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3234,16 +3168,16 @@ impl ToPyo3Ast for crate::StmtMatch<SourceRange> {
             cases,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (subject.to_pyo3_ast(py)?, cases.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((subject.to_pyo3_ast(py)?, cases.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3252,7 +3186,7 @@ impl ToPyo3Ast for crate::StmtMatch<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtRaise<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3260,16 +3194,16 @@ impl ToPyo3Ast for crate::StmtRaise<SourceRange> {
             cause,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (exc.to_pyo3_ast(py)?, cause.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((exc.to_pyo3_ast(py)?, cause.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3278,7 +3212,7 @@ impl ToPyo3Ast for crate::StmtRaise<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtTry<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3288,22 +3222,20 @@ impl ToPyo3Ast for crate::StmtTry<SourceRange> {
             finalbody,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                body.to_pyo3_ast(py)?,
-                handlers.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                finalbody.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            body.to_pyo3_ast(py)?,
+            handlers.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+            finalbody.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3312,7 +3244,7 @@ impl ToPyo3Ast for crate::StmtTry<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtTryStar<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3322,22 +3254,20 @@ impl ToPyo3Ast for crate::StmtTryStar<SourceRange> {
             finalbody,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                body.to_pyo3_ast(py)?,
-                handlers.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                finalbody.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            body.to_pyo3_ast(py)?,
+            handlers.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+            finalbody.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3346,7 +3276,7 @@ impl ToPyo3Ast for crate::StmtTryStar<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtAssert<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3354,16 +3284,16 @@ impl ToPyo3Ast for crate::StmtAssert<SourceRange> {
             msg,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (test.to_pyo3_ast(py)?, msg.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((test.to_pyo3_ast(py)?, msg.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3372,21 +3302,22 @@ impl ToPyo3Ast for crate::StmtAssert<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtImport<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             names,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (names.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3395,7 +3326,7 @@ impl ToPyo3Ast for crate::StmtImport<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtImportFrom<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3404,21 +3335,19 @@ impl ToPyo3Ast for crate::StmtImportFrom<SourceRange> {
             level,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                module.to_pyo3_ast(py)?,
-                names.to_pyo3_ast(py)?,
-                level.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            module.to_pyo3_ast(py)?,
+            names.to_pyo3_ast(py)?,
+            level.map_or_else(|| py.None(), |level| level.to_u32().to_object(py)),
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3427,21 +3356,22 @@ impl ToPyo3Ast for crate::StmtImportFrom<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtGlobal<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             names,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (names.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3450,21 +3380,22 @@ impl ToPyo3Ast for crate::StmtGlobal<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtNonlocal<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             names,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (names.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3473,21 +3404,22 @@ impl ToPyo3Ast for crate::StmtNonlocal<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtExpr<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3496,18 +3428,18 @@ impl ToPyo3Ast for crate::StmtExpr<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtPass<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
-        let instance = cache.0.call0(py)?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
         let Self { range: _range } = self;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3516,18 +3448,18 @@ impl ToPyo3Ast for crate::StmtPass<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtBreak<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
-        let instance = cache.0.call0(py)?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
         let Self { range: _range } = self;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3536,18 +3468,18 @@ impl ToPyo3Ast for crate::StmtBreak<SourceRange> {
 
 impl ToPyo3Ast for crate::StmtContinue<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
-        let instance = cache.0.call0(py)?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
         let Self { range: _range } = self;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3556,7 +3488,7 @@ impl ToPyo3Ast for crate::StmtContinue<SourceRange> {
 
 impl ToPyo3Ast for crate::generic::Expr<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
             crate::Expr::BoolOp(cons) => cons.to_pyo3_ast(py)?,
             crate::Expr::NamedExpr(cons) => cons.to_pyo3_ast(py)?,
@@ -3592,7 +3524,7 @@ impl ToPyo3Ast for crate::generic::Expr<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprBoolOp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3600,16 +3532,16 @@ impl ToPyo3Ast for crate::ExprBoolOp<SourceRange> {
             values,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (op.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((op.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3618,7 +3550,7 @@ impl ToPyo3Ast for crate::ExprBoolOp<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprNamedExpr<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3626,16 +3558,16 @@ impl ToPyo3Ast for crate::ExprNamedExpr<SourceRange> {
             value,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (target.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((target.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3644,7 +3576,7 @@ impl ToPyo3Ast for crate::ExprNamedExpr<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprBinOp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3653,21 +3585,19 @@ impl ToPyo3Ast for crate::ExprBinOp<SourceRange> {
             right,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                left.to_pyo3_ast(py)?,
-                op.to_pyo3_ast(py)?,
-                right.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            left.to_pyo3_ast(py)?,
+            op.to_pyo3_ast(py)?,
+            right.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3676,7 +3606,7 @@ impl ToPyo3Ast for crate::ExprBinOp<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprUnaryOp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3684,16 +3614,16 @@ impl ToPyo3Ast for crate::ExprUnaryOp<SourceRange> {
             operand,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (op.to_pyo3_ast(py)?, operand.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((op.to_pyo3_ast(py)?, operand.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3702,7 +3632,7 @@ impl ToPyo3Ast for crate::ExprUnaryOp<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprLambda<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3710,16 +3640,16 @@ impl ToPyo3Ast for crate::ExprLambda<SourceRange> {
             body,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (args.to_pyo3_ast(py)?, body.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((args.to_pyo3_ast(py)?, body.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3728,7 +3658,7 @@ impl ToPyo3Ast for crate::ExprLambda<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprIfExp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3737,21 +3667,19 @@ impl ToPyo3Ast for crate::ExprIfExp<SourceRange> {
             orelse,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                test.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            test.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+            orelse.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3760,7 +3688,7 @@ impl ToPyo3Ast for crate::ExprIfExp<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprDict<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3768,16 +3696,16 @@ impl ToPyo3Ast for crate::ExprDict<SourceRange> {
             values,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (keys.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((keys.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3786,21 +3714,22 @@ impl ToPyo3Ast for crate::ExprDict<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprSet<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             elts,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (elts.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3809,7 +3738,7 @@ impl ToPyo3Ast for crate::ExprSet<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprListComp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3817,16 +3746,16 @@ impl ToPyo3Ast for crate::ExprListComp<SourceRange> {
             generators,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3835,7 +3764,7 @@ impl ToPyo3Ast for crate::ExprListComp<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprSetComp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3843,16 +3772,16 @@ impl ToPyo3Ast for crate::ExprSetComp<SourceRange> {
             generators,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3861,7 +3790,7 @@ impl ToPyo3Ast for crate::ExprSetComp<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprDictComp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3870,21 +3799,19 @@ impl ToPyo3Ast for crate::ExprDictComp<SourceRange> {
             generators,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                key.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-                generators.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            key.to_pyo3_ast(py)?,
+            value.to_pyo3_ast(py)?,
+            generators.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3893,7 +3820,7 @@ impl ToPyo3Ast for crate::ExprDictComp<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprGeneratorExp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3901,16 +3828,16 @@ impl ToPyo3Ast for crate::ExprGeneratorExp<SourceRange> {
             generators,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3919,21 +3846,22 @@ impl ToPyo3Ast for crate::ExprGeneratorExp<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprAwait<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3942,21 +3870,22 @@ impl ToPyo3Ast for crate::ExprAwait<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprYield<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3965,21 +3894,22 @@ impl ToPyo3Ast for crate::ExprYield<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprYieldFrom<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -3988,7 +3918,7 @@ impl ToPyo3Ast for crate::ExprYieldFrom<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprCompare<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3997,21 +3927,19 @@ impl ToPyo3Ast for crate::ExprCompare<SourceRange> {
             comparators,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                left.to_pyo3_ast(py)?,
-                ops.to_pyo3_ast(py)?,
-                comparators.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            left.to_pyo3_ast(py)?,
+            ops.to_pyo3_ast(py)?,
+            comparators.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4020,7 +3948,7 @@ impl ToPyo3Ast for crate::ExprCompare<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprCall<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4029,21 +3957,19 @@ impl ToPyo3Ast for crate::ExprCall<SourceRange> {
             keywords,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                func.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                keywords.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            func.to_pyo3_ast(py)?,
+            args.to_pyo3_ast(py)?,
+            keywords.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4052,7 +3978,7 @@ impl ToPyo3Ast for crate::ExprCall<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprFormattedValue<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4061,21 +3987,19 @@ impl ToPyo3Ast for crate::ExprFormattedValue<SourceRange> {
             format_spec,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                value.to_pyo3_ast(py)?,
-                conversion.to_pyo3_ast(py)?,
-                format_spec.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            value.to_pyo3_ast(py)?,
+            conversion.to_pyo3_ast(py)?,
+            format_spec.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4084,21 +4008,22 @@ impl ToPyo3Ast for crate::ExprFormattedValue<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprJoinedStr<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             values,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (values.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((values.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4107,7 +4032,7 @@ impl ToPyo3Ast for crate::ExprJoinedStr<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprConstant<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4115,16 +4040,16 @@ impl ToPyo3Ast for crate::ExprConstant<SourceRange> {
             kind,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (value.to_pyo3_ast(py)?, kind.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((value.to_object(py), kind.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4133,7 +4058,7 @@ impl ToPyo3Ast for crate::ExprConstant<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprAttribute<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4142,21 +4067,19 @@ impl ToPyo3Ast for crate::ExprAttribute<SourceRange> {
             ctx,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                value.to_pyo3_ast(py)?,
-                attr.to_pyo3_ast(py)?,
-                ctx.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            value.to_pyo3_ast(py)?,
+            attr.to_pyo3_ast(py)?,
+            ctx.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4165,7 +4088,7 @@ impl ToPyo3Ast for crate::ExprAttribute<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprSubscript<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4174,21 +4097,19 @@ impl ToPyo3Ast for crate::ExprSubscript<SourceRange> {
             ctx,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                value.to_pyo3_ast(py)?,
-                slice.to_pyo3_ast(py)?,
-                ctx.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            value.to_pyo3_ast(py)?,
+            slice.to_pyo3_ast(py)?,
+            ctx.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4197,7 +4118,7 @@ impl ToPyo3Ast for crate::ExprSubscript<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprStarred<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4205,16 +4126,16 @@ impl ToPyo3Ast for crate::ExprStarred<SourceRange> {
             ctx,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (value.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((value.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4223,7 +4144,7 @@ impl ToPyo3Ast for crate::ExprStarred<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprName<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4231,16 +4152,16 @@ impl ToPyo3Ast for crate::ExprName<SourceRange> {
             ctx,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (id.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((id.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4249,7 +4170,7 @@ impl ToPyo3Ast for crate::ExprName<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprList<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4257,16 +4178,16 @@ impl ToPyo3Ast for crate::ExprList<SourceRange> {
             ctx,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4275,7 +4196,7 @@ impl ToPyo3Ast for crate::ExprList<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprTuple<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4283,16 +4204,16 @@ impl ToPyo3Ast for crate::ExprTuple<SourceRange> {
             ctx,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4301,7 +4222,7 @@ impl ToPyo3Ast for crate::ExprTuple<SourceRange> {
 
 impl ToPyo3Ast for crate::ExprSlice<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4310,21 +4231,19 @@ impl ToPyo3Ast for crate::ExprSlice<SourceRange> {
             step,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                lower.to_pyo3_ast(py)?,
-                upper.to_pyo3_ast(py)?,
-                step.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            lower.to_pyo3_ast(py)?,
+            upper.to_pyo3_ast(py)?,
+            step.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4333,7 +4252,7 @@ impl ToPyo3Ast for crate::ExprSlice<SourceRange> {
 
 impl ToPyo3Ast for crate::Comprehension<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4343,15 +4262,13 @@ impl ToPyo3Ast for crate::Comprehension<SourceRange> {
             is_async,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                iter.to_pyo3_ast(py)?,
-                ifs.to_pyo3_ast(py)?,
-                is_async.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_pyo3_ast(py)?,
+            iter.to_pyo3_ast(py)?,
+            ifs.to_pyo3_ast(py)?,
+            is_async.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -4359,7 +4276,7 @@ impl ToPyo3Ast for crate::Comprehension<SourceRange> {
 
 impl ToPyo3Ast for crate::generic::Excepthandler<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
             crate::Excepthandler::ExceptHandler(cons) => cons.to_pyo3_ast(py)?,
         };
@@ -4369,7 +4286,7 @@ impl ToPyo3Ast for crate::generic::Excepthandler<SourceRange> {
 
 impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4378,21 +4295,19 @@ impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<SourceRange> {
             body,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                type_.to_pyo3_ast(py)?,
-                name.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            type_.to_pyo3_ast(py)?,
+            name.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4401,7 +4316,7 @@ impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<SourceRange> {
 
 impl ToPyo3Ast for crate::Arguments<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4414,18 +4329,16 @@ impl ToPyo3Ast for crate::Arguments<SourceRange> {
             defaults,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                posonlyargs.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                vararg.to_pyo3_ast(py)?,
-                kwonlyargs.to_pyo3_ast(py)?,
-                kw_defaults.to_pyo3_ast(py)?,
-                kwarg.to_pyo3_ast(py)?,
-                defaults.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            posonlyargs.to_pyo3_ast(py)?,
+            args.to_pyo3_ast(py)?,
+            vararg.to_pyo3_ast(py)?,
+            kwonlyargs.to_pyo3_ast(py)?,
+            kw_defaults.to_pyo3_ast(py)?,
+            kwarg.to_pyo3_ast(py)?,
+            defaults.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -4433,7 +4346,7 @@ impl ToPyo3Ast for crate::Arguments<SourceRange> {
 
 impl ToPyo3Ast for crate::Arg<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4442,21 +4355,19 @@ impl ToPyo3Ast for crate::Arg<SourceRange> {
             type_comment,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                arg.to_pyo3_ast(py)?,
-                annotation.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            arg.to_pyo3_ast(py)?,
+            annotation.to_pyo3_ast(py)?,
+            type_comment.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4465,7 +4376,7 @@ impl ToPyo3Ast for crate::Arg<SourceRange> {
 
 impl ToPyo3Ast for crate::Keyword<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4473,16 +4384,16 @@ impl ToPyo3Ast for crate::Keyword<SourceRange> {
             value,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (arg.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((arg.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4491,7 +4402,7 @@ impl ToPyo3Ast for crate::Keyword<SourceRange> {
 
 impl ToPyo3Ast for crate::Alias<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4499,16 +4410,16 @@ impl ToPyo3Ast for crate::Alias<SourceRange> {
             asname,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (name.to_pyo3_ast(py)?, asname.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((name.to_pyo3_ast(py)?, asname.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4517,7 +4428,7 @@ impl ToPyo3Ast for crate::Alias<SourceRange> {
 
 impl ToPyo3Ast for crate::Withitem<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4525,13 +4436,11 @@ impl ToPyo3Ast for crate::Withitem<SourceRange> {
             optional_vars,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                context_expr.to_pyo3_ast(py)?,
-                optional_vars.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            context_expr.to_pyo3_ast(py)?,
+            optional_vars.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -4539,7 +4448,7 @@ impl ToPyo3Ast for crate::Withitem<SourceRange> {
 
 impl ToPyo3Ast for crate::MatchCase<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4548,14 +4457,12 @@ impl ToPyo3Ast for crate::MatchCase<SourceRange> {
             body,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                pattern.to_pyo3_ast(py)?,
-                guard.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-            ),
-        )?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            pattern.to_pyo3_ast(py)?,
+            guard.to_pyo3_ast(py)?,
+            body.to_pyo3_ast(py)?,
+        ))?;
 
         Ok(instance)
     }
@@ -4563,7 +4470,7 @@ impl ToPyo3Ast for crate::MatchCase<SourceRange> {
 
 impl ToPyo3Ast for crate::generic::Pattern<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
             crate::Pattern::MatchValue(cons) => cons.to_pyo3_ast(py)?,
             crate::Pattern::MatchSingleton(cons) => cons.to_pyo3_ast(py)?,
@@ -4580,21 +4487,22 @@ impl ToPyo3Ast for crate::generic::Pattern<SourceRange> {
 
 impl ToPyo3Ast for crate::PatternMatchValue<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4603,21 +4511,22 @@ impl ToPyo3Ast for crate::PatternMatchValue<SourceRange> {
 
 impl ToPyo3Ast for crate::PatternMatchSingleton<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             value,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_object(py),))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4626,21 +4535,22 @@ impl ToPyo3Ast for crate::PatternMatchSingleton<SourceRange> {
 
 impl ToPyo3Ast for crate::PatternMatchSequence<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             patterns,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (patterns.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4649,7 +4559,7 @@ impl ToPyo3Ast for crate::PatternMatchSequence<SourceRange> {
 
 impl ToPyo3Ast for crate::PatternMatchMapping<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4658,21 +4568,19 @@ impl ToPyo3Ast for crate::PatternMatchMapping<SourceRange> {
             rest,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                keys.to_pyo3_ast(py)?,
-                patterns.to_pyo3_ast(py)?,
-                rest.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            keys.to_pyo3_ast(py)?,
+            patterns.to_pyo3_ast(py)?,
+            rest.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4681,7 +4589,7 @@ impl ToPyo3Ast for crate::PatternMatchMapping<SourceRange> {
 
 impl ToPyo3Ast for crate::PatternMatchClass<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4691,22 +4599,20 @@ impl ToPyo3Ast for crate::PatternMatchClass<SourceRange> {
             kwd_patterns,
             range: _range,
         } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                cls.to_pyo3_ast(py)?,
-                patterns.to_pyo3_ast(py)?,
-                kwd_attrs.to_pyo3_ast(py)?,
-                kwd_patterns.to_pyo3_ast(py)?,
-            ),
-        )?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            cls.to_pyo3_ast(py)?,
+            patterns.to_pyo3_ast(py)?,
+            kwd_attrs.to_pyo3_ast(py)?,
+            kwd_patterns.to_pyo3_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4715,21 +4621,22 @@ impl ToPyo3Ast for crate::PatternMatchClass<SourceRange> {
 
 impl ToPyo3Ast for crate::PatternMatchStar<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             name,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (name.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4738,7 +4645,7 @@ impl ToPyo3Ast for crate::PatternMatchStar<SourceRange> {
 
 impl ToPyo3Ast for crate::PatternMatchAs<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4746,16 +4653,16 @@ impl ToPyo3Ast for crate::PatternMatchAs<SourceRange> {
             name,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (pattern.to_pyo3_ast(py)?, name.to_pyo3_ast(py)?))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((pattern.to_pyo3_ast(py)?, name.to_pyo3_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4764,21 +4671,22 @@ impl ToPyo3Ast for crate::PatternMatchAs<SourceRange> {
 
 impl ToPyo3Ast for crate::PatternMatchOr<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
             patterns,
             range: _range,
         } = self;
-        let instance = cache.0.call1(py, (patterns.to_pyo3_ast(py)?,))?;
 
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_pyo3_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
         if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
         }
 
         Ok(instance)
@@ -4787,7 +4695,7 @@ impl ToPyo3Ast for crate::PatternMatchOr<SourceRange> {
 
 impl ToPyo3Ast for crate::generic::TypeIgnore<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
             crate::TypeIgnore::TypeIgnore(cons) => cons.to_pyo3_ast(py)?,
         };
@@ -4797,7 +4705,7 @@ impl ToPyo3Ast for crate::generic::TypeIgnore<SourceRange> {
 
 impl ToPyo3Ast for crate::TypeIgnoreTypeIgnore<SourceRange> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4805,9 +4713,9 @@ impl ToPyo3Ast for crate::TypeIgnoreTypeIgnore<SourceRange> {
             tag,
             range: _range,
         } = self;
-        let instance = cache
-            .0
-            .call1(py, (lineno.to_pyo3_ast(py)?, tag.to_pyo3_ast(py)?))?;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((lineno.to_u32().to_object(py), tag.to_pyo3_ast(py)?))?;
 
         Ok(instance)
     }
diff --git a/ast/src/pyo3.rs b/ast/src/pyo3.rs
index 74e51720..928b5371 100644
--- a/ast/src/pyo3.rs
+++ b/ast/src/pyo3.rs
@@ -3,7 +3,8 @@ use num_complex::Complex64;
 use once_cell::sync::OnceCell;
 use pyo3::{
     prelude::*,
-    types::{PyBytes, PyList, PyString, PyTuple},
+    types::{PyBool, PyBytes, PyList, PyString, PyTuple},
+    ToPyObject,
 };
 
 pub trait Pyo3Node {
@@ -16,28 +17,28 @@ pub trait Pyo3Node {
 }
 
 pub trait ToPyo3Ast {
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>>;
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny>;
 }
 
 impl<T: ToPyo3Ast> ToPyo3Ast for Box<T> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         (**self).to_pyo3_ast(py)
     }
 }
 
 impl<T: ToPyo3Ast> ToPyo3Ast for Option<T> {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         match self {
             Some(ast) => ast.to_pyo3_ast(py),
-            None => Ok(py.None()),
+            None => Ok(ast_cache().none_ref(py)),
         }
     }
 }
 
 impl<T: ToPyo3Ast> ToPyo3Ast for Vec<T> {
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let elts = self
             .iter()
             .map(|item| item.to_pyo3_ast(py))
@@ -49,60 +50,74 @@ impl<T: ToPyo3Ast> ToPyo3Ast for Vec<T> {
 
 impl ToPyo3Ast for crate::Identifier {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok(self.as_str().to_object(py))
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        Ok(PyString::new(py, self.as_str()).into())
     }
 }
 
 impl ToPyo3Ast for crate::String {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok(self.as_str().to_object(py))
-    }
-}
-
-impl ToPyo3Ast for crate::Int {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok((self.to_u32()).to_object(py))
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        Ok(PyString::new(py, self.as_str()).into())
     }
 }
 
 impl ToPyo3Ast for bool {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok((*self as u32).to_object(py))
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        Ok(ast_cache().bool_int(py, *self))
     }
 }
 
 impl ToPyo3Ast for ConversionFlag {
     #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok((*self as i8).to_object(py))
+    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        Ok(ast_cache().conversion_flag(py, *self))
     }
 }
 
-impl ToPyo3Ast for crate::Constant {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let value = match self {
-            crate::Constant::None => py.None(),
-            crate::Constant::Bool(bool) => bool.to_object(py),
+impl ToPyObject for crate::Constant {
+    fn to_object(&self, py: Python) -> PyObject {
+        let cache = ast_cache();
+        match self {
+            crate::Constant::None => cache.none.clone_ref(py),
+            crate::Constant::Bool(bool) => cache.bool(py, *bool).into(),
             crate::Constant::Str(string) => string.to_object(py),
             crate::Constant::Bytes(bytes) => PyBytes::new(py, bytes).into(),
             crate::Constant::Int(int) => int.to_object(py),
             crate::Constant::Tuple(elts) => {
-                let elts: PyResult<Vec<_>> = elts.iter().map(|c| c.to_pyo3_ast(py)).collect();
-                PyTuple::new(py, elts?).into()
+                let elts: Vec<_> = elts.iter().map(|c| c.to_object(py)).collect();
+                PyTuple::new(py, elts).into()
             }
             crate::Constant::Float(f64) => f64.to_object(py),
             crate::Constant::Complex { real, imag } => Complex64::new(*real, *imag).to_object(py),
             crate::Constant::Ellipsis => py.Ellipsis(),
-        };
-        Ok(value)
+        }
     }
 }
 
+// impl ToPyo3Ast for crate::Constant {
+//     #[inline]
+//     fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+//         let cache = ast_cache();
+//         let value = match self {
+//             crate::Constant::None => cache.none_ref(py),
+//             crate::Constant::Bool(bool) => cache.bool_ref(py),
+//             crate::Constant::Str(string) => string.to_object(py),
+//             crate::Constant::Bytes(bytes) => PyBytes::new(py, bytes).into(),
+//             crate::Constant::Int(int) => int.to_object(py),
+//             crate::Constant::Tuple(elts) => {
+//                 let elts: PyResult<Vec<_>> = elts.iter().map(|c| c.to_pyo3_ast(py)).collect();
+//                 PyTuple::new(py, elts?).into()
+//             }
+//             crate::Constant::Float(f64) => f64.to_object(py),
+//             crate::Constant::Complex { real, imag } => Complex64::new(*real, *imag).to_object(py),
+//             crate::Constant::Ellipsis => py.Ellipsis(),
+//         };
+//         Ok(value)
+//     }
+// }
+
 #[pyclass(module = "rustpython_ast", subclass)]
 pub struct AST;
 
@@ -125,26 +140,70 @@ fn cache_py_type<N: Pyo3Node + Node>(ast_module: &PyAny) -> PyResult<()> {
     Ok(())
 }
 
-struct AstKeyCache {
+// TODO: This cache must be bound to 'py
+struct AstCache {
     lineno: Py<PyString>,
     col_offset: Py<PyString>,
     end_lineno: Py<PyString>,
     end_col_offset: Py<PyString>,
+    none: Py<PyAny>,
+    bool_values: (Py<PyBool>, Py<PyBool>),
+    bool_int_values: (Py<PyAny>, Py<PyAny>),
+    conversion_flags: (Py<PyAny>, Py<PyAny>, Py<PyAny>, Py<PyAny>),
+}
+
+impl AstCache {
+    #[inline]
+    fn none_ref<'py>(&'static self, py: Python<'py>) -> &'py PyAny {
+        Py::<PyAny>::as_ref(&self.none, py)
+    }
+    #[inline]
+    fn bool_int<'py>(&'static self, py: Python<'py>, value: bool) -> &'py PyAny {
+        let v = &self.bool_int_values;
+        Py::<PyAny>::as_ref(if value { &v.1 } else { &v.0 }, py)
+    }
+    #[inline]
+    fn bool(&'static self, py: Python, value: bool) -> Py<PyBool> {
+        let v = &self.bool_values;
+        (if value { &v.1 } else { &v.0 }).clone_ref(py)
+    }
+    fn conversion_flag<'py>(&'static self, py: Python<'py>, value: ConversionFlag) -> &'py PyAny {
+        let v = &self.conversion_flags;
+        match value {
+            ConversionFlag::None => v.0.as_ref(py),
+            ConversionFlag::Str => v.1.as_ref(py),
+            ConversionFlag::Ascii => v.2.as_ref(py),
+            ConversionFlag::Repr => v.3.as_ref(py),
+        }
+    }
 }
 
-fn ast_key_cache() -> &'static OnceCell<AstKeyCache> {
+fn ast_cache_cell() -> &'static OnceCell<AstCache> {
     {
-        static PY_TYPE: OnceCell<AstKeyCache> = OnceCell::new();
+        static PY_TYPE: OnceCell<AstCache> = OnceCell::new();
         &PY_TYPE
     }
 }
 
+fn ast_cache() -> &'static AstCache {
+    ast_cache_cell().get().unwrap()
+}
+
 pub fn init(py: Python) -> PyResult<()> {
-    ast_key_cache().get_or_init(|| AstKeyCache {
+    ast_cache_cell().get_or_init(|| AstCache {
         lineno: pyo3::intern!(py, "lineno").into_py(py),
         col_offset: pyo3::intern!(py, "col_offset").into_py(py),
         end_lineno: pyo3::intern!(py, "end_lineno").into_py(py),
         end_col_offset: pyo3::intern!(py, "end_col_offset").into_py(py),
+        none: py.None(),
+        bool_values: (PyBool::new(py, false).into(), PyBool::new(py, true).into()),
+        bool_int_values: ((0).to_object(py), (1).to_object(py)),
+        conversion_flags: (
+            (-1).to_object(py),
+            (b's').to_object(py),
+            (b'a').to_object(py),
+            (b'r').to_object(py),
+        ),
     });
 
     init_types(py)

From 7d384d88d0d113975fabd0d4b768456a1f041bc6 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Tue, 23 May 2023 02:24:03 +0900
Subject: [PATCH 2/2] Separate rustpython_ast_pyo3

---
 Cargo.toml                                    |    1 +
 ast-pyo3/Cargo.toml                           |   16 +
 .../src/gen/to_py_ast.rs                      | 2136 ++++++++---------
 .../src/gen/wrapper_located.rs                | 1968 ++++++++-------
 .../src/gen/wrapper_ranged.rs                 | 1820 +++++++-------
 ast-pyo3/src/lib.rs                           |    5 +
 ast/src/pyo3.rs => ast-pyo3/src/py_ast.rs     |  104 +-
 ast-pyo3/src/wrapper.rs                       |  141 ++
 ast/Cargo.toml                                |    8 +-
 ast/asdl_rs.py                                |   81 +-
 ast/src/lib.rs                                |    5 -
 ast/src/pyo3_wrapper.rs                       |  128 -
 scripts/update_asdl.sh                        |    4 +-
 13 files changed, 3209 insertions(+), 3208 deletions(-)
 create mode 100644 ast-pyo3/Cargo.toml
 rename ast/src/gen/to_pyo3.rs => ast-pyo3/src/gen/to_py_ast.rs (60%)
 rename ast/src/gen/pyo3_wrapper_located.rs => ast-pyo3/src/gen/wrapper_located.rs (54%)
 rename ast/src/gen/pyo3_wrapper_ranged.rs => ast-pyo3/src/gen/wrapper_ranged.rs (55%)
 create mode 100644 ast-pyo3/src/lib.rs
 rename ast/src/pyo3.rs => ast-pyo3/src/py_ast.rs (53%)
 create mode 100644 ast-pyo3/src/wrapper.rs
 delete mode 100644 ast/src/pyo3_wrapper.rs

diff --git a/Cargo.toml b/Cargo.toml
index 8e43b189..df2b843b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,6 +12,7 @@ include = ["LICENSE", "Cargo.toml", "src/**/*.rs"]
 resolver = "2"
 members = [
     "ast", "core", "format", "literal", "parser",
+    "ast-pyo3",
     "ruff_text_size", "ruff_source_location",
 ]
 
diff --git a/ast-pyo3/Cargo.toml b/ast-pyo3/Cargo.toml
new file mode 100644
index 00000000..c1394a4c
--- /dev/null
+++ b/ast-pyo3/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "rustpython-ast-pyo3"
+version = "0.1.0"
+edition = "2021"
+
+[features]
+# This feature is experimental
+# It reimplements AST types, but currently both slower than python AST types and limited to use in other API
+wrapper = []
+
+[dependencies]
+rustpython-ast = { workspace = true, features = ["location"] }
+num-complex = { workspace = true }
+once_cell = { workspace = true }
+
+pyo3 = { workspace = true, features = ["num-bigint", "num-complex"] }
diff --git a/ast/src/gen/to_pyo3.rs b/ast-pyo3/src/gen/to_py_ast.rs
similarity index 60%
rename from ast/src/gen/to_pyo3.rs
rename to ast-pyo3/src/gen/to_py_ast.rs
index 07c4bb06..16ccadb9 100644
--- a/ast/src/gen/to_pyo3.rs
+++ b/ast-pyo3/src/gen/to_py_ast.rs
@@ -1,6 +1,6 @@
 // File automatically generated by ast/asdl_rs.py.
 
-impl<R> Pyo3Node for crate::generic::Mod<R> {
+impl<R> PyNode for ast::Mod<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -8,7 +8,7 @@ impl<R> Pyo3Node for crate::generic::Mod<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ModModule<R> {
+impl<R> PyNode for ast::ModModule<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -16,7 +16,7 @@ impl<R> Pyo3Node for crate::generic::ModModule<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ModInteractive<R> {
+impl<R> PyNode for ast::ModInteractive<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -24,7 +24,7 @@ impl<R> Pyo3Node for crate::generic::ModInteractive<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ModExpression<R> {
+impl<R> PyNode for ast::ModExpression<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -32,7 +32,7 @@ impl<R> Pyo3Node for crate::generic::ModExpression<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ModFunctionType<R> {
+impl<R> PyNode for ast::ModFunctionType<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -40,7 +40,7 @@ impl<R> Pyo3Node for crate::generic::ModFunctionType<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::Stmt<R> {
+impl<R> PyNode for ast::Stmt<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -48,7 +48,7 @@ impl<R> Pyo3Node for crate::generic::Stmt<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtFunctionDef<R> {
+impl<R> PyNode for ast::StmtFunctionDef<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -56,7 +56,7 @@ impl<R> Pyo3Node for crate::generic::StmtFunctionDef<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtAsyncFunctionDef<R> {
+impl<R> PyNode for ast::StmtAsyncFunctionDef<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -64,7 +64,7 @@ impl<R> Pyo3Node for crate::generic::StmtAsyncFunctionDef<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtClassDef<R> {
+impl<R> PyNode for ast::StmtClassDef<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -72,7 +72,7 @@ impl<R> Pyo3Node for crate::generic::StmtClassDef<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtReturn<R> {
+impl<R> PyNode for ast::StmtReturn<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -80,7 +80,7 @@ impl<R> Pyo3Node for crate::generic::StmtReturn<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtDelete<R> {
+impl<R> PyNode for ast::StmtDelete<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -88,7 +88,7 @@ impl<R> Pyo3Node for crate::generic::StmtDelete<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtAssign<R> {
+impl<R> PyNode for ast::StmtAssign<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -96,7 +96,7 @@ impl<R> Pyo3Node for crate::generic::StmtAssign<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtAugAssign<R> {
+impl<R> PyNode for ast::StmtAugAssign<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -104,7 +104,7 @@ impl<R> Pyo3Node for crate::generic::StmtAugAssign<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtAnnAssign<R> {
+impl<R> PyNode for ast::StmtAnnAssign<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -112,7 +112,7 @@ impl<R> Pyo3Node for crate::generic::StmtAnnAssign<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtFor<R> {
+impl<R> PyNode for ast::StmtFor<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -120,7 +120,7 @@ impl<R> Pyo3Node for crate::generic::StmtFor<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtAsyncFor<R> {
+impl<R> PyNode for ast::StmtAsyncFor<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -128,7 +128,7 @@ impl<R> Pyo3Node for crate::generic::StmtAsyncFor<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtWhile<R> {
+impl<R> PyNode for ast::StmtWhile<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -136,7 +136,7 @@ impl<R> Pyo3Node for crate::generic::StmtWhile<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtIf<R> {
+impl<R> PyNode for ast::StmtIf<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -144,7 +144,7 @@ impl<R> Pyo3Node for crate::generic::StmtIf<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtWith<R> {
+impl<R> PyNode for ast::StmtWith<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -152,7 +152,7 @@ impl<R> Pyo3Node for crate::generic::StmtWith<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtAsyncWith<R> {
+impl<R> PyNode for ast::StmtAsyncWith<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -160,7 +160,7 @@ impl<R> Pyo3Node for crate::generic::StmtAsyncWith<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtMatch<R> {
+impl<R> PyNode for ast::StmtMatch<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -168,7 +168,7 @@ impl<R> Pyo3Node for crate::generic::StmtMatch<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtRaise<R> {
+impl<R> PyNode for ast::StmtRaise<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -176,7 +176,7 @@ impl<R> Pyo3Node for crate::generic::StmtRaise<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtTry<R> {
+impl<R> PyNode for ast::StmtTry<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -184,7 +184,7 @@ impl<R> Pyo3Node for crate::generic::StmtTry<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtTryStar<R> {
+impl<R> PyNode for ast::StmtTryStar<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -192,7 +192,7 @@ impl<R> Pyo3Node for crate::generic::StmtTryStar<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtAssert<R> {
+impl<R> PyNode for ast::StmtAssert<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -200,7 +200,7 @@ impl<R> Pyo3Node for crate::generic::StmtAssert<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtImport<R> {
+impl<R> PyNode for ast::StmtImport<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -208,7 +208,7 @@ impl<R> Pyo3Node for crate::generic::StmtImport<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtImportFrom<R> {
+impl<R> PyNode for ast::StmtImportFrom<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -216,7 +216,7 @@ impl<R> Pyo3Node for crate::generic::StmtImportFrom<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtGlobal<R> {
+impl<R> PyNode for ast::StmtGlobal<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -224,7 +224,7 @@ impl<R> Pyo3Node for crate::generic::StmtGlobal<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtNonlocal<R> {
+impl<R> PyNode for ast::StmtNonlocal<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -232,7 +232,7 @@ impl<R> Pyo3Node for crate::generic::StmtNonlocal<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtExpr<R> {
+impl<R> PyNode for ast::StmtExpr<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -240,7 +240,7 @@ impl<R> Pyo3Node for crate::generic::StmtExpr<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtPass<R> {
+impl<R> PyNode for ast::StmtPass<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -248,7 +248,7 @@ impl<R> Pyo3Node for crate::generic::StmtPass<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtBreak<R> {
+impl<R> PyNode for ast::StmtBreak<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -256,7 +256,7 @@ impl<R> Pyo3Node for crate::generic::StmtBreak<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::StmtContinue<R> {
+impl<R> PyNode for ast::StmtContinue<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -264,7 +264,7 @@ impl<R> Pyo3Node for crate::generic::StmtContinue<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::Expr<R> {
+impl<R> PyNode for ast::Expr<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -272,7 +272,7 @@ impl<R> Pyo3Node for crate::generic::Expr<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprBoolOp<R> {
+impl<R> PyNode for ast::ExprBoolOp<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -280,7 +280,7 @@ impl<R> Pyo3Node for crate::generic::ExprBoolOp<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprNamedExpr<R> {
+impl<R> PyNode for ast::ExprNamedExpr<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -288,7 +288,7 @@ impl<R> Pyo3Node for crate::generic::ExprNamedExpr<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprBinOp<R> {
+impl<R> PyNode for ast::ExprBinOp<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -296,7 +296,7 @@ impl<R> Pyo3Node for crate::generic::ExprBinOp<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprUnaryOp<R> {
+impl<R> PyNode for ast::ExprUnaryOp<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -304,7 +304,7 @@ impl<R> Pyo3Node for crate::generic::ExprUnaryOp<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprLambda<R> {
+impl<R> PyNode for ast::ExprLambda<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -312,7 +312,7 @@ impl<R> Pyo3Node for crate::generic::ExprLambda<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprIfExp<R> {
+impl<R> PyNode for ast::ExprIfExp<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -320,7 +320,7 @@ impl<R> Pyo3Node for crate::generic::ExprIfExp<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprDict<R> {
+impl<R> PyNode for ast::ExprDict<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -328,7 +328,7 @@ impl<R> Pyo3Node for crate::generic::ExprDict<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprSet<R> {
+impl<R> PyNode for ast::ExprSet<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -336,7 +336,7 @@ impl<R> Pyo3Node for crate::generic::ExprSet<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprListComp<R> {
+impl<R> PyNode for ast::ExprListComp<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -344,7 +344,7 @@ impl<R> Pyo3Node for crate::generic::ExprListComp<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprSetComp<R> {
+impl<R> PyNode for ast::ExprSetComp<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -352,7 +352,7 @@ impl<R> Pyo3Node for crate::generic::ExprSetComp<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprDictComp<R> {
+impl<R> PyNode for ast::ExprDictComp<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -360,7 +360,7 @@ impl<R> Pyo3Node for crate::generic::ExprDictComp<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprGeneratorExp<R> {
+impl<R> PyNode for ast::ExprGeneratorExp<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -368,7 +368,7 @@ impl<R> Pyo3Node for crate::generic::ExprGeneratorExp<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprAwait<R> {
+impl<R> PyNode for ast::ExprAwait<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -376,7 +376,7 @@ impl<R> Pyo3Node for crate::generic::ExprAwait<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprYield<R> {
+impl<R> PyNode for ast::ExprYield<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -384,7 +384,7 @@ impl<R> Pyo3Node for crate::generic::ExprYield<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprYieldFrom<R> {
+impl<R> PyNode for ast::ExprYieldFrom<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -392,7 +392,7 @@ impl<R> Pyo3Node for crate::generic::ExprYieldFrom<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprCompare<R> {
+impl<R> PyNode for ast::ExprCompare<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -400,7 +400,7 @@ impl<R> Pyo3Node for crate::generic::ExprCompare<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprCall<R> {
+impl<R> PyNode for ast::ExprCall<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -408,7 +408,7 @@ impl<R> Pyo3Node for crate::generic::ExprCall<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprFormattedValue<R> {
+impl<R> PyNode for ast::ExprFormattedValue<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -416,7 +416,7 @@ impl<R> Pyo3Node for crate::generic::ExprFormattedValue<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprJoinedStr<R> {
+impl<R> PyNode for ast::ExprJoinedStr<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -424,7 +424,7 @@ impl<R> Pyo3Node for crate::generic::ExprJoinedStr<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprConstant<R> {
+impl<R> PyNode for ast::ExprConstant<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -432,7 +432,7 @@ impl<R> Pyo3Node for crate::generic::ExprConstant<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprAttribute<R> {
+impl<R> PyNode for ast::ExprAttribute<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -440,7 +440,7 @@ impl<R> Pyo3Node for crate::generic::ExprAttribute<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprSubscript<R> {
+impl<R> PyNode for ast::ExprSubscript<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -448,7 +448,7 @@ impl<R> Pyo3Node for crate::generic::ExprSubscript<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprStarred<R> {
+impl<R> PyNode for ast::ExprStarred<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -456,7 +456,7 @@ impl<R> Pyo3Node for crate::generic::ExprStarred<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprName<R> {
+impl<R> PyNode for ast::ExprName<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -464,7 +464,7 @@ impl<R> Pyo3Node for crate::generic::ExprName<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprList<R> {
+impl<R> PyNode for ast::ExprList<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -472,7 +472,7 @@ impl<R> Pyo3Node for crate::generic::ExprList<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprTuple<R> {
+impl<R> PyNode for ast::ExprTuple<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -480,7 +480,7 @@ impl<R> Pyo3Node for crate::generic::ExprTuple<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExprSlice<R> {
+impl<R> PyNode for ast::ExprSlice<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -488,7 +488,7 @@ impl<R> Pyo3Node for crate::generic::ExprSlice<R> {
     }
 }
 
-impl Pyo3Node for crate::generic::ExprContext {
+impl PyNode for ast::ExprContext {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -496,7 +496,7 @@ impl Pyo3Node for crate::generic::ExprContext {
     }
 }
 
-impl Pyo3Node for crate::generic::ExprContextLoad {
+impl PyNode for ast::ExprContextLoad {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -504,7 +504,7 @@ impl Pyo3Node for crate::generic::ExprContextLoad {
     }
 }
 
-impl Pyo3Node for crate::generic::ExprContextStore {
+impl PyNode for ast::ExprContextStore {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -512,7 +512,7 @@ impl Pyo3Node for crate::generic::ExprContextStore {
     }
 }
 
-impl Pyo3Node for crate::generic::ExprContextDel {
+impl PyNode for ast::ExprContextDel {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -520,7 +520,7 @@ impl Pyo3Node for crate::generic::ExprContextDel {
     }
 }
 
-impl Pyo3Node for crate::generic::Boolop {
+impl PyNode for ast::Boolop {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -528,7 +528,7 @@ impl Pyo3Node for crate::generic::Boolop {
     }
 }
 
-impl Pyo3Node for crate::generic::BoolopAnd {
+impl PyNode for ast::BoolopAnd {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -536,7 +536,7 @@ impl Pyo3Node for crate::generic::BoolopAnd {
     }
 }
 
-impl Pyo3Node for crate::generic::BoolopOr {
+impl PyNode for ast::BoolopOr {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -544,7 +544,7 @@ impl Pyo3Node for crate::generic::BoolopOr {
     }
 }
 
-impl Pyo3Node for crate::generic::Operator {
+impl PyNode for ast::Operator {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -552,7 +552,7 @@ impl Pyo3Node for crate::generic::Operator {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorAdd {
+impl PyNode for ast::OperatorAdd {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -560,7 +560,7 @@ impl Pyo3Node for crate::generic::OperatorAdd {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorSub {
+impl PyNode for ast::OperatorSub {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -568,7 +568,7 @@ impl Pyo3Node for crate::generic::OperatorSub {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorMult {
+impl PyNode for ast::OperatorMult {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -576,7 +576,7 @@ impl Pyo3Node for crate::generic::OperatorMult {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorMatMult {
+impl PyNode for ast::OperatorMatMult {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -584,7 +584,7 @@ impl Pyo3Node for crate::generic::OperatorMatMult {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorDiv {
+impl PyNode for ast::OperatorDiv {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -592,7 +592,7 @@ impl Pyo3Node for crate::generic::OperatorDiv {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorMod {
+impl PyNode for ast::OperatorMod {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -600,7 +600,7 @@ impl Pyo3Node for crate::generic::OperatorMod {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorPow {
+impl PyNode for ast::OperatorPow {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -608,7 +608,7 @@ impl Pyo3Node for crate::generic::OperatorPow {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorLShift {
+impl PyNode for ast::OperatorLShift {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -616,7 +616,7 @@ impl Pyo3Node for crate::generic::OperatorLShift {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorRShift {
+impl PyNode for ast::OperatorRShift {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -624,7 +624,7 @@ impl Pyo3Node for crate::generic::OperatorRShift {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorBitOr {
+impl PyNode for ast::OperatorBitOr {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -632,7 +632,7 @@ impl Pyo3Node for crate::generic::OperatorBitOr {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorBitXor {
+impl PyNode for ast::OperatorBitXor {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -640,7 +640,7 @@ impl Pyo3Node for crate::generic::OperatorBitXor {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorBitAnd {
+impl PyNode for ast::OperatorBitAnd {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -648,7 +648,7 @@ impl Pyo3Node for crate::generic::OperatorBitAnd {
     }
 }
 
-impl Pyo3Node for crate::generic::OperatorFloorDiv {
+impl PyNode for ast::OperatorFloorDiv {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -656,7 +656,7 @@ impl Pyo3Node for crate::generic::OperatorFloorDiv {
     }
 }
 
-impl Pyo3Node for crate::generic::Unaryop {
+impl PyNode for ast::Unaryop {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -664,7 +664,7 @@ impl Pyo3Node for crate::generic::Unaryop {
     }
 }
 
-impl Pyo3Node for crate::generic::UnaryopInvert {
+impl PyNode for ast::UnaryopInvert {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -672,7 +672,7 @@ impl Pyo3Node for crate::generic::UnaryopInvert {
     }
 }
 
-impl Pyo3Node for crate::generic::UnaryopNot {
+impl PyNode for ast::UnaryopNot {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -680,7 +680,7 @@ impl Pyo3Node for crate::generic::UnaryopNot {
     }
 }
 
-impl Pyo3Node for crate::generic::UnaryopUAdd {
+impl PyNode for ast::UnaryopUAdd {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -688,7 +688,7 @@ impl Pyo3Node for crate::generic::UnaryopUAdd {
     }
 }
 
-impl Pyo3Node for crate::generic::UnaryopUSub {
+impl PyNode for ast::UnaryopUSub {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -696,7 +696,7 @@ impl Pyo3Node for crate::generic::UnaryopUSub {
     }
 }
 
-impl Pyo3Node for crate::generic::Cmpop {
+impl PyNode for ast::Cmpop {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -704,7 +704,7 @@ impl Pyo3Node for crate::generic::Cmpop {
     }
 }
 
-impl Pyo3Node for crate::generic::CmpopEq {
+impl PyNode for ast::CmpopEq {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -712,7 +712,7 @@ impl Pyo3Node for crate::generic::CmpopEq {
     }
 }
 
-impl Pyo3Node for crate::generic::CmpopNotEq {
+impl PyNode for ast::CmpopNotEq {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -720,7 +720,7 @@ impl Pyo3Node for crate::generic::CmpopNotEq {
     }
 }
 
-impl Pyo3Node for crate::generic::CmpopLt {
+impl PyNode for ast::CmpopLt {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -728,7 +728,7 @@ impl Pyo3Node for crate::generic::CmpopLt {
     }
 }
 
-impl Pyo3Node for crate::generic::CmpopLtE {
+impl PyNode for ast::CmpopLtE {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -736,7 +736,7 @@ impl Pyo3Node for crate::generic::CmpopLtE {
     }
 }
 
-impl Pyo3Node for crate::generic::CmpopGt {
+impl PyNode for ast::CmpopGt {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -744,7 +744,7 @@ impl Pyo3Node for crate::generic::CmpopGt {
     }
 }
 
-impl Pyo3Node for crate::generic::CmpopGtE {
+impl PyNode for ast::CmpopGtE {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -752,7 +752,7 @@ impl Pyo3Node for crate::generic::CmpopGtE {
     }
 }
 
-impl Pyo3Node for crate::generic::CmpopIs {
+impl PyNode for ast::CmpopIs {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -760,7 +760,7 @@ impl Pyo3Node for crate::generic::CmpopIs {
     }
 }
 
-impl Pyo3Node for crate::generic::CmpopIsNot {
+impl PyNode for ast::CmpopIsNot {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -768,7 +768,7 @@ impl Pyo3Node for crate::generic::CmpopIsNot {
     }
 }
 
-impl Pyo3Node for crate::generic::CmpopIn {
+impl PyNode for ast::CmpopIn {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -776,7 +776,7 @@ impl Pyo3Node for crate::generic::CmpopIn {
     }
 }
 
-impl Pyo3Node for crate::generic::CmpopNotIn {
+impl PyNode for ast::CmpopNotIn {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -784,7 +784,7 @@ impl Pyo3Node for crate::generic::CmpopNotIn {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::Comprehension<R> {
+impl<R> PyNode for ast::Comprehension<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -792,7 +792,7 @@ impl<R> Pyo3Node for crate::generic::Comprehension<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::Excepthandler<R> {
+impl<R> PyNode for ast::Excepthandler<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -800,7 +800,7 @@ impl<R> Pyo3Node for crate::generic::Excepthandler<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::ExcepthandlerExceptHandler<R> {
+impl<R> PyNode for ast::ExcepthandlerExceptHandler<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -808,7 +808,7 @@ impl<R> Pyo3Node for crate::generic::ExcepthandlerExceptHandler<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::Arguments<R> {
+impl<R> PyNode for ast::Arguments<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -816,7 +816,7 @@ impl<R> Pyo3Node for crate::generic::Arguments<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::Arg<R> {
+impl<R> PyNode for ast::Arg<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -824,7 +824,7 @@ impl<R> Pyo3Node for crate::generic::Arg<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::Keyword<R> {
+impl<R> PyNode for ast::Keyword<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -832,7 +832,7 @@ impl<R> Pyo3Node for crate::generic::Keyword<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::Alias<R> {
+impl<R> PyNode for ast::Alias<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -840,7 +840,7 @@ impl<R> Pyo3Node for crate::generic::Alias<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::Withitem<R> {
+impl<R> PyNode for ast::Withitem<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -848,7 +848,7 @@ impl<R> Pyo3Node for crate::generic::Withitem<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::MatchCase<R> {
+impl<R> PyNode for ast::MatchCase<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -856,7 +856,7 @@ impl<R> Pyo3Node for crate::generic::MatchCase<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::Pattern<R> {
+impl<R> PyNode for ast::Pattern<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -864,7 +864,7 @@ impl<R> Pyo3Node for crate::generic::Pattern<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::PatternMatchValue<R> {
+impl<R> PyNode for ast::PatternMatchValue<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -872,7 +872,7 @@ impl<R> Pyo3Node for crate::generic::PatternMatchValue<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::PatternMatchSingleton<R> {
+impl<R> PyNode for ast::PatternMatchSingleton<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -880,7 +880,7 @@ impl<R> Pyo3Node for crate::generic::PatternMatchSingleton<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::PatternMatchSequence<R> {
+impl<R> PyNode for ast::PatternMatchSequence<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -888,7 +888,7 @@ impl<R> Pyo3Node for crate::generic::PatternMatchSequence<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::PatternMatchMapping<R> {
+impl<R> PyNode for ast::PatternMatchMapping<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -896,7 +896,7 @@ impl<R> Pyo3Node for crate::generic::PatternMatchMapping<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::PatternMatchClass<R> {
+impl<R> PyNode for ast::PatternMatchClass<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -904,7 +904,7 @@ impl<R> Pyo3Node for crate::generic::PatternMatchClass<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::PatternMatchStar<R> {
+impl<R> PyNode for ast::PatternMatchStar<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -912,7 +912,7 @@ impl<R> Pyo3Node for crate::generic::PatternMatchStar<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::PatternMatchAs<R> {
+impl<R> PyNode for ast::PatternMatchAs<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -920,7 +920,7 @@ impl<R> Pyo3Node for crate::generic::PatternMatchAs<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::PatternMatchOr<R> {
+impl<R> PyNode for ast::PatternMatchOr<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -928,7 +928,7 @@ impl<R> Pyo3Node for crate::generic::PatternMatchOr<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::TypeIgnore<R> {
+impl<R> PyNode for ast::TypeIgnore<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -936,7 +936,7 @@ impl<R> Pyo3Node for crate::generic::TypeIgnore<R> {
     }
 }
 
-impl<R> Pyo3Node for crate::generic::TypeIgnoreTypeIgnore<R> {
+impl<R> PyNode for ast::TypeIgnoreTypeIgnore<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -944,99 +944,99 @@ impl<R> Pyo3Node for crate::generic::TypeIgnoreTypeIgnore<R> {
     }
 }
 
-impl ToPyo3Ast for crate::generic::ExprContext {
+impl ToPyAst for ast::ExprContext {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cell = match &self {
-            crate::ExprContext::Load => crate::ExprContextLoad::py_type_cache(),
-            crate::ExprContext::Store => crate::ExprContextStore::py_type_cache(),
-            crate::ExprContext::Del => crate::ExprContextDel::py_type_cache(),
+            ast::ExprContext::Load => ast::ExprContextLoad::py_type_cache(),
+            ast::ExprContext::Store => ast::ExprContextStore::py_type_cache(),
+            ast::ExprContext::Del => ast::ExprContextDel::py_type_cache(),
         };
         Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
     }
 }
 
-impl ToPyo3Ast for crate::generic::Boolop {
+impl ToPyAst for ast::Boolop {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cell = match &self {
-            crate::Boolop::And => crate::BoolopAnd::py_type_cache(),
-            crate::Boolop::Or => crate::BoolopOr::py_type_cache(),
+            ast::Boolop::And => ast::BoolopAnd::py_type_cache(),
+            ast::Boolop::Or => ast::BoolopOr::py_type_cache(),
         };
         Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
     }
 }
 
-impl ToPyo3Ast for crate::generic::Operator {
+impl ToPyAst for ast::Operator {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cell = match &self {
-            crate::Operator::Add => crate::OperatorAdd::py_type_cache(),
-            crate::Operator::Sub => crate::OperatorSub::py_type_cache(),
-            crate::Operator::Mult => crate::OperatorMult::py_type_cache(),
-            crate::Operator::MatMult => crate::OperatorMatMult::py_type_cache(),
-            crate::Operator::Div => crate::OperatorDiv::py_type_cache(),
-            crate::Operator::Mod => crate::OperatorMod::py_type_cache(),
-            crate::Operator::Pow => crate::OperatorPow::py_type_cache(),
-            crate::Operator::LShift => crate::OperatorLShift::py_type_cache(),
-            crate::Operator::RShift => crate::OperatorRShift::py_type_cache(),
-            crate::Operator::BitOr => crate::OperatorBitOr::py_type_cache(),
-            crate::Operator::BitXor => crate::OperatorBitXor::py_type_cache(),
-            crate::Operator::BitAnd => crate::OperatorBitAnd::py_type_cache(),
-            crate::Operator::FloorDiv => crate::OperatorFloorDiv::py_type_cache(),
+            ast::Operator::Add => ast::OperatorAdd::py_type_cache(),
+            ast::Operator::Sub => ast::OperatorSub::py_type_cache(),
+            ast::Operator::Mult => ast::OperatorMult::py_type_cache(),
+            ast::Operator::MatMult => ast::OperatorMatMult::py_type_cache(),
+            ast::Operator::Div => ast::OperatorDiv::py_type_cache(),
+            ast::Operator::Mod => ast::OperatorMod::py_type_cache(),
+            ast::Operator::Pow => ast::OperatorPow::py_type_cache(),
+            ast::Operator::LShift => ast::OperatorLShift::py_type_cache(),
+            ast::Operator::RShift => ast::OperatorRShift::py_type_cache(),
+            ast::Operator::BitOr => ast::OperatorBitOr::py_type_cache(),
+            ast::Operator::BitXor => ast::OperatorBitXor::py_type_cache(),
+            ast::Operator::BitAnd => ast::OperatorBitAnd::py_type_cache(),
+            ast::Operator::FloorDiv => ast::OperatorFloorDiv::py_type_cache(),
         };
         Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
     }
 }
 
-impl ToPyo3Ast for crate::generic::Unaryop {
+impl ToPyAst for ast::Unaryop {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cell = match &self {
-            crate::Unaryop::Invert => crate::UnaryopInvert::py_type_cache(),
-            crate::Unaryop::Not => crate::UnaryopNot::py_type_cache(),
-            crate::Unaryop::UAdd => crate::UnaryopUAdd::py_type_cache(),
-            crate::Unaryop::USub => crate::UnaryopUSub::py_type_cache(),
+            ast::Unaryop::Invert => ast::UnaryopInvert::py_type_cache(),
+            ast::Unaryop::Not => ast::UnaryopNot::py_type_cache(),
+            ast::Unaryop::UAdd => ast::UnaryopUAdd::py_type_cache(),
+            ast::Unaryop::USub => ast::UnaryopUSub::py_type_cache(),
         };
         Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
     }
 }
 
-impl ToPyo3Ast for crate::generic::Cmpop {
+impl ToPyAst for ast::Cmpop {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cell = match &self {
-            crate::Cmpop::Eq => crate::CmpopEq::py_type_cache(),
-            crate::Cmpop::NotEq => crate::CmpopNotEq::py_type_cache(),
-            crate::Cmpop::Lt => crate::CmpopLt::py_type_cache(),
-            crate::Cmpop::LtE => crate::CmpopLtE::py_type_cache(),
-            crate::Cmpop::Gt => crate::CmpopGt::py_type_cache(),
-            crate::Cmpop::GtE => crate::CmpopGtE::py_type_cache(),
-            crate::Cmpop::Is => crate::CmpopIs::py_type_cache(),
-            crate::Cmpop::IsNot => crate::CmpopIsNot::py_type_cache(),
-            crate::Cmpop::In => crate::CmpopIn::py_type_cache(),
-            crate::Cmpop::NotIn => crate::CmpopNotIn::py_type_cache(),
+            ast::Cmpop::Eq => ast::CmpopEq::py_type_cache(),
+            ast::Cmpop::NotEq => ast::CmpopNotEq::py_type_cache(),
+            ast::Cmpop::Lt => ast::CmpopLt::py_type_cache(),
+            ast::Cmpop::LtE => ast::CmpopLtE::py_type_cache(),
+            ast::Cmpop::Gt => ast::CmpopGt::py_type_cache(),
+            ast::Cmpop::GtE => ast::CmpopGtE::py_type_cache(),
+            ast::Cmpop::Is => ast::CmpopIs::py_type_cache(),
+            ast::Cmpop::IsNot => ast::CmpopIsNot::py_type_cache(),
+            ast::Cmpop::In => ast::CmpopIn::py_type_cache(),
+            ast::Cmpop::NotIn => ast::CmpopNotIn::py_type_cache(),
         };
         Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
     }
 }
 
-impl ToPyo3Ast for crate::generic::Mod<TextRange> {
+impl ToPyAst for ast::Mod<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
-            crate::Mod::Module(cons) => cons.to_pyo3_ast(py)?,
-            crate::Mod::Interactive(cons) => cons.to_pyo3_ast(py)?,
-            crate::Mod::Expression(cons) => cons.to_pyo3_ast(py)?,
-            crate::Mod::FunctionType(cons) => cons.to_pyo3_ast(py)?,
+            ast::Mod::Module(cons) => cons.to_py_ast(py)?,
+            ast::Mod::Interactive(cons) => cons.to_py_ast(py)?,
+            ast::Mod::Expression(cons) => cons.to_py_ast(py)?,
+            ast::Mod::FunctionType(cons) => cons.to_py_ast(py)?,
         };
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ModModule<TextRange> {
+impl ToPyAst for ast::ModModule<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1046,15 +1046,15 @@ impl ToPyo3Ast for crate::ModModule<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((body.to_pyo3_ast(py)?, type_ignores.to_pyo3_ast(py)?))?;
+            .call1((body.to_py_ast(py)?, type_ignores.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ModInteractive<TextRange> {
+impl ToPyAst for ast::ModInteractive<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1062,15 +1062,15 @@ impl ToPyo3Ast for crate::ModInteractive<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ModExpression<TextRange> {
+impl ToPyAst for ast::ModExpression<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1078,15 +1078,15 @@ impl ToPyo3Ast for crate::ModExpression<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ModFunctionType<TextRange> {
+impl ToPyAst for ast::ModFunctionType<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1096,51 +1096,51 @@ impl ToPyo3Ast for crate::ModFunctionType<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((argtypes.to_pyo3_ast(py)?, returns.to_pyo3_ast(py)?))?;
+            .call1((argtypes.to_py_ast(py)?, returns.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::generic::Stmt<TextRange> {
+impl ToPyAst for ast::Stmt<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
-            crate::Stmt::FunctionDef(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AsyncFunctionDef(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::ClassDef(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Return(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Delete(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Assign(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AugAssign(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AnnAssign(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::For(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AsyncFor(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::While(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::If(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::With(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AsyncWith(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Match(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Raise(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Try(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::TryStar(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Assert(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Import(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::ImportFrom(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Global(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Nonlocal(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Expr(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Pass(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Break(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Continue(cons) => cons.to_pyo3_ast(py)?,
+            ast::Stmt::FunctionDef(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AsyncFunctionDef(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::ClassDef(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Return(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Delete(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Assign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AugAssign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AnnAssign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::For(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AsyncFor(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::While(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::If(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::With(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AsyncWith(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Match(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Raise(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Try(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::TryStar(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Assert(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Import(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::ImportFrom(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Global(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Nonlocal(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Expr(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Pass(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Break(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Continue(cons) => cons.to_py_ast(py)?,
         };
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtFunctionDef<TextRange> {
+impl ToPyAst for ast::StmtFunctionDef<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1154,21 +1154,21 @@ impl ToPyo3Ast for crate::StmtFunctionDef<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            name.to_pyo3_ast(py)?,
-            args.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            decorator_list.to_pyo3_ast(py)?,
-            returns.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            name.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            decorator_list.to_py_ast(py)?,
+            returns.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtAsyncFunctionDef<TextRange> {
+impl ToPyAst for ast::StmtAsyncFunctionDef<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1182,21 +1182,21 @@ impl ToPyo3Ast for crate::StmtAsyncFunctionDef<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            name.to_pyo3_ast(py)?,
-            args.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            decorator_list.to_pyo3_ast(py)?,
-            returns.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            name.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            decorator_list.to_py_ast(py)?,
+            returns.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtClassDef<TextRange> {
+impl ToPyAst for ast::StmtClassDef<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1209,20 +1209,20 @@ impl ToPyo3Ast for crate::StmtClassDef<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            name.to_pyo3_ast(py)?,
-            bases.to_pyo3_ast(py)?,
-            keywords.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            decorator_list.to_pyo3_ast(py)?,
+            name.to_py_ast(py)?,
+            bases.to_py_ast(py)?,
+            keywords.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            decorator_list.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtReturn<TextRange> {
+impl ToPyAst for ast::StmtReturn<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1230,15 +1230,15 @@ impl ToPyo3Ast for crate::StmtReturn<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtDelete<TextRange> {
+impl ToPyAst for ast::StmtDelete<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1246,15 +1246,15 @@ impl ToPyo3Ast for crate::StmtDelete<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((targets.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((targets.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtAssign<TextRange> {
+impl ToPyAst for ast::StmtAssign<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1265,18 +1265,18 @@ impl ToPyo3Ast for crate::StmtAssign<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            targets.to_pyo3_ast(py)?,
-            value.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            targets.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtAugAssign<TextRange> {
+impl ToPyAst for ast::StmtAugAssign<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1287,18 +1287,18 @@ impl ToPyo3Ast for crate::StmtAugAssign<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            target.to_pyo3_ast(py)?,
-            op.to_pyo3_ast(py)?,
-            value.to_pyo3_ast(py)?,
+            target.to_py_ast(py)?,
+            op.to_py_ast(py)?,
+            value.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtAnnAssign<TextRange> {
+impl ToPyAst for ast::StmtAnnAssign<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1310,19 +1310,19 @@ impl ToPyo3Ast for crate::StmtAnnAssign<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            target.to_pyo3_ast(py)?,
-            annotation.to_pyo3_ast(py)?,
-            value.to_pyo3_ast(py)?,
-            simple.to_pyo3_ast(py)?,
+            target.to_py_ast(py)?,
+            annotation.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+            simple.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtFor<TextRange> {
+impl ToPyAst for ast::StmtFor<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1335,20 +1335,20 @@ impl ToPyo3Ast for crate::StmtFor<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            target.to_pyo3_ast(py)?,
-            iter.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            target.to_py_ast(py)?,
+            iter.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtAsyncFor<TextRange> {
+impl ToPyAst for ast::StmtAsyncFor<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1361,20 +1361,20 @@ impl ToPyo3Ast for crate::StmtAsyncFor<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            target.to_pyo3_ast(py)?,
-            iter.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            target.to_py_ast(py)?,
+            iter.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtWhile<TextRange> {
+impl ToPyAst for ast::StmtWhile<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1385,18 +1385,18 @@ impl ToPyo3Ast for crate::StmtWhile<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            test.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
+            test.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtIf<TextRange> {
+impl ToPyAst for ast::StmtIf<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1407,18 +1407,18 @@ impl ToPyo3Ast for crate::StmtIf<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            test.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
+            test.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtWith<TextRange> {
+impl ToPyAst for ast::StmtWith<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1429,18 +1429,18 @@ impl ToPyo3Ast for crate::StmtWith<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            items.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            items.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtAsyncWith<TextRange> {
+impl ToPyAst for ast::StmtAsyncWith<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1451,18 +1451,18 @@ impl ToPyo3Ast for crate::StmtAsyncWith<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            items.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            items.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtMatch<TextRange> {
+impl ToPyAst for ast::StmtMatch<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1472,15 +1472,15 @@ impl ToPyo3Ast for crate::StmtMatch<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((subject.to_pyo3_ast(py)?, cases.to_pyo3_ast(py)?))?;
+            .call1((subject.to_py_ast(py)?, cases.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtRaise<TextRange> {
+impl ToPyAst for ast::StmtRaise<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1489,16 +1489,16 @@ impl ToPyo3Ast for crate::StmtRaise<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((exc.to_pyo3_ast(py)?, cause.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((exc.to_py_ast(py)?, cause.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtTry<TextRange> {
+impl ToPyAst for ast::StmtTry<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1510,19 +1510,19 @@ impl ToPyo3Ast for crate::StmtTry<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            body.to_pyo3_ast(py)?,
-            handlers.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
-            finalbody.to_pyo3_ast(py)?,
+            body.to_py_ast(py)?,
+            handlers.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            finalbody.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtTryStar<TextRange> {
+impl ToPyAst for ast::StmtTryStar<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1534,19 +1534,19 @@ impl ToPyo3Ast for crate::StmtTryStar<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            body.to_pyo3_ast(py)?,
-            handlers.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
-            finalbody.to_pyo3_ast(py)?,
+            body.to_py_ast(py)?,
+            handlers.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            finalbody.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtAssert<TextRange> {
+impl ToPyAst for ast::StmtAssert<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1555,16 +1555,16 @@ impl ToPyo3Ast for crate::StmtAssert<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((test.to_pyo3_ast(py)?, msg.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((test.to_py_ast(py)?, msg.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtImport<TextRange> {
+impl ToPyAst for ast::StmtImport<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1572,15 +1572,15 @@ impl ToPyo3Ast for crate::StmtImport<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtImportFrom<TextRange> {
+impl ToPyAst for ast::StmtImportFrom<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1591,8 +1591,8 @@ impl ToPyo3Ast for crate::StmtImportFrom<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            module.to_pyo3_ast(py)?,
-            names.to_pyo3_ast(py)?,
+            module.to_py_ast(py)?,
+            names.to_py_ast(py)?,
             level.map_or_else(|| py.None(), |level| level.to_u32().to_object(py)),
         ))?;
 
@@ -1600,9 +1600,9 @@ impl ToPyo3Ast for crate::StmtImportFrom<TextRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtGlobal<TextRange> {
+impl ToPyAst for ast::StmtGlobal<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1610,15 +1610,15 @@ impl ToPyo3Ast for crate::StmtGlobal<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtNonlocal<TextRange> {
+impl ToPyAst for ast::StmtNonlocal<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1626,15 +1626,15 @@ impl ToPyo3Ast for crate::StmtNonlocal<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtExpr<TextRange> {
+impl ToPyAst for ast::StmtExpr<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1642,15 +1642,15 @@ impl ToPyo3Ast for crate::StmtExpr<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtPass<TextRange> {
+impl ToPyAst for ast::StmtPass<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
@@ -1660,9 +1660,9 @@ impl ToPyo3Ast for crate::StmtPass<TextRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtBreak<TextRange> {
+impl ToPyAst for ast::StmtBreak<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
@@ -1672,9 +1672,9 @@ impl ToPyo3Ast for crate::StmtBreak<TextRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtContinue<TextRange> {
+impl ToPyAst for ast::StmtContinue<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
@@ -1684,45 +1684,45 @@ impl ToPyo3Ast for crate::StmtContinue<TextRange> {
     }
 }
 
-impl ToPyo3Ast for crate::generic::Expr<TextRange> {
+impl ToPyAst for ast::Expr<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
-            crate::Expr::BoolOp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::NamedExpr(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::BinOp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::UnaryOp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Lambda(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::IfExp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Dict(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Set(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::ListComp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::SetComp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::DictComp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::GeneratorExp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Await(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Yield(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::YieldFrom(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Compare(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Call(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::FormattedValue(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::JoinedStr(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Constant(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Attribute(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Subscript(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Starred(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Name(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::List(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Tuple(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Slice(cons) => cons.to_pyo3_ast(py)?,
+            ast::Expr::BoolOp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::NamedExpr(cons) => cons.to_py_ast(py)?,
+            ast::Expr::BinOp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::UnaryOp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Lambda(cons) => cons.to_py_ast(py)?,
+            ast::Expr::IfExp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Dict(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Set(cons) => cons.to_py_ast(py)?,
+            ast::Expr::ListComp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::SetComp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::DictComp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::GeneratorExp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Await(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Yield(cons) => cons.to_py_ast(py)?,
+            ast::Expr::YieldFrom(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Compare(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Call(cons) => cons.to_py_ast(py)?,
+            ast::Expr::FormattedValue(cons) => cons.to_py_ast(py)?,
+            ast::Expr::JoinedStr(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Constant(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Attribute(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Subscript(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Starred(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Name(cons) => cons.to_py_ast(py)?,
+            ast::Expr::List(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Tuple(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Slice(cons) => cons.to_py_ast(py)?,
         };
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprBoolOp<TextRange> {
+impl ToPyAst for ast::ExprBoolOp<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1731,16 +1731,16 @@ impl ToPyo3Ast for crate::ExprBoolOp<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((op.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((op.to_py_ast(py)?, values.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprNamedExpr<TextRange> {
+impl ToPyAst for ast::ExprNamedExpr<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1750,15 +1750,15 @@ impl ToPyo3Ast for crate::ExprNamedExpr<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((target.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
+            .call1((target.to_py_ast(py)?, value.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprBinOp<TextRange> {
+impl ToPyAst for ast::ExprBinOp<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1769,18 +1769,18 @@ impl ToPyo3Ast for crate::ExprBinOp<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            left.to_pyo3_ast(py)?,
-            op.to_pyo3_ast(py)?,
-            right.to_pyo3_ast(py)?,
+            left.to_py_ast(py)?,
+            op.to_py_ast(py)?,
+            right.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprUnaryOp<TextRange> {
+impl ToPyAst for ast::ExprUnaryOp<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1789,16 +1789,16 @@ impl ToPyo3Ast for crate::ExprUnaryOp<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((op.to_pyo3_ast(py)?, operand.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((op.to_py_ast(py)?, operand.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprLambda<TextRange> {
+impl ToPyAst for ast::ExprLambda<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1807,16 +1807,16 @@ impl ToPyo3Ast for crate::ExprLambda<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((args.to_pyo3_ast(py)?, body.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((args.to_py_ast(py)?, body.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprIfExp<TextRange> {
+impl ToPyAst for ast::ExprIfExp<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1827,18 +1827,18 @@ impl ToPyo3Ast for crate::ExprIfExp<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            test.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
+            test.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprDict<TextRange> {
+impl ToPyAst for ast::ExprDict<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1848,15 +1848,15 @@ impl ToPyo3Ast for crate::ExprDict<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((keys.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
+            .call1((keys.to_py_ast(py)?, values.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprSet<TextRange> {
+impl ToPyAst for ast::ExprSet<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1864,15 +1864,15 @@ impl ToPyo3Ast for crate::ExprSet<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprListComp<TextRange> {
+impl ToPyAst for ast::ExprListComp<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1882,15 +1882,15 @@ impl ToPyo3Ast for crate::ExprListComp<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
+            .call1((elt.to_py_ast(py)?, generators.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprSetComp<TextRange> {
+impl ToPyAst for ast::ExprSetComp<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1900,15 +1900,15 @@ impl ToPyo3Ast for crate::ExprSetComp<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
+            .call1((elt.to_py_ast(py)?, generators.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprDictComp<TextRange> {
+impl ToPyAst for ast::ExprDictComp<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1919,18 +1919,18 @@ impl ToPyo3Ast for crate::ExprDictComp<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            key.to_pyo3_ast(py)?,
-            value.to_pyo3_ast(py)?,
-            generators.to_pyo3_ast(py)?,
+            key.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+            generators.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprGeneratorExp<TextRange> {
+impl ToPyAst for ast::ExprGeneratorExp<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1940,15 +1940,15 @@ impl ToPyo3Ast for crate::ExprGeneratorExp<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
+            .call1((elt.to_py_ast(py)?, generators.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprAwait<TextRange> {
+impl ToPyAst for ast::ExprAwait<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1956,15 +1956,15 @@ impl ToPyo3Ast for crate::ExprAwait<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprYield<TextRange> {
+impl ToPyAst for ast::ExprYield<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1972,15 +1972,15 @@ impl ToPyo3Ast for crate::ExprYield<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprYieldFrom<TextRange> {
+impl ToPyAst for ast::ExprYieldFrom<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -1988,15 +1988,15 @@ impl ToPyo3Ast for crate::ExprYieldFrom<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprCompare<TextRange> {
+impl ToPyAst for ast::ExprCompare<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2007,18 +2007,18 @@ impl ToPyo3Ast for crate::ExprCompare<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            left.to_pyo3_ast(py)?,
-            ops.to_pyo3_ast(py)?,
-            comparators.to_pyo3_ast(py)?,
+            left.to_py_ast(py)?,
+            ops.to_py_ast(py)?,
+            comparators.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprCall<TextRange> {
+impl ToPyAst for ast::ExprCall<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2029,18 +2029,18 @@ impl ToPyo3Ast for crate::ExprCall<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            func.to_pyo3_ast(py)?,
-            args.to_pyo3_ast(py)?,
-            keywords.to_pyo3_ast(py)?,
+            func.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            keywords.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprFormattedValue<TextRange> {
+impl ToPyAst for ast::ExprFormattedValue<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2051,18 +2051,18 @@ impl ToPyo3Ast for crate::ExprFormattedValue<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            value.to_pyo3_ast(py)?,
-            conversion.to_pyo3_ast(py)?,
-            format_spec.to_pyo3_ast(py)?,
+            value.to_py_ast(py)?,
+            conversion.to_py_ast(py)?,
+            format_spec.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprJoinedStr<TextRange> {
+impl ToPyAst for ast::ExprJoinedStr<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2070,15 +2070,15 @@ impl ToPyo3Ast for crate::ExprJoinedStr<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((values.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((values.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprConstant<TextRange> {
+impl ToPyAst for ast::ExprConstant<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2088,15 +2088,15 @@ impl ToPyo3Ast for crate::ExprConstant<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((value.to_object(py), kind.to_pyo3_ast(py)?))?;
+            .call1((constant_to_object(value, py), kind.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprAttribute<TextRange> {
+impl ToPyAst for ast::ExprAttribute<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2107,18 +2107,18 @@ impl ToPyo3Ast for crate::ExprAttribute<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            value.to_pyo3_ast(py)?,
-            attr.to_pyo3_ast(py)?,
-            ctx.to_pyo3_ast(py)?,
+            value.to_py_ast(py)?,
+            attr.to_py_ast(py)?,
+            ctx.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprSubscript<TextRange> {
+impl ToPyAst for ast::ExprSubscript<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2129,18 +2129,18 @@ impl ToPyo3Ast for crate::ExprSubscript<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            value.to_pyo3_ast(py)?,
-            slice.to_pyo3_ast(py)?,
-            ctx.to_pyo3_ast(py)?,
+            value.to_py_ast(py)?,
+            slice.to_py_ast(py)?,
+            ctx.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprStarred<TextRange> {
+impl ToPyAst for ast::ExprStarred<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2149,16 +2149,16 @@ impl ToPyo3Ast for crate::ExprStarred<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((value.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprName<TextRange> {
+impl ToPyAst for ast::ExprName<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2168,15 +2168,15 @@ impl ToPyo3Ast for crate::ExprName<TextRange> {
         } = self;
 
         let instance =
-            Py::<PyAny>::as_ref(&cache.0, py).call1((id.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+            Py::<PyAny>::as_ref(&cache.0, py).call1((id.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprList<TextRange> {
+impl ToPyAst for ast::ExprList<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2185,16 +2185,16 @@ impl ToPyo3Ast for crate::ExprList<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprTuple<TextRange> {
+impl ToPyAst for ast::ExprTuple<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2203,16 +2203,16 @@ impl ToPyo3Ast for crate::ExprTuple<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprSlice<TextRange> {
+impl ToPyAst for ast::ExprSlice<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2223,18 +2223,18 @@ impl ToPyo3Ast for crate::ExprSlice<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            lower.to_pyo3_ast(py)?,
-            upper.to_pyo3_ast(py)?,
-            step.to_pyo3_ast(py)?,
+            lower.to_py_ast(py)?,
+            upper.to_py_ast(py)?,
+            step.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::Comprehension<TextRange> {
+impl ToPyAst for ast::Comprehension<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2246,29 +2246,29 @@ impl ToPyo3Ast for crate::Comprehension<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            target.to_pyo3_ast(py)?,
-            iter.to_pyo3_ast(py)?,
-            ifs.to_pyo3_ast(py)?,
-            is_async.to_pyo3_ast(py)?,
+            target.to_py_ast(py)?,
+            iter.to_py_ast(py)?,
+            ifs.to_py_ast(py)?,
+            is_async.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::generic::Excepthandler<TextRange> {
+impl ToPyAst for ast::Excepthandler<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
-            crate::Excepthandler::ExceptHandler(cons) => cons.to_pyo3_ast(py)?,
+            ast::Excepthandler::ExceptHandler(cons) => cons.to_py_ast(py)?,
         };
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<TextRange> {
+impl ToPyAst for ast::ExcepthandlerExceptHandler<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2279,18 +2279,18 @@ impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            type_.to_pyo3_ast(py)?,
-            name.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
+            type_.to_py_ast(py)?,
+            name.to_py_ast(py)?,
+            body.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::Arguments<TextRange> {
+impl ToPyAst for ast::Arguments<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2305,22 +2305,22 @@ impl ToPyo3Ast for crate::Arguments<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            posonlyargs.to_pyo3_ast(py)?,
-            args.to_pyo3_ast(py)?,
-            vararg.to_pyo3_ast(py)?,
-            kwonlyargs.to_pyo3_ast(py)?,
-            kw_defaults.to_pyo3_ast(py)?,
-            kwarg.to_pyo3_ast(py)?,
-            defaults.to_pyo3_ast(py)?,
+            posonlyargs.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            vararg.to_py_ast(py)?,
+            kwonlyargs.to_py_ast(py)?,
+            kw_defaults.to_py_ast(py)?,
+            kwarg.to_py_ast(py)?,
+            defaults.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::Arg<TextRange> {
+impl ToPyAst for ast::Arg<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2331,18 +2331,18 @@ impl ToPyo3Ast for crate::Arg<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            arg.to_pyo3_ast(py)?,
-            annotation.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            arg.to_py_ast(py)?,
+            annotation.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::Keyword<TextRange> {
+impl ToPyAst for ast::Keyword<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2351,16 +2351,16 @@ impl ToPyo3Ast for crate::Keyword<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((arg.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((arg.to_py_ast(py)?, value.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::Alias<TextRange> {
+impl ToPyAst for ast::Alias<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2370,15 +2370,15 @@ impl ToPyo3Ast for crate::Alias<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((name.to_pyo3_ast(py)?, asname.to_pyo3_ast(py)?))?;
+            .call1((name.to_py_ast(py)?, asname.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::Withitem<TextRange> {
+impl ToPyAst for ast::Withitem<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2387,18 +2387,16 @@ impl ToPyo3Ast for crate::Withitem<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            context_expr.to_pyo3_ast(py)?,
-            optional_vars.to_pyo3_ast(py)?,
-        ))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((context_expr.to_py_ast(py)?, optional_vars.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::MatchCase<TextRange> {
+impl ToPyAst for ast::MatchCase<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2409,35 +2407,35 @@ impl ToPyo3Ast for crate::MatchCase<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            pattern.to_pyo3_ast(py)?,
-            guard.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
+            pattern.to_py_ast(py)?,
+            guard.to_py_ast(py)?,
+            body.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::generic::Pattern<TextRange> {
+impl ToPyAst for ast::Pattern<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
-            crate::Pattern::MatchValue(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchSingleton(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchSequence(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchMapping(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchClass(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchStar(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchAs(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchOr(cons) => cons.to_pyo3_ast(py)?,
+            ast::Pattern::MatchValue(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchSingleton(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchSequence(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchMapping(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchClass(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchStar(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchAs(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchOr(cons) => cons.to_py_ast(py)?,
         };
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchValue<TextRange> {
+impl ToPyAst for ast::PatternMatchValue<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2445,15 +2443,15 @@ impl ToPyo3Ast for crate::PatternMatchValue<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchSingleton<TextRange> {
+impl ToPyAst for ast::PatternMatchSingleton<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2461,15 +2459,15 @@ impl ToPyo3Ast for crate::PatternMatchSingleton<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_object(py),))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((constant_to_object(value, py),))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchSequence<TextRange> {
+impl ToPyAst for ast::PatternMatchSequence<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2477,15 +2475,15 @@ impl ToPyo3Ast for crate::PatternMatchSequence<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchMapping<TextRange> {
+impl ToPyAst for ast::PatternMatchMapping<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2496,18 +2494,18 @@ impl ToPyo3Ast for crate::PatternMatchMapping<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            keys.to_pyo3_ast(py)?,
-            patterns.to_pyo3_ast(py)?,
-            rest.to_pyo3_ast(py)?,
+            keys.to_py_ast(py)?,
+            patterns.to_py_ast(py)?,
+            rest.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchClass<TextRange> {
+impl ToPyAst for ast::PatternMatchClass<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2519,19 +2517,19 @@ impl ToPyo3Ast for crate::PatternMatchClass<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            cls.to_pyo3_ast(py)?,
-            patterns.to_pyo3_ast(py)?,
-            kwd_attrs.to_pyo3_ast(py)?,
-            kwd_patterns.to_pyo3_ast(py)?,
+            cls.to_py_ast(py)?,
+            patterns.to_py_ast(py)?,
+            kwd_attrs.to_py_ast(py)?,
+            kwd_patterns.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchStar<TextRange> {
+impl ToPyAst for ast::PatternMatchStar<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2539,15 +2537,15 @@ impl ToPyo3Ast for crate::PatternMatchStar<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchAs<TextRange> {
+impl ToPyAst for ast::PatternMatchAs<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2557,15 +2555,15 @@ impl ToPyo3Ast for crate::PatternMatchAs<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((pattern.to_pyo3_ast(py)?, name.to_pyo3_ast(py)?))?;
+            .call1((pattern.to_py_ast(py)?, name.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchOr<TextRange> {
+impl ToPyAst for ast::PatternMatchOr<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2573,25 +2571,25 @@ impl ToPyo3Ast for crate::PatternMatchOr<TextRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::generic::TypeIgnore<TextRange> {
+impl ToPyAst for ast::TypeIgnore<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
-            crate::TypeIgnore::TypeIgnore(cons) => cons.to_pyo3_ast(py)?,
+            ast::TypeIgnore::TypeIgnore(cons) => cons.to_py_ast(py)?,
         };
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::TypeIgnoreTypeIgnore<TextRange> {
+impl ToPyAst for ast::TypeIgnoreTypeIgnore<TextRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2601,28 +2599,28 @@ impl ToPyo3Ast for crate::TypeIgnoreTypeIgnore<TextRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((lineno.to_u32().to_object(py), tag.to_pyo3_ast(py)?))?;
+            .call1((lineno.to_u32().to_object(py), tag.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::generic::Mod<SourceRange> {
+impl ToPyAst for ast::Mod<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
-            crate::Mod::Module(cons) => cons.to_pyo3_ast(py)?,
-            crate::Mod::Interactive(cons) => cons.to_pyo3_ast(py)?,
-            crate::Mod::Expression(cons) => cons.to_pyo3_ast(py)?,
-            crate::Mod::FunctionType(cons) => cons.to_pyo3_ast(py)?,
+            ast::Mod::Module(cons) => cons.to_py_ast(py)?,
+            ast::Mod::Interactive(cons) => cons.to_py_ast(py)?,
+            ast::Mod::Expression(cons) => cons.to_py_ast(py)?,
+            ast::Mod::FunctionType(cons) => cons.to_py_ast(py)?,
         };
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ModModule<SourceRange> {
+impl ToPyAst for ast::ModModule<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2632,15 +2630,15 @@ impl ToPyo3Ast for crate::ModModule<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((body.to_pyo3_ast(py)?, type_ignores.to_pyo3_ast(py)?))?;
+            .call1((body.to_py_ast(py)?, type_ignores.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ModInteractive<SourceRange> {
+impl ToPyAst for ast::ModInteractive<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2648,15 +2646,15 @@ impl ToPyo3Ast for crate::ModInteractive<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ModExpression<SourceRange> {
+impl ToPyAst for ast::ModExpression<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2664,15 +2662,15 @@ impl ToPyo3Ast for crate::ModExpression<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_py_ast(py)?,))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ModFunctionType<SourceRange> {
+impl ToPyAst for ast::ModFunctionType<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2682,51 +2680,51 @@ impl ToPyo3Ast for crate::ModFunctionType<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((argtypes.to_pyo3_ast(py)?, returns.to_pyo3_ast(py)?))?;
+            .call1((argtypes.to_py_ast(py)?, returns.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::generic::Stmt<SourceRange> {
+impl ToPyAst for ast::Stmt<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
-            crate::Stmt::FunctionDef(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AsyncFunctionDef(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::ClassDef(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Return(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Delete(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Assign(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AugAssign(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AnnAssign(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::For(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AsyncFor(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::While(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::If(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::With(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AsyncWith(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Match(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Raise(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Try(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::TryStar(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Assert(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Import(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::ImportFrom(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Global(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Nonlocal(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Expr(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Pass(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Break(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Continue(cons) => cons.to_pyo3_ast(py)?,
+            ast::Stmt::FunctionDef(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AsyncFunctionDef(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::ClassDef(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Return(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Delete(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Assign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AugAssign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AnnAssign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::For(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AsyncFor(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::While(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::If(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::With(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AsyncWith(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Match(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Raise(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Try(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::TryStar(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Assert(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Import(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::ImportFrom(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Global(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Nonlocal(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Expr(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Pass(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Break(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Continue(cons) => cons.to_py_ast(py)?,
         };
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::StmtFunctionDef<SourceRange> {
+impl ToPyAst for ast::StmtFunctionDef<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2740,12 +2738,12 @@ impl ToPyo3Ast for crate::StmtFunctionDef<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            name.to_pyo3_ast(py)?,
-            args.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            decorator_list.to_pyo3_ast(py)?,
-            returns.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            name.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            decorator_list.to_py_ast(py)?,
+            returns.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -2760,9 +2758,9 @@ impl ToPyo3Ast for crate::StmtFunctionDef<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtAsyncFunctionDef<SourceRange> {
+impl ToPyAst for ast::StmtAsyncFunctionDef<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2776,12 +2774,12 @@ impl ToPyo3Ast for crate::StmtAsyncFunctionDef<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            name.to_pyo3_ast(py)?,
-            args.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            decorator_list.to_pyo3_ast(py)?,
-            returns.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            name.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            decorator_list.to_py_ast(py)?,
+            returns.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -2796,9 +2794,9 @@ impl ToPyo3Ast for crate::StmtAsyncFunctionDef<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtClassDef<SourceRange> {
+impl ToPyAst for ast::StmtClassDef<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2811,11 +2809,11 @@ impl ToPyo3Ast for crate::StmtClassDef<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            name.to_pyo3_ast(py)?,
-            bases.to_pyo3_ast(py)?,
-            keywords.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            decorator_list.to_pyo3_ast(py)?,
+            name.to_py_ast(py)?,
+            bases.to_py_ast(py)?,
+            keywords.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            decorator_list.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -2830,9 +2828,9 @@ impl ToPyo3Ast for crate::StmtClassDef<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtReturn<SourceRange> {
+impl ToPyAst for ast::StmtReturn<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2840,7 +2838,7 @@ impl ToPyo3Ast for crate::StmtReturn<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -2854,9 +2852,9 @@ impl ToPyo3Ast for crate::StmtReturn<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtDelete<SourceRange> {
+impl ToPyAst for ast::StmtDelete<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2864,7 +2862,7 @@ impl ToPyo3Ast for crate::StmtDelete<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((targets.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((targets.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -2878,9 +2876,9 @@ impl ToPyo3Ast for crate::StmtDelete<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtAssign<SourceRange> {
+impl ToPyAst for ast::StmtAssign<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2891,9 +2889,9 @@ impl ToPyo3Ast for crate::StmtAssign<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            targets.to_pyo3_ast(py)?,
-            value.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            targets.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -2908,9 +2906,9 @@ impl ToPyo3Ast for crate::StmtAssign<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtAugAssign<SourceRange> {
+impl ToPyAst for ast::StmtAugAssign<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2921,9 +2919,9 @@ impl ToPyo3Ast for crate::StmtAugAssign<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            target.to_pyo3_ast(py)?,
-            op.to_pyo3_ast(py)?,
-            value.to_pyo3_ast(py)?,
+            target.to_py_ast(py)?,
+            op.to_py_ast(py)?,
+            value.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -2938,9 +2936,9 @@ impl ToPyo3Ast for crate::StmtAugAssign<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtAnnAssign<SourceRange> {
+impl ToPyAst for ast::StmtAnnAssign<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2952,10 +2950,10 @@ impl ToPyo3Ast for crate::StmtAnnAssign<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            target.to_pyo3_ast(py)?,
-            annotation.to_pyo3_ast(py)?,
-            value.to_pyo3_ast(py)?,
-            simple.to_pyo3_ast(py)?,
+            target.to_py_ast(py)?,
+            annotation.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+            simple.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -2970,9 +2968,9 @@ impl ToPyo3Ast for crate::StmtAnnAssign<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtFor<SourceRange> {
+impl ToPyAst for ast::StmtFor<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -2985,11 +2983,11 @@ impl ToPyo3Ast for crate::StmtFor<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            target.to_pyo3_ast(py)?,
-            iter.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            target.to_py_ast(py)?,
+            iter.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3004,9 +3002,9 @@ impl ToPyo3Ast for crate::StmtFor<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtAsyncFor<SourceRange> {
+impl ToPyAst for ast::StmtAsyncFor<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3019,11 +3017,11 @@ impl ToPyo3Ast for crate::StmtAsyncFor<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            target.to_pyo3_ast(py)?,
-            iter.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            target.to_py_ast(py)?,
+            iter.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3038,9 +3036,9 @@ impl ToPyo3Ast for crate::StmtAsyncFor<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtWhile<SourceRange> {
+impl ToPyAst for ast::StmtWhile<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3051,9 +3049,9 @@ impl ToPyo3Ast for crate::StmtWhile<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            test.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
+            test.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3068,9 +3066,9 @@ impl ToPyo3Ast for crate::StmtWhile<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtIf<SourceRange> {
+impl ToPyAst for ast::StmtIf<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3081,9 +3079,9 @@ impl ToPyo3Ast for crate::StmtIf<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            test.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
+            test.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3098,9 +3096,9 @@ impl ToPyo3Ast for crate::StmtIf<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtWith<SourceRange> {
+impl ToPyAst for ast::StmtWith<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3111,9 +3109,9 @@ impl ToPyo3Ast for crate::StmtWith<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            items.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            items.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3128,9 +3126,9 @@ impl ToPyo3Ast for crate::StmtWith<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtAsyncWith<SourceRange> {
+impl ToPyAst for ast::StmtAsyncWith<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3141,9 +3139,9 @@ impl ToPyo3Ast for crate::StmtAsyncWith<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            items.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            items.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3158,9 +3156,9 @@ impl ToPyo3Ast for crate::StmtAsyncWith<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtMatch<SourceRange> {
+impl ToPyAst for ast::StmtMatch<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3170,7 +3168,7 @@ impl ToPyo3Ast for crate::StmtMatch<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((subject.to_pyo3_ast(py)?, cases.to_pyo3_ast(py)?))?;
+            .call1((subject.to_py_ast(py)?, cases.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3184,9 +3182,9 @@ impl ToPyo3Ast for crate::StmtMatch<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtRaise<SourceRange> {
+impl ToPyAst for ast::StmtRaise<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3195,8 +3193,8 @@ impl ToPyo3Ast for crate::StmtRaise<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((exc.to_pyo3_ast(py)?, cause.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((exc.to_py_ast(py)?, cause.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3210,9 +3208,9 @@ impl ToPyo3Ast for crate::StmtRaise<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtTry<SourceRange> {
+impl ToPyAst for ast::StmtTry<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3224,10 +3222,10 @@ impl ToPyo3Ast for crate::StmtTry<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            body.to_pyo3_ast(py)?,
-            handlers.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
-            finalbody.to_pyo3_ast(py)?,
+            body.to_py_ast(py)?,
+            handlers.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            finalbody.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3242,9 +3240,9 @@ impl ToPyo3Ast for crate::StmtTry<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtTryStar<SourceRange> {
+impl ToPyAst for ast::StmtTryStar<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3256,10 +3254,10 @@ impl ToPyo3Ast for crate::StmtTryStar<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            body.to_pyo3_ast(py)?,
-            handlers.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
-            finalbody.to_pyo3_ast(py)?,
+            body.to_py_ast(py)?,
+            handlers.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            finalbody.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3274,9 +3272,9 @@ impl ToPyo3Ast for crate::StmtTryStar<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtAssert<SourceRange> {
+impl ToPyAst for ast::StmtAssert<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3285,8 +3283,8 @@ impl ToPyo3Ast for crate::StmtAssert<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((test.to_pyo3_ast(py)?, msg.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((test.to_py_ast(py)?, msg.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3300,9 +3298,9 @@ impl ToPyo3Ast for crate::StmtAssert<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtImport<SourceRange> {
+impl ToPyAst for ast::StmtImport<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3310,7 +3308,7 @@ impl ToPyo3Ast for crate::StmtImport<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3324,9 +3322,9 @@ impl ToPyo3Ast for crate::StmtImport<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtImportFrom<SourceRange> {
+impl ToPyAst for ast::StmtImportFrom<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3337,8 +3335,8 @@ impl ToPyo3Ast for crate::StmtImportFrom<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            module.to_pyo3_ast(py)?,
-            names.to_pyo3_ast(py)?,
+            module.to_py_ast(py)?,
+            names.to_py_ast(py)?,
             level.map_or_else(|| py.None(), |level| level.to_u32().to_object(py)),
         ))?;
 
@@ -3354,9 +3352,9 @@ impl ToPyo3Ast for crate::StmtImportFrom<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtGlobal<SourceRange> {
+impl ToPyAst for ast::StmtGlobal<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3364,7 +3362,7 @@ impl ToPyo3Ast for crate::StmtGlobal<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3378,9 +3376,9 @@ impl ToPyo3Ast for crate::StmtGlobal<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtNonlocal<SourceRange> {
+impl ToPyAst for ast::StmtNonlocal<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3388,7 +3386,7 @@ impl ToPyo3Ast for crate::StmtNonlocal<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3402,9 +3400,9 @@ impl ToPyo3Ast for crate::StmtNonlocal<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtExpr<SourceRange> {
+impl ToPyAst for ast::StmtExpr<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3412,7 +3410,7 @@ impl ToPyo3Ast for crate::StmtExpr<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3426,9 +3424,9 @@ impl ToPyo3Ast for crate::StmtExpr<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtPass<SourceRange> {
+impl ToPyAst for ast::StmtPass<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
@@ -3446,9 +3444,9 @@ impl ToPyo3Ast for crate::StmtPass<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtBreak<SourceRange> {
+impl ToPyAst for ast::StmtBreak<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
@@ -3466,9 +3464,9 @@ impl ToPyo3Ast for crate::StmtBreak<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::StmtContinue<SourceRange> {
+impl ToPyAst for ast::StmtContinue<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
@@ -3486,45 +3484,45 @@ impl ToPyo3Ast for crate::StmtContinue<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::generic::Expr<SourceRange> {
+impl ToPyAst for ast::Expr<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
-            crate::Expr::BoolOp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::NamedExpr(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::BinOp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::UnaryOp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Lambda(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::IfExp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Dict(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Set(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::ListComp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::SetComp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::DictComp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::GeneratorExp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Await(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Yield(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::YieldFrom(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Compare(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Call(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::FormattedValue(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::JoinedStr(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Constant(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Attribute(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Subscript(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Starred(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Name(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::List(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Tuple(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Slice(cons) => cons.to_pyo3_ast(py)?,
+            ast::Expr::BoolOp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::NamedExpr(cons) => cons.to_py_ast(py)?,
+            ast::Expr::BinOp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::UnaryOp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Lambda(cons) => cons.to_py_ast(py)?,
+            ast::Expr::IfExp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Dict(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Set(cons) => cons.to_py_ast(py)?,
+            ast::Expr::ListComp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::SetComp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::DictComp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::GeneratorExp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Await(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Yield(cons) => cons.to_py_ast(py)?,
+            ast::Expr::YieldFrom(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Compare(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Call(cons) => cons.to_py_ast(py)?,
+            ast::Expr::FormattedValue(cons) => cons.to_py_ast(py)?,
+            ast::Expr::JoinedStr(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Constant(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Attribute(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Subscript(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Starred(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Name(cons) => cons.to_py_ast(py)?,
+            ast::Expr::List(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Tuple(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Slice(cons) => cons.to_py_ast(py)?,
         };
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExprBoolOp<SourceRange> {
+impl ToPyAst for ast::ExprBoolOp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3533,8 +3531,8 @@ impl ToPyo3Ast for crate::ExprBoolOp<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((op.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((op.to_py_ast(py)?, values.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3548,9 +3546,9 @@ impl ToPyo3Ast for crate::ExprBoolOp<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprNamedExpr<SourceRange> {
+impl ToPyAst for ast::ExprNamedExpr<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3560,7 +3558,7 @@ impl ToPyo3Ast for crate::ExprNamedExpr<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((target.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
+            .call1((target.to_py_ast(py)?, value.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3574,9 +3572,9 @@ impl ToPyo3Ast for crate::ExprNamedExpr<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprBinOp<SourceRange> {
+impl ToPyAst for ast::ExprBinOp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3587,9 +3585,9 @@ impl ToPyo3Ast for crate::ExprBinOp<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            left.to_pyo3_ast(py)?,
-            op.to_pyo3_ast(py)?,
-            right.to_pyo3_ast(py)?,
+            left.to_py_ast(py)?,
+            op.to_py_ast(py)?,
+            right.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3604,9 +3602,9 @@ impl ToPyo3Ast for crate::ExprBinOp<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprUnaryOp<SourceRange> {
+impl ToPyAst for ast::ExprUnaryOp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3615,8 +3613,8 @@ impl ToPyo3Ast for crate::ExprUnaryOp<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((op.to_pyo3_ast(py)?, operand.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((op.to_py_ast(py)?, operand.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3630,9 +3628,9 @@ impl ToPyo3Ast for crate::ExprUnaryOp<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprLambda<SourceRange> {
+impl ToPyAst for ast::ExprLambda<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3641,8 +3639,8 @@ impl ToPyo3Ast for crate::ExprLambda<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((args.to_pyo3_ast(py)?, body.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((args.to_py_ast(py)?, body.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3656,9 +3654,9 @@ impl ToPyo3Ast for crate::ExprLambda<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprIfExp<SourceRange> {
+impl ToPyAst for ast::ExprIfExp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3669,9 +3667,9 @@ impl ToPyo3Ast for crate::ExprIfExp<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            test.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
-            orelse.to_pyo3_ast(py)?,
+            test.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3686,9 +3684,9 @@ impl ToPyo3Ast for crate::ExprIfExp<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprDict<SourceRange> {
+impl ToPyAst for ast::ExprDict<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3698,7 +3696,7 @@ impl ToPyo3Ast for crate::ExprDict<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((keys.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
+            .call1((keys.to_py_ast(py)?, values.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3712,9 +3710,9 @@ impl ToPyo3Ast for crate::ExprDict<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprSet<SourceRange> {
+impl ToPyAst for ast::ExprSet<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3722,7 +3720,7 @@ impl ToPyo3Ast for crate::ExprSet<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3736,9 +3734,9 @@ impl ToPyo3Ast for crate::ExprSet<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprListComp<SourceRange> {
+impl ToPyAst for ast::ExprListComp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3748,7 +3746,7 @@ impl ToPyo3Ast for crate::ExprListComp<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
+            .call1((elt.to_py_ast(py)?, generators.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3762,9 +3760,9 @@ impl ToPyo3Ast for crate::ExprListComp<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprSetComp<SourceRange> {
+impl ToPyAst for ast::ExprSetComp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3774,7 +3772,7 @@ impl ToPyo3Ast for crate::ExprSetComp<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
+            .call1((elt.to_py_ast(py)?, generators.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3788,9 +3786,9 @@ impl ToPyo3Ast for crate::ExprSetComp<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprDictComp<SourceRange> {
+impl ToPyAst for ast::ExprDictComp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3801,9 +3799,9 @@ impl ToPyo3Ast for crate::ExprDictComp<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            key.to_pyo3_ast(py)?,
-            value.to_pyo3_ast(py)?,
-            generators.to_pyo3_ast(py)?,
+            key.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+            generators.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3818,9 +3816,9 @@ impl ToPyo3Ast for crate::ExprDictComp<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprGeneratorExp<SourceRange> {
+impl ToPyAst for ast::ExprGeneratorExp<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3830,7 +3828,7 @@ impl ToPyo3Ast for crate::ExprGeneratorExp<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
+            .call1((elt.to_py_ast(py)?, generators.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3844,9 +3842,9 @@ impl ToPyo3Ast for crate::ExprGeneratorExp<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprAwait<SourceRange> {
+impl ToPyAst for ast::ExprAwait<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3854,7 +3852,7 @@ impl ToPyo3Ast for crate::ExprAwait<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3868,9 +3866,9 @@ impl ToPyo3Ast for crate::ExprAwait<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprYield<SourceRange> {
+impl ToPyAst for ast::ExprYield<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3878,7 +3876,7 @@ impl ToPyo3Ast for crate::ExprYield<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3892,9 +3890,9 @@ impl ToPyo3Ast for crate::ExprYield<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprYieldFrom<SourceRange> {
+impl ToPyAst for ast::ExprYieldFrom<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3902,7 +3900,7 @@ impl ToPyo3Ast for crate::ExprYieldFrom<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -3916,9 +3914,9 @@ impl ToPyo3Ast for crate::ExprYieldFrom<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprCompare<SourceRange> {
+impl ToPyAst for ast::ExprCompare<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3929,9 +3927,9 @@ impl ToPyo3Ast for crate::ExprCompare<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            left.to_pyo3_ast(py)?,
-            ops.to_pyo3_ast(py)?,
-            comparators.to_pyo3_ast(py)?,
+            left.to_py_ast(py)?,
+            ops.to_py_ast(py)?,
+            comparators.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3946,9 +3944,9 @@ impl ToPyo3Ast for crate::ExprCompare<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprCall<SourceRange> {
+impl ToPyAst for ast::ExprCall<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3959,9 +3957,9 @@ impl ToPyo3Ast for crate::ExprCall<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            func.to_pyo3_ast(py)?,
-            args.to_pyo3_ast(py)?,
-            keywords.to_pyo3_ast(py)?,
+            func.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            keywords.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -3976,9 +3974,9 @@ impl ToPyo3Ast for crate::ExprCall<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprFormattedValue<SourceRange> {
+impl ToPyAst for ast::ExprFormattedValue<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -3989,9 +3987,9 @@ impl ToPyo3Ast for crate::ExprFormattedValue<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            value.to_pyo3_ast(py)?,
-            conversion.to_pyo3_ast(py)?,
-            format_spec.to_pyo3_ast(py)?,
+            value.to_py_ast(py)?,
+            conversion.to_py_ast(py)?,
+            format_spec.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -4006,9 +4004,9 @@ impl ToPyo3Ast for crate::ExprFormattedValue<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprJoinedStr<SourceRange> {
+impl ToPyAst for ast::ExprJoinedStr<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4016,7 +4014,7 @@ impl ToPyo3Ast for crate::ExprJoinedStr<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((values.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((values.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4030,9 +4028,9 @@ impl ToPyo3Ast for crate::ExprJoinedStr<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprConstant<SourceRange> {
+impl ToPyAst for ast::ExprConstant<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4042,7 +4040,7 @@ impl ToPyo3Ast for crate::ExprConstant<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((value.to_object(py), kind.to_pyo3_ast(py)?))?;
+            .call1((constant_to_object(value, py), kind.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4056,9 +4054,9 @@ impl ToPyo3Ast for crate::ExprConstant<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprAttribute<SourceRange> {
+impl ToPyAst for ast::ExprAttribute<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4069,9 +4067,9 @@ impl ToPyo3Ast for crate::ExprAttribute<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            value.to_pyo3_ast(py)?,
-            attr.to_pyo3_ast(py)?,
-            ctx.to_pyo3_ast(py)?,
+            value.to_py_ast(py)?,
+            attr.to_py_ast(py)?,
+            ctx.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -4086,9 +4084,9 @@ impl ToPyo3Ast for crate::ExprAttribute<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprSubscript<SourceRange> {
+impl ToPyAst for ast::ExprSubscript<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4099,9 +4097,9 @@ impl ToPyo3Ast for crate::ExprSubscript<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            value.to_pyo3_ast(py)?,
-            slice.to_pyo3_ast(py)?,
-            ctx.to_pyo3_ast(py)?,
+            value.to_py_ast(py)?,
+            slice.to_py_ast(py)?,
+            ctx.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -4116,9 +4114,9 @@ impl ToPyo3Ast for crate::ExprSubscript<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprStarred<SourceRange> {
+impl ToPyAst for ast::ExprStarred<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4127,8 +4125,8 @@ impl ToPyo3Ast for crate::ExprStarred<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((value.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4142,9 +4140,9 @@ impl ToPyo3Ast for crate::ExprStarred<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprName<SourceRange> {
+impl ToPyAst for ast::ExprName<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4154,7 +4152,7 @@ impl ToPyo3Ast for crate::ExprName<SourceRange> {
         } = self;
 
         let instance =
-            Py::<PyAny>::as_ref(&cache.0, py).call1((id.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+            Py::<PyAny>::as_ref(&cache.0, py).call1((id.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4168,9 +4166,9 @@ impl ToPyo3Ast for crate::ExprName<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprList<SourceRange> {
+impl ToPyAst for ast::ExprList<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4179,8 +4177,8 @@ impl ToPyo3Ast for crate::ExprList<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4194,9 +4192,9 @@ impl ToPyo3Ast for crate::ExprList<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprTuple<SourceRange> {
+impl ToPyAst for ast::ExprTuple<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4205,8 +4203,8 @@ impl ToPyo3Ast for crate::ExprTuple<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4220,9 +4218,9 @@ impl ToPyo3Ast for crate::ExprTuple<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::ExprSlice<SourceRange> {
+impl ToPyAst for ast::ExprSlice<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4233,9 +4231,9 @@ impl ToPyo3Ast for crate::ExprSlice<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            lower.to_pyo3_ast(py)?,
-            upper.to_pyo3_ast(py)?,
-            step.to_pyo3_ast(py)?,
+            lower.to_py_ast(py)?,
+            upper.to_py_ast(py)?,
+            step.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -4250,9 +4248,9 @@ impl ToPyo3Ast for crate::ExprSlice<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::Comprehension<SourceRange> {
+impl ToPyAst for ast::Comprehension<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4264,29 +4262,29 @@ impl ToPyo3Ast for crate::Comprehension<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            target.to_pyo3_ast(py)?,
-            iter.to_pyo3_ast(py)?,
-            ifs.to_pyo3_ast(py)?,
-            is_async.to_pyo3_ast(py)?,
+            target.to_py_ast(py)?,
+            iter.to_py_ast(py)?,
+            ifs.to_py_ast(py)?,
+            is_async.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::generic::Excepthandler<SourceRange> {
+impl ToPyAst for ast::Excepthandler<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
-            crate::Excepthandler::ExceptHandler(cons) => cons.to_pyo3_ast(py)?,
+            ast::Excepthandler::ExceptHandler(cons) => cons.to_py_ast(py)?,
         };
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<SourceRange> {
+impl ToPyAst for ast::ExcepthandlerExceptHandler<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4297,9 +4295,9 @@ impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            type_.to_pyo3_ast(py)?,
-            name.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
+            type_.to_py_ast(py)?,
+            name.to_py_ast(py)?,
+            body.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -4314,9 +4312,9 @@ impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::Arguments<SourceRange> {
+impl ToPyAst for ast::Arguments<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4331,22 +4329,22 @@ impl ToPyo3Ast for crate::Arguments<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            posonlyargs.to_pyo3_ast(py)?,
-            args.to_pyo3_ast(py)?,
-            vararg.to_pyo3_ast(py)?,
-            kwonlyargs.to_pyo3_ast(py)?,
-            kw_defaults.to_pyo3_ast(py)?,
-            kwarg.to_pyo3_ast(py)?,
-            defaults.to_pyo3_ast(py)?,
+            posonlyargs.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            vararg.to_py_ast(py)?,
+            kwonlyargs.to_py_ast(py)?,
+            kw_defaults.to_py_ast(py)?,
+            kwarg.to_py_ast(py)?,
+            defaults.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::Arg<SourceRange> {
+impl ToPyAst for ast::Arg<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4357,9 +4355,9 @@ impl ToPyo3Ast for crate::Arg<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            arg.to_pyo3_ast(py)?,
-            annotation.to_pyo3_ast(py)?,
-            type_comment.to_pyo3_ast(py)?,
+            arg.to_py_ast(py)?,
+            annotation.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -4374,9 +4372,9 @@ impl ToPyo3Ast for crate::Arg<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::Keyword<SourceRange> {
+impl ToPyAst for ast::Keyword<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4385,8 +4383,8 @@ impl ToPyo3Ast for crate::Keyword<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((arg.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((arg.to_py_ast(py)?, value.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4400,9 +4398,9 @@ impl ToPyo3Ast for crate::Keyword<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::Alias<SourceRange> {
+impl ToPyAst for ast::Alias<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4412,7 +4410,7 @@ impl ToPyo3Ast for crate::Alias<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((name.to_pyo3_ast(py)?, asname.to_pyo3_ast(py)?))?;
+            .call1((name.to_py_ast(py)?, asname.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4426,9 +4424,9 @@ impl ToPyo3Ast for crate::Alias<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::Withitem<SourceRange> {
+impl ToPyAst for ast::Withitem<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4437,18 +4435,16 @@ impl ToPyo3Ast for crate::Withitem<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            context_expr.to_pyo3_ast(py)?,
-            optional_vars.to_pyo3_ast(py)?,
-        ))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((context_expr.to_py_ast(py)?, optional_vars.to_py_ast(py)?))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::MatchCase<SourceRange> {
+impl ToPyAst for ast::MatchCase<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4459,35 +4455,35 @@ impl ToPyo3Ast for crate::MatchCase<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            pattern.to_pyo3_ast(py)?,
-            guard.to_pyo3_ast(py)?,
-            body.to_pyo3_ast(py)?,
+            pattern.to_py_ast(py)?,
+            guard.to_py_ast(py)?,
+            body.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::generic::Pattern<SourceRange> {
+impl ToPyAst for ast::Pattern<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
-            crate::Pattern::MatchValue(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchSingleton(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchSequence(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchMapping(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchClass(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchStar(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchAs(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchOr(cons) => cons.to_pyo3_ast(py)?,
+            ast::Pattern::MatchValue(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchSingleton(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchSequence(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchMapping(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchClass(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchStar(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchAs(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchOr(cons) => cons.to_py_ast(py)?,
         };
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchValue<SourceRange> {
+impl ToPyAst for ast::PatternMatchValue<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4495,7 +4491,7 @@ impl ToPyo3Ast for crate::PatternMatchValue<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4509,9 +4505,9 @@ impl ToPyo3Ast for crate::PatternMatchValue<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchSingleton<SourceRange> {
+impl ToPyAst for ast::PatternMatchSingleton<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4519,7 +4515,7 @@ impl ToPyo3Ast for crate::PatternMatchSingleton<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_object(py),))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((constant_to_object(value, py),))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4533,9 +4529,9 @@ impl ToPyo3Ast for crate::PatternMatchSingleton<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchSequence<SourceRange> {
+impl ToPyAst for ast::PatternMatchSequence<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4543,7 +4539,7 @@ impl ToPyo3Ast for crate::PatternMatchSequence<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4557,9 +4553,9 @@ impl ToPyo3Ast for crate::PatternMatchSequence<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchMapping<SourceRange> {
+impl ToPyAst for ast::PatternMatchMapping<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4570,9 +4566,9 @@ impl ToPyo3Ast for crate::PatternMatchMapping<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            keys.to_pyo3_ast(py)?,
-            patterns.to_pyo3_ast(py)?,
-            rest.to_pyo3_ast(py)?,
+            keys.to_py_ast(py)?,
+            patterns.to_py_ast(py)?,
+            rest.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -4587,9 +4583,9 @@ impl ToPyo3Ast for crate::PatternMatchMapping<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchClass<SourceRange> {
+impl ToPyAst for ast::PatternMatchClass<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4601,10 +4597,10 @@ impl ToPyo3Ast for crate::PatternMatchClass<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
-            cls.to_pyo3_ast(py)?,
-            patterns.to_pyo3_ast(py)?,
-            kwd_attrs.to_pyo3_ast(py)?,
-            kwd_patterns.to_pyo3_ast(py)?,
+            cls.to_py_ast(py)?,
+            patterns.to_py_ast(py)?,
+            kwd_attrs.to_py_ast(py)?,
+            kwd_patterns.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -4619,9 +4615,9 @@ impl ToPyo3Ast for crate::PatternMatchClass<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchStar<SourceRange> {
+impl ToPyAst for ast::PatternMatchStar<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4629,7 +4625,7 @@ impl ToPyo3Ast for crate::PatternMatchStar<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4643,9 +4639,9 @@ impl ToPyo3Ast for crate::PatternMatchStar<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchAs<SourceRange> {
+impl ToPyAst for ast::PatternMatchAs<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4655,7 +4651,7 @@ impl ToPyo3Ast for crate::PatternMatchAs<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((pattern.to_pyo3_ast(py)?, name.to_pyo3_ast(py)?))?;
+            .call1((pattern.to_py_ast(py)?, name.to_py_ast(py)?))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4669,9 +4665,9 @@ impl ToPyo3Ast for crate::PatternMatchAs<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::PatternMatchOr<SourceRange> {
+impl ToPyAst for ast::PatternMatchOr<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4679,7 +4675,7 @@ impl ToPyo3Ast for crate::PatternMatchOr<SourceRange> {
             range: _range,
         } = self;
 
-        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_pyo3_ast(py)?,))?;
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_py_ast(py)?,))?;
 
         let cache = ast_cache();
         instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
@@ -4693,19 +4689,19 @@ impl ToPyo3Ast for crate::PatternMatchOr<SourceRange> {
     }
 }
 
-impl ToPyo3Ast for crate::generic::TypeIgnore<SourceRange> {
+impl ToPyAst for ast::TypeIgnore<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let instance = match &self {
-            crate::TypeIgnore::TypeIgnore(cons) => cons.to_pyo3_ast(py)?,
+            ast::TypeIgnore::TypeIgnore(cons) => cons.to_py_ast(py)?,
         };
         Ok(instance)
     }
 }
 
-impl ToPyo3Ast for crate::TypeIgnoreTypeIgnore<SourceRange> {
+impl ToPyAst for ast::TypeIgnoreTypeIgnore<SourceRange> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
 
         let Self {
@@ -4715,7 +4711,7 @@ impl ToPyo3Ast for crate::TypeIgnoreTypeIgnore<SourceRange> {
         } = self;
 
         let instance = Py::<PyAny>::as_ref(&cache.0, py)
-            .call1((lineno.to_u32().to_object(py), tag.to_pyo3_ast(py)?))?;
+            .call1((lineno.to_u32().to_object(py), tag.to_py_ast(py)?))?;
 
         Ok(instance)
     }
@@ -4723,123 +4719,123 @@ impl ToPyo3Ast for crate::TypeIgnoreTypeIgnore<SourceRange> {
 
 fn init_types(py: Python) -> PyResult<()> {
     let ast_module = PyModule::import(py, "_ast")?;
-    cache_py_type::<crate::generic::Mod>(ast_module)?;
-    cache_py_type::<crate::generic::ModModule>(ast_module)?;
-    cache_py_type::<crate::generic::ModInteractive>(ast_module)?;
-    cache_py_type::<crate::generic::ModExpression>(ast_module)?;
-    cache_py_type::<crate::generic::ModFunctionType>(ast_module)?;
-    cache_py_type::<crate::generic::Stmt>(ast_module)?;
-    cache_py_type::<crate::generic::StmtFunctionDef>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAsyncFunctionDef>(ast_module)?;
-    cache_py_type::<crate::generic::StmtClassDef>(ast_module)?;
-    cache_py_type::<crate::generic::StmtReturn>(ast_module)?;
-    cache_py_type::<crate::generic::StmtDelete>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAssign>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAugAssign>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAnnAssign>(ast_module)?;
-    cache_py_type::<crate::generic::StmtFor>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAsyncFor>(ast_module)?;
-    cache_py_type::<crate::generic::StmtWhile>(ast_module)?;
-    cache_py_type::<crate::generic::StmtIf>(ast_module)?;
-    cache_py_type::<crate::generic::StmtWith>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAsyncWith>(ast_module)?;
-    cache_py_type::<crate::generic::StmtMatch>(ast_module)?;
-    cache_py_type::<crate::generic::StmtRaise>(ast_module)?;
-    cache_py_type::<crate::generic::StmtTry>(ast_module)?;
-    cache_py_type::<crate::generic::StmtTryStar>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAssert>(ast_module)?;
-    cache_py_type::<crate::generic::StmtImport>(ast_module)?;
-    cache_py_type::<crate::generic::StmtImportFrom>(ast_module)?;
-    cache_py_type::<crate::generic::StmtGlobal>(ast_module)?;
-    cache_py_type::<crate::generic::StmtNonlocal>(ast_module)?;
-    cache_py_type::<crate::generic::StmtExpr>(ast_module)?;
-    cache_py_type::<crate::generic::StmtPass>(ast_module)?;
-    cache_py_type::<crate::generic::StmtBreak>(ast_module)?;
-    cache_py_type::<crate::generic::StmtContinue>(ast_module)?;
-    cache_py_type::<crate::generic::Expr>(ast_module)?;
-    cache_py_type::<crate::generic::ExprBoolOp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprNamedExpr>(ast_module)?;
-    cache_py_type::<crate::generic::ExprBinOp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprUnaryOp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprLambda>(ast_module)?;
-    cache_py_type::<crate::generic::ExprIfExp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprDict>(ast_module)?;
-    cache_py_type::<crate::generic::ExprSet>(ast_module)?;
-    cache_py_type::<crate::generic::ExprListComp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprSetComp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprDictComp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprGeneratorExp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprAwait>(ast_module)?;
-    cache_py_type::<crate::generic::ExprYield>(ast_module)?;
-    cache_py_type::<crate::generic::ExprYieldFrom>(ast_module)?;
-    cache_py_type::<crate::generic::ExprCompare>(ast_module)?;
-    cache_py_type::<crate::generic::ExprCall>(ast_module)?;
-    cache_py_type::<crate::generic::ExprFormattedValue>(ast_module)?;
-    cache_py_type::<crate::generic::ExprJoinedStr>(ast_module)?;
-    cache_py_type::<crate::generic::ExprConstant>(ast_module)?;
-    cache_py_type::<crate::generic::ExprAttribute>(ast_module)?;
-    cache_py_type::<crate::generic::ExprSubscript>(ast_module)?;
-    cache_py_type::<crate::generic::ExprStarred>(ast_module)?;
-    cache_py_type::<crate::generic::ExprName>(ast_module)?;
-    cache_py_type::<crate::generic::ExprList>(ast_module)?;
-    cache_py_type::<crate::generic::ExprTuple>(ast_module)?;
-    cache_py_type::<crate::generic::ExprSlice>(ast_module)?;
-    cache_py_type::<crate::generic::ExprContext>(ast_module)?;
-    cache_py_type::<crate::generic::ExprContextLoad>(ast_module)?;
-    cache_py_type::<crate::generic::ExprContextStore>(ast_module)?;
-    cache_py_type::<crate::generic::ExprContextDel>(ast_module)?;
-    cache_py_type::<crate::generic::Boolop>(ast_module)?;
-    cache_py_type::<crate::generic::BoolopAnd>(ast_module)?;
-    cache_py_type::<crate::generic::BoolopOr>(ast_module)?;
-    cache_py_type::<crate::generic::Operator>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorAdd>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorSub>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorMult>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorMatMult>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorDiv>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorMod>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorPow>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorLShift>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorRShift>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorBitOr>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorBitXor>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorBitAnd>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorFloorDiv>(ast_module)?;
-    cache_py_type::<crate::generic::Unaryop>(ast_module)?;
-    cache_py_type::<crate::generic::UnaryopInvert>(ast_module)?;
-    cache_py_type::<crate::generic::UnaryopNot>(ast_module)?;
-    cache_py_type::<crate::generic::UnaryopUAdd>(ast_module)?;
-    cache_py_type::<crate::generic::UnaryopUSub>(ast_module)?;
-    cache_py_type::<crate::generic::Cmpop>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopEq>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopNotEq>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopLt>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopLtE>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopGt>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopGtE>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopIs>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopIsNot>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopIn>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopNotIn>(ast_module)?;
-    cache_py_type::<crate::generic::Comprehension>(ast_module)?;
-    cache_py_type::<crate::generic::Excepthandler>(ast_module)?;
-    cache_py_type::<crate::generic::ExcepthandlerExceptHandler>(ast_module)?;
-    cache_py_type::<crate::generic::Arguments>(ast_module)?;
-    cache_py_type::<crate::generic::Arg>(ast_module)?;
-    cache_py_type::<crate::generic::Keyword>(ast_module)?;
-    cache_py_type::<crate::generic::Alias>(ast_module)?;
-    cache_py_type::<crate::generic::Withitem>(ast_module)?;
-    cache_py_type::<crate::generic::MatchCase>(ast_module)?;
-    cache_py_type::<crate::generic::Pattern>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchValue>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchSingleton>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchSequence>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchMapping>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchClass>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchStar>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchAs>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchOr>(ast_module)?;
-    cache_py_type::<crate::generic::TypeIgnore>(ast_module)?;
-    cache_py_type::<crate::generic::TypeIgnoreTypeIgnore>(ast_module)?;
+    cache_py_type::<ast::Mod>(ast_module)?;
+    cache_py_type::<ast::ModModule>(ast_module)?;
+    cache_py_type::<ast::ModInteractive>(ast_module)?;
+    cache_py_type::<ast::ModExpression>(ast_module)?;
+    cache_py_type::<ast::ModFunctionType>(ast_module)?;
+    cache_py_type::<ast::Stmt>(ast_module)?;
+    cache_py_type::<ast::StmtFunctionDef>(ast_module)?;
+    cache_py_type::<ast::StmtAsyncFunctionDef>(ast_module)?;
+    cache_py_type::<ast::StmtClassDef>(ast_module)?;
+    cache_py_type::<ast::StmtReturn>(ast_module)?;
+    cache_py_type::<ast::StmtDelete>(ast_module)?;
+    cache_py_type::<ast::StmtAssign>(ast_module)?;
+    cache_py_type::<ast::StmtAugAssign>(ast_module)?;
+    cache_py_type::<ast::StmtAnnAssign>(ast_module)?;
+    cache_py_type::<ast::StmtFor>(ast_module)?;
+    cache_py_type::<ast::StmtAsyncFor>(ast_module)?;
+    cache_py_type::<ast::StmtWhile>(ast_module)?;
+    cache_py_type::<ast::StmtIf>(ast_module)?;
+    cache_py_type::<ast::StmtWith>(ast_module)?;
+    cache_py_type::<ast::StmtAsyncWith>(ast_module)?;
+    cache_py_type::<ast::StmtMatch>(ast_module)?;
+    cache_py_type::<ast::StmtRaise>(ast_module)?;
+    cache_py_type::<ast::StmtTry>(ast_module)?;
+    cache_py_type::<ast::StmtTryStar>(ast_module)?;
+    cache_py_type::<ast::StmtAssert>(ast_module)?;
+    cache_py_type::<ast::StmtImport>(ast_module)?;
+    cache_py_type::<ast::StmtImportFrom>(ast_module)?;
+    cache_py_type::<ast::StmtGlobal>(ast_module)?;
+    cache_py_type::<ast::StmtNonlocal>(ast_module)?;
+    cache_py_type::<ast::StmtExpr>(ast_module)?;
+    cache_py_type::<ast::StmtPass>(ast_module)?;
+    cache_py_type::<ast::StmtBreak>(ast_module)?;
+    cache_py_type::<ast::StmtContinue>(ast_module)?;
+    cache_py_type::<ast::Expr>(ast_module)?;
+    cache_py_type::<ast::ExprBoolOp>(ast_module)?;
+    cache_py_type::<ast::ExprNamedExpr>(ast_module)?;
+    cache_py_type::<ast::ExprBinOp>(ast_module)?;
+    cache_py_type::<ast::ExprUnaryOp>(ast_module)?;
+    cache_py_type::<ast::ExprLambda>(ast_module)?;
+    cache_py_type::<ast::ExprIfExp>(ast_module)?;
+    cache_py_type::<ast::ExprDict>(ast_module)?;
+    cache_py_type::<ast::ExprSet>(ast_module)?;
+    cache_py_type::<ast::ExprListComp>(ast_module)?;
+    cache_py_type::<ast::ExprSetComp>(ast_module)?;
+    cache_py_type::<ast::ExprDictComp>(ast_module)?;
+    cache_py_type::<ast::ExprGeneratorExp>(ast_module)?;
+    cache_py_type::<ast::ExprAwait>(ast_module)?;
+    cache_py_type::<ast::ExprYield>(ast_module)?;
+    cache_py_type::<ast::ExprYieldFrom>(ast_module)?;
+    cache_py_type::<ast::ExprCompare>(ast_module)?;
+    cache_py_type::<ast::ExprCall>(ast_module)?;
+    cache_py_type::<ast::ExprFormattedValue>(ast_module)?;
+    cache_py_type::<ast::ExprJoinedStr>(ast_module)?;
+    cache_py_type::<ast::ExprConstant>(ast_module)?;
+    cache_py_type::<ast::ExprAttribute>(ast_module)?;
+    cache_py_type::<ast::ExprSubscript>(ast_module)?;
+    cache_py_type::<ast::ExprStarred>(ast_module)?;
+    cache_py_type::<ast::ExprName>(ast_module)?;
+    cache_py_type::<ast::ExprList>(ast_module)?;
+    cache_py_type::<ast::ExprTuple>(ast_module)?;
+    cache_py_type::<ast::ExprSlice>(ast_module)?;
+    cache_py_type::<ast::ExprContext>(ast_module)?;
+    cache_py_type::<ast::ExprContextLoad>(ast_module)?;
+    cache_py_type::<ast::ExprContextStore>(ast_module)?;
+    cache_py_type::<ast::ExprContextDel>(ast_module)?;
+    cache_py_type::<ast::Boolop>(ast_module)?;
+    cache_py_type::<ast::BoolopAnd>(ast_module)?;
+    cache_py_type::<ast::BoolopOr>(ast_module)?;
+    cache_py_type::<ast::Operator>(ast_module)?;
+    cache_py_type::<ast::OperatorAdd>(ast_module)?;
+    cache_py_type::<ast::OperatorSub>(ast_module)?;
+    cache_py_type::<ast::OperatorMult>(ast_module)?;
+    cache_py_type::<ast::OperatorMatMult>(ast_module)?;
+    cache_py_type::<ast::OperatorDiv>(ast_module)?;
+    cache_py_type::<ast::OperatorMod>(ast_module)?;
+    cache_py_type::<ast::OperatorPow>(ast_module)?;
+    cache_py_type::<ast::OperatorLShift>(ast_module)?;
+    cache_py_type::<ast::OperatorRShift>(ast_module)?;
+    cache_py_type::<ast::OperatorBitOr>(ast_module)?;
+    cache_py_type::<ast::OperatorBitXor>(ast_module)?;
+    cache_py_type::<ast::OperatorBitAnd>(ast_module)?;
+    cache_py_type::<ast::OperatorFloorDiv>(ast_module)?;
+    cache_py_type::<ast::Unaryop>(ast_module)?;
+    cache_py_type::<ast::UnaryopInvert>(ast_module)?;
+    cache_py_type::<ast::UnaryopNot>(ast_module)?;
+    cache_py_type::<ast::UnaryopUAdd>(ast_module)?;
+    cache_py_type::<ast::UnaryopUSub>(ast_module)?;
+    cache_py_type::<ast::Cmpop>(ast_module)?;
+    cache_py_type::<ast::CmpopEq>(ast_module)?;
+    cache_py_type::<ast::CmpopNotEq>(ast_module)?;
+    cache_py_type::<ast::CmpopLt>(ast_module)?;
+    cache_py_type::<ast::CmpopLtE>(ast_module)?;
+    cache_py_type::<ast::CmpopGt>(ast_module)?;
+    cache_py_type::<ast::CmpopGtE>(ast_module)?;
+    cache_py_type::<ast::CmpopIs>(ast_module)?;
+    cache_py_type::<ast::CmpopIsNot>(ast_module)?;
+    cache_py_type::<ast::CmpopIn>(ast_module)?;
+    cache_py_type::<ast::CmpopNotIn>(ast_module)?;
+    cache_py_type::<ast::Comprehension>(ast_module)?;
+    cache_py_type::<ast::Excepthandler>(ast_module)?;
+    cache_py_type::<ast::ExcepthandlerExceptHandler>(ast_module)?;
+    cache_py_type::<ast::Arguments>(ast_module)?;
+    cache_py_type::<ast::Arg>(ast_module)?;
+    cache_py_type::<ast::Keyword>(ast_module)?;
+    cache_py_type::<ast::Alias>(ast_module)?;
+    cache_py_type::<ast::Withitem>(ast_module)?;
+    cache_py_type::<ast::MatchCase>(ast_module)?;
+    cache_py_type::<ast::Pattern>(ast_module)?;
+    cache_py_type::<ast::PatternMatchValue>(ast_module)?;
+    cache_py_type::<ast::PatternMatchSingleton>(ast_module)?;
+    cache_py_type::<ast::PatternMatchSequence>(ast_module)?;
+    cache_py_type::<ast::PatternMatchMapping>(ast_module)?;
+    cache_py_type::<ast::PatternMatchClass>(ast_module)?;
+    cache_py_type::<ast::PatternMatchStar>(ast_module)?;
+    cache_py_type::<ast::PatternMatchAs>(ast_module)?;
+    cache_py_type::<ast::PatternMatchOr>(ast_module)?;
+    cache_py_type::<ast::TypeIgnore>(ast_module)?;
+    cache_py_type::<ast::TypeIgnoreTypeIgnore>(ast_module)?;
     Ok(())
 }
diff --git a/ast/src/gen/pyo3_wrapper_located.rs b/ast-pyo3/src/gen/wrapper_located.rs
similarity index 54%
rename from ast/src/gen/pyo3_wrapper_located.rs
rename to ast-pyo3/src/gen/wrapper_located.rs
index ba55ee24..1f4e0d6d 100644
--- a/ast/src/gen/pyo3_wrapper_located.rs
+++ b/ast-pyo3/src/gen/wrapper_located.rs
@@ -1,11 +1,11 @@
 // File automatically generated by ast/asdl_rs.py.
 
-#[pyclass(module="rustpython_ast.located", name="_mod", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_mod", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Mod;
 
-impl From<&'static crate::Mod<SourceRange>> for Mod {
-    fn from(_node: &'static crate::Mod<SourceRange>) -> Self {
+impl From<&'static ast::Mod<SourceRange>> for Mod {
+    fn from(_node: &'static ast::Mod<SourceRange>) -> Self {
         Mod
     }
 }
@@ -14,7 +14,7 @@ impl From<&'static crate::Mod<SourceRange>> for Mod {
 impl Mod {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Mod {
@@ -24,40 +24,40 @@ impl ToPyObject for Mod {
     }
 }
 
-impl ToPyo3Wrapper for crate::Mod<SourceRange> {
+impl ToPyWrapper for ast::Mod<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::Module(cons) => cons.to_pyo3_wrapper(py),
-            Self::Interactive(cons) => cons.to_pyo3_wrapper(py),
-            Self::Expression(cons) => cons.to_pyo3_wrapper(py),
-            Self::FunctionType(cons) => cons.to_pyo3_wrapper(py),
+            Self::Module(cons) => cons.to_py_wrapper(py),
+            Self::Interactive(cons) => cons.to_py_wrapper(py),
+            Self::Expression(cons) => cons.to_py_wrapper(py),
+            Self::FunctionType(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Module", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModModule(pub &'static crate::ModModule<SourceRange>);
+pub struct ModModule(pub &'static ast::ModModule<SourceRange>);
 
-impl From<&'static crate::ModModule<SourceRange>> for ModModule {
-    fn from(node: &'static crate::ModModule<SourceRange>) -> Self {
+impl From<&'static ast::ModModule<SourceRange>> for ModModule {
+    fn from(node: &'static ast::ModModule<SourceRange>) -> Self {
         ModModule(node)
     }
 }
 
 impl ToPyObject for ModModule {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModModule<SourceRange> {
+impl ToPyWrapper for ast::ModModule<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModModule(self).to_object(py))
     }
 }
@@ -67,38 +67,38 @@ impl ModModule {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_ignores(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_ignores.to_pyo3_wrapper(py)
+        self.0.type_ignores.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Interactive", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModInteractive(pub &'static crate::ModInteractive<SourceRange>);
+pub struct ModInteractive(pub &'static ast::ModInteractive<SourceRange>);
 
-impl From<&'static crate::ModInteractive<SourceRange>> for ModInteractive {
-    fn from(node: &'static crate::ModInteractive<SourceRange>) -> Self {
+impl From<&'static ast::ModInteractive<SourceRange>> for ModInteractive {
+    fn from(node: &'static ast::ModInteractive<SourceRange>) -> Self {
         ModInteractive(node)
     }
 }
 
 impl ToPyObject for ModInteractive {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModInteractive<SourceRange> {
+impl ToPyWrapper for ast::ModInteractive<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModInteractive(self).to_object(py))
     }
 }
@@ -108,32 +108,32 @@ impl ModInteractive {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Expression", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModExpression(pub &'static crate::ModExpression<SourceRange>);
+pub struct ModExpression(pub &'static ast::ModExpression<SourceRange>);
 
-impl From<&'static crate::ModExpression<SourceRange>> for ModExpression {
-    fn from(node: &'static crate::ModExpression<SourceRange>) -> Self {
+impl From<&'static ast::ModExpression<SourceRange>> for ModExpression {
+    fn from(node: &'static ast::ModExpression<SourceRange>) -> Self {
         ModExpression(node)
     }
 }
 
 impl ToPyObject for ModExpression {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModExpression<SourceRange> {
+impl ToPyWrapper for ast::ModExpression<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModExpression(self).to_object(py))
     }
 }
@@ -143,32 +143,32 @@ impl ModExpression {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_FunctionType", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModFunctionType(pub &'static crate::ModFunctionType<SourceRange>);
+pub struct ModFunctionType(pub &'static ast::ModFunctionType<SourceRange>);
 
-impl From<&'static crate::ModFunctionType<SourceRange>> for ModFunctionType {
-    fn from(node: &'static crate::ModFunctionType<SourceRange>) -> Self {
+impl From<&'static ast::ModFunctionType<SourceRange>> for ModFunctionType {
+    fn from(node: &'static ast::ModFunctionType<SourceRange>) -> Self {
         ModFunctionType(node)
     }
 }
 
 impl ToPyObject for ModFunctionType {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModFunctionType<SourceRange> {
+impl ToPyWrapper for ast::ModFunctionType<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModFunctionType(self).to_object(py))
     }
 }
@@ -178,22 +178,22 @@ impl ModFunctionType {
     #[getter]
     #[inline]
     fn get_argtypes(&self, py: Python) -> PyResult<PyObject> {
-        self.0.argtypes.to_pyo3_wrapper(py)
+        self.0.argtypes.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_returns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.returns.to_pyo3_wrapper(py)
+        self.0.returns.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_stmt", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_stmt", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Stmt;
 
-impl From<&'static crate::Stmt<SourceRange>> for Stmt {
-    fn from(_node: &'static crate::Stmt<SourceRange>) -> Self {
+impl From<&'static ast::Stmt<SourceRange>> for Stmt {
+    fn from(_node: &'static ast::Stmt<SourceRange>) -> Self {
         Stmt
     }
 }
@@ -202,7 +202,7 @@ impl From<&'static crate::Stmt<SourceRange>> for Stmt {
 impl Stmt {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Stmt {
@@ -212,63 +212,63 @@ impl ToPyObject for Stmt {
     }
 }
 
-impl ToPyo3Wrapper for crate::Stmt<SourceRange> {
+impl ToPyWrapper for ast::Stmt<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::FunctionDef(cons) => cons.to_pyo3_wrapper(py),
-            Self::AsyncFunctionDef(cons) => cons.to_pyo3_wrapper(py),
-            Self::ClassDef(cons) => cons.to_pyo3_wrapper(py),
-            Self::Return(cons) => cons.to_pyo3_wrapper(py),
-            Self::Delete(cons) => cons.to_pyo3_wrapper(py),
-            Self::Assign(cons) => cons.to_pyo3_wrapper(py),
-            Self::AugAssign(cons) => cons.to_pyo3_wrapper(py),
-            Self::AnnAssign(cons) => cons.to_pyo3_wrapper(py),
-            Self::For(cons) => cons.to_pyo3_wrapper(py),
-            Self::AsyncFor(cons) => cons.to_pyo3_wrapper(py),
-            Self::While(cons) => cons.to_pyo3_wrapper(py),
-            Self::If(cons) => cons.to_pyo3_wrapper(py),
-            Self::With(cons) => cons.to_pyo3_wrapper(py),
-            Self::AsyncWith(cons) => cons.to_pyo3_wrapper(py),
-            Self::Match(cons) => cons.to_pyo3_wrapper(py),
-            Self::Raise(cons) => cons.to_pyo3_wrapper(py),
-            Self::Try(cons) => cons.to_pyo3_wrapper(py),
-            Self::TryStar(cons) => cons.to_pyo3_wrapper(py),
-            Self::Assert(cons) => cons.to_pyo3_wrapper(py),
-            Self::Import(cons) => cons.to_pyo3_wrapper(py),
-            Self::ImportFrom(cons) => cons.to_pyo3_wrapper(py),
-            Self::Global(cons) => cons.to_pyo3_wrapper(py),
-            Self::Nonlocal(cons) => cons.to_pyo3_wrapper(py),
-            Self::Expr(cons) => cons.to_pyo3_wrapper(py),
-            Self::Pass(cons) => cons.to_pyo3_wrapper(py),
-            Self::Break(cons) => cons.to_pyo3_wrapper(py),
-            Self::Continue(cons) => cons.to_pyo3_wrapper(py),
+            Self::FunctionDef(cons) => cons.to_py_wrapper(py),
+            Self::AsyncFunctionDef(cons) => cons.to_py_wrapper(py),
+            Self::ClassDef(cons) => cons.to_py_wrapper(py),
+            Self::Return(cons) => cons.to_py_wrapper(py),
+            Self::Delete(cons) => cons.to_py_wrapper(py),
+            Self::Assign(cons) => cons.to_py_wrapper(py),
+            Self::AugAssign(cons) => cons.to_py_wrapper(py),
+            Self::AnnAssign(cons) => cons.to_py_wrapper(py),
+            Self::For(cons) => cons.to_py_wrapper(py),
+            Self::AsyncFor(cons) => cons.to_py_wrapper(py),
+            Self::While(cons) => cons.to_py_wrapper(py),
+            Self::If(cons) => cons.to_py_wrapper(py),
+            Self::With(cons) => cons.to_py_wrapper(py),
+            Self::AsyncWith(cons) => cons.to_py_wrapper(py),
+            Self::Match(cons) => cons.to_py_wrapper(py),
+            Self::Raise(cons) => cons.to_py_wrapper(py),
+            Self::Try(cons) => cons.to_py_wrapper(py),
+            Self::TryStar(cons) => cons.to_py_wrapper(py),
+            Self::Assert(cons) => cons.to_py_wrapper(py),
+            Self::Import(cons) => cons.to_py_wrapper(py),
+            Self::ImportFrom(cons) => cons.to_py_wrapper(py),
+            Self::Global(cons) => cons.to_py_wrapper(py),
+            Self::Nonlocal(cons) => cons.to_py_wrapper(py),
+            Self::Expr(cons) => cons.to_py_wrapper(py),
+            Self::Pass(cons) => cons.to_py_wrapper(py),
+            Self::Break(cons) => cons.to_py_wrapper(py),
+            Self::Continue(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_FunctionDef", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtFunctionDef(pub &'static crate::StmtFunctionDef<SourceRange>);
+pub struct StmtFunctionDef(pub &'static ast::StmtFunctionDef<SourceRange>);
 
-impl From<&'static crate::StmtFunctionDef<SourceRange>> for StmtFunctionDef {
-    fn from(node: &'static crate::StmtFunctionDef<SourceRange>) -> Self {
+impl From<&'static ast::StmtFunctionDef<SourceRange>> for StmtFunctionDef {
+    fn from(node: &'static ast::StmtFunctionDef<SourceRange>) -> Self {
         StmtFunctionDef(node)
     }
 }
 
 impl ToPyObject for StmtFunctionDef {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtFunctionDef<SourceRange> {
+impl ToPyWrapper for ast::StmtFunctionDef<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtFunctionDef(self).to_object(py))
     }
 }
@@ -278,62 +278,62 @@ impl StmtFunctionDef {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
-        self.0.decorator_list.to_pyo3_wrapper(py)
+        self.0.decorator_list.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_returns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.returns.to_pyo3_wrapper(py)
+        self.0.returns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_AsyncFunctionDef", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAsyncFunctionDef(pub &'static crate::StmtAsyncFunctionDef<SourceRange>);
+pub struct StmtAsyncFunctionDef(pub &'static ast::StmtAsyncFunctionDef<SourceRange>);
 
-impl From<&'static crate::StmtAsyncFunctionDef<SourceRange>> for StmtAsyncFunctionDef {
-    fn from(node: &'static crate::StmtAsyncFunctionDef<SourceRange>) -> Self {
+impl From<&'static ast::StmtAsyncFunctionDef<SourceRange>> for StmtAsyncFunctionDef {
+    fn from(node: &'static ast::StmtAsyncFunctionDef<SourceRange>) -> Self {
         StmtAsyncFunctionDef(node)
     }
 }
 
 impl ToPyObject for StmtAsyncFunctionDef {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAsyncFunctionDef<SourceRange> {
+impl ToPyWrapper for ast::StmtAsyncFunctionDef<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAsyncFunctionDef(self).to_object(py))
     }
 }
@@ -343,62 +343,62 @@ impl StmtAsyncFunctionDef {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
-        self.0.decorator_list.to_pyo3_wrapper(py)
+        self.0.decorator_list.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_returns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.returns.to_pyo3_wrapper(py)
+        self.0.returns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_ClassDef", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtClassDef(pub &'static crate::StmtClassDef<SourceRange>);
+pub struct StmtClassDef(pub &'static ast::StmtClassDef<SourceRange>);
 
-impl From<&'static crate::StmtClassDef<SourceRange>> for StmtClassDef {
-    fn from(node: &'static crate::StmtClassDef<SourceRange>) -> Self {
+impl From<&'static ast::StmtClassDef<SourceRange>> for StmtClassDef {
+    fn from(node: &'static ast::StmtClassDef<SourceRange>) -> Self {
         StmtClassDef(node)
     }
 }
 
 impl ToPyObject for StmtClassDef {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtClassDef<SourceRange> {
+impl ToPyWrapper for ast::StmtClassDef<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtClassDef(self).to_object(py))
     }
 }
@@ -408,56 +408,56 @@ impl StmtClassDef {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_bases(&self, py: Python) -> PyResult<PyObject> {
-        self.0.bases.to_pyo3_wrapper(py)
+        self.0.bases.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_keywords(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keywords.to_pyo3_wrapper(py)
+        self.0.keywords.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
-        self.0.decorator_list.to_pyo3_wrapper(py)
+        self.0.decorator_list.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Return", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtReturn(pub &'static crate::StmtReturn<SourceRange>);
+pub struct StmtReturn(pub &'static ast::StmtReturn<SourceRange>);
 
-impl From<&'static crate::StmtReturn<SourceRange>> for StmtReturn {
-    fn from(node: &'static crate::StmtReturn<SourceRange>) -> Self {
+impl From<&'static ast::StmtReturn<SourceRange>> for StmtReturn {
+    fn from(node: &'static ast::StmtReturn<SourceRange>) -> Self {
         StmtReturn(node)
     }
 }
 
 impl ToPyObject for StmtReturn {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtReturn<SourceRange> {
+impl ToPyWrapper for ast::StmtReturn<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtReturn(self).to_object(py))
     }
 }
@@ -467,32 +467,32 @@ impl StmtReturn {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Delete", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtDelete(pub &'static crate::StmtDelete<SourceRange>);
+pub struct StmtDelete(pub &'static ast::StmtDelete<SourceRange>);
 
-impl From<&'static crate::StmtDelete<SourceRange>> for StmtDelete {
-    fn from(node: &'static crate::StmtDelete<SourceRange>) -> Self {
+impl From<&'static ast::StmtDelete<SourceRange>> for StmtDelete {
+    fn from(node: &'static ast::StmtDelete<SourceRange>) -> Self {
         StmtDelete(node)
     }
 }
 
 impl ToPyObject for StmtDelete {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtDelete<SourceRange> {
+impl ToPyWrapper for ast::StmtDelete<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtDelete(self).to_object(py))
     }
 }
@@ -502,32 +502,32 @@ impl StmtDelete {
     #[getter]
     #[inline]
     fn get_targets(&self, py: Python) -> PyResult<PyObject> {
-        self.0.targets.to_pyo3_wrapper(py)
+        self.0.targets.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Assign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAssign(pub &'static crate::StmtAssign<SourceRange>);
+pub struct StmtAssign(pub &'static ast::StmtAssign<SourceRange>);
 
-impl From<&'static crate::StmtAssign<SourceRange>> for StmtAssign {
-    fn from(node: &'static crate::StmtAssign<SourceRange>) -> Self {
+impl From<&'static ast::StmtAssign<SourceRange>> for StmtAssign {
+    fn from(node: &'static ast::StmtAssign<SourceRange>) -> Self {
         StmtAssign(node)
     }
 }
 
 impl ToPyObject for StmtAssign {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAssign<SourceRange> {
+impl ToPyWrapper for ast::StmtAssign<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAssign(self).to_object(py))
     }
 }
@@ -537,44 +537,44 @@ impl StmtAssign {
     #[getter]
     #[inline]
     fn get_targets(&self, py: Python) -> PyResult<PyObject> {
-        self.0.targets.to_pyo3_wrapper(py)
+        self.0.targets.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_AugAssign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAugAssign(pub &'static crate::StmtAugAssign<SourceRange>);
+pub struct StmtAugAssign(pub &'static ast::StmtAugAssign<SourceRange>);
 
-impl From<&'static crate::StmtAugAssign<SourceRange>> for StmtAugAssign {
-    fn from(node: &'static crate::StmtAugAssign<SourceRange>) -> Self {
+impl From<&'static ast::StmtAugAssign<SourceRange>> for StmtAugAssign {
+    fn from(node: &'static ast::StmtAugAssign<SourceRange>) -> Self {
         StmtAugAssign(node)
     }
 }
 
 impl ToPyObject for StmtAugAssign {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAugAssign<SourceRange> {
+impl ToPyWrapper for ast::StmtAugAssign<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAugAssign(self).to_object(py))
     }
 }
@@ -584,44 +584,44 @@ impl StmtAugAssign {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_AnnAssign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAnnAssign(pub &'static crate::StmtAnnAssign<SourceRange>);
+pub struct StmtAnnAssign(pub &'static ast::StmtAnnAssign<SourceRange>);
 
-impl From<&'static crate::StmtAnnAssign<SourceRange>> for StmtAnnAssign {
-    fn from(node: &'static crate::StmtAnnAssign<SourceRange>) -> Self {
+impl From<&'static ast::StmtAnnAssign<SourceRange>> for StmtAnnAssign {
+    fn from(node: &'static ast::StmtAnnAssign<SourceRange>) -> Self {
         StmtAnnAssign(node)
     }
 }
 
 impl ToPyObject for StmtAnnAssign {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAnnAssign<SourceRange> {
+impl ToPyWrapper for ast::StmtAnnAssign<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAnnAssign(self).to_object(py))
     }
 }
@@ -631,50 +631,50 @@ impl StmtAnnAssign {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_annotation(&self, py: Python) -> PyResult<PyObject> {
-        self.0.annotation.to_pyo3_wrapper(py)
+        self.0.annotation.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_simple(&self, py: Python) -> PyResult<PyObject> {
-        self.0.simple.to_pyo3_wrapper(py)
+        self.0.simple.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_For", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtFor(pub &'static crate::StmtFor<SourceRange>);
+pub struct StmtFor(pub &'static ast::StmtFor<SourceRange>);
 
-impl From<&'static crate::StmtFor<SourceRange>> for StmtFor {
-    fn from(node: &'static crate::StmtFor<SourceRange>) -> Self {
+impl From<&'static ast::StmtFor<SourceRange>> for StmtFor {
+    fn from(node: &'static ast::StmtFor<SourceRange>) -> Self {
         StmtFor(node)
     }
 }
 
 impl ToPyObject for StmtFor {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtFor<SourceRange> {
+impl ToPyWrapper for ast::StmtFor<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtFor(self).to_object(py))
     }
 }
@@ -684,56 +684,56 @@ impl StmtFor {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_iter(&self, py: Python) -> PyResult<PyObject> {
-        self.0.iter.to_pyo3_wrapper(py)
+        self.0.iter.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_AsyncFor", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAsyncFor(pub &'static crate::StmtAsyncFor<SourceRange>);
+pub struct StmtAsyncFor(pub &'static ast::StmtAsyncFor<SourceRange>);
 
-impl From<&'static crate::StmtAsyncFor<SourceRange>> for StmtAsyncFor {
-    fn from(node: &'static crate::StmtAsyncFor<SourceRange>) -> Self {
+impl From<&'static ast::StmtAsyncFor<SourceRange>> for StmtAsyncFor {
+    fn from(node: &'static ast::StmtAsyncFor<SourceRange>) -> Self {
         StmtAsyncFor(node)
     }
 }
 
 impl ToPyObject for StmtAsyncFor {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAsyncFor<SourceRange> {
+impl ToPyWrapper for ast::StmtAsyncFor<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAsyncFor(self).to_object(py))
     }
 }
@@ -743,56 +743,56 @@ impl StmtAsyncFor {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_iter(&self, py: Python) -> PyResult<PyObject> {
-        self.0.iter.to_pyo3_wrapper(py)
+        self.0.iter.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_While", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtWhile(pub &'static crate::StmtWhile<SourceRange>);
+pub struct StmtWhile(pub &'static ast::StmtWhile<SourceRange>);
 
-impl From<&'static crate::StmtWhile<SourceRange>> for StmtWhile {
-    fn from(node: &'static crate::StmtWhile<SourceRange>) -> Self {
+impl From<&'static ast::StmtWhile<SourceRange>> for StmtWhile {
+    fn from(node: &'static ast::StmtWhile<SourceRange>) -> Self {
         StmtWhile(node)
     }
 }
 
 impl ToPyObject for StmtWhile {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtWhile<SourceRange> {
+impl ToPyWrapper for ast::StmtWhile<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtWhile(self).to_object(py))
     }
 }
@@ -802,44 +802,44 @@ impl StmtWhile {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_If", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtIf(pub &'static crate::StmtIf<SourceRange>);
+pub struct StmtIf(pub &'static ast::StmtIf<SourceRange>);
 
-impl From<&'static crate::StmtIf<SourceRange>> for StmtIf {
-    fn from(node: &'static crate::StmtIf<SourceRange>) -> Self {
+impl From<&'static ast::StmtIf<SourceRange>> for StmtIf {
+    fn from(node: &'static ast::StmtIf<SourceRange>) -> Self {
         StmtIf(node)
     }
 }
 
 impl ToPyObject for StmtIf {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtIf<SourceRange> {
+impl ToPyWrapper for ast::StmtIf<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtIf(self).to_object(py))
     }
 }
@@ -849,44 +849,44 @@ impl StmtIf {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_With", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtWith(pub &'static crate::StmtWith<SourceRange>);
+pub struct StmtWith(pub &'static ast::StmtWith<SourceRange>);
 
-impl From<&'static crate::StmtWith<SourceRange>> for StmtWith {
-    fn from(node: &'static crate::StmtWith<SourceRange>) -> Self {
+impl From<&'static ast::StmtWith<SourceRange>> for StmtWith {
+    fn from(node: &'static ast::StmtWith<SourceRange>) -> Self {
         StmtWith(node)
     }
 }
 
 impl ToPyObject for StmtWith {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtWith<SourceRange> {
+impl ToPyWrapper for ast::StmtWith<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtWith(self).to_object(py))
     }
 }
@@ -896,44 +896,44 @@ impl StmtWith {
     #[getter]
     #[inline]
     fn get_items(&self, py: Python) -> PyResult<PyObject> {
-        self.0.items.to_pyo3_wrapper(py)
+        self.0.items.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_AsyncWith", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAsyncWith(pub &'static crate::StmtAsyncWith<SourceRange>);
+pub struct StmtAsyncWith(pub &'static ast::StmtAsyncWith<SourceRange>);
 
-impl From<&'static crate::StmtAsyncWith<SourceRange>> for StmtAsyncWith {
-    fn from(node: &'static crate::StmtAsyncWith<SourceRange>) -> Self {
+impl From<&'static ast::StmtAsyncWith<SourceRange>> for StmtAsyncWith {
+    fn from(node: &'static ast::StmtAsyncWith<SourceRange>) -> Self {
         StmtAsyncWith(node)
     }
 }
 
 impl ToPyObject for StmtAsyncWith {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAsyncWith<SourceRange> {
+impl ToPyWrapper for ast::StmtAsyncWith<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAsyncWith(self).to_object(py))
     }
 }
@@ -943,44 +943,44 @@ impl StmtAsyncWith {
     #[getter]
     #[inline]
     fn get_items(&self, py: Python) -> PyResult<PyObject> {
-        self.0.items.to_pyo3_wrapper(py)
+        self.0.items.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Match", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtMatch(pub &'static crate::StmtMatch<SourceRange>);
+pub struct StmtMatch(pub &'static ast::StmtMatch<SourceRange>);
 
-impl From<&'static crate::StmtMatch<SourceRange>> for StmtMatch {
-    fn from(node: &'static crate::StmtMatch<SourceRange>) -> Self {
+impl From<&'static ast::StmtMatch<SourceRange>> for StmtMatch {
+    fn from(node: &'static ast::StmtMatch<SourceRange>) -> Self {
         StmtMatch(node)
     }
 }
 
 impl ToPyObject for StmtMatch {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtMatch<SourceRange> {
+impl ToPyWrapper for ast::StmtMatch<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtMatch(self).to_object(py))
     }
 }
@@ -990,38 +990,38 @@ impl StmtMatch {
     #[getter]
     #[inline]
     fn get_subject(&self, py: Python) -> PyResult<PyObject> {
-        self.0.subject.to_pyo3_wrapper(py)
+        self.0.subject.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_cases(&self, py: Python) -> PyResult<PyObject> {
-        self.0.cases.to_pyo3_wrapper(py)
+        self.0.cases.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Raise", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtRaise(pub &'static crate::StmtRaise<SourceRange>);
+pub struct StmtRaise(pub &'static ast::StmtRaise<SourceRange>);
 
-impl From<&'static crate::StmtRaise<SourceRange>> for StmtRaise {
-    fn from(node: &'static crate::StmtRaise<SourceRange>) -> Self {
+impl From<&'static ast::StmtRaise<SourceRange>> for StmtRaise {
+    fn from(node: &'static ast::StmtRaise<SourceRange>) -> Self {
         StmtRaise(node)
     }
 }
 
 impl ToPyObject for StmtRaise {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtRaise<SourceRange> {
+impl ToPyWrapper for ast::StmtRaise<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtRaise(self).to_object(py))
     }
 }
@@ -1031,38 +1031,38 @@ impl StmtRaise {
     #[getter]
     #[inline]
     fn get_exc(&self, py: Python) -> PyResult<PyObject> {
-        self.0.exc.to_pyo3_wrapper(py)
+        self.0.exc.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_cause(&self, py: Python) -> PyResult<PyObject> {
-        self.0.cause.to_pyo3_wrapper(py)
+        self.0.cause.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Try", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtTry(pub &'static crate::StmtTry<SourceRange>);
+pub struct StmtTry(pub &'static ast::StmtTry<SourceRange>);
 
-impl From<&'static crate::StmtTry<SourceRange>> for StmtTry {
-    fn from(node: &'static crate::StmtTry<SourceRange>) -> Self {
+impl From<&'static ast::StmtTry<SourceRange>> for StmtTry {
+    fn from(node: &'static ast::StmtTry<SourceRange>) -> Self {
         StmtTry(node)
     }
 }
 
 impl ToPyObject for StmtTry {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtTry<SourceRange> {
+impl ToPyWrapper for ast::StmtTry<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtTry(self).to_object(py))
     }
 }
@@ -1072,50 +1072,50 @@ impl StmtTry {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_handlers(&self, py: Python) -> PyResult<PyObject> {
-        self.0.handlers.to_pyo3_wrapper(py)
+        self.0.handlers.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_finalbody(&self, py: Python) -> PyResult<PyObject> {
-        self.0.finalbody.to_pyo3_wrapper(py)
+        self.0.finalbody.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_TryStar", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtTryStar(pub &'static crate::StmtTryStar<SourceRange>);
+pub struct StmtTryStar(pub &'static ast::StmtTryStar<SourceRange>);
 
-impl From<&'static crate::StmtTryStar<SourceRange>> for StmtTryStar {
-    fn from(node: &'static crate::StmtTryStar<SourceRange>) -> Self {
+impl From<&'static ast::StmtTryStar<SourceRange>> for StmtTryStar {
+    fn from(node: &'static ast::StmtTryStar<SourceRange>) -> Self {
         StmtTryStar(node)
     }
 }
 
 impl ToPyObject for StmtTryStar {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtTryStar<SourceRange> {
+impl ToPyWrapper for ast::StmtTryStar<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtTryStar(self).to_object(py))
     }
 }
@@ -1125,50 +1125,50 @@ impl StmtTryStar {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_handlers(&self, py: Python) -> PyResult<PyObject> {
-        self.0.handlers.to_pyo3_wrapper(py)
+        self.0.handlers.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_finalbody(&self, py: Python) -> PyResult<PyObject> {
-        self.0.finalbody.to_pyo3_wrapper(py)
+        self.0.finalbody.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Assert", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAssert(pub &'static crate::StmtAssert<SourceRange>);
+pub struct StmtAssert(pub &'static ast::StmtAssert<SourceRange>);
 
-impl From<&'static crate::StmtAssert<SourceRange>> for StmtAssert {
-    fn from(node: &'static crate::StmtAssert<SourceRange>) -> Self {
+impl From<&'static ast::StmtAssert<SourceRange>> for StmtAssert {
+    fn from(node: &'static ast::StmtAssert<SourceRange>) -> Self {
         StmtAssert(node)
     }
 }
 
 impl ToPyObject for StmtAssert {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAssert<SourceRange> {
+impl ToPyWrapper for ast::StmtAssert<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAssert(self).to_object(py))
     }
 }
@@ -1178,38 +1178,38 @@ impl StmtAssert {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_msg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.msg.to_pyo3_wrapper(py)
+        self.0.msg.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Import", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtImport(pub &'static crate::StmtImport<SourceRange>);
+pub struct StmtImport(pub &'static ast::StmtImport<SourceRange>);
 
-impl From<&'static crate::StmtImport<SourceRange>> for StmtImport {
-    fn from(node: &'static crate::StmtImport<SourceRange>) -> Self {
+impl From<&'static ast::StmtImport<SourceRange>> for StmtImport {
+    fn from(node: &'static ast::StmtImport<SourceRange>) -> Self {
         StmtImport(node)
     }
 }
 
 impl ToPyObject for StmtImport {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtImport<SourceRange> {
+impl ToPyWrapper for ast::StmtImport<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtImport(self).to_object(py))
     }
 }
@@ -1219,32 +1219,32 @@ impl StmtImport {
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_ImportFrom", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtImportFrom(pub &'static crate::StmtImportFrom<SourceRange>);
+pub struct StmtImportFrom(pub &'static ast::StmtImportFrom<SourceRange>);
 
-impl From<&'static crate::StmtImportFrom<SourceRange>> for StmtImportFrom {
-    fn from(node: &'static crate::StmtImportFrom<SourceRange>) -> Self {
+impl From<&'static ast::StmtImportFrom<SourceRange>> for StmtImportFrom {
+    fn from(node: &'static ast::StmtImportFrom<SourceRange>) -> Self {
         StmtImportFrom(node)
     }
 }
 
 impl ToPyObject for StmtImportFrom {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtImportFrom<SourceRange> {
+impl ToPyWrapper for ast::StmtImportFrom<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtImportFrom(self).to_object(py))
     }
 }
@@ -1254,44 +1254,44 @@ impl StmtImportFrom {
     #[getter]
     #[inline]
     fn get_module(&self, py: Python) -> PyResult<PyObject> {
-        self.0.module.to_pyo3_wrapper(py)
+        self.0.module.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_level(&self, py: Python) -> PyResult<PyObject> {
-        self.0.level.to_pyo3_wrapper(py)
+        self.0.level.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Global", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtGlobal(pub &'static crate::StmtGlobal<SourceRange>);
+pub struct StmtGlobal(pub &'static ast::StmtGlobal<SourceRange>);
 
-impl From<&'static crate::StmtGlobal<SourceRange>> for StmtGlobal {
-    fn from(node: &'static crate::StmtGlobal<SourceRange>) -> Self {
+impl From<&'static ast::StmtGlobal<SourceRange>> for StmtGlobal {
+    fn from(node: &'static ast::StmtGlobal<SourceRange>) -> Self {
         StmtGlobal(node)
     }
 }
 
 impl ToPyObject for StmtGlobal {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtGlobal<SourceRange> {
+impl ToPyWrapper for ast::StmtGlobal<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtGlobal(self).to_object(py))
     }
 }
@@ -1301,32 +1301,32 @@ impl StmtGlobal {
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Nonlocal", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtNonlocal(pub &'static crate::StmtNonlocal<SourceRange>);
+pub struct StmtNonlocal(pub &'static ast::StmtNonlocal<SourceRange>);
 
-impl From<&'static crate::StmtNonlocal<SourceRange>> for StmtNonlocal {
-    fn from(node: &'static crate::StmtNonlocal<SourceRange>) -> Self {
+impl From<&'static ast::StmtNonlocal<SourceRange>> for StmtNonlocal {
+    fn from(node: &'static ast::StmtNonlocal<SourceRange>) -> Self {
         StmtNonlocal(node)
     }
 }
 
 impl ToPyObject for StmtNonlocal {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtNonlocal<SourceRange> {
+impl ToPyWrapper for ast::StmtNonlocal<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtNonlocal(self).to_object(py))
     }
 }
@@ -1336,32 +1336,32 @@ impl StmtNonlocal {
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Expr", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtExpr(pub &'static crate::StmtExpr<SourceRange>);
+pub struct StmtExpr(pub &'static ast::StmtExpr<SourceRange>);
 
-impl From<&'static crate::StmtExpr<SourceRange>> for StmtExpr {
-    fn from(node: &'static crate::StmtExpr<SourceRange>) -> Self {
+impl From<&'static ast::StmtExpr<SourceRange>> for StmtExpr {
+    fn from(node: &'static ast::StmtExpr<SourceRange>) -> Self {
         StmtExpr(node)
     }
 }
 
 impl ToPyObject for StmtExpr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtExpr<SourceRange> {
+impl ToPyWrapper for ast::StmtExpr<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtExpr(self).to_object(py))
     }
 }
@@ -1371,32 +1371,32 @@ impl StmtExpr {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Pass", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtPass(pub &'static crate::StmtPass<SourceRange>);
+pub struct StmtPass(pub &'static ast::StmtPass<SourceRange>);
 
-impl From<&'static crate::StmtPass<SourceRange>> for StmtPass {
-    fn from(node: &'static crate::StmtPass<SourceRange>) -> Self {
+impl From<&'static ast::StmtPass<SourceRange>> for StmtPass {
+    fn from(node: &'static ast::StmtPass<SourceRange>) -> Self {
         StmtPass(node)
     }
 }
 
 impl ToPyObject for StmtPass {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtPass<SourceRange> {
+impl ToPyWrapper for ast::StmtPass<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtPass(self).to_object(py))
     }
 }
@@ -1406,26 +1406,26 @@ impl StmtPass {}
 
 #[pyclass(module="rustpython_ast.located", name="_Break", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtBreak(pub &'static crate::StmtBreak<SourceRange>);
+pub struct StmtBreak(pub &'static ast::StmtBreak<SourceRange>);
 
-impl From<&'static crate::StmtBreak<SourceRange>> for StmtBreak {
-    fn from(node: &'static crate::StmtBreak<SourceRange>) -> Self {
+impl From<&'static ast::StmtBreak<SourceRange>> for StmtBreak {
+    fn from(node: &'static ast::StmtBreak<SourceRange>) -> Self {
         StmtBreak(node)
     }
 }
 
 impl ToPyObject for StmtBreak {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtBreak<SourceRange> {
+impl ToPyWrapper for ast::StmtBreak<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtBreak(self).to_object(py))
     }
 }
@@ -1435,26 +1435,26 @@ impl StmtBreak {}
 
 #[pyclass(module="rustpython_ast.located", name="_Continue", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtContinue(pub &'static crate::StmtContinue<SourceRange>);
+pub struct StmtContinue(pub &'static ast::StmtContinue<SourceRange>);
 
-impl From<&'static crate::StmtContinue<SourceRange>> for StmtContinue {
-    fn from(node: &'static crate::StmtContinue<SourceRange>) -> Self {
+impl From<&'static ast::StmtContinue<SourceRange>> for StmtContinue {
+    fn from(node: &'static ast::StmtContinue<SourceRange>) -> Self {
         StmtContinue(node)
     }
 }
 
 impl ToPyObject for StmtContinue {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtContinue<SourceRange> {
+impl ToPyWrapper for ast::StmtContinue<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtContinue(self).to_object(py))
     }
 }
@@ -1462,12 +1462,12 @@ impl ToPyo3Wrapper for crate::StmtContinue<SourceRange> {
 #[pymethods]
 impl StmtContinue {}
 
-#[pyclass(module="rustpython_ast.located", name="_expr", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_expr", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Expr;
 
-impl From<&'static crate::Expr<SourceRange>> for Expr {
-    fn from(_node: &'static crate::Expr<SourceRange>) -> Self {
+impl From<&'static ast::Expr<SourceRange>> for Expr {
+    fn from(_node: &'static ast::Expr<SourceRange>) -> Self {
         Expr
     }
 }
@@ -1476,7 +1476,7 @@ impl From<&'static crate::Expr<SourceRange>> for Expr {
 impl Expr {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Expr {
@@ -1486,63 +1486,63 @@ impl ToPyObject for Expr {
     }
 }
 
-impl ToPyo3Wrapper for crate::Expr<SourceRange> {
+impl ToPyWrapper for ast::Expr<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::BoolOp(cons) => cons.to_pyo3_wrapper(py),
-            Self::NamedExpr(cons) => cons.to_pyo3_wrapper(py),
-            Self::BinOp(cons) => cons.to_pyo3_wrapper(py),
-            Self::UnaryOp(cons) => cons.to_pyo3_wrapper(py),
-            Self::Lambda(cons) => cons.to_pyo3_wrapper(py),
-            Self::IfExp(cons) => cons.to_pyo3_wrapper(py),
-            Self::Dict(cons) => cons.to_pyo3_wrapper(py),
-            Self::Set(cons) => cons.to_pyo3_wrapper(py),
-            Self::ListComp(cons) => cons.to_pyo3_wrapper(py),
-            Self::SetComp(cons) => cons.to_pyo3_wrapper(py),
-            Self::DictComp(cons) => cons.to_pyo3_wrapper(py),
-            Self::GeneratorExp(cons) => cons.to_pyo3_wrapper(py),
-            Self::Await(cons) => cons.to_pyo3_wrapper(py),
-            Self::Yield(cons) => cons.to_pyo3_wrapper(py),
-            Self::YieldFrom(cons) => cons.to_pyo3_wrapper(py),
-            Self::Compare(cons) => cons.to_pyo3_wrapper(py),
-            Self::Call(cons) => cons.to_pyo3_wrapper(py),
-            Self::FormattedValue(cons) => cons.to_pyo3_wrapper(py),
-            Self::JoinedStr(cons) => cons.to_pyo3_wrapper(py),
-            Self::Constant(cons) => cons.to_pyo3_wrapper(py),
-            Self::Attribute(cons) => cons.to_pyo3_wrapper(py),
-            Self::Subscript(cons) => cons.to_pyo3_wrapper(py),
-            Self::Starred(cons) => cons.to_pyo3_wrapper(py),
-            Self::Name(cons) => cons.to_pyo3_wrapper(py),
-            Self::List(cons) => cons.to_pyo3_wrapper(py),
-            Self::Tuple(cons) => cons.to_pyo3_wrapper(py),
-            Self::Slice(cons) => cons.to_pyo3_wrapper(py),
+            Self::BoolOp(cons) => cons.to_py_wrapper(py),
+            Self::NamedExpr(cons) => cons.to_py_wrapper(py),
+            Self::BinOp(cons) => cons.to_py_wrapper(py),
+            Self::UnaryOp(cons) => cons.to_py_wrapper(py),
+            Self::Lambda(cons) => cons.to_py_wrapper(py),
+            Self::IfExp(cons) => cons.to_py_wrapper(py),
+            Self::Dict(cons) => cons.to_py_wrapper(py),
+            Self::Set(cons) => cons.to_py_wrapper(py),
+            Self::ListComp(cons) => cons.to_py_wrapper(py),
+            Self::SetComp(cons) => cons.to_py_wrapper(py),
+            Self::DictComp(cons) => cons.to_py_wrapper(py),
+            Self::GeneratorExp(cons) => cons.to_py_wrapper(py),
+            Self::Await(cons) => cons.to_py_wrapper(py),
+            Self::Yield(cons) => cons.to_py_wrapper(py),
+            Self::YieldFrom(cons) => cons.to_py_wrapper(py),
+            Self::Compare(cons) => cons.to_py_wrapper(py),
+            Self::Call(cons) => cons.to_py_wrapper(py),
+            Self::FormattedValue(cons) => cons.to_py_wrapper(py),
+            Self::JoinedStr(cons) => cons.to_py_wrapper(py),
+            Self::Constant(cons) => cons.to_py_wrapper(py),
+            Self::Attribute(cons) => cons.to_py_wrapper(py),
+            Self::Subscript(cons) => cons.to_py_wrapper(py),
+            Self::Starred(cons) => cons.to_py_wrapper(py),
+            Self::Name(cons) => cons.to_py_wrapper(py),
+            Self::List(cons) => cons.to_py_wrapper(py),
+            Self::Tuple(cons) => cons.to_py_wrapper(py),
+            Self::Slice(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_BoolOp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprBoolOp(pub &'static crate::ExprBoolOp<SourceRange>);
+pub struct ExprBoolOp(pub &'static ast::ExprBoolOp<SourceRange>);
 
-impl From<&'static crate::ExprBoolOp<SourceRange>> for ExprBoolOp {
-    fn from(node: &'static crate::ExprBoolOp<SourceRange>) -> Self {
+impl From<&'static ast::ExprBoolOp<SourceRange>> for ExprBoolOp {
+    fn from(node: &'static ast::ExprBoolOp<SourceRange>) -> Self {
         ExprBoolOp(node)
     }
 }
 
 impl ToPyObject for ExprBoolOp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprBoolOp<SourceRange> {
+impl ToPyWrapper for ast::ExprBoolOp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprBoolOp(self).to_object(py))
     }
 }
@@ -1552,38 +1552,38 @@ impl ExprBoolOp {
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_values(&self, py: Python) -> PyResult<PyObject> {
-        self.0.values.to_pyo3_wrapper(py)
+        self.0.values.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_NamedExpr", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprNamedExpr(pub &'static crate::ExprNamedExpr<SourceRange>);
+pub struct ExprNamedExpr(pub &'static ast::ExprNamedExpr<SourceRange>);
 
-impl From<&'static crate::ExprNamedExpr<SourceRange>> for ExprNamedExpr {
-    fn from(node: &'static crate::ExprNamedExpr<SourceRange>) -> Self {
+impl From<&'static ast::ExprNamedExpr<SourceRange>> for ExprNamedExpr {
+    fn from(node: &'static ast::ExprNamedExpr<SourceRange>) -> Self {
         ExprNamedExpr(node)
     }
 }
 
 impl ToPyObject for ExprNamedExpr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprNamedExpr<SourceRange> {
+impl ToPyWrapper for ast::ExprNamedExpr<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprNamedExpr(self).to_object(py))
     }
 }
@@ -1593,38 +1593,38 @@ impl ExprNamedExpr {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_BinOp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprBinOp(pub &'static crate::ExprBinOp<SourceRange>);
+pub struct ExprBinOp(pub &'static ast::ExprBinOp<SourceRange>);
 
-impl From<&'static crate::ExprBinOp<SourceRange>> for ExprBinOp {
-    fn from(node: &'static crate::ExprBinOp<SourceRange>) -> Self {
+impl From<&'static ast::ExprBinOp<SourceRange>> for ExprBinOp {
+    fn from(node: &'static ast::ExprBinOp<SourceRange>) -> Self {
         ExprBinOp(node)
     }
 }
 
 impl ToPyObject for ExprBinOp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprBinOp<SourceRange> {
+impl ToPyWrapper for ast::ExprBinOp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprBinOp(self).to_object(py))
     }
 }
@@ -1634,44 +1634,44 @@ impl ExprBinOp {
     #[getter]
     #[inline]
     fn get_left(&self, py: Python) -> PyResult<PyObject> {
-        self.0.left.to_pyo3_wrapper(py)
+        self.0.left.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_right(&self, py: Python) -> PyResult<PyObject> {
-        self.0.right.to_pyo3_wrapper(py)
+        self.0.right.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_UnaryOp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprUnaryOp(pub &'static crate::ExprUnaryOp<SourceRange>);
+pub struct ExprUnaryOp(pub &'static ast::ExprUnaryOp<SourceRange>);
 
-impl From<&'static crate::ExprUnaryOp<SourceRange>> for ExprUnaryOp {
-    fn from(node: &'static crate::ExprUnaryOp<SourceRange>) -> Self {
+impl From<&'static ast::ExprUnaryOp<SourceRange>> for ExprUnaryOp {
+    fn from(node: &'static ast::ExprUnaryOp<SourceRange>) -> Self {
         ExprUnaryOp(node)
     }
 }
 
 impl ToPyObject for ExprUnaryOp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprUnaryOp<SourceRange> {
+impl ToPyWrapper for ast::ExprUnaryOp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprUnaryOp(self).to_object(py))
     }
 }
@@ -1681,38 +1681,38 @@ impl ExprUnaryOp {
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_operand(&self, py: Python) -> PyResult<PyObject> {
-        self.0.operand.to_pyo3_wrapper(py)
+        self.0.operand.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Lambda", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprLambda(pub &'static crate::ExprLambda<SourceRange>);
+pub struct ExprLambda(pub &'static ast::ExprLambda<SourceRange>);
 
-impl From<&'static crate::ExprLambda<SourceRange>> for ExprLambda {
-    fn from(node: &'static crate::ExprLambda<SourceRange>) -> Self {
+impl From<&'static ast::ExprLambda<SourceRange>> for ExprLambda {
+    fn from(node: &'static ast::ExprLambda<SourceRange>) -> Self {
         ExprLambda(node)
     }
 }
 
 impl ToPyObject for ExprLambda {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprLambda<SourceRange> {
+impl ToPyWrapper for ast::ExprLambda<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprLambda(self).to_object(py))
     }
 }
@@ -1722,38 +1722,38 @@ impl ExprLambda {
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_IfExp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprIfExp(pub &'static crate::ExprIfExp<SourceRange>);
+pub struct ExprIfExp(pub &'static ast::ExprIfExp<SourceRange>);
 
-impl From<&'static crate::ExprIfExp<SourceRange>> for ExprIfExp {
-    fn from(node: &'static crate::ExprIfExp<SourceRange>) -> Self {
+impl From<&'static ast::ExprIfExp<SourceRange>> for ExprIfExp {
+    fn from(node: &'static ast::ExprIfExp<SourceRange>) -> Self {
         ExprIfExp(node)
     }
 }
 
 impl ToPyObject for ExprIfExp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprIfExp<SourceRange> {
+impl ToPyWrapper for ast::ExprIfExp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprIfExp(self).to_object(py))
     }
 }
@@ -1763,44 +1763,44 @@ impl ExprIfExp {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Dict", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprDict(pub &'static crate::ExprDict<SourceRange>);
+pub struct ExprDict(pub &'static ast::ExprDict<SourceRange>);
 
-impl From<&'static crate::ExprDict<SourceRange>> for ExprDict {
-    fn from(node: &'static crate::ExprDict<SourceRange>) -> Self {
+impl From<&'static ast::ExprDict<SourceRange>> for ExprDict {
+    fn from(node: &'static ast::ExprDict<SourceRange>) -> Self {
         ExprDict(node)
     }
 }
 
 impl ToPyObject for ExprDict {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprDict<SourceRange> {
+impl ToPyWrapper for ast::ExprDict<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprDict(self).to_object(py))
     }
 }
@@ -1810,38 +1810,38 @@ impl ExprDict {
     #[getter]
     #[inline]
     fn get_keys(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keys.to_pyo3_wrapper(py)
+        self.0.keys.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_values(&self, py: Python) -> PyResult<PyObject> {
-        self.0.values.to_pyo3_wrapper(py)
+        self.0.values.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Set", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSet(pub &'static crate::ExprSet<SourceRange>);
+pub struct ExprSet(pub &'static ast::ExprSet<SourceRange>);
 
-impl From<&'static crate::ExprSet<SourceRange>> for ExprSet {
-    fn from(node: &'static crate::ExprSet<SourceRange>) -> Self {
+impl From<&'static ast::ExprSet<SourceRange>> for ExprSet {
+    fn from(node: &'static ast::ExprSet<SourceRange>) -> Self {
         ExprSet(node)
     }
 }
 
 impl ToPyObject for ExprSet {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSet<SourceRange> {
+impl ToPyWrapper for ast::ExprSet<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSet(self).to_object(py))
     }
 }
@@ -1851,32 +1851,32 @@ impl ExprSet {
     #[getter]
     #[inline]
     fn get_elts(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elts.to_pyo3_wrapper(py)
+        self.0.elts.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_ListComp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprListComp(pub &'static crate::ExprListComp<SourceRange>);
+pub struct ExprListComp(pub &'static ast::ExprListComp<SourceRange>);
 
-impl From<&'static crate::ExprListComp<SourceRange>> for ExprListComp {
-    fn from(node: &'static crate::ExprListComp<SourceRange>) -> Self {
+impl From<&'static ast::ExprListComp<SourceRange>> for ExprListComp {
+    fn from(node: &'static ast::ExprListComp<SourceRange>) -> Self {
         ExprListComp(node)
     }
 }
 
 impl ToPyObject for ExprListComp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprListComp<SourceRange> {
+impl ToPyWrapper for ast::ExprListComp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprListComp(self).to_object(py))
     }
 }
@@ -1886,38 +1886,38 @@ impl ExprListComp {
     #[getter]
     #[inline]
     fn get_elt(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elt.to_pyo3_wrapper(py)
+        self.0.elt.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_SetComp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSetComp(pub &'static crate::ExprSetComp<SourceRange>);
+pub struct ExprSetComp(pub &'static ast::ExprSetComp<SourceRange>);
 
-impl From<&'static crate::ExprSetComp<SourceRange>> for ExprSetComp {
-    fn from(node: &'static crate::ExprSetComp<SourceRange>) -> Self {
+impl From<&'static ast::ExprSetComp<SourceRange>> for ExprSetComp {
+    fn from(node: &'static ast::ExprSetComp<SourceRange>) -> Self {
         ExprSetComp(node)
     }
 }
 
 impl ToPyObject for ExprSetComp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSetComp<SourceRange> {
+impl ToPyWrapper for ast::ExprSetComp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSetComp(self).to_object(py))
     }
 }
@@ -1927,38 +1927,38 @@ impl ExprSetComp {
     #[getter]
     #[inline]
     fn get_elt(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elt.to_pyo3_wrapper(py)
+        self.0.elt.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_DictComp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprDictComp(pub &'static crate::ExprDictComp<SourceRange>);
+pub struct ExprDictComp(pub &'static ast::ExprDictComp<SourceRange>);
 
-impl From<&'static crate::ExprDictComp<SourceRange>> for ExprDictComp {
-    fn from(node: &'static crate::ExprDictComp<SourceRange>) -> Self {
+impl From<&'static ast::ExprDictComp<SourceRange>> for ExprDictComp {
+    fn from(node: &'static ast::ExprDictComp<SourceRange>) -> Self {
         ExprDictComp(node)
     }
 }
 
 impl ToPyObject for ExprDictComp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprDictComp<SourceRange> {
+impl ToPyWrapper for ast::ExprDictComp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprDictComp(self).to_object(py))
     }
 }
@@ -1968,44 +1968,44 @@ impl ExprDictComp {
     #[getter]
     #[inline]
     fn get_key(&self, py: Python) -> PyResult<PyObject> {
-        self.0.key.to_pyo3_wrapper(py)
+        self.0.key.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_GeneratorExp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprGeneratorExp(pub &'static crate::ExprGeneratorExp<SourceRange>);
+pub struct ExprGeneratorExp(pub &'static ast::ExprGeneratorExp<SourceRange>);
 
-impl From<&'static crate::ExprGeneratorExp<SourceRange>> for ExprGeneratorExp {
-    fn from(node: &'static crate::ExprGeneratorExp<SourceRange>) -> Self {
+impl From<&'static ast::ExprGeneratorExp<SourceRange>> for ExprGeneratorExp {
+    fn from(node: &'static ast::ExprGeneratorExp<SourceRange>) -> Self {
         ExprGeneratorExp(node)
     }
 }
 
 impl ToPyObject for ExprGeneratorExp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprGeneratorExp<SourceRange> {
+impl ToPyWrapper for ast::ExprGeneratorExp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprGeneratorExp(self).to_object(py))
     }
 }
@@ -2015,38 +2015,38 @@ impl ExprGeneratorExp {
     #[getter]
     #[inline]
     fn get_elt(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elt.to_pyo3_wrapper(py)
+        self.0.elt.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Await", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprAwait(pub &'static crate::ExprAwait<SourceRange>);
+pub struct ExprAwait(pub &'static ast::ExprAwait<SourceRange>);
 
-impl From<&'static crate::ExprAwait<SourceRange>> for ExprAwait {
-    fn from(node: &'static crate::ExprAwait<SourceRange>) -> Self {
+impl From<&'static ast::ExprAwait<SourceRange>> for ExprAwait {
+    fn from(node: &'static ast::ExprAwait<SourceRange>) -> Self {
         ExprAwait(node)
     }
 }
 
 impl ToPyObject for ExprAwait {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprAwait<SourceRange> {
+impl ToPyWrapper for ast::ExprAwait<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprAwait(self).to_object(py))
     }
 }
@@ -2056,32 +2056,32 @@ impl ExprAwait {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Yield", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprYield(pub &'static crate::ExprYield<SourceRange>);
+pub struct ExprYield(pub &'static ast::ExprYield<SourceRange>);
 
-impl From<&'static crate::ExprYield<SourceRange>> for ExprYield {
-    fn from(node: &'static crate::ExprYield<SourceRange>) -> Self {
+impl From<&'static ast::ExprYield<SourceRange>> for ExprYield {
+    fn from(node: &'static ast::ExprYield<SourceRange>) -> Self {
         ExprYield(node)
     }
 }
 
 impl ToPyObject for ExprYield {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprYield<SourceRange> {
+impl ToPyWrapper for ast::ExprYield<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprYield(self).to_object(py))
     }
 }
@@ -2091,32 +2091,32 @@ impl ExprYield {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_YieldFrom", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprYieldFrom(pub &'static crate::ExprYieldFrom<SourceRange>);
+pub struct ExprYieldFrom(pub &'static ast::ExprYieldFrom<SourceRange>);
 
-impl From<&'static crate::ExprYieldFrom<SourceRange>> for ExprYieldFrom {
-    fn from(node: &'static crate::ExprYieldFrom<SourceRange>) -> Self {
+impl From<&'static ast::ExprYieldFrom<SourceRange>> for ExprYieldFrom {
+    fn from(node: &'static ast::ExprYieldFrom<SourceRange>) -> Self {
         ExprYieldFrom(node)
     }
 }
 
 impl ToPyObject for ExprYieldFrom {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprYieldFrom<SourceRange> {
+impl ToPyWrapper for ast::ExprYieldFrom<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprYieldFrom(self).to_object(py))
     }
 }
@@ -2126,32 +2126,32 @@ impl ExprYieldFrom {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Compare", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprCompare(pub &'static crate::ExprCompare<SourceRange>);
+pub struct ExprCompare(pub &'static ast::ExprCompare<SourceRange>);
 
-impl From<&'static crate::ExprCompare<SourceRange>> for ExprCompare {
-    fn from(node: &'static crate::ExprCompare<SourceRange>) -> Self {
+impl From<&'static ast::ExprCompare<SourceRange>> for ExprCompare {
+    fn from(node: &'static ast::ExprCompare<SourceRange>) -> Self {
         ExprCompare(node)
     }
 }
 
 impl ToPyObject for ExprCompare {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprCompare<SourceRange> {
+impl ToPyWrapper for ast::ExprCompare<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprCompare(self).to_object(py))
     }
 }
@@ -2161,44 +2161,44 @@ impl ExprCompare {
     #[getter]
     #[inline]
     fn get_left(&self, py: Python) -> PyResult<PyObject> {
-        self.0.left.to_pyo3_wrapper(py)
+        self.0.left.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ops(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ops.to_pyo3_wrapper(py)
+        self.0.ops.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_comparators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.comparators.to_pyo3_wrapper(py)
+        self.0.comparators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Call", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprCall(pub &'static crate::ExprCall<SourceRange>);
+pub struct ExprCall(pub &'static ast::ExprCall<SourceRange>);
 
-impl From<&'static crate::ExprCall<SourceRange>> for ExprCall {
-    fn from(node: &'static crate::ExprCall<SourceRange>) -> Self {
+impl From<&'static ast::ExprCall<SourceRange>> for ExprCall {
+    fn from(node: &'static ast::ExprCall<SourceRange>) -> Self {
         ExprCall(node)
     }
 }
 
 impl ToPyObject for ExprCall {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprCall<SourceRange> {
+impl ToPyWrapper for ast::ExprCall<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprCall(self).to_object(py))
     }
 }
@@ -2208,44 +2208,44 @@ impl ExprCall {
     #[getter]
     #[inline]
     fn get_func(&self, py: Python) -> PyResult<PyObject> {
-        self.0.func.to_pyo3_wrapper(py)
+        self.0.func.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_keywords(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keywords.to_pyo3_wrapper(py)
+        self.0.keywords.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_FormattedValue", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprFormattedValue(pub &'static crate::ExprFormattedValue<SourceRange>);
+pub struct ExprFormattedValue(pub &'static ast::ExprFormattedValue<SourceRange>);
 
-impl From<&'static crate::ExprFormattedValue<SourceRange>> for ExprFormattedValue {
-    fn from(node: &'static crate::ExprFormattedValue<SourceRange>) -> Self {
+impl From<&'static ast::ExprFormattedValue<SourceRange>> for ExprFormattedValue {
+    fn from(node: &'static ast::ExprFormattedValue<SourceRange>) -> Self {
         ExprFormattedValue(node)
     }
 }
 
 impl ToPyObject for ExprFormattedValue {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprFormattedValue<SourceRange> {
+impl ToPyWrapper for ast::ExprFormattedValue<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprFormattedValue(self).to_object(py))
     }
 }
@@ -2255,44 +2255,44 @@ impl ExprFormattedValue {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_conversion(&self, py: Python) -> PyResult<PyObject> {
-        self.0.conversion.to_pyo3_wrapper(py)
+        self.0.conversion.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_format_spec(&self, py: Python) -> PyResult<PyObject> {
-        self.0.format_spec.to_pyo3_wrapper(py)
+        self.0.format_spec.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_JoinedStr", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprJoinedStr(pub &'static crate::ExprJoinedStr<SourceRange>);
+pub struct ExprJoinedStr(pub &'static ast::ExprJoinedStr<SourceRange>);
 
-impl From<&'static crate::ExprJoinedStr<SourceRange>> for ExprJoinedStr {
-    fn from(node: &'static crate::ExprJoinedStr<SourceRange>) -> Self {
+impl From<&'static ast::ExprJoinedStr<SourceRange>> for ExprJoinedStr {
+    fn from(node: &'static ast::ExprJoinedStr<SourceRange>) -> Self {
         ExprJoinedStr(node)
     }
 }
 
 impl ToPyObject for ExprJoinedStr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprJoinedStr<SourceRange> {
+impl ToPyWrapper for ast::ExprJoinedStr<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprJoinedStr(self).to_object(py))
     }
 }
@@ -2302,32 +2302,32 @@ impl ExprJoinedStr {
     #[getter]
     #[inline]
     fn get_values(&self, py: Python) -> PyResult<PyObject> {
-        self.0.values.to_pyo3_wrapper(py)
+        self.0.values.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Constant", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprConstant(pub &'static crate::ExprConstant<SourceRange>);
+pub struct ExprConstant(pub &'static ast::ExprConstant<SourceRange>);
 
-impl From<&'static crate::ExprConstant<SourceRange>> for ExprConstant {
-    fn from(node: &'static crate::ExprConstant<SourceRange>) -> Self {
+impl From<&'static ast::ExprConstant<SourceRange>> for ExprConstant {
+    fn from(node: &'static ast::ExprConstant<SourceRange>) -> Self {
         ExprConstant(node)
     }
 }
 
 impl ToPyObject for ExprConstant {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprConstant<SourceRange> {
+impl ToPyWrapper for ast::ExprConstant<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprConstant(self).to_object(py))
     }
 }
@@ -2337,38 +2337,38 @@ impl ExprConstant {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kind(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kind.to_pyo3_wrapper(py)
+        self.0.kind.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Attribute", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprAttribute(pub &'static crate::ExprAttribute<SourceRange>);
+pub struct ExprAttribute(pub &'static ast::ExprAttribute<SourceRange>);
 
-impl From<&'static crate::ExprAttribute<SourceRange>> for ExprAttribute {
-    fn from(node: &'static crate::ExprAttribute<SourceRange>) -> Self {
+impl From<&'static ast::ExprAttribute<SourceRange>> for ExprAttribute {
+    fn from(node: &'static ast::ExprAttribute<SourceRange>) -> Self {
         ExprAttribute(node)
     }
 }
 
 impl ToPyObject for ExprAttribute {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprAttribute<SourceRange> {
+impl ToPyWrapper for ast::ExprAttribute<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprAttribute(self).to_object(py))
     }
 }
@@ -2378,44 +2378,44 @@ impl ExprAttribute {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_attr(&self, py: Python) -> PyResult<PyObject> {
-        self.0.attr.to_pyo3_wrapper(py)
+        self.0.attr.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Subscript", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSubscript(pub &'static crate::ExprSubscript<SourceRange>);
+pub struct ExprSubscript(pub &'static ast::ExprSubscript<SourceRange>);
 
-impl From<&'static crate::ExprSubscript<SourceRange>> for ExprSubscript {
-    fn from(node: &'static crate::ExprSubscript<SourceRange>) -> Self {
+impl From<&'static ast::ExprSubscript<SourceRange>> for ExprSubscript {
+    fn from(node: &'static ast::ExprSubscript<SourceRange>) -> Self {
         ExprSubscript(node)
     }
 }
 
 impl ToPyObject for ExprSubscript {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSubscript<SourceRange> {
+impl ToPyWrapper for ast::ExprSubscript<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSubscript(self).to_object(py))
     }
 }
@@ -2425,44 +2425,44 @@ impl ExprSubscript {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_slice(&self, py: Python) -> PyResult<PyObject> {
-        self.0.slice.to_pyo3_wrapper(py)
+        self.0.slice.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Starred", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprStarred(pub &'static crate::ExprStarred<SourceRange>);
+pub struct ExprStarred(pub &'static ast::ExprStarred<SourceRange>);
 
-impl From<&'static crate::ExprStarred<SourceRange>> for ExprStarred {
-    fn from(node: &'static crate::ExprStarred<SourceRange>) -> Self {
+impl From<&'static ast::ExprStarred<SourceRange>> for ExprStarred {
+    fn from(node: &'static ast::ExprStarred<SourceRange>) -> Self {
         ExprStarred(node)
     }
 }
 
 impl ToPyObject for ExprStarred {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprStarred<SourceRange> {
+impl ToPyWrapper for ast::ExprStarred<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprStarred(self).to_object(py))
     }
 }
@@ -2472,38 +2472,38 @@ impl ExprStarred {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Name", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprName(pub &'static crate::ExprName<SourceRange>);
+pub struct ExprName(pub &'static ast::ExprName<SourceRange>);
 
-impl From<&'static crate::ExprName<SourceRange>> for ExprName {
-    fn from(node: &'static crate::ExprName<SourceRange>) -> Self {
+impl From<&'static ast::ExprName<SourceRange>> for ExprName {
+    fn from(node: &'static ast::ExprName<SourceRange>) -> Self {
         ExprName(node)
     }
 }
 
 impl ToPyObject for ExprName {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprName<SourceRange> {
+impl ToPyWrapper for ast::ExprName<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprName(self).to_object(py))
     }
 }
@@ -2513,38 +2513,38 @@ impl ExprName {
     #[getter]
     #[inline]
     fn get_id(&self, py: Python) -> PyResult<PyObject> {
-        self.0.id.to_pyo3_wrapper(py)
+        self.0.id.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_List", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprList(pub &'static crate::ExprList<SourceRange>);
+pub struct ExprList(pub &'static ast::ExprList<SourceRange>);
 
-impl From<&'static crate::ExprList<SourceRange>> for ExprList {
-    fn from(node: &'static crate::ExprList<SourceRange>) -> Self {
+impl From<&'static ast::ExprList<SourceRange>> for ExprList {
+    fn from(node: &'static ast::ExprList<SourceRange>) -> Self {
         ExprList(node)
     }
 }
 
 impl ToPyObject for ExprList {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprList<SourceRange> {
+impl ToPyWrapper for ast::ExprList<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprList(self).to_object(py))
     }
 }
@@ -2554,38 +2554,38 @@ impl ExprList {
     #[getter]
     #[inline]
     fn get_elts(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elts.to_pyo3_wrapper(py)
+        self.0.elts.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Tuple", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprTuple(pub &'static crate::ExprTuple<SourceRange>);
+pub struct ExprTuple(pub &'static ast::ExprTuple<SourceRange>);
 
-impl From<&'static crate::ExprTuple<SourceRange>> for ExprTuple {
-    fn from(node: &'static crate::ExprTuple<SourceRange>) -> Self {
+impl From<&'static ast::ExprTuple<SourceRange>> for ExprTuple {
+    fn from(node: &'static ast::ExprTuple<SourceRange>) -> Self {
         ExprTuple(node)
     }
 }
 
 impl ToPyObject for ExprTuple {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprTuple<SourceRange> {
+impl ToPyWrapper for ast::ExprTuple<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprTuple(self).to_object(py))
     }
 }
@@ -2595,38 +2595,38 @@ impl ExprTuple {
     #[getter]
     #[inline]
     fn get_elts(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elts.to_pyo3_wrapper(py)
+        self.0.elts.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Slice", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSlice(pub &'static crate::ExprSlice<SourceRange>);
+pub struct ExprSlice(pub &'static ast::ExprSlice<SourceRange>);
 
-impl From<&'static crate::ExprSlice<SourceRange>> for ExprSlice {
-    fn from(node: &'static crate::ExprSlice<SourceRange>) -> Self {
+impl From<&'static ast::ExprSlice<SourceRange>> for ExprSlice {
+    fn from(node: &'static ast::ExprSlice<SourceRange>) -> Self {
         ExprSlice(node)
     }
 }
 
 impl ToPyObject for ExprSlice {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSlice<SourceRange> {
+impl ToPyWrapper for ast::ExprSlice<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSlice(self).to_object(py))
     }
 }
@@ -2636,28 +2636,28 @@ impl ExprSlice {
     #[getter]
     #[inline]
     fn get_lower(&self, py: Python) -> PyResult<PyObject> {
-        self.0.lower.to_pyo3_wrapper(py)
+        self.0.lower.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_upper(&self, py: Python) -> PyResult<PyObject> {
-        self.0.upper.to_pyo3_wrapper(py)
+        self.0.upper.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_step(&self, py: Python) -> PyResult<PyObject> {
-        self.0.step.to_pyo3_wrapper(py)
+        self.0.step.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_expr_context", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_expr_context", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct ExprContext;
 
-impl From<&'static crate::ExprContext> for ExprContext {
-    fn from(_node: &'static crate::ExprContext) -> Self {
+impl From<&'static ast::ExprContext> for ExprContext {
+    fn from(_node: &'static ast::ExprContext) -> Self {
         ExprContext
     }
 }
@@ -2666,7 +2666,7 @@ impl From<&'static crate::ExprContext> for ExprContext {
 impl ExprContext {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for ExprContext {
@@ -2681,7 +2681,7 @@ pub struct ExprContextLoad;
 
 impl ToPyObject for ExprContextLoad {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(ExprContext)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2693,7 +2693,7 @@ pub struct ExprContextStore;
 
 impl ToPyObject for ExprContextStore {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(ExprContext)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2705,19 +2705,19 @@ pub struct ExprContextDel;
 
 impl ToPyObject for ExprContextDel {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(ExprContext)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_boolop", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_boolop", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Boolop;
 
-impl From<&'static crate::Boolop> for Boolop {
-    fn from(_node: &'static crate::Boolop) -> Self {
+impl From<&'static ast::Boolop> for Boolop {
+    fn from(_node: &'static ast::Boolop) -> Self {
         Boolop
     }
 }
@@ -2726,7 +2726,7 @@ impl From<&'static crate::Boolop> for Boolop {
 impl Boolop {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Boolop {
@@ -2741,7 +2741,7 @@ pub struct BoolopAnd;
 
 impl ToPyObject for BoolopAnd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Boolop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2753,19 +2753,19 @@ pub struct BoolopOr;
 
 impl ToPyObject for BoolopOr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Boolop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_operator", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_operator", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Operator;
 
-impl From<&'static crate::Operator> for Operator {
-    fn from(_node: &'static crate::Operator) -> Self {
+impl From<&'static ast::Operator> for Operator {
+    fn from(_node: &'static ast::Operator) -> Self {
         Operator
     }
 }
@@ -2774,7 +2774,7 @@ impl From<&'static crate::Operator> for Operator {
 impl Operator {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Operator {
@@ -2789,7 +2789,7 @@ pub struct OperatorAdd;
 
 impl ToPyObject for OperatorAdd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2801,7 +2801,7 @@ pub struct OperatorSub;
 
 impl ToPyObject for OperatorSub {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2813,7 +2813,7 @@ pub struct OperatorMult;
 
 impl ToPyObject for OperatorMult {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2825,7 +2825,7 @@ pub struct OperatorMatMult;
 
 impl ToPyObject for OperatorMatMult {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2837,7 +2837,7 @@ pub struct OperatorDiv;
 
 impl ToPyObject for OperatorDiv {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2849,7 +2849,7 @@ pub struct OperatorMod;
 
 impl ToPyObject for OperatorMod {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2861,7 +2861,7 @@ pub struct OperatorPow;
 
 impl ToPyObject for OperatorPow {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2873,7 +2873,7 @@ pub struct OperatorLShift;
 
 impl ToPyObject for OperatorLShift {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2885,7 +2885,7 @@ pub struct OperatorRShift;
 
 impl ToPyObject for OperatorRShift {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2897,7 +2897,7 @@ pub struct OperatorBitOr;
 
 impl ToPyObject for OperatorBitOr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2909,7 +2909,7 @@ pub struct OperatorBitXor;
 
 impl ToPyObject for OperatorBitXor {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2921,7 +2921,7 @@ pub struct OperatorBitAnd;
 
 impl ToPyObject for OperatorBitAnd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2933,19 +2933,19 @@ pub struct OperatorFloorDiv;
 
 impl ToPyObject for OperatorFloorDiv {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_unaryop", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_unaryop", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Unaryop;
 
-impl From<&'static crate::Unaryop> for Unaryop {
-    fn from(_node: &'static crate::Unaryop) -> Self {
+impl From<&'static ast::Unaryop> for Unaryop {
+    fn from(_node: &'static ast::Unaryop) -> Self {
         Unaryop
     }
 }
@@ -2954,7 +2954,7 @@ impl From<&'static crate::Unaryop> for Unaryop {
 impl Unaryop {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Unaryop {
@@ -2969,7 +2969,7 @@ pub struct UnaryopInvert;
 
 impl ToPyObject for UnaryopInvert {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2981,7 +2981,7 @@ pub struct UnaryopNot;
 
 impl ToPyObject for UnaryopNot {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2993,7 +2993,7 @@ pub struct UnaryopUAdd;
 
 impl ToPyObject for UnaryopUAdd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3005,19 +3005,19 @@ pub struct UnaryopUSub;
 
 impl ToPyObject for UnaryopUSub {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_cmpop", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_cmpop", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Cmpop;
 
-impl From<&'static crate::Cmpop> for Cmpop {
-    fn from(_node: &'static crate::Cmpop) -> Self {
+impl From<&'static ast::Cmpop> for Cmpop {
+    fn from(_node: &'static ast::Cmpop) -> Self {
         Cmpop
     }
 }
@@ -3026,7 +3026,7 @@ impl From<&'static crate::Cmpop> for Cmpop {
 impl Cmpop {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Cmpop {
@@ -3041,7 +3041,7 @@ pub struct CmpopEq;
 
 impl ToPyObject for CmpopEq {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3053,7 +3053,7 @@ pub struct CmpopNotEq;
 
 impl ToPyObject for CmpopNotEq {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3065,7 +3065,7 @@ pub struct CmpopLt;
 
 impl ToPyObject for CmpopLt {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3077,7 +3077,7 @@ pub struct CmpopLtE;
 
 impl ToPyObject for CmpopLtE {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3089,7 +3089,7 @@ pub struct CmpopGt;
 
 impl ToPyObject for CmpopGt {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3101,7 +3101,7 @@ pub struct CmpopGtE;
 
 impl ToPyObject for CmpopGtE {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3113,7 +3113,7 @@ pub struct CmpopIs;
 
 impl ToPyObject for CmpopIs {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3125,7 +3125,7 @@ pub struct CmpopIsNot;
 
 impl ToPyObject for CmpopIsNot {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3137,7 +3137,7 @@ pub struct CmpopIn;
 
 impl ToPyObject for CmpopIn {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3149,33 +3149,33 @@ pub struct CmpopNotIn;
 
 impl ToPyObject for CmpopNotIn {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_comprehension", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_comprehension", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Comprehension(pub &'static crate::Comprehension<SourceRange>);
+pub struct Comprehension(pub &'static ast::Comprehension<SourceRange>);
 
-impl From<&'static crate::Comprehension<SourceRange>> for Comprehension {
-    fn from(node: &'static crate::Comprehension<SourceRange>) -> Self {
+impl From<&'static ast::Comprehension<SourceRange>> for Comprehension {
+    fn from(node: &'static ast::Comprehension<SourceRange>) -> Self {
         Comprehension(node)
     }
 }
 
 impl ToPyObject for Comprehension {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Comprehension<SourceRange> {
+impl ToPyWrapper for ast::Comprehension<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Comprehension(self).to_object(py))
     }
 }
@@ -3185,34 +3185,34 @@ impl Comprehension {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_iter(&self, py: Python) -> PyResult<PyObject> {
-        self.0.iter.to_pyo3_wrapper(py)
+        self.0.iter.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ifs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ifs.to_pyo3_wrapper(py)
+        self.0.ifs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_is_async(&self, py: Python) -> PyResult<PyObject> {
-        self.0.is_async.to_pyo3_wrapper(py)
+        self.0.is_async.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_excepthandler", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_excepthandler", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Excepthandler;
 
-impl From<&'static crate::Excepthandler<SourceRange>> for Excepthandler {
-    fn from(_node: &'static crate::Excepthandler<SourceRange>) -> Self {
+impl From<&'static ast::Excepthandler<SourceRange>> for Excepthandler {
+    fn from(_node: &'static ast::Excepthandler<SourceRange>) -> Self {
         Excepthandler
     }
 }
@@ -3221,7 +3221,7 @@ impl From<&'static crate::Excepthandler<SourceRange>> for Excepthandler {
 impl Excepthandler {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Excepthandler {
@@ -3231,37 +3231,37 @@ impl ToPyObject for Excepthandler {
     }
 }
 
-impl ToPyo3Wrapper for crate::Excepthandler<SourceRange> {
+impl ToPyWrapper for ast::Excepthandler<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::ExceptHandler(cons) => cons.to_pyo3_wrapper(py),
+            Self::ExceptHandler(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_ExceptHandler", extends=Excepthandler, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExcepthandlerExceptHandler(pub &'static crate::ExcepthandlerExceptHandler<SourceRange>);
+pub struct ExcepthandlerExceptHandler(pub &'static ast::ExcepthandlerExceptHandler<SourceRange>);
 
-impl From<&'static crate::ExcepthandlerExceptHandler<SourceRange>> for ExcepthandlerExceptHandler {
-    fn from(node: &'static crate::ExcepthandlerExceptHandler<SourceRange>) -> Self {
+impl From<&'static ast::ExcepthandlerExceptHandler<SourceRange>> for ExcepthandlerExceptHandler {
+    fn from(node: &'static ast::ExcepthandlerExceptHandler<SourceRange>) -> Self {
         ExcepthandlerExceptHandler(node)
     }
 }
 
 impl ToPyObject for ExcepthandlerExceptHandler {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Excepthandler)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExcepthandlerExceptHandler<SourceRange> {
+impl ToPyWrapper for ast::ExcepthandlerExceptHandler<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExcepthandlerExceptHandler(self).to_object(py))
     }
 }
@@ -3271,42 +3271,42 @@ impl ExcepthandlerExceptHandler {
     #[getter]
     #[inline]
     fn get_type(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_.to_pyo3_wrapper(py)
+        self.0.type_.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_arguments", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_arguments", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Arguments(pub &'static crate::Arguments<SourceRange>);
+pub struct Arguments(pub &'static ast::Arguments<SourceRange>);
 
-impl From<&'static crate::Arguments<SourceRange>> for Arguments {
-    fn from(node: &'static crate::Arguments<SourceRange>) -> Self {
+impl From<&'static ast::Arguments<SourceRange>> for Arguments {
+    fn from(node: &'static ast::Arguments<SourceRange>) -> Self {
         Arguments(node)
     }
 }
 
 impl ToPyObject for Arguments {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Arguments<SourceRange> {
+impl ToPyWrapper for ast::Arguments<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Arguments(self).to_object(py))
     }
 }
@@ -3316,66 +3316,66 @@ impl Arguments {
     #[getter]
     #[inline]
     fn get_posonlyargs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.posonlyargs.to_pyo3_wrapper(py)
+        self.0.posonlyargs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_vararg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.vararg.to_pyo3_wrapper(py)
+        self.0.vararg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwonlyargs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwonlyargs.to_pyo3_wrapper(py)
+        self.0.kwonlyargs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kw_defaults(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kw_defaults.to_pyo3_wrapper(py)
+        self.0.kw_defaults.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwarg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwarg.to_pyo3_wrapper(py)
+        self.0.kwarg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_defaults(&self, py: Python) -> PyResult<PyObject> {
-        self.0.defaults.to_pyo3_wrapper(py)
+        self.0.defaults.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_arg", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_arg", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Arg(pub &'static crate::Arg<SourceRange>);
+pub struct Arg(pub &'static ast::Arg<SourceRange>);
 
-impl From<&'static crate::Arg<SourceRange>> for Arg {
-    fn from(node: &'static crate::Arg<SourceRange>) -> Self {
+impl From<&'static ast::Arg<SourceRange>> for Arg {
+    fn from(node: &'static ast::Arg<SourceRange>) -> Self {
         Arg(node)
     }
 }
 
 impl ToPyObject for Arg {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Arg<SourceRange> {
+impl ToPyWrapper for ast::Arg<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Arg(self).to_object(py))
     }
 }
@@ -3385,42 +3385,42 @@ impl Arg {
     #[getter]
     #[inline]
     fn get_arg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.arg.to_pyo3_wrapper(py)
+        self.0.arg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_annotation(&self, py: Python) -> PyResult<PyObject> {
-        self.0.annotation.to_pyo3_wrapper(py)
+        self.0.annotation.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_keyword", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_keyword", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Keyword(pub &'static crate::Keyword<SourceRange>);
+pub struct Keyword(pub &'static ast::Keyword<SourceRange>);
 
-impl From<&'static crate::Keyword<SourceRange>> for Keyword {
-    fn from(node: &'static crate::Keyword<SourceRange>) -> Self {
+impl From<&'static ast::Keyword<SourceRange>> for Keyword {
+    fn from(node: &'static ast::Keyword<SourceRange>) -> Self {
         Keyword(node)
     }
 }
 
 impl ToPyObject for Keyword {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Keyword<SourceRange> {
+impl ToPyWrapper for ast::Keyword<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Keyword(self).to_object(py))
     }
 }
@@ -3430,36 +3430,36 @@ impl Keyword {
     #[getter]
     #[inline]
     fn get_arg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.arg.to_pyo3_wrapper(py)
+        self.0.arg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_alias", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_alias", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Alias(pub &'static crate::Alias<SourceRange>);
+pub struct Alias(pub &'static ast::Alias<SourceRange>);
 
-impl From<&'static crate::Alias<SourceRange>> for Alias {
-    fn from(node: &'static crate::Alias<SourceRange>) -> Self {
+impl From<&'static ast::Alias<SourceRange>> for Alias {
+    fn from(node: &'static ast::Alias<SourceRange>) -> Self {
         Alias(node)
     }
 }
 
 impl ToPyObject for Alias {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Alias<SourceRange> {
+impl ToPyWrapper for ast::Alias<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Alias(self).to_object(py))
     }
 }
@@ -3469,36 +3469,36 @@ impl Alias {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_asname(&self, py: Python) -> PyResult<PyObject> {
-        self.0.asname.to_pyo3_wrapper(py)
+        self.0.asname.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_withitem", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_withitem", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Withitem(pub &'static crate::Withitem<SourceRange>);
+pub struct Withitem(pub &'static ast::Withitem<SourceRange>);
 
-impl From<&'static crate::Withitem<SourceRange>> for Withitem {
-    fn from(node: &'static crate::Withitem<SourceRange>) -> Self {
+impl From<&'static ast::Withitem<SourceRange>> for Withitem {
+    fn from(node: &'static ast::Withitem<SourceRange>) -> Self {
         Withitem(node)
     }
 }
 
 impl ToPyObject for Withitem {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Withitem<SourceRange> {
+impl ToPyWrapper for ast::Withitem<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Withitem(self).to_object(py))
     }
 }
@@ -3508,36 +3508,36 @@ impl Withitem {
     #[getter]
     #[inline]
     fn get_context_expr(&self, py: Python) -> PyResult<PyObject> {
-        self.0.context_expr.to_pyo3_wrapper(py)
+        self.0.context_expr.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_optional_vars(&self, py: Python) -> PyResult<PyObject> {
-        self.0.optional_vars.to_pyo3_wrapper(py)
+        self.0.optional_vars.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_match_case", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_match_case", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct MatchCase(pub &'static crate::MatchCase<SourceRange>);
+pub struct MatchCase(pub &'static ast::MatchCase<SourceRange>);
 
-impl From<&'static crate::MatchCase<SourceRange>> for MatchCase {
-    fn from(node: &'static crate::MatchCase<SourceRange>) -> Self {
+impl From<&'static ast::MatchCase<SourceRange>> for MatchCase {
+    fn from(node: &'static ast::MatchCase<SourceRange>) -> Self {
         MatchCase(node)
     }
 }
 
 impl ToPyObject for MatchCase {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::MatchCase<SourceRange> {
+impl ToPyWrapper for ast::MatchCase<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(MatchCase(self).to_object(py))
     }
 }
@@ -3547,28 +3547,28 @@ impl MatchCase {
     #[getter]
     #[inline]
     fn get_pattern(&self, py: Python) -> PyResult<PyObject> {
-        self.0.pattern.to_pyo3_wrapper(py)
+        self.0.pattern.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_guard(&self, py: Python) -> PyResult<PyObject> {
-        self.0.guard.to_pyo3_wrapper(py)
+        self.0.guard.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_pattern", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_pattern", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Pattern;
 
-impl From<&'static crate::Pattern<SourceRange>> for Pattern {
-    fn from(_node: &'static crate::Pattern<SourceRange>) -> Self {
+impl From<&'static ast::Pattern<SourceRange>> for Pattern {
+    fn from(_node: &'static ast::Pattern<SourceRange>) -> Self {
         Pattern
     }
 }
@@ -3577,7 +3577,7 @@ impl From<&'static crate::Pattern<SourceRange>> for Pattern {
 impl Pattern {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Pattern {
@@ -3587,44 +3587,44 @@ impl ToPyObject for Pattern {
     }
 }
 
-impl ToPyo3Wrapper for crate::Pattern<SourceRange> {
+impl ToPyWrapper for ast::Pattern<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::MatchValue(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchSingleton(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchSequence(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchMapping(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchClass(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchStar(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchAs(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchOr(cons) => cons.to_pyo3_wrapper(py),
+            Self::MatchValue(cons) => cons.to_py_wrapper(py),
+            Self::MatchSingleton(cons) => cons.to_py_wrapper(py),
+            Self::MatchSequence(cons) => cons.to_py_wrapper(py),
+            Self::MatchMapping(cons) => cons.to_py_wrapper(py),
+            Self::MatchClass(cons) => cons.to_py_wrapper(py),
+            Self::MatchStar(cons) => cons.to_py_wrapper(py),
+            Self::MatchAs(cons) => cons.to_py_wrapper(py),
+            Self::MatchOr(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchValue", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchValue(pub &'static crate::PatternMatchValue<SourceRange>);
+pub struct PatternMatchValue(pub &'static ast::PatternMatchValue<SourceRange>);
 
-impl From<&'static crate::PatternMatchValue<SourceRange>> for PatternMatchValue {
-    fn from(node: &'static crate::PatternMatchValue<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchValue<SourceRange>> for PatternMatchValue {
+    fn from(node: &'static ast::PatternMatchValue<SourceRange>) -> Self {
         PatternMatchValue(node)
     }
 }
 
 impl ToPyObject for PatternMatchValue {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchValue<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchValue<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchValue(self).to_object(py))
     }
 }
@@ -3634,32 +3634,32 @@ impl PatternMatchValue {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchSingleton", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchSingleton(pub &'static crate::PatternMatchSingleton<SourceRange>);
+pub struct PatternMatchSingleton(pub &'static ast::PatternMatchSingleton<SourceRange>);
 
-impl From<&'static crate::PatternMatchSingleton<SourceRange>> for PatternMatchSingleton {
-    fn from(node: &'static crate::PatternMatchSingleton<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchSingleton<SourceRange>> for PatternMatchSingleton {
+    fn from(node: &'static ast::PatternMatchSingleton<SourceRange>) -> Self {
         PatternMatchSingleton(node)
     }
 }
 
 impl ToPyObject for PatternMatchSingleton {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchSingleton<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchSingleton<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchSingleton(self).to_object(py))
     }
 }
@@ -3669,32 +3669,32 @@ impl PatternMatchSingleton {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchSequence", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchSequence(pub &'static crate::PatternMatchSequence<SourceRange>);
+pub struct PatternMatchSequence(pub &'static ast::PatternMatchSequence<SourceRange>);
 
-impl From<&'static crate::PatternMatchSequence<SourceRange>> for PatternMatchSequence {
-    fn from(node: &'static crate::PatternMatchSequence<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchSequence<SourceRange>> for PatternMatchSequence {
+    fn from(node: &'static ast::PatternMatchSequence<SourceRange>) -> Self {
         PatternMatchSequence(node)
     }
 }
 
 impl ToPyObject for PatternMatchSequence {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchSequence<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchSequence<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchSequence(self).to_object(py))
     }
 }
@@ -3704,32 +3704,32 @@ impl PatternMatchSequence {
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchMapping", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchMapping(pub &'static crate::PatternMatchMapping<SourceRange>);
+pub struct PatternMatchMapping(pub &'static ast::PatternMatchMapping<SourceRange>);
 
-impl From<&'static crate::PatternMatchMapping<SourceRange>> for PatternMatchMapping {
-    fn from(node: &'static crate::PatternMatchMapping<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchMapping<SourceRange>> for PatternMatchMapping {
+    fn from(node: &'static ast::PatternMatchMapping<SourceRange>) -> Self {
         PatternMatchMapping(node)
     }
 }
 
 impl ToPyObject for PatternMatchMapping {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchMapping<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchMapping<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchMapping(self).to_object(py))
     }
 }
@@ -3739,44 +3739,44 @@ impl PatternMatchMapping {
     #[getter]
     #[inline]
     fn get_keys(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keys.to_pyo3_wrapper(py)
+        self.0.keys.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_rest(&self, py: Python) -> PyResult<PyObject> {
-        self.0.rest.to_pyo3_wrapper(py)
+        self.0.rest.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchClass", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchClass(pub &'static crate::PatternMatchClass<SourceRange>);
+pub struct PatternMatchClass(pub &'static ast::PatternMatchClass<SourceRange>);
 
-impl From<&'static crate::PatternMatchClass<SourceRange>> for PatternMatchClass {
-    fn from(node: &'static crate::PatternMatchClass<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchClass<SourceRange>> for PatternMatchClass {
+    fn from(node: &'static ast::PatternMatchClass<SourceRange>) -> Self {
         PatternMatchClass(node)
     }
 }
 
 impl ToPyObject for PatternMatchClass {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchClass<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchClass<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchClass(self).to_object(py))
     }
 }
@@ -3786,50 +3786,50 @@ impl PatternMatchClass {
     #[getter]
     #[inline]
     fn get_cls(&self, py: Python) -> PyResult<PyObject> {
-        self.0.cls.to_pyo3_wrapper(py)
+        self.0.cls.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwd_attrs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwd_attrs.to_pyo3_wrapper(py)
+        self.0.kwd_attrs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwd_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwd_patterns.to_pyo3_wrapper(py)
+        self.0.kwd_patterns.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchStar", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchStar(pub &'static crate::PatternMatchStar<SourceRange>);
+pub struct PatternMatchStar(pub &'static ast::PatternMatchStar<SourceRange>);
 
-impl From<&'static crate::PatternMatchStar<SourceRange>> for PatternMatchStar {
-    fn from(node: &'static crate::PatternMatchStar<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchStar<SourceRange>> for PatternMatchStar {
+    fn from(node: &'static ast::PatternMatchStar<SourceRange>) -> Self {
         PatternMatchStar(node)
     }
 }
 
 impl ToPyObject for PatternMatchStar {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchStar<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchStar<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchStar(self).to_object(py))
     }
 }
@@ -3839,32 +3839,32 @@ impl PatternMatchStar {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchAs", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchAs(pub &'static crate::PatternMatchAs<SourceRange>);
+pub struct PatternMatchAs(pub &'static ast::PatternMatchAs<SourceRange>);
 
-impl From<&'static crate::PatternMatchAs<SourceRange>> for PatternMatchAs {
-    fn from(node: &'static crate::PatternMatchAs<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchAs<SourceRange>> for PatternMatchAs {
+    fn from(node: &'static ast::PatternMatchAs<SourceRange>) -> Self {
         PatternMatchAs(node)
     }
 }
 
 impl ToPyObject for PatternMatchAs {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchAs<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchAs<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchAs(self).to_object(py))
     }
 }
@@ -3874,38 +3874,38 @@ impl PatternMatchAs {
     #[getter]
     #[inline]
     fn get_pattern(&self, py: Python) -> PyResult<PyObject> {
-        self.0.pattern.to_pyo3_wrapper(py)
+        self.0.pattern.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchOr", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchOr(pub &'static crate::PatternMatchOr<SourceRange>);
+pub struct PatternMatchOr(pub &'static ast::PatternMatchOr<SourceRange>);
 
-impl From<&'static crate::PatternMatchOr<SourceRange>> for PatternMatchOr {
-    fn from(node: &'static crate::PatternMatchOr<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchOr<SourceRange>> for PatternMatchOr {
+    fn from(node: &'static ast::PatternMatchOr<SourceRange>) -> Self {
         PatternMatchOr(node)
     }
 }
 
 impl ToPyObject for PatternMatchOr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchOr<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchOr<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchOr(self).to_object(py))
     }
 }
@@ -3915,16 +3915,16 @@ impl PatternMatchOr {
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_type_ignore", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_type_ignore", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct TypeIgnore;
 
-impl From<&'static crate::TypeIgnore<SourceRange>> for TypeIgnore {
-    fn from(_node: &'static crate::TypeIgnore<SourceRange>) -> Self {
+impl From<&'static ast::TypeIgnore<SourceRange>> for TypeIgnore {
+    fn from(_node: &'static ast::TypeIgnore<SourceRange>) -> Self {
         TypeIgnore
     }
 }
@@ -3933,7 +3933,7 @@ impl From<&'static crate::TypeIgnore<SourceRange>> for TypeIgnore {
 impl TypeIgnore {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for TypeIgnore {
@@ -3943,37 +3943,37 @@ impl ToPyObject for TypeIgnore {
     }
 }
 
-impl ToPyo3Wrapper for crate::TypeIgnore<SourceRange> {
+impl ToPyWrapper for ast::TypeIgnore<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::TypeIgnore(cons) => cons.to_pyo3_wrapper(py),
+            Self::TypeIgnore(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_TypeIgnore", extends=TypeIgnore, frozen)]
 #[derive(Clone, Debug)]
-pub struct TypeIgnoreTypeIgnore(pub &'static crate::TypeIgnoreTypeIgnore<SourceRange>);
+pub struct TypeIgnoreTypeIgnore(pub &'static ast::TypeIgnoreTypeIgnore<SourceRange>);
 
-impl From<&'static crate::TypeIgnoreTypeIgnore<SourceRange>> for TypeIgnoreTypeIgnore {
-    fn from(node: &'static crate::TypeIgnoreTypeIgnore<SourceRange>) -> Self {
+impl From<&'static ast::TypeIgnoreTypeIgnore<SourceRange>> for TypeIgnoreTypeIgnore {
+    fn from(node: &'static ast::TypeIgnoreTypeIgnore<SourceRange>) -> Self {
         TypeIgnoreTypeIgnore(node)
     }
 }
 
 impl ToPyObject for TypeIgnoreTypeIgnore {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(TypeIgnore)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::TypeIgnoreTypeIgnore<SourceRange> {
+impl ToPyWrapper for ast::TypeIgnoreTypeIgnore<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(TypeIgnoreTypeIgnore(self).to_object(py))
     }
 }
@@ -3983,19 +3983,19 @@ impl TypeIgnoreTypeIgnore {
     #[getter]
     #[inline]
     fn get_lineno(&self, py: Python) -> PyResult<PyObject> {
-        self.0.lineno.to_pyo3_wrapper(py)
+        self.0.lineno.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_tag(&self, py: Python) -> PyResult<PyObject> {
-        self.0.tag.to_pyo3_wrapper(py)
+        self.0.tag.to_py_wrapper(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::ExprContext {
+impl ToPyWrapper for ast::ExprContext {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
             Self::Load => Ok(ExprContextLoad.to_object(py)),
             Self::Store => Ok(ExprContextStore.to_object(py)),
@@ -4004,30 +4004,30 @@ impl ToPyo3Wrapper for crate::generic::ExprContext {
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::ExprContextLoad {
+impl ToPyWrapper for ast::ExprContextLoad {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprContextLoad.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::ExprContextStore {
+impl ToPyWrapper for ast::ExprContextStore {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprContextStore.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::ExprContextDel {
+impl ToPyWrapper for ast::ExprContextDel {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprContextDel.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::Boolop {
+impl ToPyWrapper for ast::Boolop {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
             Self::And => Ok(BoolopAnd.to_object(py)),
             Self::Or => Ok(BoolopOr.to_object(py)),
@@ -4035,23 +4035,23 @@ impl ToPyo3Wrapper for crate::generic::Boolop {
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::BoolopAnd {
+impl ToPyWrapper for ast::BoolopAnd {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(BoolopAnd.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::BoolopOr {
+impl ToPyWrapper for ast::BoolopOr {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(BoolopOr.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::Operator {
+impl ToPyWrapper for ast::Operator {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
             Self::Add => Ok(OperatorAdd.to_object(py)),
             Self::Sub => Ok(OperatorSub.to_object(py)),
@@ -4070,100 +4070,100 @@ impl ToPyo3Wrapper for crate::generic::Operator {
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorAdd {
+impl ToPyWrapper for ast::OperatorAdd {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorAdd.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorSub {
+impl ToPyWrapper for ast::OperatorSub {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorSub.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorMult {
+impl ToPyWrapper for ast::OperatorMult {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorMult.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorMatMult {
+impl ToPyWrapper for ast::OperatorMatMult {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorMatMult.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorDiv {
+impl ToPyWrapper for ast::OperatorDiv {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorDiv.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorMod {
+impl ToPyWrapper for ast::OperatorMod {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorMod.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorPow {
+impl ToPyWrapper for ast::OperatorPow {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorPow.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorLShift {
+impl ToPyWrapper for ast::OperatorLShift {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorLShift.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorRShift {
+impl ToPyWrapper for ast::OperatorRShift {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorRShift.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorBitOr {
+impl ToPyWrapper for ast::OperatorBitOr {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorBitOr.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorBitXor {
+impl ToPyWrapper for ast::OperatorBitXor {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorBitXor.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorBitAnd {
+impl ToPyWrapper for ast::OperatorBitAnd {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorBitAnd.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorFloorDiv {
+impl ToPyWrapper for ast::OperatorFloorDiv {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorFloorDiv.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::Unaryop {
+impl ToPyWrapper for ast::Unaryop {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
             Self::Invert => Ok(UnaryopInvert.to_object(py)),
             Self::Not => Ok(UnaryopNot.to_object(py)),
@@ -4173,37 +4173,37 @@ impl ToPyo3Wrapper for crate::generic::Unaryop {
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::UnaryopInvert {
+impl ToPyWrapper for ast::UnaryopInvert {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(UnaryopInvert.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::UnaryopNot {
+impl ToPyWrapper for ast::UnaryopNot {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(UnaryopNot.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::UnaryopUAdd {
+impl ToPyWrapper for ast::UnaryopUAdd {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(UnaryopUAdd.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::UnaryopUSub {
+impl ToPyWrapper for ast::UnaryopUSub {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(UnaryopUSub.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::Cmpop {
+impl ToPyWrapper for ast::Cmpop {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
             Self::Eq => Ok(CmpopEq.to_object(py)),
             Self::NotEq => Ok(CmpopNotEq.to_object(py)),
@@ -4219,197 +4219,195 @@ impl ToPyo3Wrapper for crate::generic::Cmpop {
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopEq {
+impl ToPyWrapper for ast::CmpopEq {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopEq.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopNotEq {
+impl ToPyWrapper for ast::CmpopNotEq {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopNotEq.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopLt {
+impl ToPyWrapper for ast::CmpopLt {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopLt.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopLtE {
+impl ToPyWrapper for ast::CmpopLtE {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopLtE.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopGt {
+impl ToPyWrapper for ast::CmpopGt {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopGt.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopGtE {
+impl ToPyWrapper for ast::CmpopGtE {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopGtE.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopIs {
+impl ToPyWrapper for ast::CmpopIs {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopIs.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopIsNot {
+impl ToPyWrapper for ast::CmpopIsNot {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopIsNot.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopIn {
+impl ToPyWrapper for ast::CmpopIn {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopIn.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopNotIn {
+impl ToPyWrapper for ast::CmpopNotIn {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopNotIn.to_object(py))
     }
 }
 
 pub fn add_to_module(py: Python, m: &PyModule) -> PyResult<()> {
     super::init_module(py, m)?;
-    super::init_type::<Mod, crate::generic::Mod>(py, m)?;
-    super::init_type::<ModModule, crate::generic::ModModule>(py, m)?;
-    super::init_type::<ModInteractive, crate::generic::ModInteractive>(py, m)?;
-    super::init_type::<ModExpression, crate::generic::ModExpression>(py, m)?;
-    super::init_type::<ModFunctionType, crate::generic::ModFunctionType>(py, m)?;
-    super::init_type::<Stmt, crate::generic::Stmt>(py, m)?;
-    super::init_type::<StmtFunctionDef, crate::generic::StmtFunctionDef>(py, m)?;
-    super::init_type::<StmtAsyncFunctionDef, crate::generic::StmtAsyncFunctionDef>(py, m)?;
-    super::init_type::<StmtClassDef, crate::generic::StmtClassDef>(py, m)?;
-    super::init_type::<StmtReturn, crate::generic::StmtReturn>(py, m)?;
-    super::init_type::<StmtDelete, crate::generic::StmtDelete>(py, m)?;
-    super::init_type::<StmtAssign, crate::generic::StmtAssign>(py, m)?;
-    super::init_type::<StmtAugAssign, crate::generic::StmtAugAssign>(py, m)?;
-    super::init_type::<StmtAnnAssign, crate::generic::StmtAnnAssign>(py, m)?;
-    super::init_type::<StmtFor, crate::generic::StmtFor>(py, m)?;
-    super::init_type::<StmtAsyncFor, crate::generic::StmtAsyncFor>(py, m)?;
-    super::init_type::<StmtWhile, crate::generic::StmtWhile>(py, m)?;
-    super::init_type::<StmtIf, crate::generic::StmtIf>(py, m)?;
-    super::init_type::<StmtWith, crate::generic::StmtWith>(py, m)?;
-    super::init_type::<StmtAsyncWith, crate::generic::StmtAsyncWith>(py, m)?;
-    super::init_type::<StmtMatch, crate::generic::StmtMatch>(py, m)?;
-    super::init_type::<StmtRaise, crate::generic::StmtRaise>(py, m)?;
-    super::init_type::<StmtTry, crate::generic::StmtTry>(py, m)?;
-    super::init_type::<StmtTryStar, crate::generic::StmtTryStar>(py, m)?;
-    super::init_type::<StmtAssert, crate::generic::StmtAssert>(py, m)?;
-    super::init_type::<StmtImport, crate::generic::StmtImport>(py, m)?;
-    super::init_type::<StmtImportFrom, crate::generic::StmtImportFrom>(py, m)?;
-    super::init_type::<StmtGlobal, crate::generic::StmtGlobal>(py, m)?;
-    super::init_type::<StmtNonlocal, crate::generic::StmtNonlocal>(py, m)?;
-    super::init_type::<StmtExpr, crate::generic::StmtExpr>(py, m)?;
-    super::init_type::<StmtPass, crate::generic::StmtPass>(py, m)?;
-    super::init_type::<StmtBreak, crate::generic::StmtBreak>(py, m)?;
-    super::init_type::<StmtContinue, crate::generic::StmtContinue>(py, m)?;
-    super::init_type::<Expr, crate::generic::Expr>(py, m)?;
-    super::init_type::<ExprBoolOp, crate::generic::ExprBoolOp>(py, m)?;
-    super::init_type::<ExprNamedExpr, crate::generic::ExprNamedExpr>(py, m)?;
-    super::init_type::<ExprBinOp, crate::generic::ExprBinOp>(py, m)?;
-    super::init_type::<ExprUnaryOp, crate::generic::ExprUnaryOp>(py, m)?;
-    super::init_type::<ExprLambda, crate::generic::ExprLambda>(py, m)?;
-    super::init_type::<ExprIfExp, crate::generic::ExprIfExp>(py, m)?;
-    super::init_type::<ExprDict, crate::generic::ExprDict>(py, m)?;
-    super::init_type::<ExprSet, crate::generic::ExprSet>(py, m)?;
-    super::init_type::<ExprListComp, crate::generic::ExprListComp>(py, m)?;
-    super::init_type::<ExprSetComp, crate::generic::ExprSetComp>(py, m)?;
-    super::init_type::<ExprDictComp, crate::generic::ExprDictComp>(py, m)?;
-    super::init_type::<ExprGeneratorExp, crate::generic::ExprGeneratorExp>(py, m)?;
-    super::init_type::<ExprAwait, crate::generic::ExprAwait>(py, m)?;
-    super::init_type::<ExprYield, crate::generic::ExprYield>(py, m)?;
-    super::init_type::<ExprYieldFrom, crate::generic::ExprYieldFrom>(py, m)?;
-    super::init_type::<ExprCompare, crate::generic::ExprCompare>(py, m)?;
-    super::init_type::<ExprCall, crate::generic::ExprCall>(py, m)?;
-    super::init_type::<ExprFormattedValue, crate::generic::ExprFormattedValue>(py, m)?;
-    super::init_type::<ExprJoinedStr, crate::generic::ExprJoinedStr>(py, m)?;
-    super::init_type::<ExprConstant, crate::generic::ExprConstant>(py, m)?;
-    super::init_type::<ExprAttribute, crate::generic::ExprAttribute>(py, m)?;
-    super::init_type::<ExprSubscript, crate::generic::ExprSubscript>(py, m)?;
-    super::init_type::<ExprStarred, crate::generic::ExprStarred>(py, m)?;
-    super::init_type::<ExprName, crate::generic::ExprName>(py, m)?;
-    super::init_type::<ExprList, crate::generic::ExprList>(py, m)?;
-    super::init_type::<ExprTuple, crate::generic::ExprTuple>(py, m)?;
-    super::init_type::<ExprSlice, crate::generic::ExprSlice>(py, m)?;
-    super::init_type::<ExprContext, crate::generic::ExprContext>(py, m)?;
-    super::init_type::<ExprContextLoad, crate::generic::ExprContextLoad>(py, m)?;
-    super::init_type::<ExprContextStore, crate::generic::ExprContextStore>(py, m)?;
-    super::init_type::<ExprContextDel, crate::generic::ExprContextDel>(py, m)?;
-    super::init_type::<Boolop, crate::generic::Boolop>(py, m)?;
-    super::init_type::<BoolopAnd, crate::generic::BoolopAnd>(py, m)?;
-    super::init_type::<BoolopOr, crate::generic::BoolopOr>(py, m)?;
-    super::init_type::<Operator, crate::generic::Operator>(py, m)?;
-    super::init_type::<OperatorAdd, crate::generic::OperatorAdd>(py, m)?;
-    super::init_type::<OperatorSub, crate::generic::OperatorSub>(py, m)?;
-    super::init_type::<OperatorMult, crate::generic::OperatorMult>(py, m)?;
-    super::init_type::<OperatorMatMult, crate::generic::OperatorMatMult>(py, m)?;
-    super::init_type::<OperatorDiv, crate::generic::OperatorDiv>(py, m)?;
-    super::init_type::<OperatorMod, crate::generic::OperatorMod>(py, m)?;
-    super::init_type::<OperatorPow, crate::generic::OperatorPow>(py, m)?;
-    super::init_type::<OperatorLShift, crate::generic::OperatorLShift>(py, m)?;
-    super::init_type::<OperatorRShift, crate::generic::OperatorRShift>(py, m)?;
-    super::init_type::<OperatorBitOr, crate::generic::OperatorBitOr>(py, m)?;
-    super::init_type::<OperatorBitXor, crate::generic::OperatorBitXor>(py, m)?;
-    super::init_type::<OperatorBitAnd, crate::generic::OperatorBitAnd>(py, m)?;
-    super::init_type::<OperatorFloorDiv, crate::generic::OperatorFloorDiv>(py, m)?;
-    super::init_type::<Unaryop, crate::generic::Unaryop>(py, m)?;
-    super::init_type::<UnaryopInvert, crate::generic::UnaryopInvert>(py, m)?;
-    super::init_type::<UnaryopNot, crate::generic::UnaryopNot>(py, m)?;
-    super::init_type::<UnaryopUAdd, crate::generic::UnaryopUAdd>(py, m)?;
-    super::init_type::<UnaryopUSub, crate::generic::UnaryopUSub>(py, m)?;
-    super::init_type::<Cmpop, crate::generic::Cmpop>(py, m)?;
-    super::init_type::<CmpopEq, crate::generic::CmpopEq>(py, m)?;
-    super::init_type::<CmpopNotEq, crate::generic::CmpopNotEq>(py, m)?;
-    super::init_type::<CmpopLt, crate::generic::CmpopLt>(py, m)?;
-    super::init_type::<CmpopLtE, crate::generic::CmpopLtE>(py, m)?;
-    super::init_type::<CmpopGt, crate::generic::CmpopGt>(py, m)?;
-    super::init_type::<CmpopGtE, crate::generic::CmpopGtE>(py, m)?;
-    super::init_type::<CmpopIs, crate::generic::CmpopIs>(py, m)?;
-    super::init_type::<CmpopIsNot, crate::generic::CmpopIsNot>(py, m)?;
-    super::init_type::<CmpopIn, crate::generic::CmpopIn>(py, m)?;
-    super::init_type::<CmpopNotIn, crate::generic::CmpopNotIn>(py, m)?;
-    super::init_type::<Comprehension, crate::generic::Comprehension>(py, m)?;
-    super::init_type::<Excepthandler, crate::generic::Excepthandler>(py, m)?;
-    super::init_type::<ExcepthandlerExceptHandler, crate::generic::ExcepthandlerExceptHandler>(
-        py, m,
-    )?;
-    super::init_type::<Arguments, crate::generic::Arguments>(py, m)?;
-    super::init_type::<Arg, crate::generic::Arg>(py, m)?;
-    super::init_type::<Keyword, crate::generic::Keyword>(py, m)?;
-    super::init_type::<Alias, crate::generic::Alias>(py, m)?;
-    super::init_type::<Withitem, crate::generic::Withitem>(py, m)?;
-    super::init_type::<MatchCase, crate::generic::MatchCase>(py, m)?;
-    super::init_type::<Pattern, crate::generic::Pattern>(py, m)?;
-    super::init_type::<PatternMatchValue, crate::generic::PatternMatchValue>(py, m)?;
-    super::init_type::<PatternMatchSingleton, crate::generic::PatternMatchSingleton>(py, m)?;
-    super::init_type::<PatternMatchSequence, crate::generic::PatternMatchSequence>(py, m)?;
-    super::init_type::<PatternMatchMapping, crate::generic::PatternMatchMapping>(py, m)?;
-    super::init_type::<PatternMatchClass, crate::generic::PatternMatchClass>(py, m)?;
-    super::init_type::<PatternMatchStar, crate::generic::PatternMatchStar>(py, m)?;
-    super::init_type::<PatternMatchAs, crate::generic::PatternMatchAs>(py, m)?;
-    super::init_type::<PatternMatchOr, crate::generic::PatternMatchOr>(py, m)?;
-    super::init_type::<TypeIgnore, crate::generic::TypeIgnore>(py, m)?;
-    super::init_type::<TypeIgnoreTypeIgnore, crate::generic::TypeIgnoreTypeIgnore>(py, m)?;
+    super::init_type::<Mod, ast::Mod>(py, m)?;
+    super::init_type::<ModModule, ast::ModModule>(py, m)?;
+    super::init_type::<ModInteractive, ast::ModInteractive>(py, m)?;
+    super::init_type::<ModExpression, ast::ModExpression>(py, m)?;
+    super::init_type::<ModFunctionType, ast::ModFunctionType>(py, m)?;
+    super::init_type::<Stmt, ast::Stmt>(py, m)?;
+    super::init_type::<StmtFunctionDef, ast::StmtFunctionDef>(py, m)?;
+    super::init_type::<StmtAsyncFunctionDef, ast::StmtAsyncFunctionDef>(py, m)?;
+    super::init_type::<StmtClassDef, ast::StmtClassDef>(py, m)?;
+    super::init_type::<StmtReturn, ast::StmtReturn>(py, m)?;
+    super::init_type::<StmtDelete, ast::StmtDelete>(py, m)?;
+    super::init_type::<StmtAssign, ast::StmtAssign>(py, m)?;
+    super::init_type::<StmtAugAssign, ast::StmtAugAssign>(py, m)?;
+    super::init_type::<StmtAnnAssign, ast::StmtAnnAssign>(py, m)?;
+    super::init_type::<StmtFor, ast::StmtFor>(py, m)?;
+    super::init_type::<StmtAsyncFor, ast::StmtAsyncFor>(py, m)?;
+    super::init_type::<StmtWhile, ast::StmtWhile>(py, m)?;
+    super::init_type::<StmtIf, ast::StmtIf>(py, m)?;
+    super::init_type::<StmtWith, ast::StmtWith>(py, m)?;
+    super::init_type::<StmtAsyncWith, ast::StmtAsyncWith>(py, m)?;
+    super::init_type::<StmtMatch, ast::StmtMatch>(py, m)?;
+    super::init_type::<StmtRaise, ast::StmtRaise>(py, m)?;
+    super::init_type::<StmtTry, ast::StmtTry>(py, m)?;
+    super::init_type::<StmtTryStar, ast::StmtTryStar>(py, m)?;
+    super::init_type::<StmtAssert, ast::StmtAssert>(py, m)?;
+    super::init_type::<StmtImport, ast::StmtImport>(py, m)?;
+    super::init_type::<StmtImportFrom, ast::StmtImportFrom>(py, m)?;
+    super::init_type::<StmtGlobal, ast::StmtGlobal>(py, m)?;
+    super::init_type::<StmtNonlocal, ast::StmtNonlocal>(py, m)?;
+    super::init_type::<StmtExpr, ast::StmtExpr>(py, m)?;
+    super::init_type::<StmtPass, ast::StmtPass>(py, m)?;
+    super::init_type::<StmtBreak, ast::StmtBreak>(py, m)?;
+    super::init_type::<StmtContinue, ast::StmtContinue>(py, m)?;
+    super::init_type::<Expr, ast::Expr>(py, m)?;
+    super::init_type::<ExprBoolOp, ast::ExprBoolOp>(py, m)?;
+    super::init_type::<ExprNamedExpr, ast::ExprNamedExpr>(py, m)?;
+    super::init_type::<ExprBinOp, ast::ExprBinOp>(py, m)?;
+    super::init_type::<ExprUnaryOp, ast::ExprUnaryOp>(py, m)?;
+    super::init_type::<ExprLambda, ast::ExprLambda>(py, m)?;
+    super::init_type::<ExprIfExp, ast::ExprIfExp>(py, m)?;
+    super::init_type::<ExprDict, ast::ExprDict>(py, m)?;
+    super::init_type::<ExprSet, ast::ExprSet>(py, m)?;
+    super::init_type::<ExprListComp, ast::ExprListComp>(py, m)?;
+    super::init_type::<ExprSetComp, ast::ExprSetComp>(py, m)?;
+    super::init_type::<ExprDictComp, ast::ExprDictComp>(py, m)?;
+    super::init_type::<ExprGeneratorExp, ast::ExprGeneratorExp>(py, m)?;
+    super::init_type::<ExprAwait, ast::ExprAwait>(py, m)?;
+    super::init_type::<ExprYield, ast::ExprYield>(py, m)?;
+    super::init_type::<ExprYieldFrom, ast::ExprYieldFrom>(py, m)?;
+    super::init_type::<ExprCompare, ast::ExprCompare>(py, m)?;
+    super::init_type::<ExprCall, ast::ExprCall>(py, m)?;
+    super::init_type::<ExprFormattedValue, ast::ExprFormattedValue>(py, m)?;
+    super::init_type::<ExprJoinedStr, ast::ExprJoinedStr>(py, m)?;
+    super::init_type::<ExprConstant, ast::ExprConstant>(py, m)?;
+    super::init_type::<ExprAttribute, ast::ExprAttribute>(py, m)?;
+    super::init_type::<ExprSubscript, ast::ExprSubscript>(py, m)?;
+    super::init_type::<ExprStarred, ast::ExprStarred>(py, m)?;
+    super::init_type::<ExprName, ast::ExprName>(py, m)?;
+    super::init_type::<ExprList, ast::ExprList>(py, m)?;
+    super::init_type::<ExprTuple, ast::ExprTuple>(py, m)?;
+    super::init_type::<ExprSlice, ast::ExprSlice>(py, m)?;
+    super::init_type::<ExprContext, ast::ExprContext>(py, m)?;
+    super::init_type::<ExprContextLoad, ast::ExprContextLoad>(py, m)?;
+    super::init_type::<ExprContextStore, ast::ExprContextStore>(py, m)?;
+    super::init_type::<ExprContextDel, ast::ExprContextDel>(py, m)?;
+    super::init_type::<Boolop, ast::Boolop>(py, m)?;
+    super::init_type::<BoolopAnd, ast::BoolopAnd>(py, m)?;
+    super::init_type::<BoolopOr, ast::BoolopOr>(py, m)?;
+    super::init_type::<Operator, ast::Operator>(py, m)?;
+    super::init_type::<OperatorAdd, ast::OperatorAdd>(py, m)?;
+    super::init_type::<OperatorSub, ast::OperatorSub>(py, m)?;
+    super::init_type::<OperatorMult, ast::OperatorMult>(py, m)?;
+    super::init_type::<OperatorMatMult, ast::OperatorMatMult>(py, m)?;
+    super::init_type::<OperatorDiv, ast::OperatorDiv>(py, m)?;
+    super::init_type::<OperatorMod, ast::OperatorMod>(py, m)?;
+    super::init_type::<OperatorPow, ast::OperatorPow>(py, m)?;
+    super::init_type::<OperatorLShift, ast::OperatorLShift>(py, m)?;
+    super::init_type::<OperatorRShift, ast::OperatorRShift>(py, m)?;
+    super::init_type::<OperatorBitOr, ast::OperatorBitOr>(py, m)?;
+    super::init_type::<OperatorBitXor, ast::OperatorBitXor>(py, m)?;
+    super::init_type::<OperatorBitAnd, ast::OperatorBitAnd>(py, m)?;
+    super::init_type::<OperatorFloorDiv, ast::OperatorFloorDiv>(py, m)?;
+    super::init_type::<Unaryop, ast::Unaryop>(py, m)?;
+    super::init_type::<UnaryopInvert, ast::UnaryopInvert>(py, m)?;
+    super::init_type::<UnaryopNot, ast::UnaryopNot>(py, m)?;
+    super::init_type::<UnaryopUAdd, ast::UnaryopUAdd>(py, m)?;
+    super::init_type::<UnaryopUSub, ast::UnaryopUSub>(py, m)?;
+    super::init_type::<Cmpop, ast::Cmpop>(py, m)?;
+    super::init_type::<CmpopEq, ast::CmpopEq>(py, m)?;
+    super::init_type::<CmpopNotEq, ast::CmpopNotEq>(py, m)?;
+    super::init_type::<CmpopLt, ast::CmpopLt>(py, m)?;
+    super::init_type::<CmpopLtE, ast::CmpopLtE>(py, m)?;
+    super::init_type::<CmpopGt, ast::CmpopGt>(py, m)?;
+    super::init_type::<CmpopGtE, ast::CmpopGtE>(py, m)?;
+    super::init_type::<CmpopIs, ast::CmpopIs>(py, m)?;
+    super::init_type::<CmpopIsNot, ast::CmpopIsNot>(py, m)?;
+    super::init_type::<CmpopIn, ast::CmpopIn>(py, m)?;
+    super::init_type::<CmpopNotIn, ast::CmpopNotIn>(py, m)?;
+    super::init_type::<Comprehension, ast::Comprehension>(py, m)?;
+    super::init_type::<Excepthandler, ast::Excepthandler>(py, m)?;
+    super::init_type::<ExcepthandlerExceptHandler, ast::ExcepthandlerExceptHandler>(py, m)?;
+    super::init_type::<Arguments, ast::Arguments>(py, m)?;
+    super::init_type::<Arg, ast::Arg>(py, m)?;
+    super::init_type::<Keyword, ast::Keyword>(py, m)?;
+    super::init_type::<Alias, ast::Alias>(py, m)?;
+    super::init_type::<Withitem, ast::Withitem>(py, m)?;
+    super::init_type::<MatchCase, ast::MatchCase>(py, m)?;
+    super::init_type::<Pattern, ast::Pattern>(py, m)?;
+    super::init_type::<PatternMatchValue, ast::PatternMatchValue>(py, m)?;
+    super::init_type::<PatternMatchSingleton, ast::PatternMatchSingleton>(py, m)?;
+    super::init_type::<PatternMatchSequence, ast::PatternMatchSequence>(py, m)?;
+    super::init_type::<PatternMatchMapping, ast::PatternMatchMapping>(py, m)?;
+    super::init_type::<PatternMatchClass, ast::PatternMatchClass>(py, m)?;
+    super::init_type::<PatternMatchStar, ast::PatternMatchStar>(py, m)?;
+    super::init_type::<PatternMatchAs, ast::PatternMatchAs>(py, m)?;
+    super::init_type::<PatternMatchOr, ast::PatternMatchOr>(py, m)?;
+    super::init_type::<TypeIgnore, ast::TypeIgnore>(py, m)?;
+    super::init_type::<TypeIgnoreTypeIgnore, ast::TypeIgnoreTypeIgnore>(py, m)?;
     Ok(())
 }
diff --git a/ast/src/gen/pyo3_wrapper_ranged.rs b/ast-pyo3/src/gen/wrapper_ranged.rs
similarity index 55%
rename from ast/src/gen/pyo3_wrapper_ranged.rs
rename to ast-pyo3/src/gen/wrapper_ranged.rs
index dfa0a30a..f22a5601 100644
--- a/ast/src/gen/pyo3_wrapper_ranged.rs
+++ b/ast-pyo3/src/gen/wrapper_ranged.rs
@@ -1,11 +1,11 @@
 // File automatically generated by ast/asdl_rs.py.
 
-#[pyclass(module="rustpython_ast.ranged", name="_mod", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_mod", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Mod;
 
-impl From<&'static crate::Mod<TextRange>> for Mod {
-    fn from(_node: &'static crate::Mod<TextRange>) -> Self {
+impl From<&'static ast::Mod<TextRange>> for Mod {
+    fn from(_node: &'static ast::Mod<TextRange>) -> Self {
         Mod
     }
 }
@@ -14,7 +14,7 @@ impl From<&'static crate::Mod<TextRange>> for Mod {
 impl Mod {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Mod {
@@ -24,40 +24,40 @@ impl ToPyObject for Mod {
     }
 }
 
-impl ToPyo3Wrapper for crate::Mod<TextRange> {
+impl ToPyWrapper for ast::Mod<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::Module(cons) => cons.to_pyo3_wrapper(py),
-            Self::Interactive(cons) => cons.to_pyo3_wrapper(py),
-            Self::Expression(cons) => cons.to_pyo3_wrapper(py),
-            Self::FunctionType(cons) => cons.to_pyo3_wrapper(py),
+            Self::Module(cons) => cons.to_py_wrapper(py),
+            Self::Interactive(cons) => cons.to_py_wrapper(py),
+            Self::Expression(cons) => cons.to_py_wrapper(py),
+            Self::FunctionType(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Module", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModModule(pub &'static crate::ModModule<TextRange>);
+pub struct ModModule(pub &'static ast::ModModule<TextRange>);
 
-impl From<&'static crate::ModModule<TextRange>> for ModModule {
-    fn from(node: &'static crate::ModModule<TextRange>) -> Self {
+impl From<&'static ast::ModModule<TextRange>> for ModModule {
+    fn from(node: &'static ast::ModModule<TextRange>) -> Self {
         ModModule(node)
     }
 }
 
 impl ToPyObject for ModModule {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModModule<TextRange> {
+impl ToPyWrapper for ast::ModModule<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModModule(self).to_object(py))
     }
 }
@@ -67,38 +67,38 @@ impl ModModule {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_ignores(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_ignores.to_pyo3_wrapper(py)
+        self.0.type_ignores.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Interactive", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModInteractive(pub &'static crate::ModInteractive<TextRange>);
+pub struct ModInteractive(pub &'static ast::ModInteractive<TextRange>);
 
-impl From<&'static crate::ModInteractive<TextRange>> for ModInteractive {
-    fn from(node: &'static crate::ModInteractive<TextRange>) -> Self {
+impl From<&'static ast::ModInteractive<TextRange>> for ModInteractive {
+    fn from(node: &'static ast::ModInteractive<TextRange>) -> Self {
         ModInteractive(node)
     }
 }
 
 impl ToPyObject for ModInteractive {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModInteractive<TextRange> {
+impl ToPyWrapper for ast::ModInteractive<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModInteractive(self).to_object(py))
     }
 }
@@ -108,32 +108,32 @@ impl ModInteractive {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Expression", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModExpression(pub &'static crate::ModExpression<TextRange>);
+pub struct ModExpression(pub &'static ast::ModExpression<TextRange>);
 
-impl From<&'static crate::ModExpression<TextRange>> for ModExpression {
-    fn from(node: &'static crate::ModExpression<TextRange>) -> Self {
+impl From<&'static ast::ModExpression<TextRange>> for ModExpression {
+    fn from(node: &'static ast::ModExpression<TextRange>) -> Self {
         ModExpression(node)
     }
 }
 
 impl ToPyObject for ModExpression {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModExpression<TextRange> {
+impl ToPyWrapper for ast::ModExpression<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModExpression(self).to_object(py))
     }
 }
@@ -143,32 +143,32 @@ impl ModExpression {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_FunctionType", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModFunctionType(pub &'static crate::ModFunctionType<TextRange>);
+pub struct ModFunctionType(pub &'static ast::ModFunctionType<TextRange>);
 
-impl From<&'static crate::ModFunctionType<TextRange>> for ModFunctionType {
-    fn from(node: &'static crate::ModFunctionType<TextRange>) -> Self {
+impl From<&'static ast::ModFunctionType<TextRange>> for ModFunctionType {
+    fn from(node: &'static ast::ModFunctionType<TextRange>) -> Self {
         ModFunctionType(node)
     }
 }
 
 impl ToPyObject for ModFunctionType {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModFunctionType<TextRange> {
+impl ToPyWrapper for ast::ModFunctionType<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModFunctionType(self).to_object(py))
     }
 }
@@ -178,22 +178,22 @@ impl ModFunctionType {
     #[getter]
     #[inline]
     fn get_argtypes(&self, py: Python) -> PyResult<PyObject> {
-        self.0.argtypes.to_pyo3_wrapper(py)
+        self.0.argtypes.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_returns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.returns.to_pyo3_wrapper(py)
+        self.0.returns.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_stmt", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_stmt", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Stmt;
 
-impl From<&'static crate::Stmt<TextRange>> for Stmt {
-    fn from(_node: &'static crate::Stmt<TextRange>) -> Self {
+impl From<&'static ast::Stmt<TextRange>> for Stmt {
+    fn from(_node: &'static ast::Stmt<TextRange>) -> Self {
         Stmt
     }
 }
@@ -202,7 +202,7 @@ impl From<&'static crate::Stmt<TextRange>> for Stmt {
 impl Stmt {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Stmt {
@@ -212,63 +212,63 @@ impl ToPyObject for Stmt {
     }
 }
 
-impl ToPyo3Wrapper for crate::Stmt<TextRange> {
+impl ToPyWrapper for ast::Stmt<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::FunctionDef(cons) => cons.to_pyo3_wrapper(py),
-            Self::AsyncFunctionDef(cons) => cons.to_pyo3_wrapper(py),
-            Self::ClassDef(cons) => cons.to_pyo3_wrapper(py),
-            Self::Return(cons) => cons.to_pyo3_wrapper(py),
-            Self::Delete(cons) => cons.to_pyo3_wrapper(py),
-            Self::Assign(cons) => cons.to_pyo3_wrapper(py),
-            Self::AugAssign(cons) => cons.to_pyo3_wrapper(py),
-            Self::AnnAssign(cons) => cons.to_pyo3_wrapper(py),
-            Self::For(cons) => cons.to_pyo3_wrapper(py),
-            Self::AsyncFor(cons) => cons.to_pyo3_wrapper(py),
-            Self::While(cons) => cons.to_pyo3_wrapper(py),
-            Self::If(cons) => cons.to_pyo3_wrapper(py),
-            Self::With(cons) => cons.to_pyo3_wrapper(py),
-            Self::AsyncWith(cons) => cons.to_pyo3_wrapper(py),
-            Self::Match(cons) => cons.to_pyo3_wrapper(py),
-            Self::Raise(cons) => cons.to_pyo3_wrapper(py),
-            Self::Try(cons) => cons.to_pyo3_wrapper(py),
-            Self::TryStar(cons) => cons.to_pyo3_wrapper(py),
-            Self::Assert(cons) => cons.to_pyo3_wrapper(py),
-            Self::Import(cons) => cons.to_pyo3_wrapper(py),
-            Self::ImportFrom(cons) => cons.to_pyo3_wrapper(py),
-            Self::Global(cons) => cons.to_pyo3_wrapper(py),
-            Self::Nonlocal(cons) => cons.to_pyo3_wrapper(py),
-            Self::Expr(cons) => cons.to_pyo3_wrapper(py),
-            Self::Pass(cons) => cons.to_pyo3_wrapper(py),
-            Self::Break(cons) => cons.to_pyo3_wrapper(py),
-            Self::Continue(cons) => cons.to_pyo3_wrapper(py),
+            Self::FunctionDef(cons) => cons.to_py_wrapper(py),
+            Self::AsyncFunctionDef(cons) => cons.to_py_wrapper(py),
+            Self::ClassDef(cons) => cons.to_py_wrapper(py),
+            Self::Return(cons) => cons.to_py_wrapper(py),
+            Self::Delete(cons) => cons.to_py_wrapper(py),
+            Self::Assign(cons) => cons.to_py_wrapper(py),
+            Self::AugAssign(cons) => cons.to_py_wrapper(py),
+            Self::AnnAssign(cons) => cons.to_py_wrapper(py),
+            Self::For(cons) => cons.to_py_wrapper(py),
+            Self::AsyncFor(cons) => cons.to_py_wrapper(py),
+            Self::While(cons) => cons.to_py_wrapper(py),
+            Self::If(cons) => cons.to_py_wrapper(py),
+            Self::With(cons) => cons.to_py_wrapper(py),
+            Self::AsyncWith(cons) => cons.to_py_wrapper(py),
+            Self::Match(cons) => cons.to_py_wrapper(py),
+            Self::Raise(cons) => cons.to_py_wrapper(py),
+            Self::Try(cons) => cons.to_py_wrapper(py),
+            Self::TryStar(cons) => cons.to_py_wrapper(py),
+            Self::Assert(cons) => cons.to_py_wrapper(py),
+            Self::Import(cons) => cons.to_py_wrapper(py),
+            Self::ImportFrom(cons) => cons.to_py_wrapper(py),
+            Self::Global(cons) => cons.to_py_wrapper(py),
+            Self::Nonlocal(cons) => cons.to_py_wrapper(py),
+            Self::Expr(cons) => cons.to_py_wrapper(py),
+            Self::Pass(cons) => cons.to_py_wrapper(py),
+            Self::Break(cons) => cons.to_py_wrapper(py),
+            Self::Continue(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_FunctionDef", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtFunctionDef(pub &'static crate::StmtFunctionDef<TextRange>);
+pub struct StmtFunctionDef(pub &'static ast::StmtFunctionDef<TextRange>);
 
-impl From<&'static crate::StmtFunctionDef<TextRange>> for StmtFunctionDef {
-    fn from(node: &'static crate::StmtFunctionDef<TextRange>) -> Self {
+impl From<&'static ast::StmtFunctionDef<TextRange>> for StmtFunctionDef {
+    fn from(node: &'static ast::StmtFunctionDef<TextRange>) -> Self {
         StmtFunctionDef(node)
     }
 }
 
 impl ToPyObject for StmtFunctionDef {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtFunctionDef<TextRange> {
+impl ToPyWrapper for ast::StmtFunctionDef<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtFunctionDef(self).to_object(py))
     }
 }
@@ -278,62 +278,62 @@ impl StmtFunctionDef {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
-        self.0.decorator_list.to_pyo3_wrapper(py)
+        self.0.decorator_list.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_returns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.returns.to_pyo3_wrapper(py)
+        self.0.returns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_AsyncFunctionDef", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAsyncFunctionDef(pub &'static crate::StmtAsyncFunctionDef<TextRange>);
+pub struct StmtAsyncFunctionDef(pub &'static ast::StmtAsyncFunctionDef<TextRange>);
 
-impl From<&'static crate::StmtAsyncFunctionDef<TextRange>> for StmtAsyncFunctionDef {
-    fn from(node: &'static crate::StmtAsyncFunctionDef<TextRange>) -> Self {
+impl From<&'static ast::StmtAsyncFunctionDef<TextRange>> for StmtAsyncFunctionDef {
+    fn from(node: &'static ast::StmtAsyncFunctionDef<TextRange>) -> Self {
         StmtAsyncFunctionDef(node)
     }
 }
 
 impl ToPyObject for StmtAsyncFunctionDef {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAsyncFunctionDef<TextRange> {
+impl ToPyWrapper for ast::StmtAsyncFunctionDef<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAsyncFunctionDef(self).to_object(py))
     }
 }
@@ -343,62 +343,62 @@ impl StmtAsyncFunctionDef {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
-        self.0.decorator_list.to_pyo3_wrapper(py)
+        self.0.decorator_list.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_returns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.returns.to_pyo3_wrapper(py)
+        self.0.returns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_ClassDef", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtClassDef(pub &'static crate::StmtClassDef<TextRange>);
+pub struct StmtClassDef(pub &'static ast::StmtClassDef<TextRange>);
 
-impl From<&'static crate::StmtClassDef<TextRange>> for StmtClassDef {
-    fn from(node: &'static crate::StmtClassDef<TextRange>) -> Self {
+impl From<&'static ast::StmtClassDef<TextRange>> for StmtClassDef {
+    fn from(node: &'static ast::StmtClassDef<TextRange>) -> Self {
         StmtClassDef(node)
     }
 }
 
 impl ToPyObject for StmtClassDef {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtClassDef<TextRange> {
+impl ToPyWrapper for ast::StmtClassDef<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtClassDef(self).to_object(py))
     }
 }
@@ -408,56 +408,56 @@ impl StmtClassDef {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_bases(&self, py: Python) -> PyResult<PyObject> {
-        self.0.bases.to_pyo3_wrapper(py)
+        self.0.bases.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_keywords(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keywords.to_pyo3_wrapper(py)
+        self.0.keywords.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
-        self.0.decorator_list.to_pyo3_wrapper(py)
+        self.0.decorator_list.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Return", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtReturn(pub &'static crate::StmtReturn<TextRange>);
+pub struct StmtReturn(pub &'static ast::StmtReturn<TextRange>);
 
-impl From<&'static crate::StmtReturn<TextRange>> for StmtReturn {
-    fn from(node: &'static crate::StmtReturn<TextRange>) -> Self {
+impl From<&'static ast::StmtReturn<TextRange>> for StmtReturn {
+    fn from(node: &'static ast::StmtReturn<TextRange>) -> Self {
         StmtReturn(node)
     }
 }
 
 impl ToPyObject for StmtReturn {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtReturn<TextRange> {
+impl ToPyWrapper for ast::StmtReturn<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtReturn(self).to_object(py))
     }
 }
@@ -467,32 +467,32 @@ impl StmtReturn {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Delete", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtDelete(pub &'static crate::StmtDelete<TextRange>);
+pub struct StmtDelete(pub &'static ast::StmtDelete<TextRange>);
 
-impl From<&'static crate::StmtDelete<TextRange>> for StmtDelete {
-    fn from(node: &'static crate::StmtDelete<TextRange>) -> Self {
+impl From<&'static ast::StmtDelete<TextRange>> for StmtDelete {
+    fn from(node: &'static ast::StmtDelete<TextRange>) -> Self {
         StmtDelete(node)
     }
 }
 
 impl ToPyObject for StmtDelete {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtDelete<TextRange> {
+impl ToPyWrapper for ast::StmtDelete<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtDelete(self).to_object(py))
     }
 }
@@ -502,32 +502,32 @@ impl StmtDelete {
     #[getter]
     #[inline]
     fn get_targets(&self, py: Python) -> PyResult<PyObject> {
-        self.0.targets.to_pyo3_wrapper(py)
+        self.0.targets.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Assign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAssign(pub &'static crate::StmtAssign<TextRange>);
+pub struct StmtAssign(pub &'static ast::StmtAssign<TextRange>);
 
-impl From<&'static crate::StmtAssign<TextRange>> for StmtAssign {
-    fn from(node: &'static crate::StmtAssign<TextRange>) -> Self {
+impl From<&'static ast::StmtAssign<TextRange>> for StmtAssign {
+    fn from(node: &'static ast::StmtAssign<TextRange>) -> Self {
         StmtAssign(node)
     }
 }
 
 impl ToPyObject for StmtAssign {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAssign<TextRange> {
+impl ToPyWrapper for ast::StmtAssign<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAssign(self).to_object(py))
     }
 }
@@ -537,44 +537,44 @@ impl StmtAssign {
     #[getter]
     #[inline]
     fn get_targets(&self, py: Python) -> PyResult<PyObject> {
-        self.0.targets.to_pyo3_wrapper(py)
+        self.0.targets.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_AugAssign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAugAssign(pub &'static crate::StmtAugAssign<TextRange>);
+pub struct StmtAugAssign(pub &'static ast::StmtAugAssign<TextRange>);
 
-impl From<&'static crate::StmtAugAssign<TextRange>> for StmtAugAssign {
-    fn from(node: &'static crate::StmtAugAssign<TextRange>) -> Self {
+impl From<&'static ast::StmtAugAssign<TextRange>> for StmtAugAssign {
+    fn from(node: &'static ast::StmtAugAssign<TextRange>) -> Self {
         StmtAugAssign(node)
     }
 }
 
 impl ToPyObject for StmtAugAssign {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAugAssign<TextRange> {
+impl ToPyWrapper for ast::StmtAugAssign<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAugAssign(self).to_object(py))
     }
 }
@@ -584,44 +584,44 @@ impl StmtAugAssign {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_AnnAssign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAnnAssign(pub &'static crate::StmtAnnAssign<TextRange>);
+pub struct StmtAnnAssign(pub &'static ast::StmtAnnAssign<TextRange>);
 
-impl From<&'static crate::StmtAnnAssign<TextRange>> for StmtAnnAssign {
-    fn from(node: &'static crate::StmtAnnAssign<TextRange>) -> Self {
+impl From<&'static ast::StmtAnnAssign<TextRange>> for StmtAnnAssign {
+    fn from(node: &'static ast::StmtAnnAssign<TextRange>) -> Self {
         StmtAnnAssign(node)
     }
 }
 
 impl ToPyObject for StmtAnnAssign {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAnnAssign<TextRange> {
+impl ToPyWrapper for ast::StmtAnnAssign<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAnnAssign(self).to_object(py))
     }
 }
@@ -631,50 +631,50 @@ impl StmtAnnAssign {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_annotation(&self, py: Python) -> PyResult<PyObject> {
-        self.0.annotation.to_pyo3_wrapper(py)
+        self.0.annotation.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_simple(&self, py: Python) -> PyResult<PyObject> {
-        self.0.simple.to_pyo3_wrapper(py)
+        self.0.simple.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_For", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtFor(pub &'static crate::StmtFor<TextRange>);
+pub struct StmtFor(pub &'static ast::StmtFor<TextRange>);
 
-impl From<&'static crate::StmtFor<TextRange>> for StmtFor {
-    fn from(node: &'static crate::StmtFor<TextRange>) -> Self {
+impl From<&'static ast::StmtFor<TextRange>> for StmtFor {
+    fn from(node: &'static ast::StmtFor<TextRange>) -> Self {
         StmtFor(node)
     }
 }
 
 impl ToPyObject for StmtFor {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtFor<TextRange> {
+impl ToPyWrapper for ast::StmtFor<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtFor(self).to_object(py))
     }
 }
@@ -684,56 +684,56 @@ impl StmtFor {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_iter(&self, py: Python) -> PyResult<PyObject> {
-        self.0.iter.to_pyo3_wrapper(py)
+        self.0.iter.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_AsyncFor", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAsyncFor(pub &'static crate::StmtAsyncFor<TextRange>);
+pub struct StmtAsyncFor(pub &'static ast::StmtAsyncFor<TextRange>);
 
-impl From<&'static crate::StmtAsyncFor<TextRange>> for StmtAsyncFor {
-    fn from(node: &'static crate::StmtAsyncFor<TextRange>) -> Self {
+impl From<&'static ast::StmtAsyncFor<TextRange>> for StmtAsyncFor {
+    fn from(node: &'static ast::StmtAsyncFor<TextRange>) -> Self {
         StmtAsyncFor(node)
     }
 }
 
 impl ToPyObject for StmtAsyncFor {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAsyncFor<TextRange> {
+impl ToPyWrapper for ast::StmtAsyncFor<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAsyncFor(self).to_object(py))
     }
 }
@@ -743,56 +743,56 @@ impl StmtAsyncFor {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_iter(&self, py: Python) -> PyResult<PyObject> {
-        self.0.iter.to_pyo3_wrapper(py)
+        self.0.iter.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_While", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtWhile(pub &'static crate::StmtWhile<TextRange>);
+pub struct StmtWhile(pub &'static ast::StmtWhile<TextRange>);
 
-impl From<&'static crate::StmtWhile<TextRange>> for StmtWhile {
-    fn from(node: &'static crate::StmtWhile<TextRange>) -> Self {
+impl From<&'static ast::StmtWhile<TextRange>> for StmtWhile {
+    fn from(node: &'static ast::StmtWhile<TextRange>) -> Self {
         StmtWhile(node)
     }
 }
 
 impl ToPyObject for StmtWhile {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtWhile<TextRange> {
+impl ToPyWrapper for ast::StmtWhile<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtWhile(self).to_object(py))
     }
 }
@@ -802,44 +802,44 @@ impl StmtWhile {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_If", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtIf(pub &'static crate::StmtIf<TextRange>);
+pub struct StmtIf(pub &'static ast::StmtIf<TextRange>);
 
-impl From<&'static crate::StmtIf<TextRange>> for StmtIf {
-    fn from(node: &'static crate::StmtIf<TextRange>) -> Self {
+impl From<&'static ast::StmtIf<TextRange>> for StmtIf {
+    fn from(node: &'static ast::StmtIf<TextRange>) -> Self {
         StmtIf(node)
     }
 }
 
 impl ToPyObject for StmtIf {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtIf<TextRange> {
+impl ToPyWrapper for ast::StmtIf<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtIf(self).to_object(py))
     }
 }
@@ -849,44 +849,44 @@ impl StmtIf {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_With", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtWith(pub &'static crate::StmtWith<TextRange>);
+pub struct StmtWith(pub &'static ast::StmtWith<TextRange>);
 
-impl From<&'static crate::StmtWith<TextRange>> for StmtWith {
-    fn from(node: &'static crate::StmtWith<TextRange>) -> Self {
+impl From<&'static ast::StmtWith<TextRange>> for StmtWith {
+    fn from(node: &'static ast::StmtWith<TextRange>) -> Self {
         StmtWith(node)
     }
 }
 
 impl ToPyObject for StmtWith {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtWith<TextRange> {
+impl ToPyWrapper for ast::StmtWith<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtWith(self).to_object(py))
     }
 }
@@ -896,44 +896,44 @@ impl StmtWith {
     #[getter]
     #[inline]
     fn get_items(&self, py: Python) -> PyResult<PyObject> {
-        self.0.items.to_pyo3_wrapper(py)
+        self.0.items.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_AsyncWith", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAsyncWith(pub &'static crate::StmtAsyncWith<TextRange>);
+pub struct StmtAsyncWith(pub &'static ast::StmtAsyncWith<TextRange>);
 
-impl From<&'static crate::StmtAsyncWith<TextRange>> for StmtAsyncWith {
-    fn from(node: &'static crate::StmtAsyncWith<TextRange>) -> Self {
+impl From<&'static ast::StmtAsyncWith<TextRange>> for StmtAsyncWith {
+    fn from(node: &'static ast::StmtAsyncWith<TextRange>) -> Self {
         StmtAsyncWith(node)
     }
 }
 
 impl ToPyObject for StmtAsyncWith {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAsyncWith<TextRange> {
+impl ToPyWrapper for ast::StmtAsyncWith<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAsyncWith(self).to_object(py))
     }
 }
@@ -943,44 +943,44 @@ impl StmtAsyncWith {
     #[getter]
     #[inline]
     fn get_items(&self, py: Python) -> PyResult<PyObject> {
-        self.0.items.to_pyo3_wrapper(py)
+        self.0.items.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Match", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtMatch(pub &'static crate::StmtMatch<TextRange>);
+pub struct StmtMatch(pub &'static ast::StmtMatch<TextRange>);
 
-impl From<&'static crate::StmtMatch<TextRange>> for StmtMatch {
-    fn from(node: &'static crate::StmtMatch<TextRange>) -> Self {
+impl From<&'static ast::StmtMatch<TextRange>> for StmtMatch {
+    fn from(node: &'static ast::StmtMatch<TextRange>) -> Self {
         StmtMatch(node)
     }
 }
 
 impl ToPyObject for StmtMatch {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtMatch<TextRange> {
+impl ToPyWrapper for ast::StmtMatch<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtMatch(self).to_object(py))
     }
 }
@@ -990,38 +990,38 @@ impl StmtMatch {
     #[getter]
     #[inline]
     fn get_subject(&self, py: Python) -> PyResult<PyObject> {
-        self.0.subject.to_pyo3_wrapper(py)
+        self.0.subject.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_cases(&self, py: Python) -> PyResult<PyObject> {
-        self.0.cases.to_pyo3_wrapper(py)
+        self.0.cases.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Raise", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtRaise(pub &'static crate::StmtRaise<TextRange>);
+pub struct StmtRaise(pub &'static ast::StmtRaise<TextRange>);
 
-impl From<&'static crate::StmtRaise<TextRange>> for StmtRaise {
-    fn from(node: &'static crate::StmtRaise<TextRange>) -> Self {
+impl From<&'static ast::StmtRaise<TextRange>> for StmtRaise {
+    fn from(node: &'static ast::StmtRaise<TextRange>) -> Self {
         StmtRaise(node)
     }
 }
 
 impl ToPyObject for StmtRaise {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtRaise<TextRange> {
+impl ToPyWrapper for ast::StmtRaise<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtRaise(self).to_object(py))
     }
 }
@@ -1031,38 +1031,38 @@ impl StmtRaise {
     #[getter]
     #[inline]
     fn get_exc(&self, py: Python) -> PyResult<PyObject> {
-        self.0.exc.to_pyo3_wrapper(py)
+        self.0.exc.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_cause(&self, py: Python) -> PyResult<PyObject> {
-        self.0.cause.to_pyo3_wrapper(py)
+        self.0.cause.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Try", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtTry(pub &'static crate::StmtTry<TextRange>);
+pub struct StmtTry(pub &'static ast::StmtTry<TextRange>);
 
-impl From<&'static crate::StmtTry<TextRange>> for StmtTry {
-    fn from(node: &'static crate::StmtTry<TextRange>) -> Self {
+impl From<&'static ast::StmtTry<TextRange>> for StmtTry {
+    fn from(node: &'static ast::StmtTry<TextRange>) -> Self {
         StmtTry(node)
     }
 }
 
 impl ToPyObject for StmtTry {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtTry<TextRange> {
+impl ToPyWrapper for ast::StmtTry<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtTry(self).to_object(py))
     }
 }
@@ -1072,50 +1072,50 @@ impl StmtTry {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_handlers(&self, py: Python) -> PyResult<PyObject> {
-        self.0.handlers.to_pyo3_wrapper(py)
+        self.0.handlers.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_finalbody(&self, py: Python) -> PyResult<PyObject> {
-        self.0.finalbody.to_pyo3_wrapper(py)
+        self.0.finalbody.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_TryStar", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtTryStar(pub &'static crate::StmtTryStar<TextRange>);
+pub struct StmtTryStar(pub &'static ast::StmtTryStar<TextRange>);
 
-impl From<&'static crate::StmtTryStar<TextRange>> for StmtTryStar {
-    fn from(node: &'static crate::StmtTryStar<TextRange>) -> Self {
+impl From<&'static ast::StmtTryStar<TextRange>> for StmtTryStar {
+    fn from(node: &'static ast::StmtTryStar<TextRange>) -> Self {
         StmtTryStar(node)
     }
 }
 
 impl ToPyObject for StmtTryStar {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtTryStar<TextRange> {
+impl ToPyWrapper for ast::StmtTryStar<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtTryStar(self).to_object(py))
     }
 }
@@ -1125,50 +1125,50 @@ impl StmtTryStar {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_handlers(&self, py: Python) -> PyResult<PyObject> {
-        self.0.handlers.to_pyo3_wrapper(py)
+        self.0.handlers.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_finalbody(&self, py: Python) -> PyResult<PyObject> {
-        self.0.finalbody.to_pyo3_wrapper(py)
+        self.0.finalbody.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Assert", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAssert(pub &'static crate::StmtAssert<TextRange>);
+pub struct StmtAssert(pub &'static ast::StmtAssert<TextRange>);
 
-impl From<&'static crate::StmtAssert<TextRange>> for StmtAssert {
-    fn from(node: &'static crate::StmtAssert<TextRange>) -> Self {
+impl From<&'static ast::StmtAssert<TextRange>> for StmtAssert {
+    fn from(node: &'static ast::StmtAssert<TextRange>) -> Self {
         StmtAssert(node)
     }
 }
 
 impl ToPyObject for StmtAssert {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAssert<TextRange> {
+impl ToPyWrapper for ast::StmtAssert<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAssert(self).to_object(py))
     }
 }
@@ -1178,38 +1178,38 @@ impl StmtAssert {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_msg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.msg.to_pyo3_wrapper(py)
+        self.0.msg.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Import", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtImport(pub &'static crate::StmtImport<TextRange>);
+pub struct StmtImport(pub &'static ast::StmtImport<TextRange>);
 
-impl From<&'static crate::StmtImport<TextRange>> for StmtImport {
-    fn from(node: &'static crate::StmtImport<TextRange>) -> Self {
+impl From<&'static ast::StmtImport<TextRange>> for StmtImport {
+    fn from(node: &'static ast::StmtImport<TextRange>) -> Self {
         StmtImport(node)
     }
 }
 
 impl ToPyObject for StmtImport {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtImport<TextRange> {
+impl ToPyWrapper for ast::StmtImport<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtImport(self).to_object(py))
     }
 }
@@ -1219,32 +1219,32 @@ impl StmtImport {
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_ImportFrom", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtImportFrom(pub &'static crate::StmtImportFrom<TextRange>);
+pub struct StmtImportFrom(pub &'static ast::StmtImportFrom<TextRange>);
 
-impl From<&'static crate::StmtImportFrom<TextRange>> for StmtImportFrom {
-    fn from(node: &'static crate::StmtImportFrom<TextRange>) -> Self {
+impl From<&'static ast::StmtImportFrom<TextRange>> for StmtImportFrom {
+    fn from(node: &'static ast::StmtImportFrom<TextRange>) -> Self {
         StmtImportFrom(node)
     }
 }
 
 impl ToPyObject for StmtImportFrom {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtImportFrom<TextRange> {
+impl ToPyWrapper for ast::StmtImportFrom<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtImportFrom(self).to_object(py))
     }
 }
@@ -1254,44 +1254,44 @@ impl StmtImportFrom {
     #[getter]
     #[inline]
     fn get_module(&self, py: Python) -> PyResult<PyObject> {
-        self.0.module.to_pyo3_wrapper(py)
+        self.0.module.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_level(&self, py: Python) -> PyResult<PyObject> {
-        self.0.level.to_pyo3_wrapper(py)
+        self.0.level.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Global", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtGlobal(pub &'static crate::StmtGlobal<TextRange>);
+pub struct StmtGlobal(pub &'static ast::StmtGlobal<TextRange>);
 
-impl From<&'static crate::StmtGlobal<TextRange>> for StmtGlobal {
-    fn from(node: &'static crate::StmtGlobal<TextRange>) -> Self {
+impl From<&'static ast::StmtGlobal<TextRange>> for StmtGlobal {
+    fn from(node: &'static ast::StmtGlobal<TextRange>) -> Self {
         StmtGlobal(node)
     }
 }
 
 impl ToPyObject for StmtGlobal {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtGlobal<TextRange> {
+impl ToPyWrapper for ast::StmtGlobal<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtGlobal(self).to_object(py))
     }
 }
@@ -1301,32 +1301,32 @@ impl StmtGlobal {
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Nonlocal", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtNonlocal(pub &'static crate::StmtNonlocal<TextRange>);
+pub struct StmtNonlocal(pub &'static ast::StmtNonlocal<TextRange>);
 
-impl From<&'static crate::StmtNonlocal<TextRange>> for StmtNonlocal {
-    fn from(node: &'static crate::StmtNonlocal<TextRange>) -> Self {
+impl From<&'static ast::StmtNonlocal<TextRange>> for StmtNonlocal {
+    fn from(node: &'static ast::StmtNonlocal<TextRange>) -> Self {
         StmtNonlocal(node)
     }
 }
 
 impl ToPyObject for StmtNonlocal {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtNonlocal<TextRange> {
+impl ToPyWrapper for ast::StmtNonlocal<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtNonlocal(self).to_object(py))
     }
 }
@@ -1336,32 +1336,32 @@ impl StmtNonlocal {
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Expr", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtExpr(pub &'static crate::StmtExpr<TextRange>);
+pub struct StmtExpr(pub &'static ast::StmtExpr<TextRange>);
 
-impl From<&'static crate::StmtExpr<TextRange>> for StmtExpr {
-    fn from(node: &'static crate::StmtExpr<TextRange>) -> Self {
+impl From<&'static ast::StmtExpr<TextRange>> for StmtExpr {
+    fn from(node: &'static ast::StmtExpr<TextRange>) -> Self {
         StmtExpr(node)
     }
 }
 
 impl ToPyObject for StmtExpr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtExpr<TextRange> {
+impl ToPyWrapper for ast::StmtExpr<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtExpr(self).to_object(py))
     }
 }
@@ -1371,32 +1371,32 @@ impl StmtExpr {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Pass", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtPass(pub &'static crate::StmtPass<TextRange>);
+pub struct StmtPass(pub &'static ast::StmtPass<TextRange>);
 
-impl From<&'static crate::StmtPass<TextRange>> for StmtPass {
-    fn from(node: &'static crate::StmtPass<TextRange>) -> Self {
+impl From<&'static ast::StmtPass<TextRange>> for StmtPass {
+    fn from(node: &'static ast::StmtPass<TextRange>) -> Self {
         StmtPass(node)
     }
 }
 
 impl ToPyObject for StmtPass {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtPass<TextRange> {
+impl ToPyWrapper for ast::StmtPass<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtPass(self).to_object(py))
     }
 }
@@ -1406,26 +1406,26 @@ impl StmtPass {}
 
 #[pyclass(module="rustpython_ast.ranged", name="_Break", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtBreak(pub &'static crate::StmtBreak<TextRange>);
+pub struct StmtBreak(pub &'static ast::StmtBreak<TextRange>);
 
-impl From<&'static crate::StmtBreak<TextRange>> for StmtBreak {
-    fn from(node: &'static crate::StmtBreak<TextRange>) -> Self {
+impl From<&'static ast::StmtBreak<TextRange>> for StmtBreak {
+    fn from(node: &'static ast::StmtBreak<TextRange>) -> Self {
         StmtBreak(node)
     }
 }
 
 impl ToPyObject for StmtBreak {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtBreak<TextRange> {
+impl ToPyWrapper for ast::StmtBreak<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtBreak(self).to_object(py))
     }
 }
@@ -1435,26 +1435,26 @@ impl StmtBreak {}
 
 #[pyclass(module="rustpython_ast.ranged", name="_Continue", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtContinue(pub &'static crate::StmtContinue<TextRange>);
+pub struct StmtContinue(pub &'static ast::StmtContinue<TextRange>);
 
-impl From<&'static crate::StmtContinue<TextRange>> for StmtContinue {
-    fn from(node: &'static crate::StmtContinue<TextRange>) -> Self {
+impl From<&'static ast::StmtContinue<TextRange>> for StmtContinue {
+    fn from(node: &'static ast::StmtContinue<TextRange>) -> Self {
         StmtContinue(node)
     }
 }
 
 impl ToPyObject for StmtContinue {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtContinue<TextRange> {
+impl ToPyWrapper for ast::StmtContinue<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtContinue(self).to_object(py))
     }
 }
@@ -1462,12 +1462,12 @@ impl ToPyo3Wrapper for crate::StmtContinue<TextRange> {
 #[pymethods]
 impl StmtContinue {}
 
-#[pyclass(module="rustpython_ast.ranged", name="_expr", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_expr", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Expr;
 
-impl From<&'static crate::Expr<TextRange>> for Expr {
-    fn from(_node: &'static crate::Expr<TextRange>) -> Self {
+impl From<&'static ast::Expr<TextRange>> for Expr {
+    fn from(_node: &'static ast::Expr<TextRange>) -> Self {
         Expr
     }
 }
@@ -1476,7 +1476,7 @@ impl From<&'static crate::Expr<TextRange>> for Expr {
 impl Expr {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Expr {
@@ -1486,63 +1486,63 @@ impl ToPyObject for Expr {
     }
 }
 
-impl ToPyo3Wrapper for crate::Expr<TextRange> {
+impl ToPyWrapper for ast::Expr<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::BoolOp(cons) => cons.to_pyo3_wrapper(py),
-            Self::NamedExpr(cons) => cons.to_pyo3_wrapper(py),
-            Self::BinOp(cons) => cons.to_pyo3_wrapper(py),
-            Self::UnaryOp(cons) => cons.to_pyo3_wrapper(py),
-            Self::Lambda(cons) => cons.to_pyo3_wrapper(py),
-            Self::IfExp(cons) => cons.to_pyo3_wrapper(py),
-            Self::Dict(cons) => cons.to_pyo3_wrapper(py),
-            Self::Set(cons) => cons.to_pyo3_wrapper(py),
-            Self::ListComp(cons) => cons.to_pyo3_wrapper(py),
-            Self::SetComp(cons) => cons.to_pyo3_wrapper(py),
-            Self::DictComp(cons) => cons.to_pyo3_wrapper(py),
-            Self::GeneratorExp(cons) => cons.to_pyo3_wrapper(py),
-            Self::Await(cons) => cons.to_pyo3_wrapper(py),
-            Self::Yield(cons) => cons.to_pyo3_wrapper(py),
-            Self::YieldFrom(cons) => cons.to_pyo3_wrapper(py),
-            Self::Compare(cons) => cons.to_pyo3_wrapper(py),
-            Self::Call(cons) => cons.to_pyo3_wrapper(py),
-            Self::FormattedValue(cons) => cons.to_pyo3_wrapper(py),
-            Self::JoinedStr(cons) => cons.to_pyo3_wrapper(py),
-            Self::Constant(cons) => cons.to_pyo3_wrapper(py),
-            Self::Attribute(cons) => cons.to_pyo3_wrapper(py),
-            Self::Subscript(cons) => cons.to_pyo3_wrapper(py),
-            Self::Starred(cons) => cons.to_pyo3_wrapper(py),
-            Self::Name(cons) => cons.to_pyo3_wrapper(py),
-            Self::List(cons) => cons.to_pyo3_wrapper(py),
-            Self::Tuple(cons) => cons.to_pyo3_wrapper(py),
-            Self::Slice(cons) => cons.to_pyo3_wrapper(py),
+            Self::BoolOp(cons) => cons.to_py_wrapper(py),
+            Self::NamedExpr(cons) => cons.to_py_wrapper(py),
+            Self::BinOp(cons) => cons.to_py_wrapper(py),
+            Self::UnaryOp(cons) => cons.to_py_wrapper(py),
+            Self::Lambda(cons) => cons.to_py_wrapper(py),
+            Self::IfExp(cons) => cons.to_py_wrapper(py),
+            Self::Dict(cons) => cons.to_py_wrapper(py),
+            Self::Set(cons) => cons.to_py_wrapper(py),
+            Self::ListComp(cons) => cons.to_py_wrapper(py),
+            Self::SetComp(cons) => cons.to_py_wrapper(py),
+            Self::DictComp(cons) => cons.to_py_wrapper(py),
+            Self::GeneratorExp(cons) => cons.to_py_wrapper(py),
+            Self::Await(cons) => cons.to_py_wrapper(py),
+            Self::Yield(cons) => cons.to_py_wrapper(py),
+            Self::YieldFrom(cons) => cons.to_py_wrapper(py),
+            Self::Compare(cons) => cons.to_py_wrapper(py),
+            Self::Call(cons) => cons.to_py_wrapper(py),
+            Self::FormattedValue(cons) => cons.to_py_wrapper(py),
+            Self::JoinedStr(cons) => cons.to_py_wrapper(py),
+            Self::Constant(cons) => cons.to_py_wrapper(py),
+            Self::Attribute(cons) => cons.to_py_wrapper(py),
+            Self::Subscript(cons) => cons.to_py_wrapper(py),
+            Self::Starred(cons) => cons.to_py_wrapper(py),
+            Self::Name(cons) => cons.to_py_wrapper(py),
+            Self::List(cons) => cons.to_py_wrapper(py),
+            Self::Tuple(cons) => cons.to_py_wrapper(py),
+            Self::Slice(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_BoolOp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprBoolOp(pub &'static crate::ExprBoolOp<TextRange>);
+pub struct ExprBoolOp(pub &'static ast::ExprBoolOp<TextRange>);
 
-impl From<&'static crate::ExprBoolOp<TextRange>> for ExprBoolOp {
-    fn from(node: &'static crate::ExprBoolOp<TextRange>) -> Self {
+impl From<&'static ast::ExprBoolOp<TextRange>> for ExprBoolOp {
+    fn from(node: &'static ast::ExprBoolOp<TextRange>) -> Self {
         ExprBoolOp(node)
     }
 }
 
 impl ToPyObject for ExprBoolOp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprBoolOp<TextRange> {
+impl ToPyWrapper for ast::ExprBoolOp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprBoolOp(self).to_object(py))
     }
 }
@@ -1552,38 +1552,38 @@ impl ExprBoolOp {
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_values(&self, py: Python) -> PyResult<PyObject> {
-        self.0.values.to_pyo3_wrapper(py)
+        self.0.values.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_NamedExpr", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprNamedExpr(pub &'static crate::ExprNamedExpr<TextRange>);
+pub struct ExprNamedExpr(pub &'static ast::ExprNamedExpr<TextRange>);
 
-impl From<&'static crate::ExprNamedExpr<TextRange>> for ExprNamedExpr {
-    fn from(node: &'static crate::ExprNamedExpr<TextRange>) -> Self {
+impl From<&'static ast::ExprNamedExpr<TextRange>> for ExprNamedExpr {
+    fn from(node: &'static ast::ExprNamedExpr<TextRange>) -> Self {
         ExprNamedExpr(node)
     }
 }
 
 impl ToPyObject for ExprNamedExpr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprNamedExpr<TextRange> {
+impl ToPyWrapper for ast::ExprNamedExpr<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprNamedExpr(self).to_object(py))
     }
 }
@@ -1593,38 +1593,38 @@ impl ExprNamedExpr {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_BinOp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprBinOp(pub &'static crate::ExprBinOp<TextRange>);
+pub struct ExprBinOp(pub &'static ast::ExprBinOp<TextRange>);
 
-impl From<&'static crate::ExprBinOp<TextRange>> for ExprBinOp {
-    fn from(node: &'static crate::ExprBinOp<TextRange>) -> Self {
+impl From<&'static ast::ExprBinOp<TextRange>> for ExprBinOp {
+    fn from(node: &'static ast::ExprBinOp<TextRange>) -> Self {
         ExprBinOp(node)
     }
 }
 
 impl ToPyObject for ExprBinOp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprBinOp<TextRange> {
+impl ToPyWrapper for ast::ExprBinOp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprBinOp(self).to_object(py))
     }
 }
@@ -1634,44 +1634,44 @@ impl ExprBinOp {
     #[getter]
     #[inline]
     fn get_left(&self, py: Python) -> PyResult<PyObject> {
-        self.0.left.to_pyo3_wrapper(py)
+        self.0.left.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_right(&self, py: Python) -> PyResult<PyObject> {
-        self.0.right.to_pyo3_wrapper(py)
+        self.0.right.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_UnaryOp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprUnaryOp(pub &'static crate::ExprUnaryOp<TextRange>);
+pub struct ExprUnaryOp(pub &'static ast::ExprUnaryOp<TextRange>);
 
-impl From<&'static crate::ExprUnaryOp<TextRange>> for ExprUnaryOp {
-    fn from(node: &'static crate::ExprUnaryOp<TextRange>) -> Self {
+impl From<&'static ast::ExprUnaryOp<TextRange>> for ExprUnaryOp {
+    fn from(node: &'static ast::ExprUnaryOp<TextRange>) -> Self {
         ExprUnaryOp(node)
     }
 }
 
 impl ToPyObject for ExprUnaryOp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprUnaryOp<TextRange> {
+impl ToPyWrapper for ast::ExprUnaryOp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprUnaryOp(self).to_object(py))
     }
 }
@@ -1681,38 +1681,38 @@ impl ExprUnaryOp {
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_operand(&self, py: Python) -> PyResult<PyObject> {
-        self.0.operand.to_pyo3_wrapper(py)
+        self.0.operand.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Lambda", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprLambda(pub &'static crate::ExprLambda<TextRange>);
+pub struct ExprLambda(pub &'static ast::ExprLambda<TextRange>);
 
-impl From<&'static crate::ExprLambda<TextRange>> for ExprLambda {
-    fn from(node: &'static crate::ExprLambda<TextRange>) -> Self {
+impl From<&'static ast::ExprLambda<TextRange>> for ExprLambda {
+    fn from(node: &'static ast::ExprLambda<TextRange>) -> Self {
         ExprLambda(node)
     }
 }
 
 impl ToPyObject for ExprLambda {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprLambda<TextRange> {
+impl ToPyWrapper for ast::ExprLambda<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprLambda(self).to_object(py))
     }
 }
@@ -1722,38 +1722,38 @@ impl ExprLambda {
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_IfExp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprIfExp(pub &'static crate::ExprIfExp<TextRange>);
+pub struct ExprIfExp(pub &'static ast::ExprIfExp<TextRange>);
 
-impl From<&'static crate::ExprIfExp<TextRange>> for ExprIfExp {
-    fn from(node: &'static crate::ExprIfExp<TextRange>) -> Self {
+impl From<&'static ast::ExprIfExp<TextRange>> for ExprIfExp {
+    fn from(node: &'static ast::ExprIfExp<TextRange>) -> Self {
         ExprIfExp(node)
     }
 }
 
 impl ToPyObject for ExprIfExp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprIfExp<TextRange> {
+impl ToPyWrapper for ast::ExprIfExp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprIfExp(self).to_object(py))
     }
 }
@@ -1763,44 +1763,44 @@ impl ExprIfExp {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Dict", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprDict(pub &'static crate::ExprDict<TextRange>);
+pub struct ExprDict(pub &'static ast::ExprDict<TextRange>);
 
-impl From<&'static crate::ExprDict<TextRange>> for ExprDict {
-    fn from(node: &'static crate::ExprDict<TextRange>) -> Self {
+impl From<&'static ast::ExprDict<TextRange>> for ExprDict {
+    fn from(node: &'static ast::ExprDict<TextRange>) -> Self {
         ExprDict(node)
     }
 }
 
 impl ToPyObject for ExprDict {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprDict<TextRange> {
+impl ToPyWrapper for ast::ExprDict<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprDict(self).to_object(py))
     }
 }
@@ -1810,38 +1810,38 @@ impl ExprDict {
     #[getter]
     #[inline]
     fn get_keys(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keys.to_pyo3_wrapper(py)
+        self.0.keys.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_values(&self, py: Python) -> PyResult<PyObject> {
-        self.0.values.to_pyo3_wrapper(py)
+        self.0.values.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Set", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSet(pub &'static crate::ExprSet<TextRange>);
+pub struct ExprSet(pub &'static ast::ExprSet<TextRange>);
 
-impl From<&'static crate::ExprSet<TextRange>> for ExprSet {
-    fn from(node: &'static crate::ExprSet<TextRange>) -> Self {
+impl From<&'static ast::ExprSet<TextRange>> for ExprSet {
+    fn from(node: &'static ast::ExprSet<TextRange>) -> Self {
         ExprSet(node)
     }
 }
 
 impl ToPyObject for ExprSet {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSet<TextRange> {
+impl ToPyWrapper for ast::ExprSet<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSet(self).to_object(py))
     }
 }
@@ -1851,32 +1851,32 @@ impl ExprSet {
     #[getter]
     #[inline]
     fn get_elts(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elts.to_pyo3_wrapper(py)
+        self.0.elts.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_ListComp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprListComp(pub &'static crate::ExprListComp<TextRange>);
+pub struct ExprListComp(pub &'static ast::ExprListComp<TextRange>);
 
-impl From<&'static crate::ExprListComp<TextRange>> for ExprListComp {
-    fn from(node: &'static crate::ExprListComp<TextRange>) -> Self {
+impl From<&'static ast::ExprListComp<TextRange>> for ExprListComp {
+    fn from(node: &'static ast::ExprListComp<TextRange>) -> Self {
         ExprListComp(node)
     }
 }
 
 impl ToPyObject for ExprListComp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprListComp<TextRange> {
+impl ToPyWrapper for ast::ExprListComp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprListComp(self).to_object(py))
     }
 }
@@ -1886,38 +1886,38 @@ impl ExprListComp {
     #[getter]
     #[inline]
     fn get_elt(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elt.to_pyo3_wrapper(py)
+        self.0.elt.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_SetComp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSetComp(pub &'static crate::ExprSetComp<TextRange>);
+pub struct ExprSetComp(pub &'static ast::ExprSetComp<TextRange>);
 
-impl From<&'static crate::ExprSetComp<TextRange>> for ExprSetComp {
-    fn from(node: &'static crate::ExprSetComp<TextRange>) -> Self {
+impl From<&'static ast::ExprSetComp<TextRange>> for ExprSetComp {
+    fn from(node: &'static ast::ExprSetComp<TextRange>) -> Self {
         ExprSetComp(node)
     }
 }
 
 impl ToPyObject for ExprSetComp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSetComp<TextRange> {
+impl ToPyWrapper for ast::ExprSetComp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSetComp(self).to_object(py))
     }
 }
@@ -1927,38 +1927,38 @@ impl ExprSetComp {
     #[getter]
     #[inline]
     fn get_elt(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elt.to_pyo3_wrapper(py)
+        self.0.elt.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_DictComp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprDictComp(pub &'static crate::ExprDictComp<TextRange>);
+pub struct ExprDictComp(pub &'static ast::ExprDictComp<TextRange>);
 
-impl From<&'static crate::ExprDictComp<TextRange>> for ExprDictComp {
-    fn from(node: &'static crate::ExprDictComp<TextRange>) -> Self {
+impl From<&'static ast::ExprDictComp<TextRange>> for ExprDictComp {
+    fn from(node: &'static ast::ExprDictComp<TextRange>) -> Self {
         ExprDictComp(node)
     }
 }
 
 impl ToPyObject for ExprDictComp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprDictComp<TextRange> {
+impl ToPyWrapper for ast::ExprDictComp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprDictComp(self).to_object(py))
     }
 }
@@ -1968,44 +1968,44 @@ impl ExprDictComp {
     #[getter]
     #[inline]
     fn get_key(&self, py: Python) -> PyResult<PyObject> {
-        self.0.key.to_pyo3_wrapper(py)
+        self.0.key.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_GeneratorExp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprGeneratorExp(pub &'static crate::ExprGeneratorExp<TextRange>);
+pub struct ExprGeneratorExp(pub &'static ast::ExprGeneratorExp<TextRange>);
 
-impl From<&'static crate::ExprGeneratorExp<TextRange>> for ExprGeneratorExp {
-    fn from(node: &'static crate::ExprGeneratorExp<TextRange>) -> Self {
+impl From<&'static ast::ExprGeneratorExp<TextRange>> for ExprGeneratorExp {
+    fn from(node: &'static ast::ExprGeneratorExp<TextRange>) -> Self {
         ExprGeneratorExp(node)
     }
 }
 
 impl ToPyObject for ExprGeneratorExp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprGeneratorExp<TextRange> {
+impl ToPyWrapper for ast::ExprGeneratorExp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprGeneratorExp(self).to_object(py))
     }
 }
@@ -2015,38 +2015,38 @@ impl ExprGeneratorExp {
     #[getter]
     #[inline]
     fn get_elt(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elt.to_pyo3_wrapper(py)
+        self.0.elt.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Await", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprAwait(pub &'static crate::ExprAwait<TextRange>);
+pub struct ExprAwait(pub &'static ast::ExprAwait<TextRange>);
 
-impl From<&'static crate::ExprAwait<TextRange>> for ExprAwait {
-    fn from(node: &'static crate::ExprAwait<TextRange>) -> Self {
+impl From<&'static ast::ExprAwait<TextRange>> for ExprAwait {
+    fn from(node: &'static ast::ExprAwait<TextRange>) -> Self {
         ExprAwait(node)
     }
 }
 
 impl ToPyObject for ExprAwait {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprAwait<TextRange> {
+impl ToPyWrapper for ast::ExprAwait<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprAwait(self).to_object(py))
     }
 }
@@ -2056,32 +2056,32 @@ impl ExprAwait {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Yield", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprYield(pub &'static crate::ExprYield<TextRange>);
+pub struct ExprYield(pub &'static ast::ExprYield<TextRange>);
 
-impl From<&'static crate::ExprYield<TextRange>> for ExprYield {
-    fn from(node: &'static crate::ExprYield<TextRange>) -> Self {
+impl From<&'static ast::ExprYield<TextRange>> for ExprYield {
+    fn from(node: &'static ast::ExprYield<TextRange>) -> Self {
         ExprYield(node)
     }
 }
 
 impl ToPyObject for ExprYield {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprYield<TextRange> {
+impl ToPyWrapper for ast::ExprYield<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprYield(self).to_object(py))
     }
 }
@@ -2091,32 +2091,32 @@ impl ExprYield {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_YieldFrom", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprYieldFrom(pub &'static crate::ExprYieldFrom<TextRange>);
+pub struct ExprYieldFrom(pub &'static ast::ExprYieldFrom<TextRange>);
 
-impl From<&'static crate::ExprYieldFrom<TextRange>> for ExprYieldFrom {
-    fn from(node: &'static crate::ExprYieldFrom<TextRange>) -> Self {
+impl From<&'static ast::ExprYieldFrom<TextRange>> for ExprYieldFrom {
+    fn from(node: &'static ast::ExprYieldFrom<TextRange>) -> Self {
         ExprYieldFrom(node)
     }
 }
 
 impl ToPyObject for ExprYieldFrom {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprYieldFrom<TextRange> {
+impl ToPyWrapper for ast::ExprYieldFrom<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprYieldFrom(self).to_object(py))
     }
 }
@@ -2126,32 +2126,32 @@ impl ExprYieldFrom {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Compare", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprCompare(pub &'static crate::ExprCompare<TextRange>);
+pub struct ExprCompare(pub &'static ast::ExprCompare<TextRange>);
 
-impl From<&'static crate::ExprCompare<TextRange>> for ExprCompare {
-    fn from(node: &'static crate::ExprCompare<TextRange>) -> Self {
+impl From<&'static ast::ExprCompare<TextRange>> for ExprCompare {
+    fn from(node: &'static ast::ExprCompare<TextRange>) -> Self {
         ExprCompare(node)
     }
 }
 
 impl ToPyObject for ExprCompare {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprCompare<TextRange> {
+impl ToPyWrapper for ast::ExprCompare<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprCompare(self).to_object(py))
     }
 }
@@ -2161,44 +2161,44 @@ impl ExprCompare {
     #[getter]
     #[inline]
     fn get_left(&self, py: Python) -> PyResult<PyObject> {
-        self.0.left.to_pyo3_wrapper(py)
+        self.0.left.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ops(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ops.to_pyo3_wrapper(py)
+        self.0.ops.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_comparators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.comparators.to_pyo3_wrapper(py)
+        self.0.comparators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Call", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprCall(pub &'static crate::ExprCall<TextRange>);
+pub struct ExprCall(pub &'static ast::ExprCall<TextRange>);
 
-impl From<&'static crate::ExprCall<TextRange>> for ExprCall {
-    fn from(node: &'static crate::ExprCall<TextRange>) -> Self {
+impl From<&'static ast::ExprCall<TextRange>> for ExprCall {
+    fn from(node: &'static ast::ExprCall<TextRange>) -> Self {
         ExprCall(node)
     }
 }
 
 impl ToPyObject for ExprCall {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprCall<TextRange> {
+impl ToPyWrapper for ast::ExprCall<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprCall(self).to_object(py))
     }
 }
@@ -2208,44 +2208,44 @@ impl ExprCall {
     #[getter]
     #[inline]
     fn get_func(&self, py: Python) -> PyResult<PyObject> {
-        self.0.func.to_pyo3_wrapper(py)
+        self.0.func.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_keywords(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keywords.to_pyo3_wrapper(py)
+        self.0.keywords.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_FormattedValue", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprFormattedValue(pub &'static crate::ExprFormattedValue<TextRange>);
+pub struct ExprFormattedValue(pub &'static ast::ExprFormattedValue<TextRange>);
 
-impl From<&'static crate::ExprFormattedValue<TextRange>> for ExprFormattedValue {
-    fn from(node: &'static crate::ExprFormattedValue<TextRange>) -> Self {
+impl From<&'static ast::ExprFormattedValue<TextRange>> for ExprFormattedValue {
+    fn from(node: &'static ast::ExprFormattedValue<TextRange>) -> Self {
         ExprFormattedValue(node)
     }
 }
 
 impl ToPyObject for ExprFormattedValue {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprFormattedValue<TextRange> {
+impl ToPyWrapper for ast::ExprFormattedValue<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprFormattedValue(self).to_object(py))
     }
 }
@@ -2255,44 +2255,44 @@ impl ExprFormattedValue {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_conversion(&self, py: Python) -> PyResult<PyObject> {
-        self.0.conversion.to_pyo3_wrapper(py)
+        self.0.conversion.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_format_spec(&self, py: Python) -> PyResult<PyObject> {
-        self.0.format_spec.to_pyo3_wrapper(py)
+        self.0.format_spec.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_JoinedStr", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprJoinedStr(pub &'static crate::ExprJoinedStr<TextRange>);
+pub struct ExprJoinedStr(pub &'static ast::ExprJoinedStr<TextRange>);
 
-impl From<&'static crate::ExprJoinedStr<TextRange>> for ExprJoinedStr {
-    fn from(node: &'static crate::ExprJoinedStr<TextRange>) -> Self {
+impl From<&'static ast::ExprJoinedStr<TextRange>> for ExprJoinedStr {
+    fn from(node: &'static ast::ExprJoinedStr<TextRange>) -> Self {
         ExprJoinedStr(node)
     }
 }
 
 impl ToPyObject for ExprJoinedStr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprJoinedStr<TextRange> {
+impl ToPyWrapper for ast::ExprJoinedStr<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprJoinedStr(self).to_object(py))
     }
 }
@@ -2302,32 +2302,32 @@ impl ExprJoinedStr {
     #[getter]
     #[inline]
     fn get_values(&self, py: Python) -> PyResult<PyObject> {
-        self.0.values.to_pyo3_wrapper(py)
+        self.0.values.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Constant", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprConstant(pub &'static crate::ExprConstant<TextRange>);
+pub struct ExprConstant(pub &'static ast::ExprConstant<TextRange>);
 
-impl From<&'static crate::ExprConstant<TextRange>> for ExprConstant {
-    fn from(node: &'static crate::ExprConstant<TextRange>) -> Self {
+impl From<&'static ast::ExprConstant<TextRange>> for ExprConstant {
+    fn from(node: &'static ast::ExprConstant<TextRange>) -> Self {
         ExprConstant(node)
     }
 }
 
 impl ToPyObject for ExprConstant {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprConstant<TextRange> {
+impl ToPyWrapper for ast::ExprConstant<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprConstant(self).to_object(py))
     }
 }
@@ -2337,38 +2337,38 @@ impl ExprConstant {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kind(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kind.to_pyo3_wrapper(py)
+        self.0.kind.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Attribute", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprAttribute(pub &'static crate::ExprAttribute<TextRange>);
+pub struct ExprAttribute(pub &'static ast::ExprAttribute<TextRange>);
 
-impl From<&'static crate::ExprAttribute<TextRange>> for ExprAttribute {
-    fn from(node: &'static crate::ExprAttribute<TextRange>) -> Self {
+impl From<&'static ast::ExprAttribute<TextRange>> for ExprAttribute {
+    fn from(node: &'static ast::ExprAttribute<TextRange>) -> Self {
         ExprAttribute(node)
     }
 }
 
 impl ToPyObject for ExprAttribute {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprAttribute<TextRange> {
+impl ToPyWrapper for ast::ExprAttribute<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprAttribute(self).to_object(py))
     }
 }
@@ -2378,44 +2378,44 @@ impl ExprAttribute {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_attr(&self, py: Python) -> PyResult<PyObject> {
-        self.0.attr.to_pyo3_wrapper(py)
+        self.0.attr.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Subscript", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSubscript(pub &'static crate::ExprSubscript<TextRange>);
+pub struct ExprSubscript(pub &'static ast::ExprSubscript<TextRange>);
 
-impl From<&'static crate::ExprSubscript<TextRange>> for ExprSubscript {
-    fn from(node: &'static crate::ExprSubscript<TextRange>) -> Self {
+impl From<&'static ast::ExprSubscript<TextRange>> for ExprSubscript {
+    fn from(node: &'static ast::ExprSubscript<TextRange>) -> Self {
         ExprSubscript(node)
     }
 }
 
 impl ToPyObject for ExprSubscript {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSubscript<TextRange> {
+impl ToPyWrapper for ast::ExprSubscript<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSubscript(self).to_object(py))
     }
 }
@@ -2425,44 +2425,44 @@ impl ExprSubscript {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_slice(&self, py: Python) -> PyResult<PyObject> {
-        self.0.slice.to_pyo3_wrapper(py)
+        self.0.slice.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Starred", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprStarred(pub &'static crate::ExprStarred<TextRange>);
+pub struct ExprStarred(pub &'static ast::ExprStarred<TextRange>);
 
-impl From<&'static crate::ExprStarred<TextRange>> for ExprStarred {
-    fn from(node: &'static crate::ExprStarred<TextRange>) -> Self {
+impl From<&'static ast::ExprStarred<TextRange>> for ExprStarred {
+    fn from(node: &'static ast::ExprStarred<TextRange>) -> Self {
         ExprStarred(node)
     }
 }
 
 impl ToPyObject for ExprStarred {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprStarred<TextRange> {
+impl ToPyWrapper for ast::ExprStarred<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprStarred(self).to_object(py))
     }
 }
@@ -2472,38 +2472,38 @@ impl ExprStarred {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Name", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprName(pub &'static crate::ExprName<TextRange>);
+pub struct ExprName(pub &'static ast::ExprName<TextRange>);
 
-impl From<&'static crate::ExprName<TextRange>> for ExprName {
-    fn from(node: &'static crate::ExprName<TextRange>) -> Self {
+impl From<&'static ast::ExprName<TextRange>> for ExprName {
+    fn from(node: &'static ast::ExprName<TextRange>) -> Self {
         ExprName(node)
     }
 }
 
 impl ToPyObject for ExprName {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprName<TextRange> {
+impl ToPyWrapper for ast::ExprName<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprName(self).to_object(py))
     }
 }
@@ -2513,38 +2513,38 @@ impl ExprName {
     #[getter]
     #[inline]
     fn get_id(&self, py: Python) -> PyResult<PyObject> {
-        self.0.id.to_pyo3_wrapper(py)
+        self.0.id.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_List", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprList(pub &'static crate::ExprList<TextRange>);
+pub struct ExprList(pub &'static ast::ExprList<TextRange>);
 
-impl From<&'static crate::ExprList<TextRange>> for ExprList {
-    fn from(node: &'static crate::ExprList<TextRange>) -> Self {
+impl From<&'static ast::ExprList<TextRange>> for ExprList {
+    fn from(node: &'static ast::ExprList<TextRange>) -> Self {
         ExprList(node)
     }
 }
 
 impl ToPyObject for ExprList {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprList<TextRange> {
+impl ToPyWrapper for ast::ExprList<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprList(self).to_object(py))
     }
 }
@@ -2554,38 +2554,38 @@ impl ExprList {
     #[getter]
     #[inline]
     fn get_elts(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elts.to_pyo3_wrapper(py)
+        self.0.elts.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Tuple", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprTuple(pub &'static crate::ExprTuple<TextRange>);
+pub struct ExprTuple(pub &'static ast::ExprTuple<TextRange>);
 
-impl From<&'static crate::ExprTuple<TextRange>> for ExprTuple {
-    fn from(node: &'static crate::ExprTuple<TextRange>) -> Self {
+impl From<&'static ast::ExprTuple<TextRange>> for ExprTuple {
+    fn from(node: &'static ast::ExprTuple<TextRange>) -> Self {
         ExprTuple(node)
     }
 }
 
 impl ToPyObject for ExprTuple {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprTuple<TextRange> {
+impl ToPyWrapper for ast::ExprTuple<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprTuple(self).to_object(py))
     }
 }
@@ -2595,38 +2595,38 @@ impl ExprTuple {
     #[getter]
     #[inline]
     fn get_elts(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elts.to_pyo3_wrapper(py)
+        self.0.elts.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Slice", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSlice(pub &'static crate::ExprSlice<TextRange>);
+pub struct ExprSlice(pub &'static ast::ExprSlice<TextRange>);
 
-impl From<&'static crate::ExprSlice<TextRange>> for ExprSlice {
-    fn from(node: &'static crate::ExprSlice<TextRange>) -> Self {
+impl From<&'static ast::ExprSlice<TextRange>> for ExprSlice {
+    fn from(node: &'static ast::ExprSlice<TextRange>) -> Self {
         ExprSlice(node)
     }
 }
 
 impl ToPyObject for ExprSlice {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSlice<TextRange> {
+impl ToPyWrapper for ast::ExprSlice<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSlice(self).to_object(py))
     }
 }
@@ -2636,28 +2636,28 @@ impl ExprSlice {
     #[getter]
     #[inline]
     fn get_lower(&self, py: Python) -> PyResult<PyObject> {
-        self.0.lower.to_pyo3_wrapper(py)
+        self.0.lower.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_upper(&self, py: Python) -> PyResult<PyObject> {
-        self.0.upper.to_pyo3_wrapper(py)
+        self.0.upper.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_step(&self, py: Python) -> PyResult<PyObject> {
-        self.0.step.to_pyo3_wrapper(py)
+        self.0.step.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_expr_context", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_expr_context", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct ExprContext;
 
-impl From<&'static crate::ExprContext> for ExprContext {
-    fn from(_node: &'static crate::ExprContext) -> Self {
+impl From<&'static ast::ExprContext> for ExprContext {
+    fn from(_node: &'static ast::ExprContext) -> Self {
         ExprContext
     }
 }
@@ -2666,7 +2666,7 @@ impl From<&'static crate::ExprContext> for ExprContext {
 impl ExprContext {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for ExprContext {
@@ -2681,7 +2681,7 @@ pub struct ExprContextLoad;
 
 impl ToPyObject for ExprContextLoad {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(ExprContext)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2693,7 +2693,7 @@ pub struct ExprContextStore;
 
 impl ToPyObject for ExprContextStore {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(ExprContext)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2705,19 +2705,19 @@ pub struct ExprContextDel;
 
 impl ToPyObject for ExprContextDel {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(ExprContext)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_boolop", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_boolop", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Boolop;
 
-impl From<&'static crate::Boolop> for Boolop {
-    fn from(_node: &'static crate::Boolop) -> Self {
+impl From<&'static ast::Boolop> for Boolop {
+    fn from(_node: &'static ast::Boolop) -> Self {
         Boolop
     }
 }
@@ -2726,7 +2726,7 @@ impl From<&'static crate::Boolop> for Boolop {
 impl Boolop {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Boolop {
@@ -2741,7 +2741,7 @@ pub struct BoolopAnd;
 
 impl ToPyObject for BoolopAnd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Boolop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2753,19 +2753,19 @@ pub struct BoolopOr;
 
 impl ToPyObject for BoolopOr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Boolop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_operator", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_operator", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Operator;
 
-impl From<&'static crate::Operator> for Operator {
-    fn from(_node: &'static crate::Operator) -> Self {
+impl From<&'static ast::Operator> for Operator {
+    fn from(_node: &'static ast::Operator) -> Self {
         Operator
     }
 }
@@ -2774,7 +2774,7 @@ impl From<&'static crate::Operator> for Operator {
 impl Operator {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Operator {
@@ -2789,7 +2789,7 @@ pub struct OperatorAdd;
 
 impl ToPyObject for OperatorAdd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2801,7 +2801,7 @@ pub struct OperatorSub;
 
 impl ToPyObject for OperatorSub {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2813,7 +2813,7 @@ pub struct OperatorMult;
 
 impl ToPyObject for OperatorMult {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2825,7 +2825,7 @@ pub struct OperatorMatMult;
 
 impl ToPyObject for OperatorMatMult {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2837,7 +2837,7 @@ pub struct OperatorDiv;
 
 impl ToPyObject for OperatorDiv {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2849,7 +2849,7 @@ pub struct OperatorMod;
 
 impl ToPyObject for OperatorMod {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2861,7 +2861,7 @@ pub struct OperatorPow;
 
 impl ToPyObject for OperatorPow {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2873,7 +2873,7 @@ pub struct OperatorLShift;
 
 impl ToPyObject for OperatorLShift {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2885,7 +2885,7 @@ pub struct OperatorRShift;
 
 impl ToPyObject for OperatorRShift {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2897,7 +2897,7 @@ pub struct OperatorBitOr;
 
 impl ToPyObject for OperatorBitOr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2909,7 +2909,7 @@ pub struct OperatorBitXor;
 
 impl ToPyObject for OperatorBitXor {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2921,7 +2921,7 @@ pub struct OperatorBitAnd;
 
 impl ToPyObject for OperatorBitAnd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2933,19 +2933,19 @@ pub struct OperatorFloorDiv;
 
 impl ToPyObject for OperatorFloorDiv {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_unaryop", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_unaryop", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Unaryop;
 
-impl From<&'static crate::Unaryop> for Unaryop {
-    fn from(_node: &'static crate::Unaryop) -> Self {
+impl From<&'static ast::Unaryop> for Unaryop {
+    fn from(_node: &'static ast::Unaryop) -> Self {
         Unaryop
     }
 }
@@ -2954,7 +2954,7 @@ impl From<&'static crate::Unaryop> for Unaryop {
 impl Unaryop {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Unaryop {
@@ -2969,7 +2969,7 @@ pub struct UnaryopInvert;
 
 impl ToPyObject for UnaryopInvert {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2981,7 +2981,7 @@ pub struct UnaryopNot;
 
 impl ToPyObject for UnaryopNot {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2993,7 +2993,7 @@ pub struct UnaryopUAdd;
 
 impl ToPyObject for UnaryopUAdd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3005,19 +3005,19 @@ pub struct UnaryopUSub;
 
 impl ToPyObject for UnaryopUSub {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_cmpop", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_cmpop", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Cmpop;
 
-impl From<&'static crate::Cmpop> for Cmpop {
-    fn from(_node: &'static crate::Cmpop) -> Self {
+impl From<&'static ast::Cmpop> for Cmpop {
+    fn from(_node: &'static ast::Cmpop) -> Self {
         Cmpop
     }
 }
@@ -3026,7 +3026,7 @@ impl From<&'static crate::Cmpop> for Cmpop {
 impl Cmpop {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Cmpop {
@@ -3041,7 +3041,7 @@ pub struct CmpopEq;
 
 impl ToPyObject for CmpopEq {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3053,7 +3053,7 @@ pub struct CmpopNotEq;
 
 impl ToPyObject for CmpopNotEq {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3065,7 +3065,7 @@ pub struct CmpopLt;
 
 impl ToPyObject for CmpopLt {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3077,7 +3077,7 @@ pub struct CmpopLtE;
 
 impl ToPyObject for CmpopLtE {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3089,7 +3089,7 @@ pub struct CmpopGt;
 
 impl ToPyObject for CmpopGt {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3101,7 +3101,7 @@ pub struct CmpopGtE;
 
 impl ToPyObject for CmpopGtE {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3113,7 +3113,7 @@ pub struct CmpopIs;
 
 impl ToPyObject for CmpopIs {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3125,7 +3125,7 @@ pub struct CmpopIsNot;
 
 impl ToPyObject for CmpopIsNot {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3137,7 +3137,7 @@ pub struct CmpopIn;
 
 impl ToPyObject for CmpopIn {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3149,33 +3149,33 @@ pub struct CmpopNotIn;
 
 impl ToPyObject for CmpopNotIn {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_comprehension", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_comprehension", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Comprehension(pub &'static crate::Comprehension<TextRange>);
+pub struct Comprehension(pub &'static ast::Comprehension<TextRange>);
 
-impl From<&'static crate::Comprehension<TextRange>> for Comprehension {
-    fn from(node: &'static crate::Comprehension<TextRange>) -> Self {
+impl From<&'static ast::Comprehension<TextRange>> for Comprehension {
+    fn from(node: &'static ast::Comprehension<TextRange>) -> Self {
         Comprehension(node)
     }
 }
 
 impl ToPyObject for Comprehension {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Comprehension<TextRange> {
+impl ToPyWrapper for ast::Comprehension<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Comprehension(self).to_object(py))
     }
 }
@@ -3185,34 +3185,34 @@ impl Comprehension {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_iter(&self, py: Python) -> PyResult<PyObject> {
-        self.0.iter.to_pyo3_wrapper(py)
+        self.0.iter.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ifs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ifs.to_pyo3_wrapper(py)
+        self.0.ifs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_is_async(&self, py: Python) -> PyResult<PyObject> {
-        self.0.is_async.to_pyo3_wrapper(py)
+        self.0.is_async.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_excepthandler", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_excepthandler", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Excepthandler;
 
-impl From<&'static crate::Excepthandler<TextRange>> for Excepthandler {
-    fn from(_node: &'static crate::Excepthandler<TextRange>) -> Self {
+impl From<&'static ast::Excepthandler<TextRange>> for Excepthandler {
+    fn from(_node: &'static ast::Excepthandler<TextRange>) -> Self {
         Excepthandler
     }
 }
@@ -3221,7 +3221,7 @@ impl From<&'static crate::Excepthandler<TextRange>> for Excepthandler {
 impl Excepthandler {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Excepthandler {
@@ -3231,37 +3231,37 @@ impl ToPyObject for Excepthandler {
     }
 }
 
-impl ToPyo3Wrapper for crate::Excepthandler<TextRange> {
+impl ToPyWrapper for ast::Excepthandler<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::ExceptHandler(cons) => cons.to_pyo3_wrapper(py),
+            Self::ExceptHandler(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_ExceptHandler", extends=Excepthandler, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExcepthandlerExceptHandler(pub &'static crate::ExcepthandlerExceptHandler<TextRange>);
+pub struct ExcepthandlerExceptHandler(pub &'static ast::ExcepthandlerExceptHandler<TextRange>);
 
-impl From<&'static crate::ExcepthandlerExceptHandler<TextRange>> for ExcepthandlerExceptHandler {
-    fn from(node: &'static crate::ExcepthandlerExceptHandler<TextRange>) -> Self {
+impl From<&'static ast::ExcepthandlerExceptHandler<TextRange>> for ExcepthandlerExceptHandler {
+    fn from(node: &'static ast::ExcepthandlerExceptHandler<TextRange>) -> Self {
         ExcepthandlerExceptHandler(node)
     }
 }
 
 impl ToPyObject for ExcepthandlerExceptHandler {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Excepthandler)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExcepthandlerExceptHandler<TextRange> {
+impl ToPyWrapper for ast::ExcepthandlerExceptHandler<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExcepthandlerExceptHandler(self).to_object(py))
     }
 }
@@ -3271,42 +3271,42 @@ impl ExcepthandlerExceptHandler {
     #[getter]
     #[inline]
     fn get_type(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_.to_pyo3_wrapper(py)
+        self.0.type_.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_arguments", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_arguments", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Arguments(pub &'static crate::Arguments<TextRange>);
+pub struct Arguments(pub &'static ast::Arguments<TextRange>);
 
-impl From<&'static crate::Arguments<TextRange>> for Arguments {
-    fn from(node: &'static crate::Arguments<TextRange>) -> Self {
+impl From<&'static ast::Arguments<TextRange>> for Arguments {
+    fn from(node: &'static ast::Arguments<TextRange>) -> Self {
         Arguments(node)
     }
 }
 
 impl ToPyObject for Arguments {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Arguments<TextRange> {
+impl ToPyWrapper for ast::Arguments<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Arguments(self).to_object(py))
     }
 }
@@ -3316,66 +3316,66 @@ impl Arguments {
     #[getter]
     #[inline]
     fn get_posonlyargs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.posonlyargs.to_pyo3_wrapper(py)
+        self.0.posonlyargs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_vararg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.vararg.to_pyo3_wrapper(py)
+        self.0.vararg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwonlyargs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwonlyargs.to_pyo3_wrapper(py)
+        self.0.kwonlyargs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kw_defaults(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kw_defaults.to_pyo3_wrapper(py)
+        self.0.kw_defaults.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwarg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwarg.to_pyo3_wrapper(py)
+        self.0.kwarg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_defaults(&self, py: Python) -> PyResult<PyObject> {
-        self.0.defaults.to_pyo3_wrapper(py)
+        self.0.defaults.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_arg", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_arg", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Arg(pub &'static crate::Arg<TextRange>);
+pub struct Arg(pub &'static ast::Arg<TextRange>);
 
-impl From<&'static crate::Arg<TextRange>> for Arg {
-    fn from(node: &'static crate::Arg<TextRange>) -> Self {
+impl From<&'static ast::Arg<TextRange>> for Arg {
+    fn from(node: &'static ast::Arg<TextRange>) -> Self {
         Arg(node)
     }
 }
 
 impl ToPyObject for Arg {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Arg<TextRange> {
+impl ToPyWrapper for ast::Arg<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Arg(self).to_object(py))
     }
 }
@@ -3385,42 +3385,42 @@ impl Arg {
     #[getter]
     #[inline]
     fn get_arg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.arg.to_pyo3_wrapper(py)
+        self.0.arg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_annotation(&self, py: Python) -> PyResult<PyObject> {
-        self.0.annotation.to_pyo3_wrapper(py)
+        self.0.annotation.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_keyword", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_keyword", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Keyword(pub &'static crate::Keyword<TextRange>);
+pub struct Keyword(pub &'static ast::Keyword<TextRange>);
 
-impl From<&'static crate::Keyword<TextRange>> for Keyword {
-    fn from(node: &'static crate::Keyword<TextRange>) -> Self {
+impl From<&'static ast::Keyword<TextRange>> for Keyword {
+    fn from(node: &'static ast::Keyword<TextRange>) -> Self {
         Keyword(node)
     }
 }
 
 impl ToPyObject for Keyword {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Keyword<TextRange> {
+impl ToPyWrapper for ast::Keyword<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Keyword(self).to_object(py))
     }
 }
@@ -3430,36 +3430,36 @@ impl Keyword {
     #[getter]
     #[inline]
     fn get_arg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.arg.to_pyo3_wrapper(py)
+        self.0.arg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_alias", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_alias", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Alias(pub &'static crate::Alias<TextRange>);
+pub struct Alias(pub &'static ast::Alias<TextRange>);
 
-impl From<&'static crate::Alias<TextRange>> for Alias {
-    fn from(node: &'static crate::Alias<TextRange>) -> Self {
+impl From<&'static ast::Alias<TextRange>> for Alias {
+    fn from(node: &'static ast::Alias<TextRange>) -> Self {
         Alias(node)
     }
 }
 
 impl ToPyObject for Alias {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Alias<TextRange> {
+impl ToPyWrapper for ast::Alias<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Alias(self).to_object(py))
     }
 }
@@ -3469,36 +3469,36 @@ impl Alias {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_asname(&self, py: Python) -> PyResult<PyObject> {
-        self.0.asname.to_pyo3_wrapper(py)
+        self.0.asname.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_withitem", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_withitem", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Withitem(pub &'static crate::Withitem<TextRange>);
+pub struct Withitem(pub &'static ast::Withitem<TextRange>);
 
-impl From<&'static crate::Withitem<TextRange>> for Withitem {
-    fn from(node: &'static crate::Withitem<TextRange>) -> Self {
+impl From<&'static ast::Withitem<TextRange>> for Withitem {
+    fn from(node: &'static ast::Withitem<TextRange>) -> Self {
         Withitem(node)
     }
 }
 
 impl ToPyObject for Withitem {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Withitem<TextRange> {
+impl ToPyWrapper for ast::Withitem<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Withitem(self).to_object(py))
     }
 }
@@ -3508,36 +3508,36 @@ impl Withitem {
     #[getter]
     #[inline]
     fn get_context_expr(&self, py: Python) -> PyResult<PyObject> {
-        self.0.context_expr.to_pyo3_wrapper(py)
+        self.0.context_expr.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_optional_vars(&self, py: Python) -> PyResult<PyObject> {
-        self.0.optional_vars.to_pyo3_wrapper(py)
+        self.0.optional_vars.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_match_case", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_match_case", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct MatchCase(pub &'static crate::MatchCase<TextRange>);
+pub struct MatchCase(pub &'static ast::MatchCase<TextRange>);
 
-impl From<&'static crate::MatchCase<TextRange>> for MatchCase {
-    fn from(node: &'static crate::MatchCase<TextRange>) -> Self {
+impl From<&'static ast::MatchCase<TextRange>> for MatchCase {
+    fn from(node: &'static ast::MatchCase<TextRange>) -> Self {
         MatchCase(node)
     }
 }
 
 impl ToPyObject for MatchCase {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::MatchCase<TextRange> {
+impl ToPyWrapper for ast::MatchCase<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(MatchCase(self).to_object(py))
     }
 }
@@ -3547,28 +3547,28 @@ impl MatchCase {
     #[getter]
     #[inline]
     fn get_pattern(&self, py: Python) -> PyResult<PyObject> {
-        self.0.pattern.to_pyo3_wrapper(py)
+        self.0.pattern.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_guard(&self, py: Python) -> PyResult<PyObject> {
-        self.0.guard.to_pyo3_wrapper(py)
+        self.0.guard.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_pattern", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_pattern", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Pattern;
 
-impl From<&'static crate::Pattern<TextRange>> for Pattern {
-    fn from(_node: &'static crate::Pattern<TextRange>) -> Self {
+impl From<&'static ast::Pattern<TextRange>> for Pattern {
+    fn from(_node: &'static ast::Pattern<TextRange>) -> Self {
         Pattern
     }
 }
@@ -3577,7 +3577,7 @@ impl From<&'static crate::Pattern<TextRange>> for Pattern {
 impl Pattern {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Pattern {
@@ -3587,44 +3587,44 @@ impl ToPyObject for Pattern {
     }
 }
 
-impl ToPyo3Wrapper for crate::Pattern<TextRange> {
+impl ToPyWrapper for ast::Pattern<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::MatchValue(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchSingleton(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchSequence(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchMapping(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchClass(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchStar(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchAs(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchOr(cons) => cons.to_pyo3_wrapper(py),
+            Self::MatchValue(cons) => cons.to_py_wrapper(py),
+            Self::MatchSingleton(cons) => cons.to_py_wrapper(py),
+            Self::MatchSequence(cons) => cons.to_py_wrapper(py),
+            Self::MatchMapping(cons) => cons.to_py_wrapper(py),
+            Self::MatchClass(cons) => cons.to_py_wrapper(py),
+            Self::MatchStar(cons) => cons.to_py_wrapper(py),
+            Self::MatchAs(cons) => cons.to_py_wrapper(py),
+            Self::MatchOr(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchValue", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchValue(pub &'static crate::PatternMatchValue<TextRange>);
+pub struct PatternMatchValue(pub &'static ast::PatternMatchValue<TextRange>);
 
-impl From<&'static crate::PatternMatchValue<TextRange>> for PatternMatchValue {
-    fn from(node: &'static crate::PatternMatchValue<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchValue<TextRange>> for PatternMatchValue {
+    fn from(node: &'static ast::PatternMatchValue<TextRange>) -> Self {
         PatternMatchValue(node)
     }
 }
 
 impl ToPyObject for PatternMatchValue {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchValue<TextRange> {
+impl ToPyWrapper for ast::PatternMatchValue<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchValue(self).to_object(py))
     }
 }
@@ -3634,32 +3634,32 @@ impl PatternMatchValue {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchSingleton", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchSingleton(pub &'static crate::PatternMatchSingleton<TextRange>);
+pub struct PatternMatchSingleton(pub &'static ast::PatternMatchSingleton<TextRange>);
 
-impl From<&'static crate::PatternMatchSingleton<TextRange>> for PatternMatchSingleton {
-    fn from(node: &'static crate::PatternMatchSingleton<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchSingleton<TextRange>> for PatternMatchSingleton {
+    fn from(node: &'static ast::PatternMatchSingleton<TextRange>) -> Self {
         PatternMatchSingleton(node)
     }
 }
 
 impl ToPyObject for PatternMatchSingleton {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchSingleton<TextRange> {
+impl ToPyWrapper for ast::PatternMatchSingleton<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchSingleton(self).to_object(py))
     }
 }
@@ -3669,32 +3669,32 @@ impl PatternMatchSingleton {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchSequence", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchSequence(pub &'static crate::PatternMatchSequence<TextRange>);
+pub struct PatternMatchSequence(pub &'static ast::PatternMatchSequence<TextRange>);
 
-impl From<&'static crate::PatternMatchSequence<TextRange>> for PatternMatchSequence {
-    fn from(node: &'static crate::PatternMatchSequence<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchSequence<TextRange>> for PatternMatchSequence {
+    fn from(node: &'static ast::PatternMatchSequence<TextRange>) -> Self {
         PatternMatchSequence(node)
     }
 }
 
 impl ToPyObject for PatternMatchSequence {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchSequence<TextRange> {
+impl ToPyWrapper for ast::PatternMatchSequence<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchSequence(self).to_object(py))
     }
 }
@@ -3704,32 +3704,32 @@ impl PatternMatchSequence {
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchMapping", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchMapping(pub &'static crate::PatternMatchMapping<TextRange>);
+pub struct PatternMatchMapping(pub &'static ast::PatternMatchMapping<TextRange>);
 
-impl From<&'static crate::PatternMatchMapping<TextRange>> for PatternMatchMapping {
-    fn from(node: &'static crate::PatternMatchMapping<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchMapping<TextRange>> for PatternMatchMapping {
+    fn from(node: &'static ast::PatternMatchMapping<TextRange>) -> Self {
         PatternMatchMapping(node)
     }
 }
 
 impl ToPyObject for PatternMatchMapping {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchMapping<TextRange> {
+impl ToPyWrapper for ast::PatternMatchMapping<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchMapping(self).to_object(py))
     }
 }
@@ -3739,44 +3739,44 @@ impl PatternMatchMapping {
     #[getter]
     #[inline]
     fn get_keys(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keys.to_pyo3_wrapper(py)
+        self.0.keys.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_rest(&self, py: Python) -> PyResult<PyObject> {
-        self.0.rest.to_pyo3_wrapper(py)
+        self.0.rest.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchClass", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchClass(pub &'static crate::PatternMatchClass<TextRange>);
+pub struct PatternMatchClass(pub &'static ast::PatternMatchClass<TextRange>);
 
-impl From<&'static crate::PatternMatchClass<TextRange>> for PatternMatchClass {
-    fn from(node: &'static crate::PatternMatchClass<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchClass<TextRange>> for PatternMatchClass {
+    fn from(node: &'static ast::PatternMatchClass<TextRange>) -> Self {
         PatternMatchClass(node)
     }
 }
 
 impl ToPyObject for PatternMatchClass {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchClass<TextRange> {
+impl ToPyWrapper for ast::PatternMatchClass<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchClass(self).to_object(py))
     }
 }
@@ -3786,50 +3786,50 @@ impl PatternMatchClass {
     #[getter]
     #[inline]
     fn get_cls(&self, py: Python) -> PyResult<PyObject> {
-        self.0.cls.to_pyo3_wrapper(py)
+        self.0.cls.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwd_attrs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwd_attrs.to_pyo3_wrapper(py)
+        self.0.kwd_attrs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwd_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwd_patterns.to_pyo3_wrapper(py)
+        self.0.kwd_patterns.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchStar", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchStar(pub &'static crate::PatternMatchStar<TextRange>);
+pub struct PatternMatchStar(pub &'static ast::PatternMatchStar<TextRange>);
 
-impl From<&'static crate::PatternMatchStar<TextRange>> for PatternMatchStar {
-    fn from(node: &'static crate::PatternMatchStar<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchStar<TextRange>> for PatternMatchStar {
+    fn from(node: &'static ast::PatternMatchStar<TextRange>) -> Self {
         PatternMatchStar(node)
     }
 }
 
 impl ToPyObject for PatternMatchStar {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchStar<TextRange> {
+impl ToPyWrapper for ast::PatternMatchStar<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchStar(self).to_object(py))
     }
 }
@@ -3839,32 +3839,32 @@ impl PatternMatchStar {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchAs", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchAs(pub &'static crate::PatternMatchAs<TextRange>);
+pub struct PatternMatchAs(pub &'static ast::PatternMatchAs<TextRange>);
 
-impl From<&'static crate::PatternMatchAs<TextRange>> for PatternMatchAs {
-    fn from(node: &'static crate::PatternMatchAs<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchAs<TextRange>> for PatternMatchAs {
+    fn from(node: &'static ast::PatternMatchAs<TextRange>) -> Self {
         PatternMatchAs(node)
     }
 }
 
 impl ToPyObject for PatternMatchAs {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchAs<TextRange> {
+impl ToPyWrapper for ast::PatternMatchAs<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchAs(self).to_object(py))
     }
 }
@@ -3874,38 +3874,38 @@ impl PatternMatchAs {
     #[getter]
     #[inline]
     fn get_pattern(&self, py: Python) -> PyResult<PyObject> {
-        self.0.pattern.to_pyo3_wrapper(py)
+        self.0.pattern.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchOr", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchOr(pub &'static crate::PatternMatchOr<TextRange>);
+pub struct PatternMatchOr(pub &'static ast::PatternMatchOr<TextRange>);
 
-impl From<&'static crate::PatternMatchOr<TextRange>> for PatternMatchOr {
-    fn from(node: &'static crate::PatternMatchOr<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchOr<TextRange>> for PatternMatchOr {
+    fn from(node: &'static ast::PatternMatchOr<TextRange>) -> Self {
         PatternMatchOr(node)
     }
 }
 
 impl ToPyObject for PatternMatchOr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchOr<TextRange> {
+impl ToPyWrapper for ast::PatternMatchOr<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchOr(self).to_object(py))
     }
 }
@@ -3915,16 +3915,16 @@ impl PatternMatchOr {
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_type_ignore", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_type_ignore", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct TypeIgnore;
 
-impl From<&'static crate::TypeIgnore<TextRange>> for TypeIgnore {
-    fn from(_node: &'static crate::TypeIgnore<TextRange>) -> Self {
+impl From<&'static ast::TypeIgnore<TextRange>> for TypeIgnore {
+    fn from(_node: &'static ast::TypeIgnore<TextRange>) -> Self {
         TypeIgnore
     }
 }
@@ -3933,7 +3933,7 @@ impl From<&'static crate::TypeIgnore<TextRange>> for TypeIgnore {
 impl TypeIgnore {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for TypeIgnore {
@@ -3943,37 +3943,37 @@ impl ToPyObject for TypeIgnore {
     }
 }
 
-impl ToPyo3Wrapper for crate::TypeIgnore<TextRange> {
+impl ToPyWrapper for ast::TypeIgnore<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::TypeIgnore(cons) => cons.to_pyo3_wrapper(py),
+            Self::TypeIgnore(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_TypeIgnore", extends=TypeIgnore, frozen)]
 #[derive(Clone, Debug)]
-pub struct TypeIgnoreTypeIgnore(pub &'static crate::TypeIgnoreTypeIgnore<TextRange>);
+pub struct TypeIgnoreTypeIgnore(pub &'static ast::TypeIgnoreTypeIgnore<TextRange>);
 
-impl From<&'static crate::TypeIgnoreTypeIgnore<TextRange>> for TypeIgnoreTypeIgnore {
-    fn from(node: &'static crate::TypeIgnoreTypeIgnore<TextRange>) -> Self {
+impl From<&'static ast::TypeIgnoreTypeIgnore<TextRange>> for TypeIgnoreTypeIgnore {
+    fn from(node: &'static ast::TypeIgnoreTypeIgnore<TextRange>) -> Self {
         TypeIgnoreTypeIgnore(node)
     }
 }
 
 impl ToPyObject for TypeIgnoreTypeIgnore {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(TypeIgnore)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::TypeIgnoreTypeIgnore<TextRange> {
+impl ToPyWrapper for ast::TypeIgnoreTypeIgnore<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(TypeIgnoreTypeIgnore(self).to_object(py))
     }
 }
@@ -3983,137 +3983,135 @@ impl TypeIgnoreTypeIgnore {
     #[getter]
     #[inline]
     fn get_lineno(&self, py: Python) -> PyResult<PyObject> {
-        self.0.lineno.to_pyo3_wrapper(py)
+        self.0.lineno.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_tag(&self, py: Python) -> PyResult<PyObject> {
-        self.0.tag.to_pyo3_wrapper(py)
+        self.0.tag.to_py_wrapper(py)
     }
 }
 
 pub fn add_to_module(py: Python, m: &PyModule) -> PyResult<()> {
     super::init_module(py, m)?;
-    super::init_type::<Mod, crate::generic::Mod>(py, m)?;
-    super::init_type::<ModModule, crate::generic::ModModule>(py, m)?;
-    super::init_type::<ModInteractive, crate::generic::ModInteractive>(py, m)?;
-    super::init_type::<ModExpression, crate::generic::ModExpression>(py, m)?;
-    super::init_type::<ModFunctionType, crate::generic::ModFunctionType>(py, m)?;
-    super::init_type::<Stmt, crate::generic::Stmt>(py, m)?;
-    super::init_type::<StmtFunctionDef, crate::generic::StmtFunctionDef>(py, m)?;
-    super::init_type::<StmtAsyncFunctionDef, crate::generic::StmtAsyncFunctionDef>(py, m)?;
-    super::init_type::<StmtClassDef, crate::generic::StmtClassDef>(py, m)?;
-    super::init_type::<StmtReturn, crate::generic::StmtReturn>(py, m)?;
-    super::init_type::<StmtDelete, crate::generic::StmtDelete>(py, m)?;
-    super::init_type::<StmtAssign, crate::generic::StmtAssign>(py, m)?;
-    super::init_type::<StmtAugAssign, crate::generic::StmtAugAssign>(py, m)?;
-    super::init_type::<StmtAnnAssign, crate::generic::StmtAnnAssign>(py, m)?;
-    super::init_type::<StmtFor, crate::generic::StmtFor>(py, m)?;
-    super::init_type::<StmtAsyncFor, crate::generic::StmtAsyncFor>(py, m)?;
-    super::init_type::<StmtWhile, crate::generic::StmtWhile>(py, m)?;
-    super::init_type::<StmtIf, crate::generic::StmtIf>(py, m)?;
-    super::init_type::<StmtWith, crate::generic::StmtWith>(py, m)?;
-    super::init_type::<StmtAsyncWith, crate::generic::StmtAsyncWith>(py, m)?;
-    super::init_type::<StmtMatch, crate::generic::StmtMatch>(py, m)?;
-    super::init_type::<StmtRaise, crate::generic::StmtRaise>(py, m)?;
-    super::init_type::<StmtTry, crate::generic::StmtTry>(py, m)?;
-    super::init_type::<StmtTryStar, crate::generic::StmtTryStar>(py, m)?;
-    super::init_type::<StmtAssert, crate::generic::StmtAssert>(py, m)?;
-    super::init_type::<StmtImport, crate::generic::StmtImport>(py, m)?;
-    super::init_type::<StmtImportFrom, crate::generic::StmtImportFrom>(py, m)?;
-    super::init_type::<StmtGlobal, crate::generic::StmtGlobal>(py, m)?;
-    super::init_type::<StmtNonlocal, crate::generic::StmtNonlocal>(py, m)?;
-    super::init_type::<StmtExpr, crate::generic::StmtExpr>(py, m)?;
-    super::init_type::<StmtPass, crate::generic::StmtPass>(py, m)?;
-    super::init_type::<StmtBreak, crate::generic::StmtBreak>(py, m)?;
-    super::init_type::<StmtContinue, crate::generic::StmtContinue>(py, m)?;
-    super::init_type::<Expr, crate::generic::Expr>(py, m)?;
-    super::init_type::<ExprBoolOp, crate::generic::ExprBoolOp>(py, m)?;
-    super::init_type::<ExprNamedExpr, crate::generic::ExprNamedExpr>(py, m)?;
-    super::init_type::<ExprBinOp, crate::generic::ExprBinOp>(py, m)?;
-    super::init_type::<ExprUnaryOp, crate::generic::ExprUnaryOp>(py, m)?;
-    super::init_type::<ExprLambda, crate::generic::ExprLambda>(py, m)?;
-    super::init_type::<ExprIfExp, crate::generic::ExprIfExp>(py, m)?;
-    super::init_type::<ExprDict, crate::generic::ExprDict>(py, m)?;
-    super::init_type::<ExprSet, crate::generic::ExprSet>(py, m)?;
-    super::init_type::<ExprListComp, crate::generic::ExprListComp>(py, m)?;
-    super::init_type::<ExprSetComp, crate::generic::ExprSetComp>(py, m)?;
-    super::init_type::<ExprDictComp, crate::generic::ExprDictComp>(py, m)?;
-    super::init_type::<ExprGeneratorExp, crate::generic::ExprGeneratorExp>(py, m)?;
-    super::init_type::<ExprAwait, crate::generic::ExprAwait>(py, m)?;
-    super::init_type::<ExprYield, crate::generic::ExprYield>(py, m)?;
-    super::init_type::<ExprYieldFrom, crate::generic::ExprYieldFrom>(py, m)?;
-    super::init_type::<ExprCompare, crate::generic::ExprCompare>(py, m)?;
-    super::init_type::<ExprCall, crate::generic::ExprCall>(py, m)?;
-    super::init_type::<ExprFormattedValue, crate::generic::ExprFormattedValue>(py, m)?;
-    super::init_type::<ExprJoinedStr, crate::generic::ExprJoinedStr>(py, m)?;
-    super::init_type::<ExprConstant, crate::generic::ExprConstant>(py, m)?;
-    super::init_type::<ExprAttribute, crate::generic::ExprAttribute>(py, m)?;
-    super::init_type::<ExprSubscript, crate::generic::ExprSubscript>(py, m)?;
-    super::init_type::<ExprStarred, crate::generic::ExprStarred>(py, m)?;
-    super::init_type::<ExprName, crate::generic::ExprName>(py, m)?;
-    super::init_type::<ExprList, crate::generic::ExprList>(py, m)?;
-    super::init_type::<ExprTuple, crate::generic::ExprTuple>(py, m)?;
-    super::init_type::<ExprSlice, crate::generic::ExprSlice>(py, m)?;
-    super::init_type::<ExprContext, crate::generic::ExprContext>(py, m)?;
-    super::init_type::<ExprContextLoad, crate::generic::ExprContextLoad>(py, m)?;
-    super::init_type::<ExprContextStore, crate::generic::ExprContextStore>(py, m)?;
-    super::init_type::<ExprContextDel, crate::generic::ExprContextDel>(py, m)?;
-    super::init_type::<Boolop, crate::generic::Boolop>(py, m)?;
-    super::init_type::<BoolopAnd, crate::generic::BoolopAnd>(py, m)?;
-    super::init_type::<BoolopOr, crate::generic::BoolopOr>(py, m)?;
-    super::init_type::<Operator, crate::generic::Operator>(py, m)?;
-    super::init_type::<OperatorAdd, crate::generic::OperatorAdd>(py, m)?;
-    super::init_type::<OperatorSub, crate::generic::OperatorSub>(py, m)?;
-    super::init_type::<OperatorMult, crate::generic::OperatorMult>(py, m)?;
-    super::init_type::<OperatorMatMult, crate::generic::OperatorMatMult>(py, m)?;
-    super::init_type::<OperatorDiv, crate::generic::OperatorDiv>(py, m)?;
-    super::init_type::<OperatorMod, crate::generic::OperatorMod>(py, m)?;
-    super::init_type::<OperatorPow, crate::generic::OperatorPow>(py, m)?;
-    super::init_type::<OperatorLShift, crate::generic::OperatorLShift>(py, m)?;
-    super::init_type::<OperatorRShift, crate::generic::OperatorRShift>(py, m)?;
-    super::init_type::<OperatorBitOr, crate::generic::OperatorBitOr>(py, m)?;
-    super::init_type::<OperatorBitXor, crate::generic::OperatorBitXor>(py, m)?;
-    super::init_type::<OperatorBitAnd, crate::generic::OperatorBitAnd>(py, m)?;
-    super::init_type::<OperatorFloorDiv, crate::generic::OperatorFloorDiv>(py, m)?;
-    super::init_type::<Unaryop, crate::generic::Unaryop>(py, m)?;
-    super::init_type::<UnaryopInvert, crate::generic::UnaryopInvert>(py, m)?;
-    super::init_type::<UnaryopNot, crate::generic::UnaryopNot>(py, m)?;
-    super::init_type::<UnaryopUAdd, crate::generic::UnaryopUAdd>(py, m)?;
-    super::init_type::<UnaryopUSub, crate::generic::UnaryopUSub>(py, m)?;
-    super::init_type::<Cmpop, crate::generic::Cmpop>(py, m)?;
-    super::init_type::<CmpopEq, crate::generic::CmpopEq>(py, m)?;
-    super::init_type::<CmpopNotEq, crate::generic::CmpopNotEq>(py, m)?;
-    super::init_type::<CmpopLt, crate::generic::CmpopLt>(py, m)?;
-    super::init_type::<CmpopLtE, crate::generic::CmpopLtE>(py, m)?;
-    super::init_type::<CmpopGt, crate::generic::CmpopGt>(py, m)?;
-    super::init_type::<CmpopGtE, crate::generic::CmpopGtE>(py, m)?;
-    super::init_type::<CmpopIs, crate::generic::CmpopIs>(py, m)?;
-    super::init_type::<CmpopIsNot, crate::generic::CmpopIsNot>(py, m)?;
-    super::init_type::<CmpopIn, crate::generic::CmpopIn>(py, m)?;
-    super::init_type::<CmpopNotIn, crate::generic::CmpopNotIn>(py, m)?;
-    super::init_type::<Comprehension, crate::generic::Comprehension>(py, m)?;
-    super::init_type::<Excepthandler, crate::generic::Excepthandler>(py, m)?;
-    super::init_type::<ExcepthandlerExceptHandler, crate::generic::ExcepthandlerExceptHandler>(
-        py, m,
-    )?;
-    super::init_type::<Arguments, crate::generic::Arguments>(py, m)?;
-    super::init_type::<Arg, crate::generic::Arg>(py, m)?;
-    super::init_type::<Keyword, crate::generic::Keyword>(py, m)?;
-    super::init_type::<Alias, crate::generic::Alias>(py, m)?;
-    super::init_type::<Withitem, crate::generic::Withitem>(py, m)?;
-    super::init_type::<MatchCase, crate::generic::MatchCase>(py, m)?;
-    super::init_type::<Pattern, crate::generic::Pattern>(py, m)?;
-    super::init_type::<PatternMatchValue, crate::generic::PatternMatchValue>(py, m)?;
-    super::init_type::<PatternMatchSingleton, crate::generic::PatternMatchSingleton>(py, m)?;
-    super::init_type::<PatternMatchSequence, crate::generic::PatternMatchSequence>(py, m)?;
-    super::init_type::<PatternMatchMapping, crate::generic::PatternMatchMapping>(py, m)?;
-    super::init_type::<PatternMatchClass, crate::generic::PatternMatchClass>(py, m)?;
-    super::init_type::<PatternMatchStar, crate::generic::PatternMatchStar>(py, m)?;
-    super::init_type::<PatternMatchAs, crate::generic::PatternMatchAs>(py, m)?;
-    super::init_type::<PatternMatchOr, crate::generic::PatternMatchOr>(py, m)?;
-    super::init_type::<TypeIgnore, crate::generic::TypeIgnore>(py, m)?;
-    super::init_type::<TypeIgnoreTypeIgnore, crate::generic::TypeIgnoreTypeIgnore>(py, m)?;
+    super::init_type::<Mod, ast::Mod>(py, m)?;
+    super::init_type::<ModModule, ast::ModModule>(py, m)?;
+    super::init_type::<ModInteractive, ast::ModInteractive>(py, m)?;
+    super::init_type::<ModExpression, ast::ModExpression>(py, m)?;
+    super::init_type::<ModFunctionType, ast::ModFunctionType>(py, m)?;
+    super::init_type::<Stmt, ast::Stmt>(py, m)?;
+    super::init_type::<StmtFunctionDef, ast::StmtFunctionDef>(py, m)?;
+    super::init_type::<StmtAsyncFunctionDef, ast::StmtAsyncFunctionDef>(py, m)?;
+    super::init_type::<StmtClassDef, ast::StmtClassDef>(py, m)?;
+    super::init_type::<StmtReturn, ast::StmtReturn>(py, m)?;
+    super::init_type::<StmtDelete, ast::StmtDelete>(py, m)?;
+    super::init_type::<StmtAssign, ast::StmtAssign>(py, m)?;
+    super::init_type::<StmtAugAssign, ast::StmtAugAssign>(py, m)?;
+    super::init_type::<StmtAnnAssign, ast::StmtAnnAssign>(py, m)?;
+    super::init_type::<StmtFor, ast::StmtFor>(py, m)?;
+    super::init_type::<StmtAsyncFor, ast::StmtAsyncFor>(py, m)?;
+    super::init_type::<StmtWhile, ast::StmtWhile>(py, m)?;
+    super::init_type::<StmtIf, ast::StmtIf>(py, m)?;
+    super::init_type::<StmtWith, ast::StmtWith>(py, m)?;
+    super::init_type::<StmtAsyncWith, ast::StmtAsyncWith>(py, m)?;
+    super::init_type::<StmtMatch, ast::StmtMatch>(py, m)?;
+    super::init_type::<StmtRaise, ast::StmtRaise>(py, m)?;
+    super::init_type::<StmtTry, ast::StmtTry>(py, m)?;
+    super::init_type::<StmtTryStar, ast::StmtTryStar>(py, m)?;
+    super::init_type::<StmtAssert, ast::StmtAssert>(py, m)?;
+    super::init_type::<StmtImport, ast::StmtImport>(py, m)?;
+    super::init_type::<StmtImportFrom, ast::StmtImportFrom>(py, m)?;
+    super::init_type::<StmtGlobal, ast::StmtGlobal>(py, m)?;
+    super::init_type::<StmtNonlocal, ast::StmtNonlocal>(py, m)?;
+    super::init_type::<StmtExpr, ast::StmtExpr>(py, m)?;
+    super::init_type::<StmtPass, ast::StmtPass>(py, m)?;
+    super::init_type::<StmtBreak, ast::StmtBreak>(py, m)?;
+    super::init_type::<StmtContinue, ast::StmtContinue>(py, m)?;
+    super::init_type::<Expr, ast::Expr>(py, m)?;
+    super::init_type::<ExprBoolOp, ast::ExprBoolOp>(py, m)?;
+    super::init_type::<ExprNamedExpr, ast::ExprNamedExpr>(py, m)?;
+    super::init_type::<ExprBinOp, ast::ExprBinOp>(py, m)?;
+    super::init_type::<ExprUnaryOp, ast::ExprUnaryOp>(py, m)?;
+    super::init_type::<ExprLambda, ast::ExprLambda>(py, m)?;
+    super::init_type::<ExprIfExp, ast::ExprIfExp>(py, m)?;
+    super::init_type::<ExprDict, ast::ExprDict>(py, m)?;
+    super::init_type::<ExprSet, ast::ExprSet>(py, m)?;
+    super::init_type::<ExprListComp, ast::ExprListComp>(py, m)?;
+    super::init_type::<ExprSetComp, ast::ExprSetComp>(py, m)?;
+    super::init_type::<ExprDictComp, ast::ExprDictComp>(py, m)?;
+    super::init_type::<ExprGeneratorExp, ast::ExprGeneratorExp>(py, m)?;
+    super::init_type::<ExprAwait, ast::ExprAwait>(py, m)?;
+    super::init_type::<ExprYield, ast::ExprYield>(py, m)?;
+    super::init_type::<ExprYieldFrom, ast::ExprYieldFrom>(py, m)?;
+    super::init_type::<ExprCompare, ast::ExprCompare>(py, m)?;
+    super::init_type::<ExprCall, ast::ExprCall>(py, m)?;
+    super::init_type::<ExprFormattedValue, ast::ExprFormattedValue>(py, m)?;
+    super::init_type::<ExprJoinedStr, ast::ExprJoinedStr>(py, m)?;
+    super::init_type::<ExprConstant, ast::ExprConstant>(py, m)?;
+    super::init_type::<ExprAttribute, ast::ExprAttribute>(py, m)?;
+    super::init_type::<ExprSubscript, ast::ExprSubscript>(py, m)?;
+    super::init_type::<ExprStarred, ast::ExprStarred>(py, m)?;
+    super::init_type::<ExprName, ast::ExprName>(py, m)?;
+    super::init_type::<ExprList, ast::ExprList>(py, m)?;
+    super::init_type::<ExprTuple, ast::ExprTuple>(py, m)?;
+    super::init_type::<ExprSlice, ast::ExprSlice>(py, m)?;
+    super::init_type::<ExprContext, ast::ExprContext>(py, m)?;
+    super::init_type::<ExprContextLoad, ast::ExprContextLoad>(py, m)?;
+    super::init_type::<ExprContextStore, ast::ExprContextStore>(py, m)?;
+    super::init_type::<ExprContextDel, ast::ExprContextDel>(py, m)?;
+    super::init_type::<Boolop, ast::Boolop>(py, m)?;
+    super::init_type::<BoolopAnd, ast::BoolopAnd>(py, m)?;
+    super::init_type::<BoolopOr, ast::BoolopOr>(py, m)?;
+    super::init_type::<Operator, ast::Operator>(py, m)?;
+    super::init_type::<OperatorAdd, ast::OperatorAdd>(py, m)?;
+    super::init_type::<OperatorSub, ast::OperatorSub>(py, m)?;
+    super::init_type::<OperatorMult, ast::OperatorMult>(py, m)?;
+    super::init_type::<OperatorMatMult, ast::OperatorMatMult>(py, m)?;
+    super::init_type::<OperatorDiv, ast::OperatorDiv>(py, m)?;
+    super::init_type::<OperatorMod, ast::OperatorMod>(py, m)?;
+    super::init_type::<OperatorPow, ast::OperatorPow>(py, m)?;
+    super::init_type::<OperatorLShift, ast::OperatorLShift>(py, m)?;
+    super::init_type::<OperatorRShift, ast::OperatorRShift>(py, m)?;
+    super::init_type::<OperatorBitOr, ast::OperatorBitOr>(py, m)?;
+    super::init_type::<OperatorBitXor, ast::OperatorBitXor>(py, m)?;
+    super::init_type::<OperatorBitAnd, ast::OperatorBitAnd>(py, m)?;
+    super::init_type::<OperatorFloorDiv, ast::OperatorFloorDiv>(py, m)?;
+    super::init_type::<Unaryop, ast::Unaryop>(py, m)?;
+    super::init_type::<UnaryopInvert, ast::UnaryopInvert>(py, m)?;
+    super::init_type::<UnaryopNot, ast::UnaryopNot>(py, m)?;
+    super::init_type::<UnaryopUAdd, ast::UnaryopUAdd>(py, m)?;
+    super::init_type::<UnaryopUSub, ast::UnaryopUSub>(py, m)?;
+    super::init_type::<Cmpop, ast::Cmpop>(py, m)?;
+    super::init_type::<CmpopEq, ast::CmpopEq>(py, m)?;
+    super::init_type::<CmpopNotEq, ast::CmpopNotEq>(py, m)?;
+    super::init_type::<CmpopLt, ast::CmpopLt>(py, m)?;
+    super::init_type::<CmpopLtE, ast::CmpopLtE>(py, m)?;
+    super::init_type::<CmpopGt, ast::CmpopGt>(py, m)?;
+    super::init_type::<CmpopGtE, ast::CmpopGtE>(py, m)?;
+    super::init_type::<CmpopIs, ast::CmpopIs>(py, m)?;
+    super::init_type::<CmpopIsNot, ast::CmpopIsNot>(py, m)?;
+    super::init_type::<CmpopIn, ast::CmpopIn>(py, m)?;
+    super::init_type::<CmpopNotIn, ast::CmpopNotIn>(py, m)?;
+    super::init_type::<Comprehension, ast::Comprehension>(py, m)?;
+    super::init_type::<Excepthandler, ast::Excepthandler>(py, m)?;
+    super::init_type::<ExcepthandlerExceptHandler, ast::ExcepthandlerExceptHandler>(py, m)?;
+    super::init_type::<Arguments, ast::Arguments>(py, m)?;
+    super::init_type::<Arg, ast::Arg>(py, m)?;
+    super::init_type::<Keyword, ast::Keyword>(py, m)?;
+    super::init_type::<Alias, ast::Alias>(py, m)?;
+    super::init_type::<Withitem, ast::Withitem>(py, m)?;
+    super::init_type::<MatchCase, ast::MatchCase>(py, m)?;
+    super::init_type::<Pattern, ast::Pattern>(py, m)?;
+    super::init_type::<PatternMatchValue, ast::PatternMatchValue>(py, m)?;
+    super::init_type::<PatternMatchSingleton, ast::PatternMatchSingleton>(py, m)?;
+    super::init_type::<PatternMatchSequence, ast::PatternMatchSequence>(py, m)?;
+    super::init_type::<PatternMatchMapping, ast::PatternMatchMapping>(py, m)?;
+    super::init_type::<PatternMatchClass, ast::PatternMatchClass>(py, m)?;
+    super::init_type::<PatternMatchStar, ast::PatternMatchStar>(py, m)?;
+    super::init_type::<PatternMatchAs, ast::PatternMatchAs>(py, m)?;
+    super::init_type::<PatternMatchOr, ast::PatternMatchOr>(py, m)?;
+    super::init_type::<TypeIgnore, ast::TypeIgnore>(py, m)?;
+    super::init_type::<TypeIgnoreTypeIgnore, ast::TypeIgnoreTypeIgnore>(py, m)?;
     Ok(())
 }
diff --git a/ast-pyo3/src/lib.rs b/ast-pyo3/src/lib.rs
new file mode 100644
index 00000000..5a5b6a72
--- /dev/null
+++ b/ast-pyo3/src/lib.rs
@@ -0,0 +1,5 @@
+mod py_ast;
+#[cfg(feature = "wrapper")]
+pub mod wrapper;
+
+pub use py_ast::{init, PyNode, ToPyAst};
diff --git a/ast/src/pyo3.rs b/ast-pyo3/src/py_ast.rs
similarity index 53%
rename from ast/src/pyo3.rs
rename to ast-pyo3/src/py_ast.rs
index 928b5371..e53e7b2a 100644
--- a/ast/src/pyo3.rs
+++ b/ast-pyo3/src/py_ast.rs
@@ -1,4 +1,3 @@
-use crate::{source_code::SourceRange, text_size::TextRange, ConversionFlag, Node};
 use num_complex::Complex64;
 use once_cell::sync::OnceCell;
 use pyo3::{
@@ -6,8 +5,11 @@ use pyo3::{
     types::{PyBool, PyBytes, PyList, PyString, PyTuple},
     ToPyObject,
 };
+use rustpython_ast::{
+    self as ast, source_code::SourceRange, text_size::TextRange, ConversionFlag, Node,
+};
 
-pub trait Pyo3Node {
+pub trait PyNode {
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         {
             static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -16,120 +18,96 @@ pub trait Pyo3Node {
     }
 }
 
-pub trait ToPyo3Ast {
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny>;
+pub trait ToPyAst {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny>;
 }
 
-impl<T: ToPyo3Ast> ToPyo3Ast for Box<T> {
+impl<T: ToPyAst> ToPyAst for Box<T> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
-        (**self).to_pyo3_ast(py)
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        (**self).to_py_ast(py)
     }
 }
 
-impl<T: ToPyo3Ast> ToPyo3Ast for Option<T> {
+impl<T: ToPyAst> ToPyAst for Option<T> {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         match self {
-            Some(ast) => ast.to_pyo3_ast(py),
+            Some(ast) => ast.to_py_ast(py),
             None => Ok(ast_cache().none_ref(py)),
         }
     }
 }
 
-impl<T: ToPyo3Ast> ToPyo3Ast for Vec<T> {
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+impl<T: ToPyAst> ToPyAst for Vec<T> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let elts = self
             .iter()
-            .map(|item| item.to_pyo3_ast(py))
+            .map(|item| item.to_py_ast(py))
             .collect::<Result<Vec<_>, _>>()?;
         let list = PyList::new(py, elts);
         Ok(list.into())
     }
 }
 
-impl ToPyo3Ast for crate::Identifier {
+impl ToPyAst for ast::Identifier {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         Ok(PyString::new(py, self.as_str()).into())
     }
 }
 
-impl ToPyo3Ast for crate::String {
+impl ToPyAst for ast::String {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         Ok(PyString::new(py, self.as_str()).into())
     }
 }
 
-impl ToPyo3Ast for bool {
+impl ToPyAst for bool {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         Ok(ast_cache().bool_int(py, *self))
     }
 }
 
-impl ToPyo3Ast for ConversionFlag {
+impl ToPyAst for ConversionFlag {
     #[inline]
-    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         Ok(ast_cache().conversion_flag(py, *self))
     }
 }
 
-impl ToPyObject for crate::Constant {
-    fn to_object(&self, py: Python) -> PyObject {
-        let cache = ast_cache();
-        match self {
-            crate::Constant::None => cache.none.clone_ref(py),
-            crate::Constant::Bool(bool) => cache.bool(py, *bool).into(),
-            crate::Constant::Str(string) => string.to_object(py),
-            crate::Constant::Bytes(bytes) => PyBytes::new(py, bytes).into(),
-            crate::Constant::Int(int) => int.to_object(py),
-            crate::Constant::Tuple(elts) => {
-                let elts: Vec<_> = elts.iter().map(|c| c.to_object(py)).collect();
-                PyTuple::new(py, elts).into()
-            }
-            crate::Constant::Float(f64) => f64.to_object(py),
-            crate::Constant::Complex { real, imag } => Complex64::new(*real, *imag).to_object(py),
-            crate::Constant::Ellipsis => py.Ellipsis(),
+fn constant_to_object(constant: &ast::Constant, py: Python) -> PyObject {
+    let cache = ast_cache();
+    match constant {
+        ast::Constant::None => cache.none.clone_ref(py),
+        ast::Constant::Bool(bool) => cache.bool(py, *bool).into(),
+        ast::Constant::Str(string) => string.to_object(py),
+        ast::Constant::Bytes(bytes) => PyBytes::new(py, bytes).into(),
+        ast::Constant::Int(int) => int.to_object(py),
+        ast::Constant::Tuple(elts) => {
+            let elts: Vec<_> = elts.iter().map(|c| constant_to_object(c, py)).collect();
+            PyTuple::new(py, elts).into()
         }
+        ast::Constant::Float(f64) => f64.to_object(py),
+        ast::Constant::Complex { real, imag } => Complex64::new(*real, *imag).to_object(py),
+        ast::Constant::Ellipsis => py.Ellipsis(),
     }
 }
 
-// impl ToPyo3Ast for crate::Constant {
-//     #[inline]
-//     fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
-//         let cache = ast_cache();
-//         let value = match self {
-//             crate::Constant::None => cache.none_ref(py),
-//             crate::Constant::Bool(bool) => cache.bool_ref(py),
-//             crate::Constant::Str(string) => string.to_object(py),
-//             crate::Constant::Bytes(bytes) => PyBytes::new(py, bytes).into(),
-//             crate::Constant::Int(int) => int.to_object(py),
-//             crate::Constant::Tuple(elts) => {
-//                 let elts: PyResult<Vec<_>> = elts.iter().map(|c| c.to_pyo3_ast(py)).collect();
-//                 PyTuple::new(py, elts?).into()
-//             }
-//             crate::Constant::Float(f64) => f64.to_object(py),
-//             crate::Constant::Complex { real, imag } => Complex64::new(*real, *imag).to_object(py),
-//             crate::Constant::Ellipsis => py.Ellipsis(),
-//         };
-//         Ok(value)
-//     }
-// }
-
 #[pyclass(module = "rustpython_ast", subclass)]
-pub struct AST;
+pub struct Ast;
 
 #[pymethods]
-impl AST {
+impl Ast {
     #[new]
     fn new() -> Self {
         Self
     }
 }
 
-fn cache_py_type<N: Pyo3Node + Node>(ast_module: &PyAny) -> PyResult<()> {
+fn cache_py_type<N: PyNode + Node>(ast_module: &PyAny) -> PyResult<()> {
     let class = ast_module.getattr(N::NAME)?;
     let base = if std::mem::size_of::<N>() == 0 {
         class.call0()?
@@ -209,4 +187,4 @@ pub fn init(py: Python) -> PyResult<()> {
     init_types(py)
 }
 
-include!("gen/to_pyo3.rs");
+include!("gen/to_py_ast.rs");
diff --git a/ast-pyo3/src/wrapper.rs b/ast-pyo3/src/wrapper.rs
new file mode 100644
index 00000000..9a8b1152
--- /dev/null
+++ b/ast-pyo3/src/wrapper.rs
@@ -0,0 +1,141 @@
+use crate::PyNode;
+use num_complex::Complex64;
+use pyo3::prelude::*;
+use pyo3::types::{PyBytes, PyList, PyTuple};
+use rustpython_ast::{
+    self as ast, source_code::SourceRange, text_size::TextRange, ConversionFlag, Node,
+};
+
+pub trait ToPyWrapper {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>>;
+}
+
+impl<T: ToPyWrapper> ToPyWrapper for Box<T> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        (**self).to_py_wrapper(py)
+    }
+}
+
+impl<T: ToPyWrapper> ToPyWrapper for Option<T> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        match self {
+            Some(ast) => ast.to_py_wrapper(py),
+            None => Ok(py.None()),
+        }
+    }
+}
+
+impl ToPyWrapper for ast::Identifier {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(self.as_str().to_object(py))
+    }
+}
+
+impl ToPyWrapper for ast::String {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(self.as_str().to_object(py))
+    }
+}
+
+impl ToPyWrapper for ast::Int {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok((self.to_u32()).to_object(py))
+    }
+}
+
+impl ToPyWrapper for bool {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok((*self as u32).to_object(py))
+    }
+}
+
+impl ToPyWrapper for ConversionFlag {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok((*self as i8).to_object(py))
+    }
+}
+
+impl ToPyWrapper for ast::Constant {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        let value = match self {
+            ast::Constant::None => py.None(),
+            ast::Constant::Bool(bool) => bool.to_object(py),
+            ast::Constant::Str(string) => string.to_object(py),
+            ast::Constant::Bytes(bytes) => PyBytes::new(py, bytes).into(),
+            ast::Constant::Int(int) => int.to_object(py),
+            ast::Constant::Tuple(elts) => {
+                let elts: PyResult<Vec<_>> = elts.iter().map(|c| c.to_py_wrapper(py)).collect();
+                PyTuple::new(py, elts?).into()
+            }
+            ast::Constant::Float(f64) => f64.to_object(py),
+            ast::Constant::Complex { real, imag } => Complex64::new(*real, *imag).to_object(py),
+            ast::Constant::Ellipsis => py.Ellipsis(),
+        };
+        Ok(value)
+    }
+}
+
+impl<T: ToPyWrapper> ToPyWrapper for Vec<T> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        let list = PyList::empty(py);
+        for item in self {
+            let py_item = item.to_py_wrapper(py)?;
+            list.append(py_item)?;
+        }
+        Ok(list.into())
+    }
+}
+
+#[pyclass(module = "rustpython_ast", subclass)]
+pub struct Ast;
+
+#[pymethods]
+impl Ast {
+    #[new]
+    fn new() -> Self {
+        Self
+    }
+}
+
+pub mod located {
+    pub use super::Ast;
+    use super::*;
+    include!("gen/wrapper_located.rs");
+}
+
+pub mod ranged {
+    pub use super::Ast;
+    use super::*;
+    include!("gen/wrapper_ranged.rs");
+}
+
+fn init_type<P: pyo3::PyClass, N: PyNode + Node>(py: Python, m: &PyModule) -> PyResult<()> {
+    m.add_class::<P>()?;
+    let node = m.getattr(P::NAME)?;
+    if P::NAME != N::NAME {
+        // TODO: no idea how to escape rust keyword on #[pyclass]
+        m.setattr(P::NAME, node)?;
+    }
+    let names: Vec<&'static str> = N::FIELD_NAMES.to_vec();
+    let fields = PyTuple::new(py, names);
+    node.setattr("_fields", fields)?;
+    Ok(())
+}
+
+/// A Python module implemented in Rust.
+fn init_module(py: Python, m: &PyModule) -> PyResult<()> {
+    m.add_class::<Ast>()?;
+
+    let ast = m.getattr("AST")?;
+    let fields = PyTuple::empty(py);
+    ast.setattr("_fields", fields)?;
+
+    Ok(())
+}
diff --git a/ast/Cargo.toml b/ast/Cargo.toml
index bee7c188..cedfa50e 100644
--- a/ast/Cargo.toml
+++ b/ast/Cargo.toml
@@ -15,11 +15,6 @@ fold = []
 unparse = ["rustpython-literal"]
 visitor = []
 all-nodes-with-ranges = []
-pyo3 = ["dep:pyo3", "num-complex", "once_cell"]
-
-# This feature is experimental
-# It reimplements AST types, but currently both slower than python AST types and limited to use in other API
-pyo3-wrapper = ["pyo3"]
 
 [dependencies]
 rustpython-parser-core = { workspace = true }
@@ -28,6 +23,5 @@ rustpython-literal = { workspace = true, optional = true }
 is-macro = { workspace = true }
 num-bigint = { workspace = true }
 static_assertions = "1.1.0"
-num-complex = { workspace = true, optional = true }
-once_cell = { workspace = true, optional = true }
+
 pyo3 = { workspace = true, optional = true, features = ["num-bigint", "num-complex"] }
diff --git a/ast/asdl_rs.py b/ast/asdl_rs.py
index c61a553e..9fc36393 100755
--- a/ast/asdl_rs.py
+++ b/ast/asdl_rs.py
@@ -1102,16 +1102,16 @@ def visitSum(self, sum, type):
 
         self.emit(
             f"""
-            impl ToPyo3Ast for crate::generic::{rust_name}{self.generics} {{
+            impl ToPyAst for ast::{rust_name}{self.generics} {{
                 #[inline]
-                fn to_pyo3_ast<'py>(&self, {"_" if simple else ""}py: Python<'py>) -> PyResult<&'py PyAny> {{
+                fn to_py_ast<'py>(&self, {"_" if simple else ""}py: Python<'py>) -> PyResult<&'py PyAny> {{
                     let instance = match &self {{
             """,
             0,
         )
         for cons in sum.types:
             self.emit(
-                f"crate::{rust_name}::{cons.name}(cons) => cons.to_pyo3_ast(py)?,",
+                f"ast::{rust_name}::{cons.name}(cons) => cons.to_py_ast(py)?,",
                 1,
             )
         self.emit(
@@ -1135,9 +1135,9 @@ def emit_to_pyo3_with_fields(self, cons, type, name):
         type_info = self.type_info[type.name]
         self.emit(
             f"""
-            impl ToPyo3Ast for crate::{name}{self.generics} {{
+            impl ToPyAst for ast::{name}{self.generics} {{
                 #[inline]
-                    fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {{
+                    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {{
                         let cache = Self::py_type_cache().get().unwrap();
             """,
             0,
@@ -1159,7 +1159,7 @@ def emit_to_pyo3_with_fields(self, cons, type, name):
             for field in cons.fields:
                 if field.type == "constant":
                     self.emit(
-                        f"{rust_field(field.name)}.to_object(py),",
+                        f"constant_to_object({rust_field(field.name)}, py),",
                         3,
                     )
                     continue
@@ -1183,7 +1183,7 @@ def emit_to_pyo3_with_fields(self, cons, type, name):
                         )
                         continue
                 self.emit(
-                    f"{rust_field(field.name)}.to_pyo3_ast(py)?,",
+                    f"{rust_field(field.name)}.to_py_ast(py)?,",
                     3,
                 )
             self.emit(
@@ -1252,7 +1252,7 @@ def ref_def(self):
     def ref(self):
         return "&" if self.borrow else ""
 
-    def emit_class(self, name, rust_name, simple, base="super::AST"):
+    def emit_class(self, name, rust_name, simple, base="super::Ast"):
         info = self.type_info[name]
         if simple:
             generics = ""
@@ -1264,7 +1264,7 @@ def emit_class(self, name, rust_name, simple, base="super::AST"):
             into = f"{rust_name}"
         else:
             subclass = ""
-            body = f"(pub {self.ref_def} crate::{rust_name}{generics})"
+            body = f"(pub {self.ref_def} ast::{rust_name}{generics})"
             into = f"{rust_name}(node)"
 
         self.emit(
@@ -1273,8 +1273,8 @@ def emit_class(self, name, rust_name, simple, base="super::AST"):
             #[derive(Clone, Debug)]
             pub struct {rust_name} {body};
 
-            impl From<{self.ref_def} crate::{rust_name}{generics}> for {rust_name} {{
-                fn from({"" if body else "_"}node: {self.ref_def} crate::{rust_name}{generics}) -> Self {{
+            impl From<{self.ref_def} ast::{rust_name}{generics}> for {rust_name} {{
+                fn from({"" if body else "_"}node: {self.ref_def} ast::{rust_name}{generics}) -> Self {{
                     {into}
                 }}
             }}
@@ -1288,7 +1288,7 @@ def emit_class(self, name, rust_name, simple, base="super::AST"):
                 impl {rust_name} {{
                     #[new]
                     fn new() -> PyClassInitializer<Self> {{
-                        PyClassInitializer::from(AST)
+                        PyClassInitializer::from(Ast)
                             .add_subclass(Self)
                     }}
 
@@ -1303,7 +1303,7 @@ def emit_class(self, name, rust_name, simple, base="super::AST"):
                 0,
             )
         else:
-            if base != "super::AST":
+            if base != "super::Ast":
                 add_subclass = f".add_subclass({base})"
             else:
                 add_subclass = ""
@@ -1311,7 +1311,7 @@ def emit_class(self, name, rust_name, simple, base="super::AST"):
                 f"""
                 impl ToPyObject for {rust_name} {{
                     fn to_object(&self, py: Python) -> PyObject {{
-                        let initializer = PyClassInitializer::from(AST)
+                        let initializer = PyClassInitializer::from(Ast)
                         {add_subclass}
                         .add_subclass(self.clone());
                         Py::new(py, initializer).unwrap().into_py(py)
@@ -1339,7 +1339,7 @@ def emit_getter(self, owner, type_name):
                 #[getter]
                 #[inline]
                 fn get_{field.name}(&self, py: Python) -> PyResult<PyObject> {{
-                    self.0.{rust_field(field.name)}.to_pyo3_wrapper(py)
+                    self.0.{rust_field(field.name)}.to_py_wrapper(py)
                 }}
                 """,
                 3,
@@ -1365,7 +1365,7 @@ def emit_getattr(self, owner, type_name):
 
         for field in owner.fields:
             self.emit(
-                f'"{field.name}" => self.0.{rust_field(field.name)}.to_pyo3_wrapper(py)?,',
+                f'"{field.name}" => self.0.{rust_field(field.name)}.to_py_wrapper(py)?,',
                 3,
             )
 
@@ -1383,9 +1383,9 @@ def emit_getattr(self, owner, type_name):
     def emit_wrapper(self, rust_name):
         self.emit(
             f"""
-            impl ToPyo3Wrapper for crate::{rust_name}{self.generics} {{
+            impl ToPyWrapper for ast::{rust_name}{self.generics} {{
                 #[inline]
-                fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {{
+                fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {{
                     Ok({rust_name}(self).to_object(py))
                 }}
             }}
@@ -1409,16 +1409,16 @@ def visitSum(self, sum, type, depth=0):
         if not simple:
             self.emit(
                 f"""
-                impl ToPyo3Wrapper for crate::{rust_name}{self.generics} {{
+                impl ToPyWrapper for ast::{rust_name}{self.generics} {{
                     #[inline]
-                    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {{
+                    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {{
                         match &self {{
                 """,
                 0,
             )
 
             for cons in sum.types:
-                self.emit(f"Self::{cons.name}(cons) => cons.to_pyo3_wrapper(py),", 3)
+                self.emit(f"Self::{cons.name}(cons) => cons.to_py_wrapper(py),", 3)
 
             self.emit(
                 """
@@ -1447,7 +1447,7 @@ def visitConstructor(self, cons, parent, simple, depth):
 
                 impl ToPyObject for {parent}{cons.name} {{
                     fn to_object(&self, py: Python) -> PyObject {{
-                        let initializer = PyClassInitializer::from(AST)
+                        let initializer = PyClassInitializer::from(Ast)
                         .add_subclass({parent})
                         .add_subclass(Self);
                         Py::new(py, initializer).unwrap().into_py(py)
@@ -1496,9 +1496,7 @@ def visitConstructor(self, cons, parent, simple, depth):
         self.emit_fields(cons.name, rust_name, simple)
 
     def emit_fields(self, name, rust_name, simple):
-        self.emit(
-            f"super::init_type::<{rust_name}, crate::generic::{rust_name}>(py, m)?;", 1
-        )
+        self.emit(f"super::init_type::<{rust_name}, ast::{rust_name}>(py, m)?;", 1)
 
 
 class StdlibClassDefVisitor(EmitVisitor):
@@ -1846,7 +1844,7 @@ def write(info: TypeInfo):
 
         f.write(
             f"""
-            impl{generics} Pyo3Node for crate::generic::{rust_name}{generics} {{
+            impl{generics} PyNode for ast::{rust_name}{generics} {{
                 #[inline]
                 fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {{
                     static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -1876,7 +1874,7 @@ def write_to_pyo3(mod, type_info, f):
 
     for info in type_info.values():
         rust_name = info.rust_sum_name
-        f.write(f"cache_py_type::<crate::generic::{rust_name}>(ast_module)?;\n")
+        f.write(f"cache_py_type::<ast::{rust_name}>(ast_module)?;\n")
     f.write("Ok(())\n}")
 
 
@@ -1890,15 +1888,15 @@ def write_to_pyo3_simple(type_info, f):
         rust_name = type_info.rust_sum_name
         f.write(
             f"""
-            impl ToPyo3Ast for crate::generic::{rust_name} {{
+            impl ToPyAst for ast::{rust_name} {{
                 #[inline]
-                fn to_pyo3_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {{
+                fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {{
                     let cell = match &self {{
             """,
         )
         for cons in type_info.type.value.types:
             f.write(
-                f"""crate::{rust_name}::{cons.name} => crate::{rust_name}{cons.name}::py_type_cache(),""",
+                f"""ast::{rust_name}::{cons.name} => ast::{rust_name}{cons.name}::py_type_cache(),""",
             )
         f.write(
             """
@@ -1921,9 +1919,9 @@ def write_pyo3_wrapper(mod, type_info, namespace, f):
             rust_name = type_info.rust_sum_name
             f.write(
                 f"""
-                impl ToPyo3Wrapper for crate::generic::{rust_name} {{
+                impl ToPyWrapper for ast::{rust_name} {{
                     #[inline]
-                    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {{
+                    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {{
                         match &self {{
                 """,
             )
@@ -1942,9 +1940,9 @@ def write_pyo3_wrapper(mod, type_info, namespace, f):
             for cons in type_info.type.value.types:
                 f.write(
                     f"""
-                    impl ToPyo3Wrapper for crate::generic::{rust_name}{cons.name} {{
+                    impl ToPyWrapper for ast::{rust_name}{cons.name} {{
                         #[inline]
-                        fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {{
+                        fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {{
                             Ok({rust_name}{cons.name}.to_object(py))
                         }}
                     }}
@@ -1983,6 +1981,7 @@ def write_ast_mod(mod, type_info, f):
 def main(
     input_filename,
     ast_dir,
+    ast_pyo3_dir,
     module_filename,
     dump_module=False,
 ):
@@ -2005,14 +2004,20 @@ def main(
         ("ranged", p(write_ranged_def, mod, type_info)),
         ("located", p(write_located_def, mod, type_info)),
         ("visitor", p(write_visitor_def, mod, type_info)),
-        ("to_pyo3", p(write_to_pyo3, mod, type_info)),
-        ("pyo3_wrapper_located", p(write_pyo3_wrapper, mod, type_info, "located")),
-        ("pyo3_wrapper_ranged", p(write_pyo3_wrapper, mod, type_info, "ranged")),
     ]:
         with (ast_dir / f"{filename}.rs").open("w") as f:
             f.write(auto_gen_msg)
             write(f)
 
+    for filename, write in [
+        ("to_py_ast", p(write_to_pyo3, mod, type_info)),
+        ("wrapper_located", p(write_pyo3_wrapper, mod, type_info, "located")),
+        ("wrapper_ranged", p(write_pyo3_wrapper, mod, type_info, "ranged")),
+    ]:
+        with (ast_pyo3_dir / f"{filename}.rs").open("w") as f:
+            f.write(auto_gen_msg)
+            write(f)
+
     with module_filename.open("w") as module_file:
         module_file.write(auto_gen_msg)
         write_ast_mod(mod, type_info, module_file)
@@ -2024,6 +2029,7 @@ def main(
     parser = ArgumentParser()
     parser.add_argument("input_file", type=Path)
     parser.add_argument("-A", "--ast-dir", type=Path, required=True)
+    parser.add_argument("-O", "--ast-pyo3-dir", type=Path, required=True)
     parser.add_argument("-M", "--module-file", type=Path, required=True)
     parser.add_argument("-d", "--dump-module", action="store_true")
 
@@ -2031,6 +2037,7 @@ def main(
     main(
         args.input_file,
         args.ast_dir,
+        args.ast_pyo3_dir,
         args.module_file,
         args.dump_module,
     )
diff --git a/ast/src/lib.rs b/ast/src/lib.rs
index 21cca63e..5a3c1ff5 100644
--- a/ast/src/lib.rs
+++ b/ast/src/lib.rs
@@ -41,8 +41,3 @@ pub use visitor::Visitor;
 mod optimizer;
 #[cfg(feature = "constant-optimization")]
 pub use optimizer::ConstantOptimizer;
-
-#[cfg(feature = "pyo3")]
-pub mod pyo3;
-#[cfg(feature = "pyo3-wrapper")]
-pub mod pyo3_wrapper;
diff --git a/ast/src/pyo3_wrapper.rs b/ast/src/pyo3_wrapper.rs
deleted file mode 100644
index a622ed06..00000000
--- a/ast/src/pyo3_wrapper.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-use crate::pyo3::{Pyo3Node, AST};
-use crate::{source_code::SourceRange, text_size::TextRange, ConversionFlag, Node};
-use num_complex::Complex64;
-use pyo3::prelude::*;
-use pyo3::types::{PyBytes, PyList, PyTuple};
-
-pub trait ToPyo3Wrapper {
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>>;
-}
-
-impl<T: ToPyo3Wrapper> ToPyo3Wrapper for Box<T> {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        (**self).to_pyo3_wrapper(py)
-    }
-}
-
-impl<T: ToPyo3Wrapper> ToPyo3Wrapper for Option<T> {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        match self {
-            Some(ast) => ast.to_pyo3_wrapper(py),
-            None => Ok(py.None()),
-        }
-    }
-}
-
-impl ToPyo3Wrapper for crate::Identifier {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok(self.as_str().to_object(py))
-    }
-}
-
-impl ToPyo3Wrapper for crate::String {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok(self.as_str().to_object(py))
-    }
-}
-
-impl ToPyo3Wrapper for crate::Int {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok((self.to_u32()).to_object(py))
-    }
-}
-
-impl ToPyo3Wrapper for bool {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok((*self as u32).to_object(py))
-    }
-}
-
-impl ToPyo3Wrapper for ConversionFlag {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok((*self as i8).to_object(py))
-    }
-}
-
-impl ToPyo3Wrapper for crate::Constant {
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        let value = match self {
-            crate::Constant::None => py.None(),
-            crate::Constant::Bool(bool) => bool.to_object(py),
-            crate::Constant::Str(string) => string.to_object(py),
-            crate::Constant::Bytes(bytes) => PyBytes::new(py, bytes).into(),
-            crate::Constant::Int(int) => int.to_object(py),
-            crate::Constant::Tuple(elts) => {
-                let elts: PyResult<Vec<_>> = elts.iter().map(|c| c.to_pyo3_wrapper(py)).collect();
-                PyTuple::new(py, elts?).into()
-            }
-            crate::Constant::Float(f64) => f64.to_object(py),
-            crate::Constant::Complex { real, imag } => Complex64::new(*real, *imag).to_object(py),
-            crate::Constant::Ellipsis => py.Ellipsis(),
-        };
-        Ok(value)
-    }
-}
-
-impl<T: ToPyo3Wrapper> ToPyo3Wrapper for Vec<T> {
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        let list = PyList::empty(py);
-        for item in self {
-            let py_item = item.to_pyo3_wrapper(py)?;
-            list.append(py_item)?;
-        }
-        Ok(list.into())
-    }
-}
-
-pub mod located {
-    use super::*;
-    pub use crate::pyo3::AST;
-    include!("gen/pyo3_wrapper_located.rs");
-}
-
-pub mod ranged {
-    use super::*;
-    pub use crate::pyo3::AST;
-    include!("gen/pyo3_wrapper_ranged.rs");
-}
-
-fn init_type<P: pyo3::PyClass, N: Pyo3Node + Node>(py: Python, m: &PyModule) -> PyResult<()> {
-    m.add_class::<P>()?;
-    let node = m.getattr(P::NAME)?;
-    if P::NAME != N::NAME {
-        // TODO: no idea how to escape rust keyword on #[pyclass]
-        m.setattr(P::NAME, node)?;
-    }
-    let names: Vec<&'static str> = N::FIELD_NAMES.to_vec();
-    let fields = PyTuple::new(py, names);
-    node.setattr("_fields", fields)?;
-    Ok(())
-}
-
-/// A Python module implemented in Rust.
-fn init_module(py: Python, m: &PyModule) -> PyResult<()> {
-    m.add_class::<AST>()?;
-
-    let ast = m.getattr("AST")?;
-    let fields = PyTuple::empty(py);
-    ast.setattr("_fields", fields)?;
-
-    Ok(())
-}
diff --git a/scripts/update_asdl.sh b/scripts/update_asdl.sh
index f2e3db25..af34cd22 100755
--- a/scripts/update_asdl.sh
+++ b/scripts/update_asdl.sh
@@ -4,5 +4,5 @@ set -e
 cd "$(dirname "$(dirname "$0")")"
 
 # rm ast/src/gen/*.rs
-python ast/asdl_rs.py --ast-dir ast/src/gen/ --module-file ../RustPython/vm/src/stdlib/ast/gen.rs ast/Python.asdl
-rustfmt ast/src/gen/*.rs ../RustPython/vm/src/stdlib/ast/gen.rs
+python ast/asdl_rs.py --ast-dir ast/src/gen/ --ast-pyo3-dir ast-pyo3/src/gen/ --module-file ../RustPython/vm/src/stdlib/ast/gen.rs ast/Python.asdl
+rustfmt ast/src/gen/*.rs ast-pyo3/src/gen/*.rs ../RustPython/vm/src/stdlib/ast/gen.rs