extract empty_arguments_object helper

youknowone · youknowone · commit 0e4bec34e673 · 2026-02-03T09:29:07.000+09:00
diff --git a/crates/vm/src/stdlib/ast.rs b/crates/vm/src/stdlib/ast.rs
@@ -265,6 +265,22 @@ fn node_add_location(
     .unwrap();
 }
 
+/// Create an empty `arguments` AST node (no parameters).
+fn empty_arguments_object(vm: &VirtualMachine) -> PyObjectRef {
+    let node = NodeAst
+        .into_ref_with_type(vm, pyast::NodeArguments::static_type().to_owned())
+        .unwrap();
+    let dict = node.as_object().dict().unwrap();
+    for list_field in ["posonlyargs", "args", "kwonlyargs", "kw_defaults", "defaults"] {
+        dict.set_item(list_field, vm.ctx.new_list(vec![]).into(), vm)
+            .unwrap();
+    }
+    for none_field in ["vararg", "kwarg"] {
+        dict.set_item(none_field, vm.ctx.none(), vm).unwrap();
+    }
+    node.into()
+}
+
 #[cfg(feature = "parser")]
 pub(crate) fn parse(
     vm: &VirtualMachine,
diff --git a/crates/vm/src/stdlib/ast/expression.rs b/crates/vm/src/stdlib/ast/expression.rs
@@ -330,31 +330,7 @@ impl Node for ast::ExprLambda {
         // Lambda with no parameters should have an empty arguments object, not None
         let args = match parameters {
             Some(params) => params.ast_to_object(vm, source_file),
-            None => {
-                // Create an empty arguments object
-                let args_node = NodeAst
-                    .into_ref_with_type(vm, pyast::NodeArguments::static_type().to_owned())
-                    .unwrap();
-                let args_dict = args_node.as_object().dict().unwrap();
-                args_dict
-                    .set_item("posonlyargs", vm.ctx.new_list(vec![]).into(), vm)
-                    .unwrap();
-                args_dict
-                    .set_item("args", vm.ctx.new_list(vec![]).into(), vm)
-                    .unwrap();
-                args_dict.set_item("vararg", vm.ctx.none(), vm).unwrap();
-                args_dict
-                    .set_item("kwonlyargs", vm.ctx.new_list(vec![]).into(), vm)
-                    .unwrap();
-                args_dict
-                    .set_item("kw_defaults", vm.ctx.new_list(vec![]).into(), vm)
-                    .unwrap();
-                args_dict.set_item("kwarg", vm.ctx.none(), vm).unwrap();
-                args_dict
-                    .set_item("defaults", vm.ctx.new_list(vec![]).into(), vm)
-                    .unwrap();
-                args_node.into()
-            }
+            None => empty_arguments_object(vm),
         };
         dict.set_item("args", args, vm).unwrap();
         dict.set_item("body", body.ast_to_object(vm, source_file), vm)
diff --git a/crates/vm/src/stdlib/ast/python.rs b/crates/vm/src/stdlib/ast/python.rs
@@ -95,12 +95,11 @@ pub(crate) mod _ast {
                 .is_some();
             if has_field_types {
                 // ASDL list fields (type*) default to empty list,
-                // optional fields (type?) default to None.
+                // optional/required fields default to None.
+                // Fields that are always list-typed regardless of node class.
                 const LIST_FIELDS: &[&str] = &[
-                    "args",
                     "argtypes",
                     "bases",
-                    "body",
                     "cases",
                     "comparators",
                     "decorator_list",
@@ -125,19 +124,33 @@ pub(crate) mod _ast {
                     "values",
                 ];
 
+                let class_name = zelf.class().name().to_string();
+
                 for field in &fields {
                     if !set_fields.contains(field.as_str()) {
-                        let default: PyObjectRef = if LIST_FIELDS.contains(&field.as_str()) {
+                        let field_name = field.as_str();
+                        // "args" and "body" have different ASDL types depending on the node:
+                        //   args: expr* in Call, arg* in arguments, but single `arguments` in
+                        //         Lambda/FunctionDef/AsyncFunctionDef
+                        //   body: stmt* in most nodes, but single `expr` in Lambda/Expression
+                        let is_list_field = if field_name == "args" {
+                            class_name == "Call" || class_name == "arguments"
+                        } else if field_name == "body" {
+                            class_name != "Lambda" && class_name != "Expression"
+                        } else {
+                            LIST_FIELDS.contains(&field_name)
+                        };
+
+                        let default: PyObjectRef = if is_list_field {
                             vm.ctx.new_list(vec![]).into()
                         } else {
                             vm.ctx.none()
                         };
-                        zelf.set_attr(vm.ctx.intern_str(field.as_str()), default, vm)?;
+                        zelf.set_attr(vm.ctx.intern_str(field_name), default, vm)?;
                     }
                 }
 
                 // Special defaults that are not None or empty list
-                let class_name = &*zelf.class().name();
                 if class_name == "ImportFrom" && !set_fields.contains("level") {
                     zelf.set_attr("level", vm.ctx.new_int(0), vm)?;
                 }
