add simple implementation for fuzzing

Author: jvllmr

.gitignore

@@ -1 +1,2 @@
 /target
+.pdm-python

.vscode/settings.json

@@ -6,5 +6,7 @@
 	"editor.formatOnSave": true,
 	"[python]": {
 		"editor.defaultFormatter": "charliermarsh.ruff"
-	}
+	},
+	"python.defaultInterpreterPath": ".venv/bin/python",
+	"python.terminal.activateEnvInCurrentTerminal": true
 }

Cargo.lock

@@ -9,3 +9,4 @@ rustpython-ast = { version = "0.4.0" }
 [dev-dependencies]
 rustpython-parser = "0.4.0"
 rustpython-ast = { version = "0.4.0", features = ["fold"] }
+rand = "0.8.5"

Cargo.toml

@@ -0,0 +1 @@
+*.py

fuzzy_test_files/.gitignore

@@ -0,0 +1 @@
+*.py

fuzzy_test_files_unparsed/.gitignore

@@ -0,0 +1,15 @@
+[project]
+name = "rustpython-unparser"
+version = "0.1.0"
+description = "Default template for PDM package"
+authors = [
+    {name = "Jan Vollmer", email = "[email protected]"},
+]
+dependencies = ["pysource-codegen>=0.6.0"]
+requires-python = ">=3.10"
+readme = "README.md"
+license = {text = "MIT"}
+
+
+[tool.pdm]
+distribution = false

pdm.lock

@@ -15,6 +15,7 @@ mod tests {
     use std::fs;
     use std::io;
     use std::path::Path;
+    use std::process::Command;
 
     struct RangesEraser {}
 
@@ -38,14 +39,18 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_predefined_files() -> io::Result<()> {
-        for entry in fs::read_dir("./test_files")? {
+    fn run_tests_on_folders(source_folder: &str, results_folder: &str) -> io::Result<()> {
+        for entry in fs::read_dir(source_folder)? {
             let entry = entry?;
 
             let entry_path = entry.path();
 
-            if entry_path.is_file() {
+            if entry_path.is_file()
+                && entry_path.file_name().is_some_and(|name| {
+                    name.to_str()
+                        .is_some_and(|inner_name| inner_name.ends_with(".py"))
+                })
+            {
                 let file_content = fs::read_to_string(&entry_path)?;
                 let entry_path_str = entry_path.to_str().unwrap();
                 let mut unparser = Unparser::new();
@@ -56,7 +61,7 @@ mod tests {
                 let new_source = unparser.source;
                 let old_file_name = entry_path.file_name().unwrap().to_str().unwrap();
                 let new_file_name = old_file_name.replace(".py", "_unparsed.py");
-                let new_entry_path_str = format!("./test_files_unparsed/{}", new_file_name);
+                let new_entry_path_str = format!("{}/{}", results_folder, new_file_name);
                 let new_entry_path = Path::new(&new_entry_path_str);
                 fs::write(&new_entry_path, &new_source)?;
                 let new_stmts =
@@ -80,4 +85,30 @@ mod tests {
         }
         Ok(())
     }
+
+    #[test]
+    fn test_predefined_files() -> io::Result<()> {
+        run_tests_on_folders("./test_files", "./test_files_unparsed")
+    }
+    #[test]
+    #[ignore = "Fuzzy tests are unstable and should only be used to explore new test cases"]
+    fn test_fuzzy_files() -> io::Result<()> {
+        let seed = rand::random::<usize>();
+
+        for i in 0..10 {
+            let file_name = format!("./fuzzy_test_files/fuzzy_test{}.py", i);
+
+            let file_content = Command::new(".venv/bin/python")
+                .arg("-m")
+                .arg("pysource_codegen")
+                .arg("--seed")
+                .arg(&seed.to_string())
+                .output()
+                .expect("failed to execute process");
+            fs::write(&file_name, &file_content.stdout)?;
+        }
+
+        run_tests_on_folders("./fuzzy_test_files", "./fuzzy_test_files_unparsed")?;
+        Ok(())
+    }
 }

pyproject.toml

@@ -790,14 +790,17 @@ impl Unparser {
         for generator in &node.generators {
             self.unparse_comprehension(generator);
         }
+        self.write_str("}");
     }
 
     fn unparse_expr_generator_exp(&mut self, node: &ExprGeneratorExp<TextRange>) {
+        self.write_str("(");
         self.unparse_expr(&node.elt);
 
         for generator in &node.generators {
             self.unparse_comprehension(generator);
         }
+        self.write_str(")");
     }
 
     fn unparse_expr_await(&mut self, node: &ExprAwait<TextRange>) {
@@ -1023,9 +1026,9 @@ impl Unparser {
 
     fn unparse_comprehension(&mut self, node: &Comprehension<TextRange>) {
         if node.is_async {
-            self.write_str("async for");
+            self.write_str(" async for ");
         } else {
-            self.write_str("for");
+            self.write_str(" for ");
         }
         self.unparse_expr(&node.target);
         self.write_str(" in ");
@@ -1045,12 +1048,21 @@ impl Unparser {
         &mut self,
         node: &ExceptHandlerExceptHandler<TextRange>,
     ) {
+        self.fill("except");
+        if self.in_try_star {
+            self.write_str("*")
+        }
+
         if let Some(type_) = &node.type_ {
+            self.write_str(" ");
             self.unparse_expr(type_);
         }
-        for stmt in &node.body {
-            self.unparse_stmt(stmt);
-        }
+        self.write_str(":");
+        self.block(|block_self| {
+            for stmt in &node.body {
+                block_self.unparse_stmt(stmt);
+            }
+        });
     }
 
     fn unparse_arguments(&mut self, node: &Arguments<TextRange>) {

src/lib.rs

@@ -0,0 +1,7 @@
+import random
+import string
+
+generator = (value for value in random.choices(string.ascii_letters))
+set_ = {def_ for def_ in random.choices(string.ascii_letters)}
+dict_ = {k: v for k, v in enumerate(random.choices(string.ascii_letters))}
+list_ = [value for value in random.choices(string.ascii_letters)]

src/unparser.rs

@@ -0,0 +1,24 @@
+# example comes from fuzzing
+
+try:
+    name_0  # type: ignore # noqa: F821
+    name_4  # type: ignore # noqa: F821
+    name_4  # type: ignore # noqa: F821
+    name_1  # type: ignore # noqa: F821
+except name_1:  # type: ignore # noqa: F821
+    pass
+except name_4:  # type: ignore # noqa: F821
+    pass
+    pass
+except:  # noqa: E722
+    pass
+    pass
+else:
+    pass
+    pass
+finally:
+    pass
+    pass
+    pass
+    pass
+    pass