New Arguments and Arg/ArgWithDefault AST representation (#59)

ast-pyo3/src/gen/to_py_ast.rs

@@ -808,7 +808,7 @@ impl<R> PyNode for ast::ExcepthandlerExceptHandler<R> {
     }
 }
 
-impl<R> PyNode for ast::Arguments<R> {
+impl<R> PyNode for ast::PythonArguments<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
         static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -2288,7 +2288,7 @@ impl ToPyAst for ast::ExcepthandlerExceptHandler<TextRange> {
     }
 }
 
-impl ToPyAst for ast::Arguments<TextRange> {
+impl ToPyAst for ast::PythonArguments<TextRange> {
     #[inline]
     fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
@@ -4312,7 +4312,7 @@ impl ToPyAst for ast::ExcepthandlerExceptHandler<SourceRange> {
     }
 }
 
-impl ToPyAst for ast::Arguments<SourceRange> {
+impl ToPyAst for ast::PythonArguments<SourceRange> {
     #[inline]
     fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
         let cache = Self::py_type_cache().get().unwrap();
@@ -4820,7 +4820,7 @@ fn init_types(py: Python) -> PyResult<()> {
     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::PythonArguments>(ast_module)?;
     cache_py_type::<ast::Arg>(ast_module)?;
     cache_py_type::<ast::Keyword>(ast_module)?;
     cache_py_type::<ast::Alias>(ast_module)?;

ast-pyo3/src/gen/wrapper_located.rs

@@ -3289,10 +3289,10 @@ impl ExcepthandlerExceptHandler {
 
 #[pyclass(module="rustpython_ast.located", name="_arguments", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Arguments(pub &'static ast::Arguments<SourceRange>);
+pub struct Arguments(pub &'static ast::PythonArguments<SourceRange>);
 
-impl From<&'static ast::Arguments<SourceRange>> for Arguments {
-    fn from(node: &'static ast::Arguments<SourceRange>) -> Self {
+impl From<&'static ast::PythonArguments<SourceRange>> for Arguments {
+    fn from(node: &'static ast::PythonArguments<SourceRange>) -> Self {
         Arguments(node)
     }
 }
@@ -3304,7 +3304,7 @@ impl ToPyObject for Arguments {
     }
 }
 
-impl ToPyWrapper for ast::Arguments<SourceRange> {
+impl ToPyWrapper for ast::PythonArguments<SourceRange> {
     #[inline]
     fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Arguments(self).to_object(py))
@@ -4392,7 +4392,7 @@ pub fn add_to_module(py: Python, m: &PyModule) -> PyResult<()> {
     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::<Arguments, ast::PythonArguments>(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)?;

ast-pyo3/src/gen/wrapper_ranged.rs

@@ -3289,10 +3289,10 @@ impl ExcepthandlerExceptHandler {
 
 #[pyclass(module="rustpython_ast.ranged", name="_arguments", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Arguments(pub &'static ast::Arguments<TextRange>);
+pub struct Arguments(pub &'static ast::PythonArguments<TextRange>);
 
-impl From<&'static ast::Arguments<TextRange>> for Arguments {
-    fn from(node: &'static ast::Arguments<TextRange>) -> Self {
+impl From<&'static ast::PythonArguments<TextRange>> for Arguments {
+    fn from(node: &'static ast::PythonArguments<TextRange>) -> Self {
         Arguments(node)
     }
 }
@@ -3304,7 +3304,7 @@ impl ToPyObject for Arguments {
     }
 }
 
-impl ToPyWrapper for ast::Arguments<TextRange> {
+impl ToPyWrapper for ast::PythonArguments<TextRange> {
     #[inline]
     fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Arguments(self).to_object(py))
@@ -4096,7 +4096,7 @@ pub fn add_to_module(py: Python, m: &PyModule) -> PyResult<()> {
     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::<Arguments, ast::PythonArguments>(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)?;

ast-pyo3/src/py_ast.rs

@@ -78,6 +78,18 @@ impl ToPyAst for ConversionFlag {
     }
 }
 
+impl<R> ToPyAst for ast::Arguments<R>
+where
+    R: Clone,
+    ast::PythonArguments<R>: ToPyAst,
+{
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let arguments = self.to_python_arguments();
+        arguments.to_py_ast(py)
+    }
+}
+
 fn constant_to_object(constant: &ast::Constant, py: Python) -> PyObject {
     let cache = ast_cache();
     match constant {

ast-pyo3/src/wrapper.rs

@@ -93,6 +93,18 @@ impl<T: ToPyWrapper> ToPyWrapper for Vec<T> {
     }
 }
 
+impl<R> ToPyWrapper for ast::Arguments<R>
+where
+    Self: Clone,
+    ast::PythonArguments<R>: ToPyWrapper,
+{
+    #[inline]
+    fn to_py_wrapper(&'static self, _py: Python) -> PyResult<Py<PyAny>> {
+        todo!()
+        // Ok(FunctionArguments(self).to_object(py))
+    }
+}
+
 #[pyclass(module = "rustpython_ast", name = "AST", subclass)]
 pub struct Ast;
 

ast/asdl_rs.py

@@ -45,6 +45,74 @@ RUST_KEYWORDS = {
     "type",
 }
 
+attributes = [
+    asdl.Field("int", "lineno"),
+    asdl.Field("int", "col_offset"),
+    asdl.Field("int", "end_lineno"),
+    asdl.Field("int", "end_col_offset"),
+]
+
+ORIGINAL_NODE_WARNING = "NOTE: This type is different from original Python AST."
+
+arg_with_default = asdl.Type(
+    "arg_with_default",
+    asdl.Product(
+        [
+            asdl.Field("arg", "def"),
+            asdl.Field(
+                "expr", "default", opt=True
+            ),  # order is important for cost-free borrow!
+        ],
+    ),
+)
+arg_with_default.doc = f"""
+An alternative type of AST `arg`. This is used for each function argument that might have a default value.
+Used by `Arguments` original type.
+
+{ORIGINAL_NODE_WARNING}
+""".strip()
+
+alt_arguments = asdl.Type(
+    "alt:arguments",
+    asdl.Product(
+        [
+            asdl.Field("arg_with_default", "posonlyargs", seq=True),
+            asdl.Field("arg_with_default", "args", seq=True),
+            asdl.Field("arg", "vararg", opt=True),
+            asdl.Field("arg_with_default", "kwonlyargs", seq=True),
+            asdl.Field("arg", "kwarg", opt=True),
+        ]
+    ),
+)
+alt_arguments.doc = f"""
+An alternative type of AST `arguments`. This is parser-friendly and human-friendly definition of function arguments.
+This form also has advantage to implement pre-order traverse.
+`defaults` and `kw_defaults` fields are removed and the default values are placed under each `arg_with_default` typed argument.
+`vararg` and `kwarg` are still typed as `arg` because they never can have a default value.
+
+The matching Python style AST type is [PythonArguments]. While [PythonArguments] has ordered `kwonlyargs` fields by
+default existence, [Arguments] has location-ordered kwonlyargs fields.
+
+{ORIGINAL_NODE_WARNING}
+""".strip()
+
+# Must be used only for rust types, not python types
+CUSTOM_TYPES = [
+    alt_arguments,
+    arg_with_default,
+]
+
+CUSTOM_REPLACEMENTS = {
+    "arguments": alt_arguments,
+}
+CUSTOM_ATTACHMENTS = [
+    arg_with_default,
+]
+
+
+def maybe_custom(type):
+    return CUSTOM_REPLACEMENTS.get(type.name, type)
+
 
 def rust_field_name(name):
     name = rust_type_name(name)
@@ -137,6 +205,20 @@ class TypeInfo:
             f.type != "identifier" for f in self.type.value.fields
         )
 
+    @property
+    def is_custom(self):
+        return self.type.name in [t.name for t in CUSTOM_TYPES]
+
+    @property
+    def is_custom_replaced(self):
+        return self.type.name in CUSTOM_REPLACEMENTS
+
+    @property
+    def custom(self):
+        if self.type.name in CUSTOM_REPLACEMENTS:
+            return CUSTOM_REPLACEMENTS[self.type.name]
+        return self.type
+
     def no_cfg(self, typeinfo):
         if self.is_product:
             return self.has_attributes
@@ -150,20 +232,26 @@ class TypeInfo:
         return rust_type_name(self.name)
 
     @property
-    def sum_name(self):
+    def full_field_name(self):
+        name = self.name
+        if name.startswith("alt:"):
+            name = name[4:]
         if self.enum_name is None:
-            return self.name
+            return name
         else:
-            return f"{self.enum_name}_{self.name}"
+            return f"{self.enum_name}_{rust_field_name(name)}"
 
     @property
-    def rust_sum_name(self):
-        rust_name = rust_type_name(self.name)
-        if self.enum_name is None:
-            return rust_name
-        else:
-            name = rust_type_name(self.enum_name) + rust_name
-            return name
+    def full_type_name(self):
+        name = self.name
+        if name.startswith("alt:"):
+            name = name[4:]
+        rust_name = rust_type_name(name)
+        if self.enum_name is not None:
+            rust_name = rust_type_name(self.enum_name) + rust_name
+        if self.is_custom_replaced:
+            rust_name = "Python" + rust_name
+        return rust_name
 
     def determine_user_data(self, type_info, stack):
         if self.name in stack:
@@ -184,6 +272,10 @@ class TypeInfo:
 class TypeInfoMixin:
     type_info: Dict[str, TypeInfo]
 
+    def customized_type_info(self, type_name):
+        info = self.type_info[type_name]
+        return self.type_info[info.custom.name]
+
     def has_user_data(self, typ):
         return self.type_info[typ].has_user_data
 
@@ -223,18 +315,19 @@ class FindUserDataTypesVisitor(asdl.VisitorBase):
         super().__init__()
 
     def visitModule(self, mod):
-        for dfn in mod.dfns:
+        for dfn in mod.dfns + CUSTOM_TYPES:
             self.visit(dfn)
         stack = set()
         for info in self.type_info.values():
             info.determine_user_data(self.type_info, stack)
 
     def visitType(self, type):
-        self.type_info[type.name] = TypeInfo(type)
-        self.visit(type.value, type)
+        key = type.name
+        info = self.type_info[key] = TypeInfo(type)
+        self.visit(type.value, info)
 
-    def visitSum(self, sum, type):
-        info = self.type_info[type.name]
+    def visitSum(self, sum, info):
+        type = info.type
         info.is_simple = is_simple(sum)
         for cons in sum.types:
             self.visit(cons, type, info.is_simple)
@@ -261,8 +354,8 @@ class FindUserDataTypesVisitor(asdl.VisitorBase):
         info.enum_name = type.name
         info.is_simple = simple
 
-    def visitProduct(self, product, type):
-        info = self.type_info[type.name]
+    def visitProduct(self, product, info):
+        type = info.type
         if product.attributes:
             # attributes means located, which has the `range: R` field
             info.has_user_data = True
@@ -308,7 +401,9 @@ class StructVisitor(EmitVisitor):
             0,
         )
         for dfn in mod.dfns:
-            rust_name = rust_type_name(dfn.name)
+            info = self.customized_type_info(dfn.name)
+            dfn = info.custom
+            rust_name = info.full_type_name
             generics = "" if self.type_info[dfn.name].is_simple else "<R>"
             if dfn.name == "mod":
                 # This is exceptional rule to other enums.
@@ -329,7 +424,8 @@ class StructVisitor(EmitVisitor):
             0,
         )
         for dfn in mod.dfns:
-            rust_name = rust_type_name(dfn.name)
+            info = self.customized_type_info(dfn.name)
+            rust_name = info.full_type_name
             generics = "" if self.type_info[dfn.name].is_simple else "<R>"
             self.emit(
                 f"""
@@ -342,10 +438,13 @@ class StructVisitor(EmitVisitor):
                 0,
             )
 
-        for dfn in mod.dfns:
+        for dfn in mod.dfns + CUSTOM_TYPES:
             self.visit(dfn)
 
     def visitType(self, type, depth=0):
+        if hasattr(type, "doc"):
+            doc = "/// " + type.doc.replace("\n", "\n/// ") + "\n"
+            self.emit(doc, depth)
         self.visit(type.value, type, depth)
 
     def visitSum(self, sum, type, depth):
@@ -492,8 +591,12 @@ class StructVisitor(EmitVisitor):
             self.emit(f"{cons.name},", depth)
 
     def visitField(self, field, parent, vis, depth, constructor=None):
-        typ = rust_type_name(field.type)
-        field_type = self.type_info.get(field.type)
+        try:
+            field_type = self.customized_type_info(field.type)
+            typ = field_type.full_type_name
+        except KeyError:
+            field_type = None
+            typ = rust_type_name(field.type)
         if field_type and not field_type.is_simple:
             typ = f"{typ}<R>"
         # don't box if we're doing Vec<T>, but do box if we're doing Vec<Option<Box<T>>>
@@ -520,9 +623,8 @@ class StructVisitor(EmitVisitor):
 
     def visitProduct(self, product, type, depth):
         type_info = self.type_info[type.name]
-        product_name = rust_type_name(type.name)
+        product_name = type_info.full_type_name
         self.emit_attrs(depth)
-
         self.emit(f"pub struct {product_name}<R = TextRange> {{", depth)
         self.emit_range(product.attributes, depth + 1)
         for f in product.fields:
@@ -584,19 +686,20 @@ class FoldTraitDefVisitor(EmitVisitor):
             }""",
             depth + 1,
         )
-        for dfn in mod.dfns:
+        for dfn in mod.dfns + [arg_with_default]:
+            dfn = maybe_custom(dfn)
             self.visit(dfn, depth + 2)
         self.emit("}", depth)
 
     def visitType(self, type, depth):
-        name = type.name
-        apply_u, apply_target_u = self.apply_generics(name, "U", "Self::TargetU")
-        enum_name = rust_type_name(name)
+        info = self.type_info[type.name]
+        apply_u, apply_target_u = self.apply_generics(info.name, "U", "Self::TargetU")
+        enum_name = info.full_type_name
         self.emit(
-            f"fn fold_{name}(&mut self, node: {enum_name}{apply_u}) -> Result<{enum_name}{apply_target_u}, Self::Error> {{",
+            f"fn fold_{info.full_field_name}(&mut self, node: {enum_name}{apply_u}) -> Result<{enum_name}{apply_target_u}, Self::Error> {{",
             depth,
         )
-        self.emit(f"fold_{name}(self, node)", depth + 1)
+        self.emit(f"fold_{info.full_field_name}(self, node)", depth + 1)
         self.emit("}", depth)
 
         if isinstance(type.value, asdl.Sum) and not is_simple(type.value):
@@ -604,9 +707,10 @@ class FoldTraitDefVisitor(EmitVisitor):
                 self.visit(cons, type, depth)
 
     def visitConstructor(self, cons, type, depth):
+        info = self.type_info[type.name]
         apply_u, apply_target_u = self.apply_generics(type.name, "U", "Self::TargetU")
         enum_name = rust_type_name(type.name)
-        func_name = f"fold_{type.name}_{rust_field_name(cons.name)}"
+        func_name = f"fold_{info.full_field_name}_{rust_field_name(cons.name)}"
         self.emit(
             f"fn {func_name}(&mut self, node: {enum_name}{cons.name}{apply_u}) -> Result<{enum_name}{cons.name}{apply_target_u}, Self::Error> {{",
             depth,
@@ -617,7 +721,8 @@ class FoldTraitDefVisitor(EmitVisitor):
 
 class FoldImplVisitor(EmitVisitor):
     def visitModule(self, mod, depth):
-        for dfn in mod.dfns:
+        for dfn in mod.dfns + [arg_with_default]:
+            dfn = maybe_custom(dfn)
             self.visit(dfn, depth)
 
     def visitType(self, type, depth=0):
@@ -668,7 +773,8 @@ class FoldImplVisitor(EmitVisitor):
         apply_t, apply_u, apply_target_u = self.apply_generics(
             type.name, "T", "U", "F::TargetU"
         )
-        enum_name = rust_type_name(type.name)
+        info = self.type_info[type.name]
+        enum_name = info.full_type_name
 
         cons_type_name = f"{enum_name}{cons.name}"
 
@@ -679,21 +785,20 @@ class FoldImplVisitor(EmitVisitor):
             depth + 1,
         )
         self.emit(
-            f"folder.fold_{type.name}_{rust_field_name(cons.name)}(self)", depth + 2
+            f"folder.fold_{info.full_field_name}_{rust_field_name(cons.name)}(self)",
+            depth + 2,
         )
         self.emit("}", depth + 1)
         self.emit("}", depth)
 
         self.emit(
-            f"pub fn fold_{type.name}_{rust_field_name(cons.name)}<U, F: Fold<U> + ?Sized>(#[allow(unused)] folder: &mut F, node: {cons_type_name}{apply_u}) -> Result<{enum_name}{cons.name}{apply_target_u}, F::Error> {{",
+            f"pub fn fold_{info.full_field_name}_{rust_field_name(cons.name)}<U, F: Fold<U> + ?Sized>(#[allow(unused)] folder: &mut F, node: {cons_type_name}{apply_u}) -> Result<{enum_name}{cons.name}{apply_target_u}, F::Error> {{",
             depth,
         )
 
-        type_info = self.type_info[type.name]
-
         fields_pattern = self.make_pattern(cons.fields)
 
-        map_user_suffix = "" if type_info.has_attributes else "_cfg"
+        map_user_suffix = "" if info.has_attributes else "_cfg"
         self.emit(
             f"""
             let {cons_type_name} {{ {fields_pattern} }} = node;
@@ -710,11 +815,12 @@ class FoldImplVisitor(EmitVisitor):
         self.emit("}", depth + 2)
 
     def visitProduct(self, product, type, depth):
+        info = self.type_info[type.name]
         name = type.name
         apply_t, apply_u, apply_target_u = self.apply_generics(
             name, "T", "U", "F::TargetU"
         )
-        struct_name = rust_type_name(name)
+        struct_name = info.full_type_name
         has_attributes = bool(product.attributes)
 
         self.emit(f"impl<T, U> Foldable<T, U> for {struct_name}{apply_t} {{", depth)
@@ -723,12 +829,12 @@ class FoldImplVisitor(EmitVisitor):
             "fn fold<F: Fold<T, TargetU = U> + ?Sized>(self, folder: &mut F) -> Result<Self::Mapped, F::Error> {",
             depth + 1,
         )
-        self.emit(f"folder.fold_{name}(self)", depth + 2)
+        self.emit(f"folder.fold_{info.full_field_name}(self)", depth + 2)
         self.emit("}", depth + 1)
         self.emit("}", depth)
 
         self.emit(
-            f"pub fn fold_{name}<U, F: Fold<U> + ?Sized>(#[allow(unused)] folder: &mut F, node: {struct_name}{apply_u}) -> Result<{struct_name}{apply_target_u}, F::Error> {{",
+            f"pub fn fold_{info.full_field_name}<U, F: Fold<U> + ?Sized>(#[allow(unused)] folder: &mut F, node: {struct_name}{apply_u}) -> Result<{struct_name}{apply_target_u}, F::Error> {{",
             depth,
         )
 
@@ -777,7 +883,7 @@ class FoldModuleVisitor(EmitVisitor):
         FoldImplVisitor(self.file, self.type_info).visit(mod, depth)
 
 
-class VisitorTraitDefVisitor(StructVisitor):
+class VisitorModuleVisitor(StructVisitor):
     def full_name(self, name):
         type_info = self.type_info[name]
         if type_info.enum_name:
@@ -792,10 +898,12 @@ class VisitorTraitDefVisitor(StructVisitor):
         else:
             return rust_type_name(name)
 
-    def visitModule(self, mod, depth):
+    def visitModule(self, mod, depth=0):
+        self.emit("#[allow(unused_variables)]", depth)
         self.emit("pub trait Visitor<R=crate::text_size::TextRange> {", depth)
 
         for dfn in mod.dfns:
+            dfn = self.customized_type_info(dfn.name).type
             self.visit(dfn, depth + 1)
         self.emit("}", depth)
 
@@ -810,26 +918,28 @@ class VisitorTraitDefVisitor(StructVisitor):
 
     def emit_visitor(self, nodename, depth, has_node=True):
         type_info = self.type_info[nodename]
-        node_type = type_info.rust_sum_name
+        node_type = type_info.full_type_name
         (generic,) = self.apply_generics(nodename, "R")
         self.emit(
-            f"fn visit_{type_info.sum_name}(&mut self, node: {node_type}{generic}) {{",
+            f"fn visit_{type_info.full_field_name}(&mut self, node: {node_type}{generic}) {{",
             depth,
         )
         if has_node:
-            self.emit(f"self.generic_visit_{type_info.sum_name}(node)", depth + 1)
+            self.emit(
+                f"self.generic_visit_{type_info.full_field_name}(node)", depth + 1
+            )
 
         self.emit("}", depth)
 
     def emit_generic_visitor_signature(self, nodename, depth, has_node=True):
         type_info = self.type_info[nodename]
         if has_node:
-            node_type = type_info.rust_sum_name
+            node_type = type_info.full_type_name
         else:
             node_type = "()"
         (generic,) = self.apply_generics(nodename, "R")
         self.emit(
-            f"fn generic_visit_{type_info.sum_name}(&mut self, node: {node_type}{generic}) {{",
+            f"fn generic_visit_{type_info.full_field_name}(&mut self, node: {node_type}{generic}) {{",
             depth,
         )
 
@@ -844,7 +954,9 @@ class VisitorTraitDefVisitor(StructVisitor):
     def visit_match_for_type(self, nodename, rust_name, type_, depth):
         self.emit(f"{rust_name}::{type_.name}", depth)
         self.emit("(data)", depth)
-        self.emit(f"=> self.visit_{nodename}_{type_.name}(data),", depth)
+        self.emit(
+            f"=> self.visit_{nodename}_{rust_field_name(type_.name)}(data),", depth
+        )
 
     def visit_sum_type(self, name, type_, depth):
         self.emit_visitor(type_.name, depth, has_node=type_.fields)
@@ -852,28 +964,32 @@ class VisitorTraitDefVisitor(StructVisitor):
             return
 
         self.emit_generic_visitor_signature(type_.name, depth, has_node=True)
-        for f in type_.fields:
-            fieldname = rust_field(f.name)
-            field_type = self.type_info.get(f.type)
+        for field in type_.fields:
+            if field.type in CUSTOM_REPLACEMENTS:
+                type_name = CUSTOM_REPLACEMENTS[field.type].name
+            else:
+                type_name = field.type
+            field_name = rust_field(field.name)
+            field_type = self.type_info.get(type_name)
             if not (field_type and field_type.has_user_data):
                 continue
 
-            if f.opt:
-                self.emit(f"if let Some(value) = node.{fieldname} {{", depth + 1)
-            elif f.seq:
-                iterable = f"node.{fieldname}"
-                if type_.name == "Dict" and f.name == "keys":
+            if field.opt:
+                self.emit(f"if let Some(value) = node.{field_name} {{", depth + 1)
+            elif field.seq:
+                iterable = f"node.{field_name}"
+                if type_.name == "Dict" and field.name == "keys":
                     iterable = f"{iterable}.into_iter().flatten()"
                 self.emit(f"for value in {iterable} {{", depth + 1)
             else:
                 self.emit("{", depth + 1)
-                self.emit(f"let value = node.{fieldname};", depth + 2)
+                self.emit(f"let value = node.{field_name};", depth + 2)
 
             variable = "value"
-            if field_type.boxed and (not f.seq or f.opt):
+            if field_type.boxed and (not field.seq or field.opt):
                 variable = "*" + variable
             type_info = self.type_info[field_type.name]
-            self.emit(f"self.visit_{type_info.sum_name}({variable});", depth + 2)
+            self.emit(f"self.visit_{type_info.full_field_name}({variable});", depth + 2)
 
             self.emit("}", depth + 1)
 
@@ -903,16 +1019,9 @@ class VisitorTraitDefVisitor(StructVisitor):
         self.emit_empty_generic_visitor(name, depth)
 
 
-class VisitorModuleVisitor(EmitVisitor):
-    def visitModule(self, mod):
-        depth = 0
-        self.emit("#[allow(unused_variables, non_snake_case)]", depth)
-        VisitorTraitDefVisitor(self.file, self.type_info).visit(mod, depth)
-
-
 class RangedDefVisitor(EmitVisitor):
     def visitModule(self, mod):
-        for dfn in mod.dfns:
+        for dfn in mod.dfns + CUSTOM_TYPES:
             self.visit(dfn)
 
     def visitType(self, type, depth=0):
@@ -944,7 +1053,7 @@ class RangedDefVisitor(EmitVisitor):
 
         self.emit(
             f"""
-            impl Ranged for crate::{info.rust_sum_name} {{
+            impl Ranged for crate::{info.full_type_name} {{
                 fn range(&self) -> TextRange {{
                     match self {{
                         {sum_match_arms}
@@ -966,7 +1075,7 @@ class RangedDefVisitor(EmitVisitor):
         generics = "" if info.is_simple else "::<TextRange>"
 
         self.emit(
-            f"pub type {info.rust_sum_name} = crate::generic::{info.rust_sum_name}{generics};",
+            f"pub type {info.full_type_name} = crate::generic::{info.full_type_name}{generics};",
             0,
         )
         self.emit("", 0)
@@ -977,7 +1086,7 @@ class RangedDefVisitor(EmitVisitor):
 
         self.file.write(
             f"""
-            impl Ranged for crate::generic::{info.rust_sum_name}::<TextRange> {{
+            impl Ranged for crate::generic::{info.full_type_name}::<TextRange> {{
                 fn range(&self) -> TextRange {{
                     self.range
                 }}
@@ -988,7 +1097,7 @@ class RangedDefVisitor(EmitVisitor):
 
 class LocatedDefVisitor(EmitVisitor):
     def visitModule(self, mod):
-        for dfn in mod.dfns:
+        for dfn in mod.dfns + CUSTOM_TYPES:
             self.visit(dfn)
 
     def visitType(self, type, depth=0):
@@ -1020,7 +1129,7 @@ class LocatedDefVisitor(EmitVisitor):
 
         self.emit(
             f"""
-            impl Located for {info.rust_sum_name} {{
+            impl Located for {info.full_type_name} {{
                 fn range(&self) -> SourceRange {{
                     match self {{
                         {sum_match_arms}
@@ -1041,7 +1150,7 @@ class LocatedDefVisitor(EmitVisitor):
         generics = "" if info.is_simple else "::<SourceRange>"
 
         self.emit(
-            f"pub type {info.rust_sum_name} = crate::generic::{info.rust_sum_name}{generics};",
+            f"pub type {info.full_type_name} = crate::generic::{info.full_type_name}{generics};",
             0,
         )
         self.emit("", 0)
@@ -1052,7 +1161,7 @@ class LocatedDefVisitor(EmitVisitor):
 
         self.emit(
             f"""
-            impl Located for {info.rust_sum_name} {{
+            impl Located for {info.full_type_name} {{
                 fn range(&self) -> SourceRange {{
                     self.range
                 }}
@@ -1086,11 +1195,13 @@ class ToPyo3AstVisitor(EmitVisitor):
         self.visit(type.value, type)
 
     def visitProduct(self, product, type):
-        rust_name = rust_type_name(type.name)
+        info = self.type_info[type.name]
+        rust_name = info.full_type_name
         self.emit_to_pyo3_with_fields(product, type, rust_name)
 
     def visitSum(self, sum, type):
-        rust_name = rust_type_name(type.name)
+        info = self.type_info[type.name]
+        rust_name = info.full_type_name
         simple = is_simple(sum)
         if is_simple(sum):
             return
@@ -1243,8 +1354,9 @@ class Pyo3StructVisitor(EmitVisitor):
     def ref(self):
         return "&" if self.borrow else ""
 
-    def emit_class(self, name, rust_name, simple, base="super::Ast"):
-        info = self.type_info[name]
+    def emit_class(self, info, simple, base="super::Ast"):
+        inner_name = info.full_type_name
+        rust_name = self.type_info[info.custom.name].full_type_name
         if simple:
             generics = ""
         else:
@@ -1255,23 +1367,24 @@ class Pyo3StructVisitor(EmitVisitor):
             into = f"{rust_name}"
         else:
             subclass = ""
-            body = f"(pub {self.ref_def} ast::{rust_name}{generics})"
+            body = f"(pub {self.ref_def} ast::{inner_name}{generics})"
             into = f"{rust_name}(node)"
 
         self.emit(
             f"""
-            #[pyclass(module="{self.module_name}", name="_{name}", extends={base}, frozen{subclass})]
+            #[pyclass(module="{self.module_name}", name="_{info.name}", extends={base}, frozen{subclass})]
             #[derive(Clone, Debug)]
             pub struct {rust_name} {body};
 
-            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 {{
+            impl From<{self.ref_def} ast::{inner_name}{generics}> for {rust_name} {{
+                fn from({"" if body else "_"}node: {self.ref_def} ast::{inner_name}{generics}) -> Self {{
                     {into}
                 }}
             }}
             """,
             0,
         )
+        
         if subclass:
             self.emit(
                 f"""
@@ -1313,7 +1426,7 @@ class Pyo3StructVisitor(EmitVisitor):
             )
 
         if not subclass:
-            self.emit_wrapper(rust_name)
+            self.emit_wrapper(info)
 
     def emit_getter(self, owner, type_name):
         self.emit(
@@ -1371,10 +1484,12 @@ class Pyo3StructVisitor(EmitVisitor):
             0,
         )
 
-    def emit_wrapper(self, rust_name):
+    def emit_wrapper(self, info):
+        inner_name = info.full_type_name
+        rust_name = self.type_info[info.custom.name].full_type_name
         self.emit(
             f"""
-            impl ToPyWrapper for ast::{rust_name}{self.generics} {{
+            impl ToPyWrapper for ast::{inner_name}{self.generics} {{
                 #[inline]
                 fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {{
                     Ok({rust_name}(self).to_object(py))
@@ -1392,10 +1507,11 @@ class Pyo3StructVisitor(EmitVisitor):
         self.visit(type.value, type, depth)
 
     def visitSum(self, sum, type, depth=0):
+        info = self.type_info[type.name]
         rust_name = rust_type_name(type.name)
 
         simple = is_simple(sum)
-        self.emit_class(type.name, rust_name, simple)
+        self.emit_class(info, simple)
 
         if not simple:
             self.emit(
@@ -1424,8 +1540,9 @@ class Pyo3StructVisitor(EmitVisitor):
             self.visit(cons, rust_name, simple, depth + 1)
 
     def visitProduct(self, product, type, depth=0):
+        info = self.type_info[type.name]
         rust_name = rust_type_name(type.name)
-        self.emit_class(type.name, rust_name, False)
+        self.emit_class(info, False)
         if self.borrow:
             self.emit_getter(product, rust_name)
 
@@ -1448,9 +1565,9 @@ class Pyo3StructVisitor(EmitVisitor):
                 depth,
             )
         else:
+            info = self.type_info[cons.name]
             self.emit_class(
-                cons.name,
-                f"{parent}{cons.name}",
+                info,
                 simple=False,
                 base=parent,
             )
@@ -1471,23 +1588,25 @@ class Pyo3PymoduleVisitor(EmitVisitor):
         self.visit(type.value, type.name, depth)
 
     def visitProduct(self, product, name, depth=0):
-        rust_name = rust_type_name(name)
-        self.emit_fields(name, rust_name, False)
+        info = self.type_info[name]
+        self.emit_fields(info, False)
 
     def visitSum(self, sum, name, depth):
-        rust_name = rust_type_name(name)
+        info = self.type_info[name]
         simple = is_simple(sum)
-        self.emit_fields(name, rust_name, True)
+        self.emit_fields(info, True)
 
         for cons in sum.types:
             self.visit(cons, name, simple, depth)
 
     def visitConstructor(self, cons, parent, simple, depth):
-        rust_name = rust_type_name(parent) + rust_type_name(cons.name)
-        self.emit_fields(cons.name, rust_name, simple)
+        info = self.type_info[cons.name]
+        self.emit_fields(info, simple)
 
-    def emit_fields(self, name, rust_name, simple):
-        self.emit(f"super::init_type::<{rust_name}, ast::{rust_name}>(py, m)?;", 1)
+    def emit_fields(self, info, simple):
+        inner_name = info.full_type_name
+        rust_name = self.type_info[info.custom.name].full_type_name
+        self.emit(f"super::init_type::<{rust_name}, ast::{inner_name}>(py, m)?;", 1)
 
 
 class StdlibClassDefVisitor(EmitVisitor):
@@ -1499,7 +1618,9 @@ class StdlibClassDefVisitor(EmitVisitor):
         self.visit(type.value, type.name, depth)
 
     def visitSum(self, sum, name, depth):
-        struct_name = "Node" + rust_type_name(name)
+        # info = self.type_info[self.type_info[name].custom.name]
+        info = self.type_info[name]
+        struct_name = "Node" + info.full_type_name
         self.emit(
             f'#[pyclass(module = "_ast", name = {json.dumps(name)}, base = "NodeAst")]',
             depth,
@@ -1517,11 +1638,13 @@ class StdlibClassDefVisitor(EmitVisitor):
         self.gen_class_def(name, product.fields, product.attributes, depth)
 
     def gen_class_def(self, name, fields, attrs, depth, base=None):
+
+        info = self.type_info[self.type_info[name].custom.name]
         if base is None:
             base = "NodeAst"
-            struct_name = "Node" + rust_type_name(name)
+            struct_name = "Node" + info.full_type_name
         else:
-            struct_name = base + rust_type_name(name)
+            struct_name = "Node" + info.full_type_name
         self.emit(
             f'#[pyclass(module = "_ast", name = {json.dumps(name)}, base = {json.dumps(base)})]',
             depth,
@@ -1596,11 +1719,9 @@ class StdlibTraitImplVisitor(EmitVisitor):
         self.visit(type.value, type.name, depth)
 
     def visitSum(self, sum, name, depth):
-        rust_name = rust_type_name(name)
+        info = self.type_info[name]
+        rust_name = info.full_type_name
 
-        self.emit(f"impl NamedNode for ast::located::{rust_name} {{", depth)
-        self.emit(f"const NAME: &'static str = {json.dumps(name)};", depth + 1)
-        self.emit("}", depth)
         self.emit("// sum", depth)
         self.emit(f"impl Node for ast::located::{rust_name} {{", depth)
         self.emit(
@@ -1644,11 +1765,6 @@ class StdlibTraitImplVisitor(EmitVisitor):
     def visitConstructor(self, cons, sum, sum_rust_name, depth):
         rust_name = rust_type_name(cons.name)
         self.emit("// constructor", depth)
-        self.emit(
-            f"impl NamedNode for ast::located::{sum_rust_name}{rust_name} {{", depth
-        )
-        self.emit(f"const NAME: &'static str = {json.dumps(cons.name)};", depth + 1)
-        self.emit("}", depth)
         self.emit(f"impl Node for ast::located::{sum_rust_name}{rust_name} {{", depth)
 
         fields_pattern = self.make_pattern(cons.fields)
@@ -1677,12 +1793,10 @@ class StdlibTraitImplVisitor(EmitVisitor):
         self.emit("}", depth + 1)
 
     def visitProduct(self, product, name, depth):
-        struct_name = rust_type_name(name)
+        info = self.type_info[name]
+        struct_name = info.full_type_name
 
         self.emit("// product", depth)
-        self.emit(f"impl NamedNode for ast::located::{struct_name} {{", depth)
-        self.emit(f"const NAME: &'static str = {json.dumps(name)};", depth + 1)
-        self.emit("}", depth)
         self.emit(f"impl Node for ast::located::{struct_name} {{", depth)
         self.emit(
             "fn ast_to_object(self, _vm: &VirtualMachine) -> PyObjectRef {", depth + 1
@@ -1826,8 +1940,7 @@ def write_located_def(mod, type_info, f):
 
 
 def write_pyo3_node(type_info, f):
-    def write(info: TypeInfo):
-        rust_name = info.rust_sum_name
+    def write(info: TypeInfo, rust_name: str):
         if info.is_simple:
             generics = ""
         else:
@@ -1845,8 +1958,14 @@ def write_pyo3_node(type_info, f):
             """,
         )
 
-    for info in type_info.values():
-        write(info)
+    for type_name, info in type_info.items():
+        rust_name = info.full_type_name
+        if info.is_custom:
+            if type_name != info.type.name:
+                rust_name = "Python" + rust_name
+            else:
+                continue
+        write(info, rust_name)
 
 
 def write_to_pyo3(mod, type_info, f):
@@ -1864,7 +1983,9 @@ def write_to_pyo3(mod, type_info, f):
     )
 
     for info in type_info.values():
-        rust_name = info.rust_sum_name
+        if info.is_custom:
+            continue
+        rust_name = info.full_type_name
         f.write(f"cache_py_type::<ast::{rust_name}>(ast_module)?;\n")
     f.write("Ok(())\n}")
 
@@ -1876,7 +1997,7 @@ def write_to_pyo3_simple(type_info, f):
         if not type_info.is_simple:
             continue
 
-        rust_name = type_info.rust_sum_name
+        rust_name = type_info.full_type_name
         f.write(
             f"""
             impl ToPyAst for ast::{rust_name} {{
@@ -1903,20 +2024,21 @@ def write_pyo3_wrapper(mod, type_info, namespace, f):
     Pyo3StructVisitor(namespace, f, type_info).visit(mod)
 
     if namespace == "located":
-        for type_info in type_info.values():
-            if not type_info.is_simple or not type_info.is_sum:
+        for info in type_info.values():
+            if not info.is_simple or not info.is_sum:
                 continue
 
-            rust_name = type_info.rust_sum_name
+            rust_name = info.full_type_name
+            inner_name = type_info[info.custom.name].full_type_name
             f.write(
                 f"""
-                impl ToPyWrapper for ast::{rust_name} {{
+                impl ToPyWrapper for ast::{inner_name} {{
                     #[inline]
                     fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {{
                         match &self {{
                 """,
             )
-            for cons in type_info.type.value.types:
+            for cons in info.type.value.types:
                 f.write(
                     f"Self::{cons.name} => Ok({rust_name}{cons.name}.to_object(py)),",
                 )
@@ -1928,7 +2050,7 @@ def write_pyo3_wrapper(mod, type_info, namespace, f):
                 """,
             )
 
-            for cons in type_info.type.value.types:
+            for cons in info.type.value.types:
                 f.write(
                     f"""
                     impl ToPyWrapper for ast::{rust_name}{cons.name} {{
@@ -1960,7 +2082,7 @@ def write_parse_def(mod, type_info, f):
         cons_name = rust_type_name(info.name)
 
         f.write(f"""
-        impl Parse for ast::{info.rust_sum_name} {{
+        impl Parse for ast::{info.full_type_name} {{
             fn lex_starts_at(
                 source: &str,
                 offset: TextSize,

ast/src/gen/fold.rs

@@ -507,6 +507,12 @@ pub trait Fold<U> {
     ) -> Result<TypeIgnoreTypeIgnore<Self::TargetU>, Self::Error> {
         fold_type_ignore_type_ignore(self, node)
     }
+    fn fold_arg_with_default(
+        &mut self,
+        node: ArgWithDefault<U>,
+    ) -> Result<ArgWithDefault<Self::TargetU>, Self::Error> {
+        fold_arg_with_default(self, node)
+    }
 }
 impl<T, U> Foldable<T, U> for Mod<T> {
     type Mapped = Mod<U>;
@@ -2368,9 +2374,7 @@ pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
         args,
         vararg,
         kwonlyargs,
-        kw_defaults,
         kwarg,
-        defaults,
         range,
     } = node;
     let context = folder.will_map_user_cfg(&range);
@@ -2378,18 +2382,14 @@ pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
     let args = Foldable::fold(args, folder)?;
     let vararg = Foldable::fold(vararg, folder)?;
     let kwonlyargs = Foldable::fold(kwonlyargs, folder)?;
-    let kw_defaults = Foldable::fold(kw_defaults, folder)?;
     let kwarg = Foldable::fold(kwarg, folder)?;
-    let defaults = Foldable::fold(defaults, folder)?;
     let range = folder.map_user_cfg(range, context)?;
     Ok(Arguments {
         posonlyargs,
         args,
         vararg,
         kwonlyargs,
-        kw_defaults,
         kwarg,
-        defaults,
         range,
     })
 }
@@ -2791,3 +2791,31 @@ pub fn fold_type_ignore_type_ignore<U, F: Fold<U> + ?Sized>(
     let range = folder.map_user_cfg(range, context)?;
     Ok(TypeIgnoreTypeIgnore { lineno, tag, range })
 }
+impl<T, U> Foldable<T, U> for ArgWithDefault<T> {
+    type Mapped = ArgWithDefault<U>;
+    fn fold<F: Fold<T, TargetU = U> + ?Sized>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self::Mapped, F::Error> {
+        folder.fold_arg_with_default(self)
+    }
+}
+pub fn fold_arg_with_default<U, F: Fold<U> + ?Sized>(
+    #[allow(unused)] folder: &mut F,
+    node: ArgWithDefault<U>,
+) -> Result<ArgWithDefault<F::TargetU>, F::Error> {
+    let ArgWithDefault {
+        def,
+        default,
+        range,
+    } = node;
+    let context = folder.will_map_user_cfg(&range);
+    let def = Foldable::fold(def, folder)?;
+    let default = Foldable::fold(default, folder)?;
+    let range = folder.map_user_cfg(range, context)?;
+    Ok(ArgWithDefault {
+        def,
+        default,
+        range,
+    })
+}

ast/src/gen/generic.rs

@@ -2679,7 +2679,7 @@ impl<R> Node for Excepthandler<R> {
 }
 
 #[derive(Clone, Debug, PartialEq)]
-pub struct Arguments<R = TextRange> {
+pub struct PythonArguments<R = TextRange> {
     pub range: OptionalRange<R>,
     pub posonlyargs: Vec<Arg<R>>,
     pub args: Vec<Arg<R>>,
@@ -2690,7 +2690,7 @@ pub struct Arguments<R = TextRange> {
     pub defaults: Vec<Expr<R>>,
 }
 
-impl<R> Node for Arguments<R> {
+impl<R> Node for PythonArguments<R> {
     const NAME: &'static str = "arguments";
     const FIELD_NAMES: &'static [&'static str] = &[
         "posonlyargs",
@@ -2987,3 +2987,46 @@ impl<R> Node for TypeIgnore<R> {
     const NAME: &'static str = "type_ignore";
     const FIELD_NAMES: &'static [&'static str] = &[];
 }
+
+/// An alternative type of AST `arguments`. This is parser-friendly and human-friendly definition of function arguments.
+/// This form also has advantage to implement pre-order traverse.
+/// `defaults` and `kw_defaults` fields are removed and the default values are placed under each `arg_with_default` typed argument.
+/// `vararg` and `kwarg` are still typed as `arg` because they never can have a default value.
+///
+/// The matching Python style AST type is [PythonArguments]. While [PythonArguments] has ordered `kwonlyargs` fields by
+/// default existence, [Arguments] has location-ordered kwonlyargs fields.
+///
+/// NOTE: This type is different from original Python AST.
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Arguments<R = TextRange> {
+    pub range: OptionalRange<R>,
+    pub posonlyargs: Vec<ArgWithDefault<R>>,
+    pub args: Vec<ArgWithDefault<R>>,
+    pub vararg: Option<Box<Arg<R>>>,
+    pub kwonlyargs: Vec<ArgWithDefault<R>>,
+    pub kwarg: Option<Box<Arg<R>>>,
+}
+
+impl<R> Node for Arguments<R> {
+    const NAME: &'static str = "alt:arguments";
+    const FIELD_NAMES: &'static [&'static str] =
+        &["posonlyargs", "args", "vararg", "kwonlyargs", "kwarg"];
+}
+
+/// An alternative type of AST `arg`. This is used for each function argument that might have a default value.
+/// Used by `Arguments` original type.
+///
+/// NOTE: This type is different from original Python AST.
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ArgWithDefault<R = TextRange> {
+    pub range: OptionalRange<R>,
+    pub def: Arg<R>,
+    pub default: Option<Box<Expr<R>>>,
+}
+
+impl<R> Node for ArgWithDefault<R> {
+    const NAME: &'static str = "arg_with_default";
+    const FIELD_NAMES: &'static [&'static str] = &["def", "default"];
+}

ast/src/gen/located.rs

@@ -660,11 +660,11 @@ impl Located for Excepthandler {
     }
 }
 
-pub type Arguments = crate::generic::Arguments<SourceRange>;
+pub type PythonArguments = crate::generic::PythonArguments<SourceRange>;
 
 #[cfg(feature = "all-nodes-with-ranges")]
 
-impl Located for Arguments {
+impl Located for PythonArguments {
     fn range(&self) -> SourceRange {
         self.range
     }
@@ -815,3 +815,23 @@ impl Located for TypeIgnore {
         }
     }
 }
+
+pub type Arguments = crate::generic::Arguments<SourceRange>;
+
+#[cfg(feature = "all-nodes-with-ranges")]
+
+impl Located for Arguments {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+
+pub type ArgWithDefault = crate::generic::ArgWithDefault<SourceRange>;
+
+#[cfg(feature = "all-nodes-with-ranges")]
+
+impl Located for ArgWithDefault {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}

ast/src/gen/ranged.rs

@@ -394,7 +394,7 @@ impl Ranged for crate::Excepthandler {
 }
 
 #[cfg(feature = "all-nodes-with-ranges")]
-impl Ranged for crate::generic::Arguments<TextRange> {
+impl Ranged for crate::generic::PythonArguments<TextRange> {
     fn range(&self) -> TextRange {
         self.range
     }
@@ -495,3 +495,16 @@ impl Ranged for crate::TypeIgnore {
         }
     }
 }
+
+#[cfg(feature = "all-nodes-with-ranges")]
+impl Ranged for crate::generic::Arguments<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+#[cfg(feature = "all-nodes-with-ranges")]
+impl Ranged for crate::generic::ArgWithDefault<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}

ast/src/gen/visitor.rs

@@ -1,45 +1,45 @@
 // File automatically generated by ast/asdl_rs.py.
 
-#[allow(unused_variables, non_snake_case)]
+#[allow(unused_variables)]
 pub trait Visitor<R = crate::text_size::TextRange> {
     fn visit_stmt(&mut self, node: Stmt<R>) {
         self.generic_visit_stmt(node)
     }
     fn generic_visit_stmt(&mut self, node: Stmt<R>) {
         match node {
-            Stmt::FunctionDef(data) => self.visit_stmt_FunctionDef(data),
-            Stmt::AsyncFunctionDef(data) => self.visit_stmt_AsyncFunctionDef(data),
-            Stmt::ClassDef(data) => self.visit_stmt_ClassDef(data),
-            Stmt::Return(data) => self.visit_stmt_Return(data),
-            Stmt::Delete(data) => self.visit_stmt_Delete(data),
-            Stmt::Assign(data) => self.visit_stmt_Assign(data),
-            Stmt::AugAssign(data) => self.visit_stmt_AugAssign(data),
-            Stmt::AnnAssign(data) => self.visit_stmt_AnnAssign(data),
-            Stmt::For(data) => self.visit_stmt_For(data),
-            Stmt::AsyncFor(data) => self.visit_stmt_AsyncFor(data),
-            Stmt::While(data) => self.visit_stmt_While(data),
-            Stmt::If(data) => self.visit_stmt_If(data),
-            Stmt::With(data) => self.visit_stmt_With(data),
-            Stmt::AsyncWith(data) => self.visit_stmt_AsyncWith(data),
-            Stmt::Match(data) => self.visit_stmt_Match(data),
-            Stmt::Raise(data) => self.visit_stmt_Raise(data),
-            Stmt::Try(data) => self.visit_stmt_Try(data),
-            Stmt::TryStar(data) => self.visit_stmt_TryStar(data),
-            Stmt::Assert(data) => self.visit_stmt_Assert(data),
-            Stmt::Import(data) => self.visit_stmt_Import(data),
-            Stmt::ImportFrom(data) => self.visit_stmt_ImportFrom(data),
-            Stmt::Global(data) => self.visit_stmt_Global(data),
-            Stmt::Nonlocal(data) => self.visit_stmt_Nonlocal(data),
-            Stmt::Expr(data) => self.visit_stmt_Expr(data),
-            Stmt::Pass(data) => self.visit_stmt_Pass(data),
-            Stmt::Break(data) => self.visit_stmt_Break(data),
-            Stmt::Continue(data) => self.visit_stmt_Continue(data),
+            Stmt::FunctionDef(data) => self.visit_stmt_function_def(data),
+            Stmt::AsyncFunctionDef(data) => self.visit_stmt_async_function_def(data),
+            Stmt::ClassDef(data) => self.visit_stmt_class_def(data),
+            Stmt::Return(data) => self.visit_stmt_return(data),
+            Stmt::Delete(data) => self.visit_stmt_delete(data),
+            Stmt::Assign(data) => self.visit_stmt_assign(data),
+            Stmt::AugAssign(data) => self.visit_stmt_aug_assign(data),
+            Stmt::AnnAssign(data) => self.visit_stmt_ann_assign(data),
+            Stmt::For(data) => self.visit_stmt_for(data),
+            Stmt::AsyncFor(data) => self.visit_stmt_async_for(data),
+            Stmt::While(data) => self.visit_stmt_while(data),
+            Stmt::If(data) => self.visit_stmt_if(data),
+            Stmt::With(data) => self.visit_stmt_with(data),
+            Stmt::AsyncWith(data) => self.visit_stmt_async_with(data),
+            Stmt::Match(data) => self.visit_stmt_match(data),
+            Stmt::Raise(data) => self.visit_stmt_raise(data),
+            Stmt::Try(data) => self.visit_stmt_try(data),
+            Stmt::TryStar(data) => self.visit_stmt_try_star(data),
+            Stmt::Assert(data) => self.visit_stmt_assert(data),
+            Stmt::Import(data) => self.visit_stmt_import(data),
+            Stmt::ImportFrom(data) => self.visit_stmt_import_from(data),
+            Stmt::Global(data) => self.visit_stmt_global(data),
+            Stmt::Nonlocal(data) => self.visit_stmt_nonlocal(data),
+            Stmt::Expr(data) => self.visit_stmt_expr(data),
+            Stmt::Pass(data) => self.visit_stmt_pass(data),
+            Stmt::Break(data) => self.visit_stmt_break(data),
+            Stmt::Continue(data) => self.visit_stmt_continue(data),
         }
     }
-    fn visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef<R>) {
-        self.generic_visit_stmt_FunctionDef(node)
+    fn visit_stmt_function_def(&mut self, node: StmtFunctionDef<R>) {
+        self.generic_visit_stmt_function_def(node)
     }
-    fn generic_visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef<R>) {
+    fn generic_visit_stmt_function_def(&mut self, node: StmtFunctionDef<R>) {
         {
             let value = node.args;
             self.visit_arguments(*value);
@@ -54,10 +54,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_AsyncFunctionDef(&mut self, node: StmtAsyncFunctionDef<R>) {
-        self.generic_visit_stmt_AsyncFunctionDef(node)
+    fn visit_stmt_async_function_def(&mut self, node: StmtAsyncFunctionDef<R>) {
+        self.generic_visit_stmt_async_function_def(node)
     }
-    fn generic_visit_stmt_AsyncFunctionDef(&mut self, node: StmtAsyncFunctionDef<R>) {
+    fn generic_visit_stmt_async_function_def(&mut self, node: StmtAsyncFunctionDef<R>) {
         {
             let value = node.args;
             self.visit_arguments(*value);
@@ -72,10 +72,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_ClassDef(&mut self, node: StmtClassDef<R>) {
-        self.generic_visit_stmt_ClassDef(node)
+    fn visit_stmt_class_def(&mut self, node: StmtClassDef<R>) {
+        self.generic_visit_stmt_class_def(node)
     }
-    fn generic_visit_stmt_ClassDef(&mut self, node: StmtClassDef<R>) {
+    fn generic_visit_stmt_class_def(&mut self, node: StmtClassDef<R>) {
         for value in node.bases {
             self.visit_expr(value);
         }
@@ -89,26 +89,26 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(value);
         }
     }
-    fn visit_stmt_Return(&mut self, node: StmtReturn<R>) {
-        self.generic_visit_stmt_Return(node)
+    fn visit_stmt_return(&mut self, node: StmtReturn<R>) {
+        self.generic_visit_stmt_return(node)
     }
-    fn generic_visit_stmt_Return(&mut self, node: StmtReturn<R>) {
+    fn generic_visit_stmt_return(&mut self, node: StmtReturn<R>) {
         if let Some(value) = node.value {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_Delete(&mut self, node: StmtDelete<R>) {
-        self.generic_visit_stmt_Delete(node)
+    fn visit_stmt_delete(&mut self, node: StmtDelete<R>) {
+        self.generic_visit_stmt_delete(node)
     }
-    fn generic_visit_stmt_Delete(&mut self, node: StmtDelete<R>) {
+    fn generic_visit_stmt_delete(&mut self, node: StmtDelete<R>) {
         for value in node.targets {
             self.visit_expr(value);
         }
     }
-    fn visit_stmt_Assign(&mut self, node: StmtAssign<R>) {
-        self.generic_visit_stmt_Assign(node)
+    fn visit_stmt_assign(&mut self, node: StmtAssign<R>) {
+        self.generic_visit_stmt_assign(node)
     }
-    fn generic_visit_stmt_Assign(&mut self, node: StmtAssign<R>) {
+    fn generic_visit_stmt_assign(&mut self, node: StmtAssign<R>) {
         for value in node.targets {
             self.visit_expr(value);
         }
@@ -117,10 +117,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_AugAssign(&mut self, node: StmtAugAssign<R>) {
-        self.generic_visit_stmt_AugAssign(node)
+    fn visit_stmt_aug_assign(&mut self, node: StmtAugAssign<R>) {
+        self.generic_visit_stmt_aug_assign(node)
     }
-    fn generic_visit_stmt_AugAssign(&mut self, node: StmtAugAssign<R>) {
+    fn generic_visit_stmt_aug_assign(&mut self, node: StmtAugAssign<R>) {
         {
             let value = node.target;
             self.visit_expr(*value);
@@ -130,10 +130,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_AnnAssign(&mut self, node: StmtAnnAssign<R>) {
-        self.generic_visit_stmt_AnnAssign(node)
+    fn visit_stmt_ann_assign(&mut self, node: StmtAnnAssign<R>) {
+        self.generic_visit_stmt_ann_assign(node)
     }
-    fn generic_visit_stmt_AnnAssign(&mut self, node: StmtAnnAssign<R>) {
+    fn generic_visit_stmt_ann_assign(&mut self, node: StmtAnnAssign<R>) {
         {
             let value = node.target;
             self.visit_expr(*value);
@@ -146,10 +146,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_For(&mut self, node: StmtFor<R>) {
-        self.generic_visit_stmt_For(node)
+    fn visit_stmt_for(&mut self, node: StmtFor<R>) {
+        self.generic_visit_stmt_for(node)
     }
-    fn generic_visit_stmt_For(&mut self, node: StmtFor<R>) {
+    fn generic_visit_stmt_for(&mut self, node: StmtFor<R>) {
         {
             let value = node.target;
             self.visit_expr(*value);
@@ -165,10 +165,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_AsyncFor(&mut self, node: StmtAsyncFor<R>) {
-        self.generic_visit_stmt_AsyncFor(node)
+    fn visit_stmt_async_for(&mut self, node: StmtAsyncFor<R>) {
+        self.generic_visit_stmt_async_for(node)
     }
-    fn generic_visit_stmt_AsyncFor(&mut self, node: StmtAsyncFor<R>) {
+    fn generic_visit_stmt_async_for(&mut self, node: StmtAsyncFor<R>) {
         {
             let value = node.target;
             self.visit_expr(*value);
@@ -184,10 +184,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_While(&mut self, node: StmtWhile<R>) {
-        self.generic_visit_stmt_While(node)
+    fn visit_stmt_while(&mut self, node: StmtWhile<R>) {
+        self.generic_visit_stmt_while(node)
     }
-    fn generic_visit_stmt_While(&mut self, node: StmtWhile<R>) {
+    fn generic_visit_stmt_while(&mut self, node: StmtWhile<R>) {
         {
             let value = node.test;
             self.visit_expr(*value);
@@ -199,10 +199,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_If(&mut self, node: StmtIf<R>) {
-        self.generic_visit_stmt_If(node)
+    fn visit_stmt_if(&mut self, node: StmtIf<R>) {
+        self.generic_visit_stmt_if(node)
     }
-    fn generic_visit_stmt_If(&mut self, node: StmtIf<R>) {
+    fn generic_visit_stmt_if(&mut self, node: StmtIf<R>) {
         {
             let value = node.test;
             self.visit_expr(*value);
@@ -214,10 +214,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_With(&mut self, node: StmtWith<R>) {
-        self.generic_visit_stmt_With(node)
+    fn visit_stmt_with(&mut self, node: StmtWith<R>) {
+        self.generic_visit_stmt_with(node)
     }
-    fn generic_visit_stmt_With(&mut self, node: StmtWith<R>) {
+    fn generic_visit_stmt_with(&mut self, node: StmtWith<R>) {
         for value in node.items {
             self.visit_withitem(value);
         }
@@ -225,10 +225,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_AsyncWith(&mut self, node: StmtAsyncWith<R>) {
-        self.generic_visit_stmt_AsyncWith(node)
+    fn visit_stmt_async_with(&mut self, node: StmtAsyncWith<R>) {
+        self.generic_visit_stmt_async_with(node)
     }
-    fn generic_visit_stmt_AsyncWith(&mut self, node: StmtAsyncWith<R>) {
+    fn generic_visit_stmt_async_with(&mut self, node: StmtAsyncWith<R>) {
         for value in node.items {
             self.visit_withitem(value);
         }
@@ -236,10 +236,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_Match(&mut self, node: StmtMatch<R>) {
-        self.generic_visit_stmt_Match(node)
+    fn visit_stmt_match(&mut self, node: StmtMatch<R>) {
+        self.generic_visit_stmt_match(node)
     }
-    fn generic_visit_stmt_Match(&mut self, node: StmtMatch<R>) {
+    fn generic_visit_stmt_match(&mut self, node: StmtMatch<R>) {
         {
             let value = node.subject;
             self.visit_expr(*value);
@@ -248,10 +248,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_match_case(value);
         }
     }
-    fn visit_stmt_Raise(&mut self, node: StmtRaise<R>) {
-        self.generic_visit_stmt_Raise(node)
+    fn visit_stmt_raise(&mut self, node: StmtRaise<R>) {
+        self.generic_visit_stmt_raise(node)
     }
-    fn generic_visit_stmt_Raise(&mut self, node: StmtRaise<R>) {
+    fn generic_visit_stmt_raise(&mut self, node: StmtRaise<R>) {
         if let Some(value) = node.exc {
             self.visit_expr(*value);
         }
@@ -259,10 +259,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_Try(&mut self, node: StmtTry<R>) {
-        self.generic_visit_stmt_Try(node)
+    fn visit_stmt_try(&mut self, node: StmtTry<R>) {
+        self.generic_visit_stmt_try(node)
     }
-    fn generic_visit_stmt_Try(&mut self, node: StmtTry<R>) {
+    fn generic_visit_stmt_try(&mut self, node: StmtTry<R>) {
         for value in node.body {
             self.visit_stmt(value);
         }
@@ -276,10 +276,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_TryStar(&mut self, node: StmtTryStar<R>) {
-        self.generic_visit_stmt_TryStar(node)
+    fn visit_stmt_try_star(&mut self, node: StmtTryStar<R>) {
+        self.generic_visit_stmt_try_star(node)
     }
-    fn generic_visit_stmt_TryStar(&mut self, node: StmtTryStar<R>) {
+    fn generic_visit_stmt_try_star(&mut self, node: StmtTryStar<R>) {
         for value in node.body {
             self.visit_stmt(value);
         }
@@ -293,10 +293,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_stmt(value);
         }
     }
-    fn visit_stmt_Assert(&mut self, node: StmtAssert<R>) {
-        self.generic_visit_stmt_Assert(node)
+    fn visit_stmt_assert(&mut self, node: StmtAssert<R>) {
+        self.generic_visit_stmt_assert(node)
     }
-    fn generic_visit_stmt_Assert(&mut self, node: StmtAssert<R>) {
+    fn generic_visit_stmt_assert(&mut self, node: StmtAssert<R>) {
         {
             let value = node.test;
             self.visit_expr(*value);
@@ -305,88 +305,88 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_Import(&mut self, node: StmtImport<R>) {
-        self.generic_visit_stmt_Import(node)
+    fn visit_stmt_import(&mut self, node: StmtImport<R>) {
+        self.generic_visit_stmt_import(node)
     }
-    fn generic_visit_stmt_Import(&mut self, node: StmtImport<R>) {
+    fn generic_visit_stmt_import(&mut self, node: StmtImport<R>) {
         for value in node.names {
             self.visit_alias(value);
         }
     }
-    fn visit_stmt_ImportFrom(&mut self, node: StmtImportFrom<R>) {
-        self.generic_visit_stmt_ImportFrom(node)
+    fn visit_stmt_import_from(&mut self, node: StmtImportFrom<R>) {
+        self.generic_visit_stmt_import_from(node)
     }
-    fn generic_visit_stmt_ImportFrom(&mut self, node: StmtImportFrom<R>) {
+    fn generic_visit_stmt_import_from(&mut self, node: StmtImportFrom<R>) {
         for value in node.names {
             self.visit_alias(value);
         }
     }
-    fn visit_stmt_Global(&mut self, node: StmtGlobal<R>) {
-        self.generic_visit_stmt_Global(node)
+    fn visit_stmt_global(&mut self, node: StmtGlobal<R>) {
+        self.generic_visit_stmt_global(node)
     }
-    fn generic_visit_stmt_Global(&mut self, node: StmtGlobal<R>) {}
-    fn visit_stmt_Nonlocal(&mut self, node: StmtNonlocal<R>) {
-        self.generic_visit_stmt_Nonlocal(node)
+    fn generic_visit_stmt_global(&mut self, node: StmtGlobal<R>) {}
+    fn visit_stmt_nonlocal(&mut self, node: StmtNonlocal<R>) {
+        self.generic_visit_stmt_nonlocal(node)
     }
-    fn generic_visit_stmt_Nonlocal(&mut self, node: StmtNonlocal<R>) {}
-    fn visit_stmt_Expr(&mut self, node: StmtExpr<R>) {
-        self.generic_visit_stmt_Expr(node)
+    fn generic_visit_stmt_nonlocal(&mut self, node: StmtNonlocal<R>) {}
+    fn visit_stmt_expr(&mut self, node: StmtExpr<R>) {
+        self.generic_visit_stmt_expr(node)
     }
-    fn generic_visit_stmt_Expr(&mut self, node: StmtExpr<R>) {
+    fn generic_visit_stmt_expr(&mut self, node: StmtExpr<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
         }
     }
-    fn visit_stmt_Pass(&mut self, node: StmtPass<R>) {}
-    fn visit_stmt_Break(&mut self, node: StmtBreak<R>) {}
-    fn visit_stmt_Continue(&mut self, node: StmtContinue<R>) {}
+    fn visit_stmt_pass(&mut self, node: StmtPass<R>) {}
+    fn visit_stmt_break(&mut self, node: StmtBreak<R>) {}
+    fn visit_stmt_continue(&mut self, node: StmtContinue<R>) {}
     fn visit_expr(&mut self, node: Expr<R>) {
         self.generic_visit_expr(node)
     }
     fn generic_visit_expr(&mut self, node: Expr<R>) {
         match node {
-            Expr::BoolOp(data) => self.visit_expr_BoolOp(data),
-            Expr::NamedExpr(data) => self.visit_expr_NamedExpr(data),
-            Expr::BinOp(data) => self.visit_expr_BinOp(data),
-            Expr::UnaryOp(data) => self.visit_expr_UnaryOp(data),
-            Expr::Lambda(data) => self.visit_expr_Lambda(data),
-            Expr::IfExp(data) => self.visit_expr_IfExp(data),
-            Expr::Dict(data) => self.visit_expr_Dict(data),
-            Expr::Set(data) => self.visit_expr_Set(data),
-            Expr::ListComp(data) => self.visit_expr_ListComp(data),
-            Expr::SetComp(data) => self.visit_expr_SetComp(data),
-            Expr::DictComp(data) => self.visit_expr_DictComp(data),
-            Expr::GeneratorExp(data) => self.visit_expr_GeneratorExp(data),
-            Expr::Await(data) => self.visit_expr_Await(data),
-            Expr::Yield(data) => self.visit_expr_Yield(data),
-            Expr::YieldFrom(data) => self.visit_expr_YieldFrom(data),
-            Expr::Compare(data) => self.visit_expr_Compare(data),
-            Expr::Call(data) => self.visit_expr_Call(data),
-            Expr::FormattedValue(data) => self.visit_expr_FormattedValue(data),
-            Expr::JoinedStr(data) => self.visit_expr_JoinedStr(data),
-            Expr::Constant(data) => self.visit_expr_Constant(data),
-            Expr::Attribute(data) => self.visit_expr_Attribute(data),
-            Expr::Subscript(data) => self.visit_expr_Subscript(data),
-            Expr::Starred(data) => self.visit_expr_Starred(data),
-            Expr::Name(data) => self.visit_expr_Name(data),
-            Expr::List(data) => self.visit_expr_List(data),
-            Expr::Tuple(data) => self.visit_expr_Tuple(data),
-            Expr::Slice(data) => self.visit_expr_Slice(data),
+            Expr::BoolOp(data) => self.visit_expr_bool_op(data),
+            Expr::NamedExpr(data) => self.visit_expr_named_expr(data),
+            Expr::BinOp(data) => self.visit_expr_bin_op(data),
+            Expr::UnaryOp(data) => self.visit_expr_unary_op(data),
+            Expr::Lambda(data) => self.visit_expr_lambda(data),
+            Expr::IfExp(data) => self.visit_expr_if_exp(data),
+            Expr::Dict(data) => self.visit_expr_dict(data),
+            Expr::Set(data) => self.visit_expr_set(data),
+            Expr::ListComp(data) => self.visit_expr_list_comp(data),
+            Expr::SetComp(data) => self.visit_expr_set_comp(data),
+            Expr::DictComp(data) => self.visit_expr_dict_comp(data),
+            Expr::GeneratorExp(data) => self.visit_expr_generator_exp(data),
+            Expr::Await(data) => self.visit_expr_await(data),
+            Expr::Yield(data) => self.visit_expr_yield(data),
+            Expr::YieldFrom(data) => self.visit_expr_yield_from(data),
+            Expr::Compare(data) => self.visit_expr_compare(data),
+            Expr::Call(data) => self.visit_expr_call(data),
+            Expr::FormattedValue(data) => self.visit_expr_formatted_value(data),
+            Expr::JoinedStr(data) => self.visit_expr_joined_str(data),
+            Expr::Constant(data) => self.visit_expr_constant(data),
+            Expr::Attribute(data) => self.visit_expr_attribute(data),
+            Expr::Subscript(data) => self.visit_expr_subscript(data),
+            Expr::Starred(data) => self.visit_expr_starred(data),
+            Expr::Name(data) => self.visit_expr_name(data),
+            Expr::List(data) => self.visit_expr_list(data),
+            Expr::Tuple(data) => self.visit_expr_tuple(data),
+            Expr::Slice(data) => self.visit_expr_slice(data),
         }
     }
-    fn visit_expr_BoolOp(&mut self, node: ExprBoolOp<R>) {
-        self.generic_visit_expr_BoolOp(node)
+    fn visit_expr_bool_op(&mut self, node: ExprBoolOp<R>) {
+        self.generic_visit_expr_bool_op(node)
     }
-    fn generic_visit_expr_BoolOp(&mut self, node: ExprBoolOp<R>) {
+    fn generic_visit_expr_bool_op(&mut self, node: ExprBoolOp<R>) {
         for value in node.values {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_NamedExpr(&mut self, node: ExprNamedExpr<R>) {
-        self.generic_visit_expr_NamedExpr(node)
+    fn visit_expr_named_expr(&mut self, node: ExprNamedExpr<R>) {
+        self.generic_visit_expr_named_expr(node)
     }
-    fn generic_visit_expr_NamedExpr(&mut self, node: ExprNamedExpr<R>) {
+    fn generic_visit_expr_named_expr(&mut self, node: ExprNamedExpr<R>) {
         {
             let value = node.target;
             self.visit_expr(*value);
@@ -396,10 +396,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_BinOp(&mut self, node: ExprBinOp<R>) {
-        self.generic_visit_expr_BinOp(node)
+    fn visit_expr_bin_op(&mut self, node: ExprBinOp<R>) {
+        self.generic_visit_expr_bin_op(node)
     }
-    fn generic_visit_expr_BinOp(&mut self, node: ExprBinOp<R>) {
+    fn generic_visit_expr_bin_op(&mut self, node: ExprBinOp<R>) {
         {
             let value = node.left;
             self.visit_expr(*value);
@@ -409,19 +409,19 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_UnaryOp(&mut self, node: ExprUnaryOp<R>) {
-        self.generic_visit_expr_UnaryOp(node)
+    fn visit_expr_unary_op(&mut self, node: ExprUnaryOp<R>) {
+        self.generic_visit_expr_unary_op(node)
     }
-    fn generic_visit_expr_UnaryOp(&mut self, node: ExprUnaryOp<R>) {
+    fn generic_visit_expr_unary_op(&mut self, node: ExprUnaryOp<R>) {
         {
             let value = node.operand;
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Lambda(&mut self, node: ExprLambda<R>) {
-        self.generic_visit_expr_Lambda(node)
+    fn visit_expr_lambda(&mut self, node: ExprLambda<R>) {
+        self.generic_visit_expr_lambda(node)
     }
-    fn generic_visit_expr_Lambda(&mut self, node: ExprLambda<R>) {
+    fn generic_visit_expr_lambda(&mut self, node: ExprLambda<R>) {
         {
             let value = node.args;
             self.visit_arguments(*value);
@@ -431,10 +431,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_IfExp(&mut self, node: ExprIfExp<R>) {
-        self.generic_visit_expr_IfExp(node)
+    fn visit_expr_if_exp(&mut self, node: ExprIfExp<R>) {
+        self.generic_visit_expr_if_exp(node)
     }
-    fn generic_visit_expr_IfExp(&mut self, node: ExprIfExp<R>) {
+    fn generic_visit_expr_if_exp(&mut self, node: ExprIfExp<R>) {
         {
             let value = node.test;
             self.visit_expr(*value);
@@ -448,10 +448,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Dict(&mut self, node: ExprDict<R>) {
-        self.generic_visit_expr_Dict(node)
+    fn visit_expr_dict(&mut self, node: ExprDict<R>) {
+        self.generic_visit_expr_dict(node)
     }
-    fn generic_visit_expr_Dict(&mut self, node: ExprDict<R>) {
+    fn generic_visit_expr_dict(&mut self, node: ExprDict<R>) {
         for value in node.keys.into_iter().flatten() {
             self.visit_expr(value);
         }
@@ -459,18 +459,18 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_Set(&mut self, node: ExprSet<R>) {
-        self.generic_visit_expr_Set(node)
+    fn visit_expr_set(&mut self, node: ExprSet<R>) {
+        self.generic_visit_expr_set(node)
     }
-    fn generic_visit_expr_Set(&mut self, node: ExprSet<R>) {
+    fn generic_visit_expr_set(&mut self, node: ExprSet<R>) {
         for value in node.elts {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_ListComp(&mut self, node: ExprListComp<R>) {
-        self.generic_visit_expr_ListComp(node)
+    fn visit_expr_list_comp(&mut self, node: ExprListComp<R>) {
+        self.generic_visit_expr_list_comp(node)
     }
-    fn generic_visit_expr_ListComp(&mut self, node: ExprListComp<R>) {
+    fn generic_visit_expr_list_comp(&mut self, node: ExprListComp<R>) {
         {
             let value = node.elt;
             self.visit_expr(*value);
@@ -479,10 +479,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_comprehension(value);
         }
     }
-    fn visit_expr_SetComp(&mut self, node: ExprSetComp<R>) {
-        self.generic_visit_expr_SetComp(node)
+    fn visit_expr_set_comp(&mut self, node: ExprSetComp<R>) {
+        self.generic_visit_expr_set_comp(node)
     }
-    fn generic_visit_expr_SetComp(&mut self, node: ExprSetComp<R>) {
+    fn generic_visit_expr_set_comp(&mut self, node: ExprSetComp<R>) {
         {
             let value = node.elt;
             self.visit_expr(*value);
@@ -491,10 +491,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_comprehension(value);
         }
     }
-    fn visit_expr_DictComp(&mut self, node: ExprDictComp<R>) {
-        self.generic_visit_expr_DictComp(node)
+    fn visit_expr_dict_comp(&mut self, node: ExprDictComp<R>) {
+        self.generic_visit_expr_dict_comp(node)
     }
-    fn generic_visit_expr_DictComp(&mut self, node: ExprDictComp<R>) {
+    fn generic_visit_expr_dict_comp(&mut self, node: ExprDictComp<R>) {
         {
             let value = node.key;
             self.visit_expr(*value);
@@ -507,10 +507,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_comprehension(value);
         }
     }
-    fn visit_expr_GeneratorExp(&mut self, node: ExprGeneratorExp<R>) {
-        self.generic_visit_expr_GeneratorExp(node)
+    fn visit_expr_generator_exp(&mut self, node: ExprGeneratorExp<R>) {
+        self.generic_visit_expr_generator_exp(node)
     }
-    fn generic_visit_expr_GeneratorExp(&mut self, node: ExprGeneratorExp<R>) {
+    fn generic_visit_expr_generator_exp(&mut self, node: ExprGeneratorExp<R>) {
         {
             let value = node.elt;
             self.visit_expr(*value);
@@ -519,36 +519,36 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_comprehension(value);
         }
     }
-    fn visit_expr_Await(&mut self, node: ExprAwait<R>) {
-        self.generic_visit_expr_Await(node)
+    fn visit_expr_await(&mut self, node: ExprAwait<R>) {
+        self.generic_visit_expr_await(node)
     }
-    fn generic_visit_expr_Await(&mut self, node: ExprAwait<R>) {
+    fn generic_visit_expr_await(&mut self, node: ExprAwait<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Yield(&mut self, node: ExprYield<R>) {
-        self.generic_visit_expr_Yield(node)
+    fn visit_expr_yield(&mut self, node: ExprYield<R>) {
+        self.generic_visit_expr_yield(node)
     }
-    fn generic_visit_expr_Yield(&mut self, node: ExprYield<R>) {
+    fn generic_visit_expr_yield(&mut self, node: ExprYield<R>) {
         if let Some(value) = node.value {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_YieldFrom(&mut self, node: ExprYieldFrom<R>) {
-        self.generic_visit_expr_YieldFrom(node)
+    fn visit_expr_yield_from(&mut self, node: ExprYieldFrom<R>) {
+        self.generic_visit_expr_yield_from(node)
     }
-    fn generic_visit_expr_YieldFrom(&mut self, node: ExprYieldFrom<R>) {
+    fn generic_visit_expr_yield_from(&mut self, node: ExprYieldFrom<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Compare(&mut self, node: ExprCompare<R>) {
-        self.generic_visit_expr_Compare(node)
+    fn visit_expr_compare(&mut self, node: ExprCompare<R>) {
+        self.generic_visit_expr_compare(node)
     }
-    fn generic_visit_expr_Compare(&mut self, node: ExprCompare<R>) {
+    fn generic_visit_expr_compare(&mut self, node: ExprCompare<R>) {
         {
             let value = node.left;
             self.visit_expr(*value);
@@ -557,10 +557,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_Call(&mut self, node: ExprCall<R>) {
-        self.generic_visit_expr_Call(node)
+    fn visit_expr_call(&mut self, node: ExprCall<R>) {
+        self.generic_visit_expr_call(node)
     }
-    fn generic_visit_expr_Call(&mut self, node: ExprCall<R>) {
+    fn generic_visit_expr_call(&mut self, node: ExprCall<R>) {
         {
             let value = node.func;
             self.visit_expr(*value);
@@ -572,10 +572,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_keyword(value);
         }
     }
-    fn visit_expr_FormattedValue(&mut self, node: ExprFormattedValue<R>) {
-        self.generic_visit_expr_FormattedValue(node)
+    fn visit_expr_formatted_value(&mut self, node: ExprFormattedValue<R>) {
+        self.generic_visit_expr_formatted_value(node)
     }
-    fn generic_visit_expr_FormattedValue(&mut self, node: ExprFormattedValue<R>) {
+    fn generic_visit_expr_formatted_value(&mut self, node: ExprFormattedValue<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
@@ -584,31 +584,31 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_JoinedStr(&mut self, node: ExprJoinedStr<R>) {
-        self.generic_visit_expr_JoinedStr(node)
+    fn visit_expr_joined_str(&mut self, node: ExprJoinedStr<R>) {
+        self.generic_visit_expr_joined_str(node)
     }
-    fn generic_visit_expr_JoinedStr(&mut self, node: ExprJoinedStr<R>) {
+    fn generic_visit_expr_joined_str(&mut self, node: ExprJoinedStr<R>) {
         for value in node.values {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_Constant(&mut self, node: ExprConstant<R>) {
-        self.generic_visit_expr_Constant(node)
+    fn visit_expr_constant(&mut self, node: ExprConstant<R>) {
+        self.generic_visit_expr_constant(node)
     }
-    fn generic_visit_expr_Constant(&mut self, node: ExprConstant<R>) {}
-    fn visit_expr_Attribute(&mut self, node: ExprAttribute<R>) {
-        self.generic_visit_expr_Attribute(node)
+    fn generic_visit_expr_constant(&mut self, node: ExprConstant<R>) {}
+    fn visit_expr_attribute(&mut self, node: ExprAttribute<R>) {
+        self.generic_visit_expr_attribute(node)
     }
-    fn generic_visit_expr_Attribute(&mut self, node: ExprAttribute<R>) {
+    fn generic_visit_expr_attribute(&mut self, node: ExprAttribute<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Subscript(&mut self, node: ExprSubscript<R>) {
-        self.generic_visit_expr_Subscript(node)
+    fn visit_expr_subscript(&mut self, node: ExprSubscript<R>) {
+        self.generic_visit_expr_subscript(node)
     }
-    fn generic_visit_expr_Subscript(&mut self, node: ExprSubscript<R>) {
+    fn generic_visit_expr_subscript(&mut self, node: ExprSubscript<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
@@ -618,39 +618,39 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Starred(&mut self, node: ExprStarred<R>) {
-        self.generic_visit_expr_Starred(node)
+    fn visit_expr_starred(&mut self, node: ExprStarred<R>) {
+        self.generic_visit_expr_starred(node)
     }
-    fn generic_visit_expr_Starred(&mut self, node: ExprStarred<R>) {
+    fn generic_visit_expr_starred(&mut self, node: ExprStarred<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
         }
     }
-    fn visit_expr_Name(&mut self, node: ExprName<R>) {
-        self.generic_visit_expr_Name(node)
+    fn visit_expr_name(&mut self, node: ExprName<R>) {
+        self.generic_visit_expr_name(node)
     }
-    fn generic_visit_expr_Name(&mut self, node: ExprName<R>) {}
-    fn visit_expr_List(&mut self, node: ExprList<R>) {
-        self.generic_visit_expr_List(node)
+    fn generic_visit_expr_name(&mut self, node: ExprName<R>) {}
+    fn visit_expr_list(&mut self, node: ExprList<R>) {
+        self.generic_visit_expr_list(node)
     }
-    fn generic_visit_expr_List(&mut self, node: ExprList<R>) {
+    fn generic_visit_expr_list(&mut self, node: ExprList<R>) {
         for value in node.elts {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_Tuple(&mut self, node: ExprTuple<R>) {
-        self.generic_visit_expr_Tuple(node)
+    fn visit_expr_tuple(&mut self, node: ExprTuple<R>) {
+        self.generic_visit_expr_tuple(node)
     }
-    fn generic_visit_expr_Tuple(&mut self, node: ExprTuple<R>) {
+    fn generic_visit_expr_tuple(&mut self, node: ExprTuple<R>) {
         for value in node.elts {
             self.visit_expr(value);
         }
     }
-    fn visit_expr_Slice(&mut self, node: ExprSlice<R>) {
-        self.generic_visit_expr_Slice(node)
+    fn visit_expr_slice(&mut self, node: ExprSlice<R>) {
+        self.generic_visit_expr_slice(node)
     }
-    fn generic_visit_expr_Slice(&mut self, node: ExprSlice<R>) {
+    fn generic_visit_expr_slice(&mut self, node: ExprSlice<R>) {
         if let Some(value) = node.lower {
             self.visit_expr(*value);
         }
@@ -690,13 +690,13 @@ pub trait Visitor<R = crate::text_size::TextRange> {
     }
     fn generic_visit_excepthandler(&mut self, node: Excepthandler<R>) {
         match node {
-            Excepthandler::ExceptHandler(data) => self.visit_excepthandler_ExceptHandler(data),
+            Excepthandler::ExceptHandler(data) => self.visit_excepthandler_except_handler(data),
         }
     }
-    fn visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler<R>) {
-        self.generic_visit_excepthandler_ExceptHandler(node)
+    fn visit_excepthandler_except_handler(&mut self, node: ExcepthandlerExceptHandler<R>) {
+        self.generic_visit_excepthandler_except_handler(node)
     }
-    fn generic_visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler<R>) {
+    fn generic_visit_excepthandler_except_handler(&mut self, node: ExcepthandlerExceptHandler<R>) {
         if let Some(value) = node.type_ {
             self.visit_expr(*value);
         }
@@ -733,41 +733,41 @@ pub trait Visitor<R = crate::text_size::TextRange> {
     }
     fn generic_visit_pattern(&mut self, node: Pattern<R>) {
         match node {
-            Pattern::MatchValue(data) => self.visit_pattern_MatchValue(data),
-            Pattern::MatchSingleton(data) => self.visit_pattern_MatchSingleton(data),
-            Pattern::MatchSequence(data) => self.visit_pattern_MatchSequence(data),
-            Pattern::MatchMapping(data) => self.visit_pattern_MatchMapping(data),
-            Pattern::MatchClass(data) => self.visit_pattern_MatchClass(data),
-            Pattern::MatchStar(data) => self.visit_pattern_MatchStar(data),
-            Pattern::MatchAs(data) => self.visit_pattern_MatchAs(data),
-            Pattern::MatchOr(data) => self.visit_pattern_MatchOr(data),
+            Pattern::MatchValue(data) => self.visit_pattern_match_value(data),
+            Pattern::MatchSingleton(data) => self.visit_pattern_match_singleton(data),
+            Pattern::MatchSequence(data) => self.visit_pattern_match_sequence(data),
+            Pattern::MatchMapping(data) => self.visit_pattern_match_mapping(data),
+            Pattern::MatchClass(data) => self.visit_pattern_match_class(data),
+            Pattern::MatchStar(data) => self.visit_pattern_match_star(data),
+            Pattern::MatchAs(data) => self.visit_pattern_match_as(data),
+            Pattern::MatchOr(data) => self.visit_pattern_match_or(data),
         }
     }
-    fn visit_pattern_MatchValue(&mut self, node: PatternMatchValue<R>) {
-        self.generic_visit_pattern_MatchValue(node)
+    fn visit_pattern_match_value(&mut self, node: PatternMatchValue<R>) {
+        self.generic_visit_pattern_match_value(node)
     }
-    fn generic_visit_pattern_MatchValue(&mut self, node: PatternMatchValue<R>) {
+    fn generic_visit_pattern_match_value(&mut self, node: PatternMatchValue<R>) {
         {
             let value = node.value;
             self.visit_expr(*value);
         }
     }
-    fn visit_pattern_MatchSingleton(&mut self, node: PatternMatchSingleton<R>) {
-        self.generic_visit_pattern_MatchSingleton(node)
+    fn visit_pattern_match_singleton(&mut self, node: PatternMatchSingleton<R>) {
+        self.generic_visit_pattern_match_singleton(node)
     }
-    fn generic_visit_pattern_MatchSingleton(&mut self, node: PatternMatchSingleton<R>) {}
-    fn visit_pattern_MatchSequence(&mut self, node: PatternMatchSequence<R>) {
-        self.generic_visit_pattern_MatchSequence(node)
+    fn generic_visit_pattern_match_singleton(&mut self, node: PatternMatchSingleton<R>) {}
+    fn visit_pattern_match_sequence(&mut self, node: PatternMatchSequence<R>) {
+        self.generic_visit_pattern_match_sequence(node)
     }
-    fn generic_visit_pattern_MatchSequence(&mut self, node: PatternMatchSequence<R>) {
+    fn generic_visit_pattern_match_sequence(&mut self, node: PatternMatchSequence<R>) {
         for value in node.patterns {
             self.visit_pattern(value);
         }
     }
-    fn visit_pattern_MatchMapping(&mut self, node: PatternMatchMapping<R>) {
-        self.generic_visit_pattern_MatchMapping(node)
+    fn visit_pattern_match_mapping(&mut self, node: PatternMatchMapping<R>) {
+        self.generic_visit_pattern_match_mapping(node)
     }
-    fn generic_visit_pattern_MatchMapping(&mut self, node: PatternMatchMapping<R>) {
+    fn generic_visit_pattern_match_mapping(&mut self, node: PatternMatchMapping<R>) {
         for value in node.keys {
             self.visit_expr(value);
         }
@@ -775,10 +775,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_pattern(value);
         }
     }
-    fn visit_pattern_MatchClass(&mut self, node: PatternMatchClass<R>) {
-        self.generic_visit_pattern_MatchClass(node)
+    fn visit_pattern_match_class(&mut self, node: PatternMatchClass<R>) {
+        self.generic_visit_pattern_match_class(node)
     }
-    fn generic_visit_pattern_MatchClass(&mut self, node: PatternMatchClass<R>) {
+    fn generic_visit_pattern_match_class(&mut self, node: PatternMatchClass<R>) {
         {
             let value = node.cls;
             self.visit_expr(*value);
@@ -790,22 +790,22 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_pattern(value);
         }
     }
-    fn visit_pattern_MatchStar(&mut self, node: PatternMatchStar<R>) {
-        self.generic_visit_pattern_MatchStar(node)
+    fn visit_pattern_match_star(&mut self, node: PatternMatchStar<R>) {
+        self.generic_visit_pattern_match_star(node)
     }
-    fn generic_visit_pattern_MatchStar(&mut self, node: PatternMatchStar<R>) {}
-    fn visit_pattern_MatchAs(&mut self, node: PatternMatchAs<R>) {
-        self.generic_visit_pattern_MatchAs(node)
+    fn generic_visit_pattern_match_star(&mut self, node: PatternMatchStar<R>) {}
+    fn visit_pattern_match_as(&mut self, node: PatternMatchAs<R>) {
+        self.generic_visit_pattern_match_as(node)
     }
-    fn generic_visit_pattern_MatchAs(&mut self, node: PatternMatchAs<R>) {
+    fn generic_visit_pattern_match_as(&mut self, node: PatternMatchAs<R>) {
         if let Some(value) = node.pattern {
             self.visit_pattern(*value);
         }
     }
-    fn visit_pattern_MatchOr(&mut self, node: PatternMatchOr<R>) {
-        self.generic_visit_pattern_MatchOr(node)
+    fn visit_pattern_match_or(&mut self, node: PatternMatchOr<R>) {
+        self.generic_visit_pattern_match_or(node)
     }
-    fn generic_visit_pattern_MatchOr(&mut self, node: PatternMatchOr<R>) {
+    fn generic_visit_pattern_match_or(&mut self, node: PatternMatchOr<R>) {
         for value in node.patterns {
             self.visit_pattern(value);
         }

ast/src/generic.rs

@@ -11,6 +11,15 @@ pub type OptionalRange<R> = R;
 #[cfg(not(feature = "all-nodes-with-ranges"))]
 pub type OptionalRange<R> = EmptyRange<R>;
 
+#[cfg(not(feature = "all-nodes-with-ranges"))]
+impl<R> From<R> for OptionalRange<R> {
+    fn from(_: R) -> Self {
+        Self {
+            phantom: PhantomData,
+        }
+    }
+}
+
 #[derive(Eq, PartialEq, Hash, Copy, Clone)]
 pub struct EmptyRange<R> {
     phantom: PhantomData<R>,
@@ -62,4 +71,257 @@ impl Cmpop {
     }
 }
 
+impl<R> Arguments<R> {
+    pub fn empty(range: OptionalRange<R>) -> Self {
+        Self {
+            range,
+            posonlyargs: Vec::new(),
+            args: Vec::new(),
+            vararg: None,
+            kwonlyargs: Vec::new(),
+            kwarg: None,
+        }
+    }
+}
+
+#[allow(clippy::borrowed_box)] // local utility
+fn clone_boxed_expr<R: Clone>(expr: &Box<Expr<R>>) -> Box<Expr<R>> {
+    let expr: &Expr<_> = expr.as_ref();
+    Box::new(expr.clone())
+}
+
+impl<R> ArgWithDefault<R> {
+    pub fn from_arg(def: Arg<R>, default: Option<Expr<R>>) -> Self
+    where
+        R: Clone,
+    {
+        let range = {
+            if cfg!(feature = "all-nodes-with-ranges") {
+                todo!("range recovery is not implemented yet") // def.range.start()..default.range.end()
+            } else {
+                #[allow(clippy::useless_conversion)] // false positive by cfg
+                OptionalRange::from(def.range.clone())
+            }
+        };
+        Self {
+            range,
+            def,
+            default: default.map(Box::new),
+        }
+    }
+
+    pub fn as_arg(&self) -> &Arg<R> {
+        &self.def
+    }
+
+    pub fn to_arg(&self) -> (Arg<R>, Option<Box<Expr<R>>>)
+    where
+        R: Clone,
+    {
+        let ArgWithDefault {
+            range: _,
+            def,
+            default,
+        } = self;
+        (def.clone(), default.as_ref().map(clone_boxed_expr))
+    }
+    pub fn into_arg(self) -> (Arg<R>, Option<Box<Expr<R>>>) {
+        let ArgWithDefault {
+            range: _,
+            def,
+            default,
+        } = self;
+        (def, default)
+    }
+}
+
+impl<R> Arguments<R> {
+    pub fn defaults(&self) -> impl std::iter::Iterator<Item = &Expr<R>> {
+        self.posonlyargs
+            .iter()
+            .chain(self.args.iter())
+            .filter_map(|arg| arg.default.as_ref().map(|e| e.as_ref()))
+    }
+
+    #[allow(clippy::type_complexity)]
+    pub fn split_kwonlyargs(&self) -> (Vec<&Arg<R>>, Vec<(&Arg<R>, &Expr<R>)>) {
+        let mut args = Vec::new();
+        let mut with_defaults = Vec::new();
+        for arg in self.kwonlyargs.iter() {
+            if let Some(ref default) = arg.default {
+                with_defaults.push((arg.as_arg(), &**default));
+            } else {
+                args.push(arg.as_arg());
+            }
+        }
+        (args, with_defaults)
+    }
+
+    pub fn to_python_arguments(&self) -> PythonArguments<R>
+    where
+        R: Clone,
+    {
+        let Arguments {
+            range,
+            posonlyargs,
+            args,
+            vararg,
+            kwonlyargs,
+            kwarg,
+        } = self;
+
+        let mut pos_only = Vec::with_capacity(posonlyargs.len());
+        let mut pos_args = Vec::with_capacity(args.len());
+        let mut defaults = Vec::new();
+        for arg in posonlyargs {
+            let (arg, default) = arg.to_arg();
+            if let Some(default) = default {
+                defaults.push(*default);
+            }
+            pos_only.push(arg);
+        }
+        for arg in args {
+            let (arg, default) = arg.to_arg();
+            if let Some(default) = default {
+                defaults.push(*default);
+            }
+            pos_args.push(arg);
+        }
+
+        let mut kw_only = Vec::with_capacity(kwonlyargs.len());
+        let mut kw_defaults = Vec::new();
+        for arg in kwonlyargs {
+            let (arg, default) = arg.to_arg();
+            if let Some(default) = default {
+                kw_defaults.push(*default);
+            }
+            kw_only.push(arg);
+        }
+
+        PythonArguments {
+            range: range.clone(),
+            posonlyargs: pos_only,
+            args: pos_args,
+            defaults,
+            vararg: vararg.clone(),
+            kwonlyargs: kw_only,
+            kw_defaults,
+            kwarg: kwarg.clone(),
+        }
+    }
+
+    pub fn into_python_arguments(self) -> PythonArguments<R> {
+        let Arguments {
+            range,
+            posonlyargs,
+            args,
+            vararg,
+            kwonlyargs,
+            kwarg,
+        } = self;
+
+        let mut pos_only = Vec::with_capacity(posonlyargs.len());
+        let mut pos_args = Vec::with_capacity(args.len());
+        let mut defaults = Vec::new();
+        for arg in posonlyargs {
+            let (arg, default) = arg.into_arg();
+            if let Some(default) = default {
+                defaults.push(*default);
+            }
+            pos_only.push(arg);
+        }
+        for arg in args {
+            let (arg, default) = arg.into_arg();
+            if let Some(default) = default {
+                defaults.push(*default);
+            }
+            pos_args.push(arg);
+        }
+
+        let mut kw_only = Vec::with_capacity(kwonlyargs.len());
+        let mut kw_defaults = Vec::new();
+        for arg in kwonlyargs {
+            let (arg, default) = arg.into_arg();
+            if let Some(default) = default {
+                kw_defaults.push(*default);
+            }
+            kw_only.push(arg);
+        }
+
+        PythonArguments {
+            range,
+            posonlyargs: pos_only,
+            args: pos_args,
+            defaults,
+            vararg,
+            kwonlyargs: kw_only,
+            kw_defaults,
+            kwarg,
+        }
+    }
+}
+
+impl<R> PythonArguments<R> {
+    pub fn into_arguments(self) -> Arguments<R>
+    where
+        R: Clone,
+    {
+        let PythonArguments {
+            range,
+            posonlyargs,
+            args,
+            defaults,
+            vararg,
+            kwonlyargs,
+            kw_defaults,
+            kwarg,
+        } = self;
+
+        let mut pos_only = Vec::with_capacity(posonlyargs.len());
+        let mut pos_args = Vec::with_capacity(args.len());
+        let args_len = posonlyargs.len() + args.len();
+        // not optimal
+        let mut defaults: Vec<_> = std::iter::repeat_with(|| None)
+            .take(args_len - defaults.len())
+            .chain(defaults.into_iter().map(Some))
+            .collect();
+        debug_assert_eq!(args_len, defaults.len());
+
+        for (arg, default) in std::iter::zip(args, defaults.drain(posonlyargs.len()..)) {
+            let arg = ArgWithDefault::from_arg(arg, default);
+            pos_args.push(arg);
+        }
+
+        for (arg, default) in std::iter::zip(posonlyargs, defaults.drain(..)) {
+            let arg = ArgWithDefault::from_arg(arg, default);
+            pos_only.push(arg);
+        }
+
+        let mut kw_only = Vec::with_capacity(kwonlyargs.len());
+        let kw_defaults: Vec<_> = std::iter::repeat_with(|| None)
+            .take(kw_only.len().saturating_sub(kw_defaults.len()))
+            .chain(kw_defaults.into_iter().map(Some))
+            .collect();
+        for (arg, default) in std::iter::zip(kwonlyargs, kw_defaults) {
+            let arg = ArgWithDefault::from_arg(arg, default);
+            kw_only.push(arg);
+        }
+
+        Arguments {
+            range,
+            posonlyargs: pos_only,
+            args: pos_args,
+            vararg,
+            kwonlyargs: kw_only,
+            kwarg,
+        }
+    }
+}
+
+impl<R> From<Arguments<R>> for PythonArguments<R> {
+    fn from(arguments: Arguments<R>) -> Self {
+        arguments.into_python_arguments()
+    }
+}
+
 include!("gen/generic.rs");

ast/src/lib.rs

@@ -1,3 +1,12 @@
+//! Python AST node definitions and utilities.
+//!
+//! AST nodes are very similary defined like [Python AST](https://docs.python.org/3/library/ast.html).
+//! But a few exceptions exist due to parser optimization.
+//! They can be transformed to matching Python-styled AST in reasonable cost.
+//!
+//! [PythonArguments] is replaced by [Arguments]. The new [Arguments] type representation uses a new type
+//! [ArgWithDefault] to represent arguments with default values. See each type documentation for more details.
+
 mod builtin;
 mod generic;
 mod impls;

ast/src/unparse.rs

@@ -1,5 +1,7 @@
-use crate::ConversionFlag;
-use crate::{Arg, Arguments, Boolop, Comprehension, Constant, Expr, Identifier, Operator};
+use crate::{
+    Arg, ArgWithDefault, Arguments, Boolop, Comprehension, Constant, ConversionFlag, Expr,
+    Identifier, Operator, PythonArguments,
+};
 use std::fmt;
 
 mod precedence {
@@ -155,7 +157,7 @@ impl<'a> Unparser<'a> {
                 group_if!(precedence::TEST, {
                     let pos = args.args.len() + args.posonlyargs.len();
                     self.p(if pos > 0 { "lambda " } else { "lambda" })?;
-                    self.unparse_args(args)?;
+                    self.unparse_arguments(args)?;
                     write!(self, ": {}", **body)?;
                 })
             }
@@ -437,7 +439,44 @@ impl<'a> Unparser<'a> {
         Ok(())
     }
 
-    fn unparse_args<U>(&mut self, args: &Arguments<U>) -> fmt::Result {
+    fn unparse_arguments<U>(&mut self, args: &Arguments<U>) -> fmt::Result {
+        let mut first = true;
+        for (i, arg) in args.posonlyargs.iter().chain(&args.args).enumerate() {
+            self.p_delim(&mut first, ", ")?;
+            self.unparse_function_arg(arg)?;
+            self.p_if(i + 1 == args.posonlyargs.len(), ", /")?;
+        }
+        if args.vararg.is_some() || !args.kwonlyargs.is_empty() {
+            self.p_delim(&mut first, ", ")?;
+            self.p("*")?;
+        }
+        if let Some(vararg) = &args.vararg {
+            self.unparse_arg(vararg)?;
+        }
+        for kwarg in args.kwonlyargs.iter() {
+            self.p_delim(&mut first, ", ")?;
+            self.unparse_function_arg(kwarg)?;
+        }
+        if let Some(kwarg) = &args.kwarg {
+            self.p_delim(&mut first, ", ")?;
+            self.p("**")?;
+            self.unparse_arg(kwarg)?;
+        }
+        Ok(())
+    }
+    fn unparse_function_arg<U>(&mut self, arg: &ArgWithDefault<U>) -> fmt::Result {
+        self.p_id(&arg.def.arg)?;
+        if let Some(ann) = &arg.def.annotation {
+            write!(self, ": {}", **ann)?;
+        }
+        if let Some(default) = &arg.default {
+            write!(self, "={}", default)?;
+        }
+        Ok(())
+    }
+
+    #[allow(dead_code)]
+    fn unparse_python_arguments<U>(&mut self, args: &PythonArguments<U>) -> fmt::Result {
         let mut first = true;
         let defaults_start = args.posonlyargs.len() + args.args.len() - args.defaults.len();
         for (i, arg) in args.posonlyargs.iter().chain(&args.args).enumerate() {

parser/src/context.rs

@@ -66,7 +66,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_assign_list() {
         let source = "[x, y] = (1, 2, 3)";
         let parse_ast = ast::Suite::parse(source, "<test>").unwrap();
@@ -102,7 +102,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_assign_list_comp() {
         let source = "x = [y for y in (1, 2, 3)]";
         let parse_ast = ast::Suite::parse(source, "<test>").unwrap();
@@ -110,7 +110,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_assign_set_comp() {
         let source = "x = {y for y in (1, 2, 3)}";
         let parse_ast = ast::Suite::parse(source, "<test>").unwrap();
@@ -118,7 +118,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_assign_with() {
         let source = "with 1 as x: pass";
         let parse_ast = ast::Suite::parse(source, "<test>").unwrap();

parser/src/function.rs

@@ -14,76 +14,55 @@ pub(crate) struct ArgumentList {
     pub keywords: Vec<ast::Keyword>,
 }
 
-type ParameterDefs = (Vec<ast::Arg>, Vec<ast::Arg>, Vec<ast::Expr>);
-type ParameterDef = (ast::Arg, Option<ast::Expr>);
-
 // Perform validation of function/lambda arguments in a function definition.
-pub(crate) fn validate_arguments(
-    arguments: ast::Arguments,
-) -> Result<ast::Arguments, LexicalError> {
-    let mut all_args: Vec<&ast::Arg> = vec![];
-
-    all_args.extend(arguments.posonlyargs.iter());
-    all_args.extend(arguments.args.iter());
-
-    if let Some(a) = &arguments.vararg {
-        all_args.push(a);
-    }
-
-    all_args.extend(arguments.kwonlyargs.iter());
-
-    if let Some(a) = &arguments.kwarg {
-        all_args.push(a);
-    }
-
+pub(crate) fn validate_arguments(arguments: &ast::Arguments) -> Result<(), LexicalError> {
     let mut all_arg_names = FxHashSet::with_hasher(Default::default());
-    for arg in all_args {
-        let arg_name = &arg.arg;
-        // Check for duplicate arguments in the function definition.
+
+    let posonlyargs = arguments.posonlyargs.iter();
+    let args = arguments.args.iter();
+    let kwonlyargs = arguments.kwonlyargs.iter();
+
+    let vararg: Option<&ast::Arg> = arguments.vararg.as_deref();
+    let kwarg: Option<&ast::Arg> = arguments.kwarg.as_deref();
+
+    for arg in posonlyargs
+        .chain(args)
+        .chain(kwonlyargs)
+        .map(|arg| &arg.def)
+        .chain(vararg)
+        .chain(kwarg)
+    {
+        let range = arg.range;
+        let arg_name = arg.arg.as_str();
         if !all_arg_names.insert(arg_name) {
             return Err(LexicalError {
                 error: LexicalErrorType::DuplicateArgumentError(arg_name.to_string()),
-                location: arg.start(),
+                location: range.start(),
             });
         }
     }
 
-    Ok(arguments)
+    Ok(())
 }
 
-// Parse parameters as supplied during a function/lambda *definition*.
-pub(crate) fn parse_params(
-    params: (Vec<ParameterDef>, Vec<ParameterDef>),
-) -> Result<ParameterDefs, LexicalError> {
-    let mut pos_only = Vec::with_capacity(params.0.len());
-    let mut names = Vec::with_capacity(params.1.len());
-    let mut defaults = vec![];
-
-    let mut try_default = |name: &ast::Arg, default| {
-        if let Some(default) = default {
-            defaults.push(default);
-        } else if !defaults.is_empty() {
-            // Once we have started with defaults, all remaining arguments must
-            // have defaults.
-            return Err(LexicalError {
-                error: LexicalErrorType::DefaultArgumentError,
-                location: name.start(),
-            });
-        }
-        Ok(())
-    };
-
-    for (name, default) in params.0 {
-        try_default(&name, default)?;
-        pos_only.push(name);
+pub(crate) fn validate_pos_params(
+    args: &(Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+) -> Result<(), LexicalError> {
+    let (posonlyargs, args) = args;
+    #[allow(clippy::skip_while_next)]
+    let first_invalid = posonlyargs
+        .iter()
+        .chain(args.iter()) // for all args
+        .skip_while(|arg| arg.default.is_none()) // starting with args without default
+        .skip_while(|arg| arg.default.is_some()) // and then args with default
+        .next(); // there must not be any more args without default
+    if let Some(invalid) = first_invalid {
+        return Err(LexicalError {
+            error: LexicalErrorType::DefaultArgumentError,
+            location: invalid.def.range.start(),
+        });
     }
-
-    for (name, default) in params.1 {
-        try_default(&name, default)?;
-        names.push(name);
-    }
-
-    Ok((pos_only, names, defaults))
+    Ok(())
 }
 
 type FunctionArgument = (
@@ -157,7 +136,7 @@ mod tests {
     use super::*;
     use crate::{ast, parser::ParseErrorType, Parse};
 
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     macro_rules! function_and_lambda {
         ($($name:ident: $code:expr,)*) => {
             $(
@@ -170,7 +149,7 @@ mod tests {
         }
     }
 
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     function_and_lambda! {
         test_function_no_args: "def f(): pass",
         test_function_pos_args: "def f(a, b, c): pass",

parser/src/parser.rs

@@ -610,7 +610,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_parse_lambda() {
         let source = "lambda x, y: x * y"; // lambda(x, y): x * y";
         let parse_ast = ast::Suite::parse(source, "<test>").unwrap();
@@ -625,7 +625,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_parse_class() {
         let source = "\
 class Foo(A, B):
@@ -638,7 +638,7 @@ class Foo(A, B):
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_parse_dict_comprehension() {
         let source = "{x1: x2 for y in z}";
         let parse_ast = ast::Expr::parse(source, "<test>").unwrap();
@@ -646,7 +646,7 @@ class Foo(A, B):
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_parse_list_comprehension() {
         let source = "[x for y in z]";
         let parse_ast = ast::Expr::parse(source, "<test>").unwrap();
@@ -654,7 +654,7 @@ class Foo(A, B):
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_parse_double_list_comprehension() {
         let source = "[x for y, y2 in z for a in b if a < 5 if a > 10]";
         let parse_ast = ast::Expr::parse(source, "<test>").unwrap();
@@ -662,7 +662,7 @@ class Foo(A, B):
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_parse_generator_comprehension() {
         let source = "(x for y in z)";
         let parse_ast = ast::Expr::parse(source, "<test>").unwrap();
@@ -670,7 +670,7 @@ class Foo(A, B):
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_parse_named_expression_generator_comprehension() {
         let source = "(x := y + 1 for y in z)";
         let parse_ast = ast::Expr::parse(source, "<test>").unwrap();
@@ -678,7 +678,7 @@ class Foo(A, B):
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_parse_if_else_generator_comprehension() {
         let source = "(x if y else y for y in z)";
         let parse_ast = ast::Expr::parse(source, "<test>").unwrap();
@@ -707,7 +707,7 @@ class Foo(A, B):
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_with_statement() {
         let source = "\
 with 0: pass
@@ -777,7 +777,7 @@ array[3:5, *indexes_to_select]
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_generator_expression_argument() {
         let source = r#"' '.join(
     sql
@@ -837,7 +837,7 @@ except* OSError as e:
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_match_as_identifier() {
         let parse_ast = ast::Suite::parse(
             r#"
@@ -870,7 +870,7 @@ print(match(12))
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_patma() {
         let source = r#"# Cases sampled from Lib/test/test_patma.py
 
@@ -1042,7 +1042,7 @@ match w := x,:
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_match() {
         let parse_ast = ast::Suite::parse(
             r#"
@@ -1073,7 +1073,7 @@ match x:
     }
 
     #[test]
-    #[cfg(not(feature = "all-nodes-with-ranges"))]
+    #[cfg(feature = "all-nodes-with-ranges")]
     fn test_variadic_generics() {
         let parse_ast = ast::Suite::parse(
             r#"

parser/src/python.lalrpop

@@ -6,7 +6,7 @@
 use crate::{
     ast::{self as ast, Ranged},
     lexer::{LexicalError, LexicalErrorType},
-    function::{ArgumentList, parse_args, parse_params, validate_arguments},
+    function::{ArgumentList, parse_args, validate_pos_params, validate_arguments},
     context::set_context,
     string::parse_strings,
     token::{self, StringKind},
@@ -980,17 +980,10 @@ FuncDef: ast::Stmt = {
 };
 
 Parameters: ast::Arguments = {
-    <location:@L> "(" <a: (ParameterList<TypedParameter, StarTypedParameter>)?> ")" <end_location:@R> =>? {
-        let args = a.map(validate_arguments).transpose()?.unwrap_or_else(|| ast::Arguments {
-            posonlyargs: vec![],
-            args: vec![],
-            vararg: None,
-            kwonlyargs: vec![],
-            kw_defaults: vec![],
-            kwarg: None,
-            defaults: vec![],
-            range: optional_range(location, end_location)
-        });
+    <location:@L> "(" <a: (ParameterList<TypedParameter, StarTypedParameter, DoubleStarTypedParameter>)?> ")" <end_location:@R> =>? {
+        a.as_ref().map(validate_arguments).transpose()?;
+        let args = a
+            .unwrap_or_else(|| ast::Arguments::empty(optional_range(location, end_location)));
 
         Ok(args)
     }
@@ -998,12 +991,13 @@ Parameters: ast::Arguments = {
 
 // Note that this is a macro which is used once for function defs, and
 // once for lambda defs.
-ParameterList<ArgType, StarArgType>: ast::Arguments = {
-    <location:@L> <param1:ParameterDefs<ArgType>> <args2:("," <ParameterListStarArgs<ArgType, StarArgType>>)?> ","? <end_location:@R> =>? {
-        let (posonlyargs, args, defaults) = parse_params(param1)?;
+ParameterList<ArgType, StarArgType, DoubleStarArgType>: ast::Arguments = {
+    <location:@L> <param1:ParameterDefs<ArgType>> <args2:("," <ParameterListStarArgs<ArgType, StarArgType, DoubleStarArgType>>)?> ","? <end_location:@R> =>? {
+        validate_pos_params(&param1)?;
+        let (posonlyargs, args) = param1;
 
         // Now gather rest of parameters:
-        let (vararg, kwonlyargs, kw_defaults, kwarg) = args2.unwrap_or((None, vec![], vec![], None));
+        let (vararg, kwonlyargs, kwarg) = args2.unwrap_or((None, vec![], None));
 
         Ok(ast::Arguments {
             posonlyargs,
@@ -1011,18 +1005,16 @@ ParameterList<ArgType, StarArgType>: ast::Arguments = {
             kwonlyargs,
             vararg,
             kwarg,
-            defaults,
-            kw_defaults,
             range: optional_range(location, end_location)
         })
     },
-    <location:@L> <param1:ParameterDefs<ArgType>> <kw:("," <KwargParameter<ArgType>>)> ","? <end_location:@R> =>? {
-        let (posonlyargs, args, defaults) = parse_params(param1)?;
+    <location:@L> <param1:ParameterDefs<ArgType>> <kw:("," <KwargParameter<DoubleStarArgType>>)> ","? <end_location:@R> =>? {
+        validate_pos_params(&param1)?;
+        let (posonlyargs, args) = param1;
 
         // Now gather rest of parameters:
         let vararg = None;
         let kwonlyargs = vec![];
-        let kw_defaults = vec![];
         let kwarg = kw;
 
         Ok(ast::Arguments {
@@ -1031,33 +1023,27 @@ ParameterList<ArgType, StarArgType>: ast::Arguments = {
             kwonlyargs,
             vararg,
             kwarg,
-            defaults,
-            kw_defaults,
             range: optional_range(location, end_location)
         })
     },
-    <location:@L> <params:ParameterListStarArgs<ArgType, StarArgType>> ","? <end_location:@R> => {
-        let (vararg, kwonlyargs, kw_defaults, kwarg) = params;
+    <location:@L> <params:ParameterListStarArgs<ArgType, StarArgType, DoubleStarArgType>> ","? <end_location:@R> => {
+        let (vararg, kwonlyargs, kwarg) = params;
         ast::Arguments {
             posonlyargs: vec![],
             args: vec![],
             kwonlyargs,
             vararg,
             kwarg,
-            defaults: vec![],
-            kw_defaults,
             range: optional_range(location, end_location)
         }
     },
-    <location:@L> <kwarg:KwargParameter<ArgType>> ","? <end_location:@R> => {
+    <location:@L> <kwarg:KwargParameter<DoubleStarArgType>> ","? <end_location:@R> => {
         ast::Arguments {
             posonlyargs: vec![],
             args: vec![],
             kwonlyargs: vec![],
             vararg: None,
             kwarg,
-            defaults: vec![],
-            kw_defaults: vec![],
             range: optional_range(location, end_location)
         }
     },
@@ -1065,34 +1051,51 @@ ParameterList<ArgType, StarArgType>: ast::Arguments = {
 
 // Use inline here to make sure the "," is not creating an ambiguity.
 #[inline]
-ParameterDefs<ArgType>: (Vec<(ast::Arg, Option<ast::Expr>)>, Vec<(ast::Arg, Option<ast::Expr>)>) = {
+ParameterDefs<ArgType>: (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) = {
     <args:OneOrMore<ParameterDef<ArgType>>> => {
         (vec![], args)
     },
-    <pos_args:OneOrMore<ParameterDef<ArgType>>> "," "/" <args:("," <ParameterDef<ArgType>>)*>  => {
-        (pos_args, args)
+    <posonlyargs:OneOrMore<ParameterDef<ArgType>>> "," "/" <args:("," <ParameterDef<ArgType>>)*>  => {
+        (posonlyargs, args)
     },
 };
 
-ParameterDef<ArgType>: (ast::Arg, Option<ast::Expr>) = {
-    <i:ArgType> => (i, None),
-    <i:ArgType> "=" <e:Test<"all">> => (i, Some(e)),
+ParameterDef<ArgType>: ast::ArgWithDefault = {
+    <i:ArgType> => i,
+    <mut i:ArgType> "=" <e:Test<"all">> => {
+        i.default = Some(Box::new(e));
+        i
+    },
 };
 
-UntypedParameter: ast::Arg = {
+UntypedParameter: ast::ArgWithDefault = {
+    <location:@L> <arg:Identifier> <end_location:@R> => {
+        let def = ast::Arg { arg, annotation: None, type_comment: None, range: (location..end_location).into() };
+        ast::ArgWithDefault { def, default: None, range: optional_range(location, end_location) }
+    },
+};
+StarUntypedParameter: ast::Arg = {
     <location:@L> <arg:Identifier> <end_location:@R> => ast::Arg { arg, annotation: None, type_comment: None, range: (location..end_location).into() },
 };
 
-TypedParameter: ast::Arg = {
+TypedParameter: ast::ArgWithDefault = {
     <location:@L> <arg:Identifier> <a:(":" <Test<"all">>)?> <end_location:@R> => {
-        let annotation = a.map(|x| Box::new(x));
-        ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() }
+        let annotation = a.map(Box::new);
+        let def = ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() };
+        ast::ArgWithDefault { def, default: None, range: optional_range(location, end_location) }
     },
 };
 
 StarTypedParameter: ast::Arg = {
     <location:@L> <arg:Identifier> <a:(":" <TestOrStarExpr>)?> <end_location:@R> => {
-        let annotation = a.map(|x| Box::new(x));
+        let annotation = a.map(Box::new);
+        ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() }
+    },
+};
+
+DoubleStarTypedParameter: ast::Arg = {
+    <location:@L> <arg:Identifier> <a:(":" <Test<"all">>)?> <end_location:@R> => {
+        let annotation = a.map(Box::new);
         ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() }
     },
 };
@@ -1100,23 +1103,9 @@ StarTypedParameter: ast::Arg = {
 // Use inline here to make sure the "," is not creating an ambiguity.
 // TODO: figure out another grammar that makes this inline no longer required.
 #[inline]
-ParameterListStarArgs<ArgType, StarArgType>: (Option<Box<ast::Arg>>, Vec<ast::Arg>, Vec<ast::Expr>, Option<Box<ast::Arg>>) = {
-    <location:@L> "*" <va:StarArgType?> <kw:("," <ParameterDef<ArgType>>)*> <kwarg:("," <KwargParameter<ArgType>>)?> =>? {
-        // Extract keyword arguments:
-        let mut kwonlyargs = Vec::new();
-        let mut kw_defaults = Vec::new();
-        let mut kwargs = Vec::with_capacity(kw.len());
-        for (name, value) in kw {
-            if let Some(value) = value {
-                kwonlyargs.push(name);
-                kw_defaults.push(value);
-            } else {
-                kwargs.push(name);
-            }
-        }
-        kwargs.extend(kwonlyargs.into_iter());
-
-        if va.is_none() && kwargs.is_empty() && kwarg.is_none() {
+ParameterListStarArgs<ArgType, StarArgType, DoubleStarArgType>: (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>) = {
+    <location:@L> "*" <va:StarArgType?> <kwonlyargs:("," <ParameterDef<ArgType>>)*> <kwarg:("," <KwargParameter<DoubleStarArgType>>)?> =>? {
+        if va.is_none() && kwonlyargs.is_empty() && kwarg.is_none() {
             Err(LexicalError {
                 error: LexicalErrorType::OtherError("named arguments must follow bare *".to_string()),
                 location,
@@ -1126,7 +1115,7 @@ ParameterListStarArgs<ArgType, StarArgType>: (Option<Box<ast::Arg>>, Vec<ast::Ar
         let kwarg = kwarg.flatten();
         let va = va.map(Box::new);
 
-        Ok((va, kwargs, kw_defaults, kwarg))
+        Ok((va, kwonlyargs, kwarg))
     }
 };
 
@@ -1205,21 +1194,10 @@ NamedExpression: ast::Expr = {
 };
 
 LambdaDef: ast::Expr = {
-    <location:@L> "lambda" <p:ParameterList<UntypedParameter, UntypedParameter>?> ":" <body:Test<"all">> <end_location:@R> =>? {
-        let p = validate_arguments(
-            p.unwrap_or_else(|| {
-                ast::Arguments {
-                    posonlyargs: vec![],
-                    args: vec![],
-                    vararg: None,
-                    kwonlyargs: vec![],
-                    kw_defaults: vec![],
-                    kwarg: None,
-                    defaults: vec![],
-                    range: optional_range(location, end_location)
-                }
-            }
-        ))?;
+    <location:@L> "lambda" <p:ParameterList<UntypedParameter, StarUntypedParameter, StarUntypedParameter>?> ":" <body:Test<"all">> <end_location:@R> =>? {
+        p.as_ref().map(validate_arguments).transpose()?;
+        let p = p
+            .unwrap_or_else(|| ast::Arguments::empty(optional_range(location, end_location)));
 
         Ok(ast::Expr::Lambda(
             ast::ExprLambda {

parser/src/snapshots/rustpython_parser__context__tests__assign_list_comp.snap

@@ -31,7 +31,7 @@ expression: parse_ast
                     ),
                     generators: [
                         Comprehension {
-                            range: (),
+                            range: 7..25,
                             target: Name(
                                 ExprName {
                                     range: 11..12,

parser/src/snapshots/rustpython_parser__context__tests__assign_set_comp.snap

@@ -31,7 +31,7 @@ expression: parse_ast
                     ),
                     generators: [
                         Comprehension {
-                            range: (),
+                            range: 7..25,
                             target: Name(
                                 ExprName {
                                     range: 11..12,

parser/src/snapshots/rustpython_parser__context__tests__assign_with.snap

@@ -8,7 +8,7 @@ expression: parse_ast
             range: 0..17,
             items: [
                 Withitem {
-                    range: (),
+                    range: 5..11,
                     context_expr: Constant(
                         ExprConstant {
                             range: 5..6,

parser/src/snapshots/rustpython_parser__function__tests__function_kw_only_args.snap

@@ -11,39 +11,49 @@ Ok(
                     "f",
                 ),
                 args: Arguments {
-                    range: (),
+                    range: 6..16,
                     posonlyargs: [],
                     args: [],
                     vararg: None,
                     kwonlyargs: [
-                        Arg {
+                        ArgWithDefault {
                             range: 9..10,
-                            arg: Identifier(
-                                "a",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 9..10,
+                                arg: Identifier(
+                                    "a",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 12..13,
-                            arg: Identifier(
-                                "b",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 12..13,
+                                arg: Identifier(
+                                    "b",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 15..16,
-                            arg: Identifier(
-                                "c",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 15..16,
+                                arg: Identifier(
+                                    "c",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
                     ],
-                    kw_defaults: [],
                     kwarg: None,
-                    defaults: [],
                 },
                 body: [
                     Pass(

parser/src/snapshots/rustpython_parser__function__tests__function_kw_only_args_with_defaults.snap

@@ -11,58 +11,69 @@ Ok(
                     "f",
                 ),
                 args: Arguments {
-                    range: (),
+                    range: 6..22,
                     posonlyargs: [],
                     args: [],
                     vararg: None,
                     kwonlyargs: [
-                        Arg {
+                        ArgWithDefault {
                             range: 9..10,
-                            arg: Identifier(
-                                "a",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 9..10,
+                                arg: Identifier(
+                                    "a",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 12..13,
-                            arg: Identifier(
-                                "b",
+                            def: Arg {
+                                range: 12..13,
+                                arg: Identifier(
+                                    "b",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: Some(
+                                Constant(
+                                    ExprConstant {
+                                        range: 14..16,
+                                        value: Int(
+                                            20,
+                                        ),
+                                        kind: None,
+                                    },
+                                ),
                             ),
-                            annotation: None,
-                            type_comment: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 18..19,
-                            arg: Identifier(
-                                "c",
+                            def: Arg {
+                                range: 18..19,
+                                arg: Identifier(
+                                    "c",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: Some(
+                                Constant(
+                                    ExprConstant {
+                                        range: 20..22,
+                                        value: Int(
+                                            30,
+                                        ),
+                                        kind: None,
+                                    },
+                                ),
                             ),
-                            annotation: None,
-                            type_comment: None,
                         },
                     ],
-                    kw_defaults: [
-                        Constant(
-                            ExprConstant {
-                                range: 14..16,
-                                value: Int(
-                                    20,
-                                ),
-                                kind: None,
-                            },
-                        ),
-                        Constant(
-                            ExprConstant {
-                                range: 20..22,
-                                value: Int(
-                                    30,
-                                ),
-                                kind: None,
-                            },
-                        ),
-                    ],
                     kwarg: None,
-                    defaults: [],
                 },
                 body: [
                     Pass(

parser/src/snapshots/rustpython_parser__function__tests__function_no_args.snap

@@ -11,14 +11,12 @@ Ok(
                     "f",
                 ),
                 args: Arguments {
-                    range: (),
+                    range: 5..7,
                     posonlyargs: [],
                     args: [],
                     vararg: None,
                     kwonlyargs: [],
-                    kw_defaults: [],
                     kwarg: None,
-                    defaults: [],
                 },
                 body: [
                     Pass(

parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args.snap

@@ -11,64 +11,86 @@ Ok(
                     "f",
                 ),
                 args: Arguments {
-                    range: (),
+                    range: 6..25,
                     posonlyargs: [],
                     args: [
-                        Arg {
+                        ArgWithDefault {
                             range: 6..7,
-                            arg: Identifier(
-                                "a",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 6..7,
+                                arg: Identifier(
+                                    "a",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 9..10,
-                            arg: Identifier(
-                                "b",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 9..10,
+                                arg: Identifier(
+                                    "b",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 12..13,
-                            arg: Identifier(
-                                "c",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 12..13,
+                                arg: Identifier(
+                                    "c",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
                     ],
                     vararg: None,
                     kwonlyargs: [
-                        Arg {
+                        ArgWithDefault {
                             range: 18..19,
-                            arg: Identifier(
-                                "d",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 18..19,
+                                arg: Identifier(
+                                    "d",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 21..22,
-                            arg: Identifier(
-                                "e",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 21..22,
+                                arg: Identifier(
+                                    "e",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 24..25,
-                            arg: Identifier(
-                                "f",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 24..25,
+                                arg: Identifier(
+                                    "f",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
                     ],
-                    kw_defaults: [],
                     kwarg: None,
-                    defaults: [],
                 },
                 body: [
                     Pass(

parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults.snap

@@ -11,83 +11,106 @@ Ok(
                     "f",
                 ),
                 args: Arguments {
-                    range: (),
+                    range: 6..31,
                     posonlyargs: [],
                     args: [
-                        Arg {
+                        ArgWithDefault {
                             range: 6..7,
-                            arg: Identifier(
-                                "a",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 6..7,
+                                arg: Identifier(
+                                    "a",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 9..10,
-                            arg: Identifier(
-                                "b",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 9..10,
+                                arg: Identifier(
+                                    "b",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 12..13,
-                            arg: Identifier(
-                                "c",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 12..13,
+                                arg: Identifier(
+                                    "c",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
                     ],
                     vararg: None,
                     kwonlyargs: [
-                        Arg {
+                        ArgWithDefault {
                             range: 18..19,
-                            arg: Identifier(
-                                "d",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 18..19,
+                                arg: Identifier(
+                                    "d",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 21..22,
-                            arg: Identifier(
-                                "e",
+                            def: Arg {
+                                range: 21..22,
+                                arg: Identifier(
+                                    "e",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: Some(
+                                Constant(
+                                    ExprConstant {
+                                        range: 23..25,
+                                        value: Int(
+                                            20,
+                                        ),
+                                        kind: None,
+                                    },
+                                ),
                             ),
-                            annotation: None,
-                            type_comment: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 27..28,
-                            arg: Identifier(
-                                "f",
+                            def: Arg {
+                                range: 27..28,
+                                arg: Identifier(
+                                    "f",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: Some(
+                                Constant(
+                                    ExprConstant {
+                                        range: 29..31,
+                                        value: Int(
+                                            30,
+                                        ),
+                                        kind: None,
+                                    },
+                                ),
                             ),
-                            annotation: None,
-                            type_comment: None,
                         },
                     ],
-                    kw_defaults: [
-                        Constant(
-                            ExprConstant {
-                                range: 23..25,
-                                value: Int(
-                                    20,
-                                ),
-                                kind: None,
-                            },
-                        ),
-                        Constant(
-                            ExprConstant {
-                                range: 29..31,
-                                value: Int(
-                                    30,
-                                ),
-                                kind: None,
-                            },
-                        ),
-                    ],
                     kwarg: None,
-                    defaults: [],
                 },
                 body: [
                     Pass(

parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults_and_varargs.snap

@@ -11,32 +11,44 @@ Ok(
                     "f",
                 ),
                 args: Arguments {
-                    range: (),
+                    range: 6..35,
                     posonlyargs: [],
                     args: [
-                        Arg {
+                        ArgWithDefault {
                             range: 6..7,
-                            arg: Identifier(
-                                "a",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 6..7,
+                                arg: Identifier(
+                                    "a",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 9..10,
-                            arg: Identifier(
-                                "b",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 9..10,
+                                arg: Identifier(
+                                    "b",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 12..13,
-                            arg: Identifier(
-                                "c",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 12..13,
+                                arg: Identifier(
+                                    "c",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
                     ],
                     vararg: Some(
@@ -50,53 +62,64 @@ Ok(
                         },
                     ),
                     kwonlyargs: [
-                        Arg {
+                        ArgWithDefault {
                             range: 22..23,
-                            arg: Identifier(
-                                "d",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 22..23,
+                                arg: Identifier(
+                                    "d",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 25..26,
-                            arg: Identifier(
-                                "e",
+                            def: Arg {
+                                range: 25..26,
+                                arg: Identifier(
+                                    "e",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: Some(
+                                Constant(
+                                    ExprConstant {
+                                        range: 27..29,
+                                        value: Int(
+                                            20,
+                                        ),
+                                        kind: None,
+                                    },
+                                ),
                             ),
-                            annotation: None,
-                            type_comment: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 31..32,
-                            arg: Identifier(
-                                "f",
+                            def: Arg {
+                                range: 31..32,
+                                arg: Identifier(
+                                    "f",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: Some(
+                                Constant(
+                                    ExprConstant {
+                                        range: 33..35,
+                                        value: Int(
+                                            30,
+                                        ),
+                                        kind: None,
+                                    },
+                                ),
                             ),
-                            annotation: None,
-                            type_comment: None,
                         },
                     ],
-                    kw_defaults: [
-                        Constant(
-                            ExprConstant {
-                                range: 27..29,
-                                value: Int(
-                                    20,
-                                ),
-                                kind: None,
-                            },
-                        ),
-                        Constant(
-                            ExprConstant {
-                                range: 33..35,
-                                value: Int(
-                                    30,
-                                ),
-                                kind: None,
-                            },
-                        ),
-                    ],
                     kwarg: None,
-                    defaults: [],
                 },
                 body: [
                     Pass(

parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults_and_varargs_and_kwargs.snap

@@ -11,32 +11,44 @@ Ok(
                     "f",
                 ),
                 args: Arguments {
-                    range: (),
+                    range: 6..45,
                     posonlyargs: [],
                     args: [
-                        Arg {
+                        ArgWithDefault {
                             range: 6..7,
-                            arg: Identifier(
-                                "a",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 6..7,
+                                arg: Identifier(
+                                    "a",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 9..10,
-                            arg: Identifier(
-                                "b",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 9..10,
+                                arg: Identifier(
+                                    "b",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 12..13,
-                            arg: Identifier(
-                                "c",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 12..13,
+                                arg: Identifier(
+                                    "c",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
                     ],
                     vararg: Some(
@@ -50,51 +62,63 @@ Ok(
                         },
                     ),
                     kwonlyargs: [
-                        Arg {
+                        ArgWithDefault {
                             range: 22..23,
-                            arg: Identifier(
-                                "d",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 22..23,
+                                arg: Identifier(
+                                    "d",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 25..26,
-                            arg: Identifier(
-                                "e",
+                            def: Arg {
+                                range: 25..26,
+                                arg: Identifier(
+                                    "e",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: Some(
+                                Constant(
+                                    ExprConstant {
+                                        range: 27..29,
+                                        value: Int(
+                                            20,
+                                        ),
+                                        kind: None,
+                                    },
+                                ),
                             ),
-                            annotation: None,
-                            type_comment: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 31..32,
-                            arg: Identifier(
-                                "f",
+                            def: Arg {
+                                range: 31..32,
+                                arg: Identifier(
+                                    "f",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: Some(
+                                Constant(
+                                    ExprConstant {
+                                        range: 33..35,
+                                        value: Int(
+                                            30,
+                                        ),
+                                        kind: None,
+                                    },
+                                ),
                             ),
-                            annotation: None,
-                            type_comment: None,
                         },
                     ],
-                    kw_defaults: [
-                        Constant(
-                            ExprConstant {
-                                range: 27..29,
-                                value: Int(
-                                    20,
-                                ),
-                                kind: None,
-                            },
-                        ),
-                        Constant(
-                            ExprConstant {
-                                range: 33..35,
-                                value: Int(
-                                    30,
-                                ),
-                                kind: None,
-                            },
-                        ),
-                    ],
                     kwarg: Some(
                         Arg {
                             range: 39..45,
@@ -105,7 +129,6 @@ Ok(
                             type_comment: None,
                         },
                     ),
-                    defaults: [],
                 },
                 body: [
                     Pass(

parser/src/snapshots/rustpython_parser__function__tests__function_pos_args.snap

@@ -11,39 +11,49 @@ Ok(
                     "f",
                 ),
                 args: Arguments {
-                    range: (),
+                    range: 6..13,
                     posonlyargs: [],
                     args: [
-                        Arg {
+                        ArgWithDefault {
                             range: 6..7,
-                            arg: Identifier(
-                                "a",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 6..7,
+                                arg: Identifier(
+                                    "a",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 9..10,
-                            arg: Identifier(
-                                "b",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 9..10,
+                                arg: Identifier(
+                                    "b",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 12..13,
-                            arg: Identifier(
-                                "c",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 12..13,
+                                arg: Identifier(
+                                    "c",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
                     ],
                     vararg: None,
                     kwonlyargs: [],
-                    kw_defaults: [],
                     kwarg: None,
-                    defaults: [],
                 },
                 body: [
                     Pass(

parser/src/snapshots/rustpython_parser__function__tests__function_pos_args_with_defaults.snap

@@ -11,58 +11,69 @@ Ok(
                     "f",
                 ),
                 args: Arguments {
-                    range: (),
+                    range: 6..19,
                     posonlyargs: [],
                     args: [
-                        Arg {
+                        ArgWithDefault {
                             range: 6..7,
-                            arg: Identifier(
-                                "a",
-                            ),
-                            annotation: None,
-                            type_comment: None,
+                            def: Arg {
+                                range: 6..7,
+                                arg: Identifier(
+                                    "a",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 9..10,
-                            arg: Identifier(
-                                "b",
+                            def: Arg {
+                                range: 9..10,
+                                arg: Identifier(
+                                    "b",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: Some(
+                                Constant(
+                                    ExprConstant {
+                                        range: 11..13,
+                                        value: Int(
+                                            20,
+                                        ),
+                                        kind: None,
+                                    },
+                                ),
                             ),
-                            annotation: None,
-                            type_comment: None,
                         },
-                        Arg {
+                        ArgWithDefault {
                             range: 15..16,
-                            arg: Identifier(
-                                "c",
+                            def: Arg {
+                                range: 15..16,
+                                arg: Identifier(
+                                    "c",
+                                ),
+                                annotation: None,
+                                type_comment: None,
+                            },
+                            default: Some(
+                                Constant(
+                                    ExprConstant {
+                                        range: 17..19,
+                                        value: Int(
+                                            30,
+                                        ),
+                                        kind: None,
+                                    },
+                                ),
                             ),
-                            annotation: None,
-                            type_comment: None,
                         },
                     ],
                     vararg: None,
                     kwonlyargs: [],
-                    kw_defaults: [],
                     kwarg: None,
-                    defaults: [
-                        Constant(
-                            ExprConstant {
-                                range: 11..13,
-                                value: Int(
-                                    20,
-                                ),
-                                kind: None,
-                            },
-                        ),
-                        Constant(
-                            ExprConstant {
-                                range: 17..19,
-                                value: Int(
-                                    30,
-                                ),
-                                kind: None,
-                            },
-                        ),
-                    ],
                 },
                 body: [
                     Pass(

parser/src/snapshots/rustpython_parser__function__tests__lambda_kw_only_args.snap

@@ -11,39 +11,49 @@ Ok(
                     ExprLambda {
                         range: 0..20,
                         args: Arguments {
-                            range: (),
+                            range: 7..17,
                             posonlyargs: [],
                             args: [],
                             vararg: None,
                             kwonlyargs: [
-                                Arg {
+                                ArgWithDefault {
                                     range: 10..11,
-                                    arg: Identifier(
-                                        "a",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 10..11,
+                                        arg: Identifier(
+                                            "a",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
-                                Arg {
+                                ArgWithDefault {
                                     range: 13..14,
-                                    arg: Identifier(
-                                        "b",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 13..14,
+                                        arg: Identifier(
+                                            "b",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
-                                Arg {
+                                ArgWithDefault {
                                     range: 16..17,
-                                    arg: Identifier(
-                                        "c",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 16..17,
+                                        arg: Identifier(
+                                            "c",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
                             ],
-                            kw_defaults: [],
                             kwarg: None,
-                            defaults: [],
                         },
                         body: Constant(
                             ExprConstant {

parser/src/snapshots/rustpython_parser__function__tests__lambda_kw_only_args_with_defaults.snap

@@ -11,58 +11,69 @@ Ok(
                     ExprLambda {
                         range: 0..26,
                         args: Arguments {
-                            range: (),
+                            range: 7..23,
                             posonlyargs: [],
                             args: [],
                             vararg: None,
                             kwonlyargs: [
-                                Arg {
+                                ArgWithDefault {
                                     range: 10..11,
-                                    arg: Identifier(
-                                        "a",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 10..11,
+                                        arg: Identifier(
+                                            "a",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
-                                Arg {
+                                ArgWithDefault {
                                     range: 13..14,
-                                    arg: Identifier(
-                                        "b",
+                                    def: Arg {
+                                        range: 13..14,
+                                        arg: Identifier(
+                                            "b",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: Some(
+                                        Constant(
+                                            ExprConstant {
+                                                range: 15..17,
+                                                value: Int(
+                                                    20,
+                                                ),
+                                                kind: None,
+                                            },
+                                        ),
                                     ),
-                                    annotation: None,
-                                    type_comment: None,
                                 },
-                                Arg {
+                                ArgWithDefault {
                                     range: 19..20,
-                                    arg: Identifier(
-                                        "c",
+                                    def: Arg {
+                                        range: 19..20,
+                                        arg: Identifier(
+                                            "c",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: Some(
+                                        Constant(
+                                            ExprConstant {
+                                                range: 21..23,
+                                                value: Int(
+                                                    30,
+                                                ),
+                                                kind: None,
+                                            },
+                                        ),
                                     ),
-                                    annotation: None,
-                                    type_comment: None,
                                 },
                             ],
-                            kw_defaults: [
-                                Constant(
-                                    ExprConstant {
-                                        range: 15..17,
-                                        value: Int(
-                                            20,
-                                        ),
-                                        kind: None,
-                                    },
-                                ),
-                                Constant(
-                                    ExprConstant {
-                                        range: 21..23,
-                                        value: Int(
-                                            30,
-                                        ),
-                                        kind: None,
-                                    },
-                                ),
-                            ],
                             kwarg: None,
-                            defaults: [],
                         },
                         body: Constant(
                             ExprConstant {

parser/src/snapshots/rustpython_parser__function__tests__lambda_no_args.snap

@@ -11,14 +11,12 @@ Ok(
                     ExprLambda {
                         range: 0..9,
                         args: Arguments {
-                            range: (),
+                            range: 0..9,
                             posonlyargs: [],
                             args: [],
                             vararg: None,
                             kwonlyargs: [],
-                            kw_defaults: [],
                             kwarg: None,
-                            defaults: [],
                         },
                         body: Constant(
                             ExprConstant {

parser/src/snapshots/rustpython_parser__function__tests__lambda_pos_and_kw_only_args.snap

@@ -11,56 +11,74 @@ Ok(
                     ExprLambda {
                         range: 0..26,
                         args: Arguments {
-                            range: (),
+                            range: 7..23,
                             posonlyargs: [],
                             args: [
-                                Arg {
+                                ArgWithDefault {
                                     range: 7..8,
-                                    arg: Identifier(
-                                        "a",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 7..8,
+                                        arg: Identifier(
+                                            "a",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
-                                Arg {
+                                ArgWithDefault {
                                     range: 10..11,
-                                    arg: Identifier(
-                                        "b",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 10..11,
+                                        arg: Identifier(
+                                            "b",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
-                                Arg {
+                                ArgWithDefault {
                                     range: 13..14,
-                                    arg: Identifier(
-                                        "c",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 13..14,
+                                        arg: Identifier(
+                                            "c",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
                             ],
                             vararg: None,
                             kwonlyargs: [
-                                Arg {
+                                ArgWithDefault {
                                     range: 19..20,
-                                    arg: Identifier(
-                                        "d",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 19..20,
+                                        arg: Identifier(
+                                            "d",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
-                                Arg {
+                                ArgWithDefault {
                                     range: 22..23,
-                                    arg: Identifier(
-                                        "e",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 22..23,
+                                        arg: Identifier(
+                                            "e",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
                             ],
-                            kw_defaults: [],
                             kwarg: None,
-                            defaults: [],
                         },
                         body: Constant(
                             ExprConstant {

parser/src/snapshots/rustpython_parser__function__tests__lambda_pos_args.snap

@@ -11,39 +11,49 @@ Ok(
                     ExprLambda {
                         range: 0..17,
                         args: Arguments {
-                            range: (),
+                            range: 7..14,
                             posonlyargs: [],
                             args: [
-                                Arg {
+                                ArgWithDefault {
                                     range: 7..8,
-                                    arg: Identifier(
-                                        "a",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 7..8,
+                                        arg: Identifier(
+                                            "a",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
-                                Arg {
+                                ArgWithDefault {
                                     range: 10..11,
-                                    arg: Identifier(
-                                        "b",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 10..11,
+                                        arg: Identifier(
+                                            "b",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
-                                Arg {
+                                ArgWithDefault {
                                     range: 13..14,
-                                    arg: Identifier(
-                                        "c",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 13..14,
+                                        arg: Identifier(
+                                            "c",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
                             ],
                             vararg: None,
                             kwonlyargs: [],
-                            kw_defaults: [],
                             kwarg: None,
-                            defaults: [],
                         },
                         body: Constant(
                             ExprConstant {

parser/src/snapshots/rustpython_parser__function__tests__lambda_pos_args_with_defaults.snap

@@ -11,58 +11,69 @@ Ok(
                     ExprLambda {
                         range: 0..23,
                         args: Arguments {
-                            range: (),
+                            range: 7..20,
                             posonlyargs: [],
                             args: [
-                                Arg {
+                                ArgWithDefault {
                                     range: 7..8,
-                                    arg: Identifier(
-                                        "a",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 7..8,
+                                        arg: Identifier(
+                                            "a",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
-                                Arg {
+                                ArgWithDefault {
                                     range: 10..11,
-                                    arg: Identifier(
-                                        "b",
+                                    def: Arg {
+                                        range: 10..11,
+                                        arg: Identifier(
+                                            "b",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: Some(
+                                        Constant(
+                                            ExprConstant {
+                                                range: 12..14,
+                                                value: Int(
+                                                    20,
+                                                ),
+                                                kind: None,
+                                            },
+                                        ),
                                     ),
-                                    annotation: None,
-                                    type_comment: None,
                                 },
-                                Arg {
+                                ArgWithDefault {
                                     range: 16..17,
-                                    arg: Identifier(
-                                        "c",
+                                    def: Arg {
+                                        range: 16..17,
+                                        arg: Identifier(
+                                            "c",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: Some(
+                                        Constant(
+                                            ExprConstant {
+                                                range: 18..20,
+                                                value: Int(
+                                                    30,
+                                                ),
+                                                kind: None,
+                                            },
+                                        ),
                                     ),
-                                    annotation: None,
-                                    type_comment: None,
                                 },
                             ],
                             vararg: None,
                             kwonlyargs: [],
-                            kw_defaults: [],
                             kwarg: None,
-                            defaults: [
-                                Constant(
-                                    ExprConstant {
-                                        range: 12..14,
-                                        value: Int(
-                                            20,
-                                        ),
-                                        kind: None,
-                                    },
-                                ),
-                                Constant(
-                                    ExprConstant {
-                                        range: 18..20,
-                                        value: Int(
-                                            30,
-                                        ),
-                                        kind: None,
-                                    },
-                                ),
-                            ],
                         },
                         body: Constant(
                             ExprConstant {

parser/src/snapshots/rustpython_parser__parser__tests__generator_expression_argument.snap

@@ -38,7 +38,7 @@ Call(
                     ),
                     generators: [
                         Comprehension {
-                            range: (),
+                            range: 22..139,
                             target: Name(
                                 ExprName {
                                     range: 26..29,

parser/src/snapshots/rustpython_parser__parser__tests__match.snap

@@ -37,7 +37,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 24..73,
                     pattern: MatchMapping(
                         PatternMatchMapping {
                             range: 29..52,
@@ -122,7 +122,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 103..177,
                     pattern: MatchMapping(
                         PatternMatchMapping {
                             range: 108..155,
@@ -236,7 +236,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 191..218,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 196..203,
@@ -319,7 +319,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 232..259,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 237..244,
@@ -402,7 +402,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 273..297,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 278..282,

parser/src/snapshots/rustpython_parser__parser__tests__match_as_identifier.snap

@@ -712,7 +712,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 544..556,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 549..550,
@@ -737,7 +737,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 561..581,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 566..567,
@@ -782,23 +782,25 @@ expression: parse_ast
                 ExprLambda {
                     range: 590..618,
                     args: Arguments {
-                        range: (),
+                        range: 597..602,
                         posonlyargs: [],
                         args: [
-                            Arg {
+                            ArgWithDefault {
                                 range: 597..602,
-                                arg: Identifier(
-                                    "query",
-                                ),
-                                annotation: None,
-                                type_comment: None,
+                                def: Arg {
+                                    range: 597..602,
+                                    arg: Identifier(
+                                        "query",
+                                    ),
+                                    annotation: None,
+                                    type_comment: None,
+                                },
+                                default: None,
                             },
                         ],
                         vararg: None,
                         kwonlyargs: [],
-                        kw_defaults: [],
                         kwarg: None,
-                        defaults: [],
                     },
                     body: Compare(
                         ExprCompare {

parser/src/snapshots/rustpython_parser__parser__tests__parse_class.snap

@@ -38,23 +38,25 @@ expression: "parse_program(source, \"<test>\").unwrap()"
                             "__init__",
                         ),
                         args: Arguments {
-                            range: (),
+                            range: 31..35,
                             posonlyargs: [],
                             args: [
-                                Arg {
+                                ArgWithDefault {
                                     range: 31..35,
-                                    arg: Identifier(
-                                        "self",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 31..35,
+                                        arg: Identifier(
+                                            "self",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
                             ],
                             vararg: None,
                             kwonlyargs: [],
-                            kw_defaults: [],
                             kwarg: None,
-                            defaults: [],
                         },
                         body: [
                             Pass(
@@ -75,41 +77,47 @@ expression: "parse_program(source, \"<test>\").unwrap()"
                             "method_with_default",
                         ),
                         args: Arguments {
-                            range: (),
+                            range: 70..89,
                             posonlyargs: [],
                             args: [
-                                Arg {
+                                ArgWithDefault {
                                     range: 70..74,
-                                    arg: Identifier(
-                                        "self",
-                                    ),
-                                    annotation: None,
-                                    type_comment: None,
+                                    def: Arg {
+                                        range: 70..74,
+                                        arg: Identifier(
+                                            "self",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: None,
                                 },
-                                Arg {
+                                ArgWithDefault {
                                     range: 76..79,
-                                    arg: Identifier(
-                                        "arg",
+                                    def: Arg {
+                                        range: 76..79,
+                                        arg: Identifier(
+                                            "arg",
+                                        ),
+                                        annotation: None,
+                                        type_comment: None,
+                                    },
+                                    default: Some(
+                                        Constant(
+                                            ExprConstant {
+                                                range: 80..89,
+                                                value: Str(
+                                                    "default",
+                                                ),
+                                                kind: None,
+                                            },
+                                        ),
                                     ),
-                                    annotation: None,
-                                    type_comment: None,
                                 },
                             ],
                             vararg: None,
                             kwonlyargs: [],
-                            kw_defaults: [],
                             kwarg: None,
-                            defaults: [
-                                Constant(
-                                    ExprConstant {
-                                        range: 80..89,
-                                        value: Str(
-                                            "default",
-                                        ),
-                                        kind: None,
-                                    },
-                                ),
-                            ],
                         },
                         body: [
                             Pass(

parser/src/snapshots/rustpython_parser__parser__tests__parse_dict_comprehension.snap

@@ -25,7 +25,7 @@ DictComp(
         ),
         generators: [
             Comprehension {
-                range: (),
+                range: 8..18,
                 target: Name(
                     ExprName {
                         range: 12..13,

parser/src/snapshots/rustpython_parser__parser__tests__parse_double_list_comprehension.snap

@@ -16,7 +16,7 @@ ListComp(
         ),
         generators: [
             Comprehension {
-                range: (),
+                range: 3..17,
                 target: Tuple(
                     ExprTuple {
                         range: 7..12,
@@ -56,7 +56,7 @@ ListComp(
                 is_async: false,
             },
             Comprehension {
-                range: (),
+                range: 18..47,
                 target: Name(
                     ExprName {
                         range: 22..23,

parser/src/snapshots/rustpython_parser__parser__tests__parse_generator_comprehension.snap

@@ -16,7 +16,7 @@ GeneratorExp(
         ),
         generators: [
             Comprehension {
-                range: (),
+                range: 3..13,
                 target: Name(
                     ExprName {
                         range: 7..8,

parser/src/snapshots/rustpython_parser__parser__tests__parse_if_else_generator_comprehension.snap

@@ -39,7 +39,7 @@ GeneratorExp(
         ),
         generators: [
             Comprehension {
-                range: (),
+                range: 15..25,
                 target: Name(
                     ExprName {
                         range: 19..20,

parser/src/snapshots/rustpython_parser__parser__tests__parse_lambda.snap

@@ -10,31 +10,37 @@ expression: parse_ast
                 ExprLambda {
                     range: 0..18,
                     args: Arguments {
-                        range: (),
+                        range: 7..11,
                         posonlyargs: [],
                         args: [
-                            Arg {
+                            ArgWithDefault {
                                 range: 7..8,
-                                arg: Identifier(
-                                    "x",
-                                ),
-                                annotation: None,
-                                type_comment: None,
+                                def: Arg {
+                                    range: 7..8,
+                                    arg: Identifier(
+                                        "x",
+                                    ),
+                                    annotation: None,
+                                    type_comment: None,
+                                },
+                                default: None,
                             },
-                            Arg {
+                            ArgWithDefault {
                                 range: 10..11,
-                                arg: Identifier(
-                                    "y",
-                                ),
-                                annotation: None,
-                                type_comment: None,
+                                def: Arg {
+                                    range: 10..11,
+                                    arg: Identifier(
+                                        "y",
+                                    ),
+                                    annotation: None,
+                                    type_comment: None,
+                                },
+                                default: None,
                             },
                         ],
                         vararg: None,
                         kwonlyargs: [],
-                        kw_defaults: [],
                         kwarg: None,
-                        defaults: [],
                     },
                     body: BinOp(
                         ExprBinOp {

parser/src/snapshots/rustpython_parser__parser__tests__parse_list_comprehension.snap

@@ -16,7 +16,7 @@ ListComp(
         ),
         generators: [
             Comprehension {
-                range: (),
+                range: 3..13,
                 target: Name(
                     ExprName {
                         range: 7..8,

parser/src/snapshots/rustpython_parser__parser__tests__parse_named_expression_generator_comprehension.snap

@@ -45,7 +45,7 @@ GeneratorExp(
         ),
         generators: [
             Comprehension {
-                range: (),
+                range: 12..22,
                 target: Name(
                     ExprName {
                         range: 16..17,

parser/src/snapshots/rustpython_parser__parser__tests__patma.snap

@@ -17,7 +17,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 80..103,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 85..88,
@@ -86,7 +86,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 139..167,
                     pattern: MatchClass(
                         PatternMatchClass {
                             range: 144..152,
@@ -163,7 +163,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 203..229,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 208..209,
@@ -219,7 +219,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 234..260,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 239..240,
@@ -291,7 +291,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 296..332,
                     pattern: MatchOr(
                         PatternMatchOr {
                             range: 301..314,
@@ -402,7 +402,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 368..403,
                     pattern: MatchOr(
                         PatternMatchOr {
                             range: 373..388,
@@ -527,7 +527,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 458..489,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 463..467,
@@ -562,7 +562,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 494..523,
                     pattern: MatchMapping(
                         PatternMatchMapping {
                             range: 499..501,
@@ -608,7 +608,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 559..594,
                     pattern: MatchMapping(
                         PatternMatchMapping {
                             range: 564..579,
@@ -702,7 +702,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 599..687,
                     pattern: MatchOr(
                         PatternMatchOr {
                             range: 604..672,
@@ -940,7 +940,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 692..714,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 697..699,
@@ -994,7 +994,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 750..782,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 755..767,
@@ -1072,7 +1072,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 818..841,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 823..826,
@@ -1141,7 +1141,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 877..913,
                     pattern: MatchOr(
                         PatternMatchOr {
                             range: 882..895,
@@ -1252,7 +1252,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 949..975,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 954..955,
@@ -1324,7 +1324,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1011..1037,
                     pattern: MatchMapping(
                         PatternMatchMapping {
                             range: 1016..1022,
@@ -1389,7 +1389,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 1042..1068,
                     pattern: MatchMapping(
                         PatternMatchMapping {
                             range: 1047..1053,
@@ -1454,7 +1454,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 1073..1098,
                     pattern: MatchMapping(
                         PatternMatchMapping {
                             range: 1078..1083,
@@ -1521,7 +1521,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1138..1162,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 1143..1147,
@@ -1582,7 +1582,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1198..1219,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 1203..1204,
@@ -1628,7 +1628,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 1224..1245,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 1229..1230,
@@ -1690,7 +1690,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1281..1315,
                     pattern: MatchMapping(
                         PatternMatchMapping {
                             range: 1286..1298,
@@ -1794,7 +1794,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1359..1392,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 1364..1377,
@@ -1901,7 +1901,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1428..1451,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 1433..1436,
@@ -1954,7 +1954,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 1456..1498,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 1461..1467,
@@ -2069,7 +2069,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 1503..1529,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 1508..1514,
@@ -2152,7 +2152,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1565..1595,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 1570..1580,
@@ -2235,7 +2235,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1631..1664,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 1636..1649,
@@ -2327,7 +2327,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1703..1726,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 1708..1711,
@@ -2393,7 +2393,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1762..1789,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 1767..1774,
@@ -2482,7 +2482,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1825..1849,
                     pattern: MatchSingleton(
                         PatternMatchSingleton {
                             range: 1830..1834,
@@ -2536,7 +2536,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1885..1906,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 1890..1891,
@@ -2598,7 +2598,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 1942..1967,
                     pattern: MatchSingleton(
                         PatternMatchSingleton {
                             range: 1947..1952,
@@ -2654,7 +2654,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 2003..2025,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 2008..2010,
@@ -2692,7 +2692,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 2030..2054,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 2035..2039,
@@ -2745,7 +2745,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 2059..2081,
                     pattern: MatchValue(
                         PatternMatchValue {
                             range: 2064..2066,
@@ -2807,7 +2807,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 2117..2138,
                     pattern: MatchAs(
                         PatternMatchAs {
                             range: 2122..2123,
@@ -2866,7 +2866,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 2174..2207,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 2179..2192,
@@ -2953,7 +2953,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 2243..2307,
                     pattern: MatchOr(
                         PatternMatchOr {
                             range: 2248..2278,
@@ -3130,7 +3130,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 2343..2378,
                     pattern: MatchMapping(
                         PatternMatchMapping {
                             range: 2348..2363,
@@ -3224,7 +3224,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 2383..2472,
                     pattern: MatchOr(
                         PatternMatchOr {
                             range: 2388..2457,
@@ -3462,7 +3462,7 @@ expression: parse_ast
                     ],
                 },
                 MatchCase {
-                    range: (),
+                    range: 2477..2499,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 2482..2484,
@@ -3542,7 +3542,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 2543..2568,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 2548..2553,
@@ -3647,7 +3647,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 2612..2638,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 2617..2623,
@@ -3726,7 +3726,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 2675..2697,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 2680..2682,
@@ -3809,7 +3809,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 2736..2760,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 2741..2745,
@@ -3900,7 +3900,7 @@ expression: parse_ast
             ),
             cases: [
                 MatchCase {
-                    range: (),
+                    range: 2802..2829,
                     pattern: MatchSequence(
                         PatternMatchSequence {
                             range: 2807..2814,

parser/src/snapshots/rustpython_parser__parser__tests__variadic_generics.snap

@@ -10,7 +10,7 @@ expression: parse_ast
                 "args_to_tuple",
             ),
             args: Arguments {
-                range: (),
+                range: 19..29,
                 posonlyargs: [],
                 args: [],
                 vararg: Some(
@@ -40,9 +40,7 @@ expression: parse_ast
                     },
                 ),
                 kwonlyargs: [],
-                kw_defaults: [],
                 kwarg: None,
-                defaults: [],
             },
             body: [
                 Expr(

parser/src/snapshots/rustpython_parser__parser__tests__with_statement.snap

@@ -8,7 +8,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 0..12,
             items: [
                 Withitem {
-                    range: (),
+                    range: 5..6,
                     context_expr: Constant(
                         ExprConstant {
                             range: 5..6,
@@ -36,7 +36,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 13..30,
             items: [
                 Withitem {
-                    range: (),
+                    range: 18..24,
                     context_expr: Constant(
                         ExprConstant {
                             range: 18..19,
@@ -74,7 +74,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 31..46,
             items: [
                 Withitem {
-                    range: (),
+                    range: 36..37,
                     context_expr: Constant(
                         ExprConstant {
                             range: 36..37,
@@ -87,7 +87,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
                     optional_vars: None,
                 },
                 Withitem {
-                    range: (),
+                    range: 39..40,
                     context_expr: Constant(
                         ExprConstant {
                             range: 39..40,
@@ -115,7 +115,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 47..72,
             items: [
                 Withitem {
-                    range: (),
+                    range: 52..58,
                     context_expr: Constant(
                         ExprConstant {
                             range: 52..53,
@@ -138,7 +138,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
                     ),
                 },
                 Withitem {
-                    range: (),
+                    range: 60..66,
                     context_expr: Constant(
                         ExprConstant {
                             range: 60..61,
@@ -176,7 +176,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 73..97,
             items: [
                 Withitem {
-                    range: (),
+                    range: 78..91,
                     context_expr: IfExp(
                         ExprIfExp {
                             range: 78..91,
@@ -227,7 +227,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 98..127,
             items: [
                 Withitem {
-                    range: (),
+                    range: 103..121,
                     context_expr: IfExp(
                         ExprIfExp {
                             range: 103..116,
@@ -288,7 +288,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 128..141,
             items: [
                 Withitem {
-                    range: (),
+                    range: 133..135,
                     context_expr: Tuple(
                         ExprTuple {
                             range: 133..135,
@@ -314,7 +314,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 142..160,
             items: [
                 Withitem {
-                    range: (),
+                    range: 147..154,
                     context_expr: Tuple(
                         ExprTuple {
                             range: 147..149,
@@ -350,7 +350,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 161..175,
             items: [
                 Withitem {
-                    range: (),
+                    range: 167..168,
                     context_expr: Constant(
                         ExprConstant {
                             range: 167..168,
@@ -378,7 +378,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 176..195,
             items: [
                 Withitem {
-                    range: (),
+                    range: 181..189,
                     context_expr: Constant(
                         ExprConstant {
                             range: 182..183,
@@ -416,7 +416,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 196..211,
             items: [
                 Withitem {
-                    range: (),
+                    range: 202..203,
                     context_expr: Constant(
                         ExprConstant {
                             range: 202..203,
@@ -444,7 +444,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 212..232,
             items: [
                 Withitem {
-                    range: (),
+                    range: 217..226,
                     context_expr: Tuple(
                         ExprTuple {
                             range: 217..221,
@@ -490,7 +490,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 233..250,
             items: [
                 Withitem {
-                    range: (),
+                    range: 239..243,
                     context_expr: Constant(
                         ExprConstant {
                             range: 239..240,
@@ -503,7 +503,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
                     optional_vars: None,
                 },
                 Withitem {
-                    range: (),
+                    range: 239..243,
                     context_expr: Constant(
                         ExprConstant {
                             range: 242..243,
@@ -531,7 +531,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 251..273,
             items: [
                 Withitem {
-                    range: (),
+                    range: 256..267,
                     context_expr: Tuple(
                         ExprTuple {
                             range: 256..262,
@@ -586,7 +586,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 274..290,
             items: [
                 Withitem {
-                    range: (),
+                    range: 279..284,
                     context_expr: Tuple(
                         ExprTuple {
                             range: 279..284,
@@ -628,7 +628,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 291..312,
             items: [
                 Withitem {
-                    range: (),
+                    range: 296..306,
                     context_expr: Tuple(
                         ExprTuple {
                             range: 296..301,
@@ -680,7 +680,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 313..331,
             items: [
                 Withitem {
-                    range: (),
+                    range: 318..325,
                     context_expr: Tuple(
                         ExprTuple {
                             range: 318..325,
@@ -731,7 +731,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 332..355,
             items: [
                 Withitem {
-                    range: (),
+                    range: 337..349,
                     context_expr: Tuple(
                         ExprTuple {
                             range: 337..344,
@@ -792,7 +792,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 356..375,
             items: [
                 Withitem {
-                    range: (),
+                    range: 361..369,
                     context_expr: NamedExpr(
                         ExprNamedExpr {
                             range: 362..368,
@@ -834,7 +834,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 376..400,
             items: [
                 Withitem {
-                    range: (),
+                    range: 381..394,
                     context_expr: NamedExpr(
                         ExprNamedExpr {
                             range: 382..388,
@@ -886,7 +886,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 401..428,
             items: [
                 Withitem {
-                    range: (),
+                    range: 406..422,
                     context_expr: Tuple(
                         ExprTuple {
                             range: 406..422,
@@ -959,7 +959,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 429..461,
             items: [
                 Withitem {
-                    range: (),
+                    range: 434..455,
                     context_expr: Tuple(
                         ExprTuple {
                             range: 434..450,
@@ -1042,7 +1042,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 462..481,
             items: [
                 Withitem {
-                    range: (),
+                    range: 468..474,
                     context_expr: Constant(
                         ExprConstant {
                             range: 468..469,
@@ -1080,7 +1080,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 482..502,
             items: [
                 Withitem {
-                    range: (),
+                    range: 488..494,
                     context_expr: Constant(
                         ExprConstant {
                             range: 488..489,
@@ -1118,7 +1118,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 503..530,
             items: [
                 Withitem {
-                    range: (),
+                    range: 509..515,
                     context_expr: Constant(
                         ExprConstant {
                             range: 509..510,
@@ -1141,7 +1141,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
                     ),
                 },
                 Withitem {
-                    range: (),
+                    range: 517..523,
                     context_expr: Constant(
                         ExprConstant {
                             range: 517..518,
@@ -1179,7 +1179,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
             range: 531..559,
             items: [
                 Withitem {
-                    range: (),
+                    range: 537..543,
                     context_expr: Constant(
                         ExprConstant {
                             range: 537..538,
@@ -1202,7 +1202,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
                     ),
                 },
                 Withitem {
-                    range: (),
+                    range: 545..551,
                     context_expr: Constant(
                         ExprConstant {
                             range: 545..546,