RustPython
diff --git a/‎crates/codegen/src/unparse.rs‎
Lines changed: 16 additions & 1 deletion b/‎crates/codegen/src/unparse.rs‎
Lines changed: 16 additions & 1 deletion
diff --git a/‎crates/vm/src/stdlib/ast/expression.rs‎
Lines changed: 20 additions & 1 deletion b/‎crates/vm/src/stdlib/ast/expression.rs‎
Lines changed: 20 additions & 1 deletion
diff --git a/‎crates/vm/src/stdlib/ast/other.rs‎
Lines changed: 1 addition & 1 deletion b/‎crates/vm/src/stdlib/ast/other.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎crates/vm/src/stdlib/ast/python.rs‎
Lines changed: 27 additions & 0 deletions b/‎crates/vm/src/stdlib/ast/python.rs‎
Lines changed: 27 additions & 0 deletions
diff --git a/‎crates/vm/src/stdlib/builtins.rs‎
Lines changed: 7 additions & 0 deletions b/‎crates/vm/src/stdlib/builtins.rs‎
Lines changed: 7 additions & 0 deletions
@@ -363,7 +363,9 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 self.p(")")?;
             }
             ast::Expr::FString(ast::ExprFString { value, .. }) => self.unparse_fstring(value)?,
-            ast::Expr::TString(_) => self.p("t\"\"")?,
+            ast::Expr::TString(ast::ExprTString { value, .. }) => {
+                self.unparse_tstring(value)?
+            }
             ast::Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => {
                 if value.is_unicode() {
                     self.p("u")?
@@ -626,6 +628,19 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             .str_repr()
             .write(self.f)
     }
+
+    fn unparse_tstring(&mut self, value: &ast::TStringValue) -> fmt::Result {
+        self.p("t")?;
+        let body = fmt::from_fn(|f| {
+            value.iter().try_for_each(|tstring| {
+                Unparser::new(f, self.source).unparse_fstring_body(&tstring.elements)
+            })
+        })
+        .to_string();
+        UnicodeEscape::new_repr(body.as_str().as_ref())
+            .str_repr()
+            .write(self.f)
+    }
 }
 
 pub struct UnparseExpr<'a> {
 
@@ -327,7 +327,26 @@ impl Node for ast::ExprLambda {
             .into_ref_with_type(vm, pyast::NodeExprLambda::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("args", parameters.ast_to_object(vm, source_file), vm)
+        // 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()
+            }
+        };
+        dict.set_item("args", args, vm)
             .unwrap();
         dict.set_item("body", body.ast_to_object(vm, source_file), vm)
             .unwrap();
 
@@ -3,7 +3,7 @@ use rustpython_compiler_core::SourceFile;
 
 impl Node for ast::ConversionFlag {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
-        vm.ctx.new_int(self as u8).into()
+        vm.ctx.new_int(self as i8).into()
     }
 
     fn ast_from_object(
 
@@ -65,8 +65,13 @@ pub(crate) mod _ast {
                     if fields.len() == 1 { "" } else { "s" },
                 )));
             }
+
+            // Track which fields were set
+            let mut set_fields = std::collections::HashSet::new();
+
             for (name, arg) in fields.iter().zip(args.args) {
                 zelf.set_attr(name, arg, vm)?;
+                set_fields.insert(name.as_str().to_string());
             }
             for (key, value) in args.kwargs {
                 if let Some(pos) = fields.iter().position(|f| f.as_str() == key)
@@ -78,9 +83,31 @@ pub(crate) mod _ast {
                         key
                     )));
                 }
+                set_fields.insert(key.clone());
                 zelf.set_attr(vm.ctx.intern_str(key), value, vm)?;
             }
 
+            // Set default values for fields that weren't provided
+            let class_name = &*zelf.class().name();
+            if class_name == "Module" && !set_fields.contains("type_ignores") {
+                zelf.set_attr("type_ignores", vm.ctx.new_list(vec![]), vm)?;
+            }
+            if class_name == "ImportFrom" && !set_fields.contains("level") {
+                zelf.set_attr("level", vm.ctx.new_int(0), vm)?;
+            }
+            if class_name == "alias" && !set_fields.contains("asname") {
+                zelf.set_attr("asname", vm.ctx.none(), vm)?;
+            }
+            // Set type_comment to None for nodes that support it
+            if !set_fields.contains("type_comment") {
+                match class_name {
+                    "FunctionDef" | "AsyncFunctionDef" | "For" | "AsyncFor" | "With" | "AsyncWith" | "arg" => {
+                        zelf.set_attr("type_comment", vm.ctx.none(), vm)?;
+                    }
+                    _ => {}
+                }
+            }
+
             Ok(())
         }
 
 
@@ -141,6 +141,13 @@ mod builtins {
                 .source
                 .fast_isinstance(&ast::NodeAst::make_class(&vm.ctx))
             {
+                // If PyCF_ONLY_AST is set, just return the AST node as-is
+                use num_traits::Zero;
+                let flags = args.flags.map_or(Ok(0), |v| v.try_to_primitive(vm))?;
+                if !(flags & ast::PY_COMPILE_FLAG_AST_ONLY).is_zero() {
+                    return Ok(args.source);
+                }
+
                 #[cfg(not(feature = "rustpython-codegen"))]
                 {
                     return Err(vm.new_type_error(CODEGEN_NOT_SUPPORTED.to_owned()));
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ use rustpython_compiler_core::SourceFile;`
`3`	`3`
`4`	`4`	`impl Node for ast::ConversionFlag {`
`5`	`5`	`fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {`
`6`		`- vm.ctx.new_int(self as u8).into()`
	`6`	`+ vm.ctx.new_int(self as i8).into()`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`fn ast_from_object(`
Original file line number	Diff line number	Diff line change
`@@ -141,6 +141,13 @@ mod builtins {`
`141`	`141`	`.source`
`142`	`142`	`.fast_isinstance(&ast::NodeAst::make_class(&vm.ctx))`
`143`	`143`	`{`
	`144`	`+ // If PyCF_ONLY_AST is set, just return the AST node as-is`
	`145`	`+ use num_traits::Zero;`
	`146`	`+ let flags = args.flags.map_or(Ok(0), \|v\| v.try_to_primitive(vm))?;`
	`147`	`+ if !(flags & ast::PY_COMPILE_FLAG_AST_ONLY).is_zero() {`
	`148`	`+ return Ok(args.source);`
	`149`	`+ }`
	`150`	`+`
`144`	`151`	`#[cfg(not(feature = "rustpython-codegen"))]`
`145`	`152`	`{`
`146`	`153`	`return Err(vm.new_type_error(CODEGEN_NOT_SUPPORTED.to_owned()));`