Fix codegen for positional arguments with defaults

qingshi163 · Sep 10, 2024 · Oct 7, 2024 · Oct 7, 2024 · Oct 15, 2024 · Oct 15, 2024
commit 6b49cfb77572b2d50aa20bedecf148958da8f639
diff --git a/Cargo.toml b/Cargo.toml
@@ -27,7 +27,7 @@ ssl-vendor = ["ssl", "rustpython-stdlib/ssl-vendor"]
 rustpython-compiler = { workspace = true }
 rustpython-pylib = { workspace = true, optional = true }
 rustpython-stdlib = { workspace = true, optional = true, features = ["compiler"] }
-rustpython-vm = { workspace = true, features = ["compiler"] }
+rustpython-vm = { workspace = true, features = ["compiler", "ast"] }
 ruff_python_parser = { workspace = true }
 
 atty = { workspace = true }

diff --git a/compiler/codegen/src/compile.rs b/compiler/codegen/src/compile.rs
@@ -1023,11 +1023,10 @@ impl Compiler<'_> {
         name: &str,
         parameters: &Parameters,
     ) -> CompileResult<bytecode::MakeFunctionFlags> {
-        // let defaults: Vec<_> = args.defaults().collect();
-        let defaults: Vec<_> = parameters
-            .iter_non_variadic_params()
-            // FIXME: clone?
-            .filter_map(|x| x.default.clone())
+        let defaults: Vec<_> = std::iter::empty()
+            .chain(&parameters.posonlyargs)
+            .chain(&parameters.args)
+            .filter_map(|x| x.default.as_deref())
             .collect();
         let have_defaults = !defaults.is_empty();
         if have_defaults {
@@ -1525,8 +1524,6 @@ impl Compiler<'_> {
     ) -> CompileResult<()> {
         self.prepare_decorators(decorator_list)?;
 
-        emit!(self, Instruction::LoadBuildClass);
-
         let prev_ctx = self.ctx;
         self.ctx = CompileContext {
             func: FunctionContext::NoFunction,
@@ -1601,6 +1598,8 @@ impl Compiler<'_> {
         self.qualified_path.append(global_path_prefix.as_mut());
         self.ctx = prev_ctx;
 
+        emit!(self, Instruction::LoadBuildClass);
+
         let mut func_flags = bytecode::MakeFunctionFlags::empty();
 
         // Prepare generic type parameters:

diff --git a/compiler/src/lib.rs b/compiler/src/lib.rs
@@ -166,7 +166,7 @@ pub fn _compile_symtable(
 fn test_compile() {
     let code = "x = 'abc'";
     let compiled = compile(&code, Mode::Single, "<>", CompileOpts::default());
-    dbg!(compiled);
+    dbg!(compiled.expect("compile error"));
 }
 
 #[test]
@@ -288,3 +288,17 @@ assert f"{{{(lambda x: f'hello, {x}')('world}')}" == '{hello, world}'
     let compiled = compile(&code6, Mode::Exec, "<>", CompileOpts::default());
     dbg!(compiled.expect("compile error"));
 }
+
+#[test]
+fn test_simple_enum() {
+    let code = r#"
+import enum
+@enum._simple_enum(enum.IntFlag, boundary=enum.KEEP)
+class RegexFlag:
+    NOFLAG = 0
+    DEBUG = 1
+print(RegexFlag.NOFLAG & RegexFlag.DEBUG)
+"#;
+    let compiled = compile(&code, Mode::Exec, "<string>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+}
diff --git a/example_projects/barebone/Cargo.toml b/example_projects/barebone/Cargo.toml
@@ -6,5 +6,7 @@ edition = "2021"
 [dependencies]
 # FIXME: Remove unnessary features
 rustpython-vm = { path = "../../vm", default-features = false, features = ["compiler", "ast"] }
+rustpython = { path = "../.." }
+env_logger = "0.11.6"
 
 [workspace]
diff --git a/example_projects/barebone/src/main.rs b/example_projects/barebone/src/main.rs
@@ -1,17 +1,58 @@
-use rustpython_vm::Interpreter;
+use rustpython::InterpreterConfig;
+use rustpython_vm::stdlib::get_module_inits;
+use rustpython_vm::{Interpreter, PyResult, Settings, VirtualMachine};
+use std::env;
+use std::env::split_paths;
 
 pub fn main() {
-    let interp = Interpreter::without_stdlib(Default::default());
+    env_logger::init();
+    // let mut stdlib = get_module_inits();
+    // let interp = Interpreter::with_init(Default::default(), |vm: &mut VirtualMachine| {
+    //     vm.add_native_module("_ast", stdlib.remove("_ast").unwrap())
+    //
+    // });
+    let mut settings = Settings::default();
+    settings.path_list.extend(get_paths("RUSTPYTHONPATH"));
+    let mut config = InterpreterConfig::new().init_stdlib().settings(settings);
+
+    let interp = config.interpreter();
     let value = interp.enter(|vm| {
-        let max = vm.builtins.get_attr("max", vm)?;
-        let value = max.call((vm.ctx.new_int(5), vm.ctx.new_int(10)), vm)?;
-        vm.print((vm.ctx.new_str("python print"), value.clone()))?;
-        Ok(value)
+        // import ast
+        // let module = vm.import("ast", 0);
+        // module
+
+        vm.run_code_string(
+            vm.new_scope_with_builtins(),
+            "
+import enum
+@enum._simple_enum(enum.IntFlag, boundary=enum.KEEP)
+class RegexFlag:
+    NOFLAG = 0
+    DEBUG = 1
+RegexFlag.NOFLAG & RegexFlag.DEBUG
+",
+            "<string>".to_string(),
+        )
     });
     match value {
         Ok(value) => println!("Rust repr: {:?}", value),
         Err(err) => {
-            interp.finalize(err);
+            interp.finalize(Some(err));
         }
     }
 }
+
+/// Helper function to retrieve a sequence of paths from an environment variable.
+fn get_paths(env_variable_name: &str) -> impl Iterator<Item = String> + '_ {
+    env::var_os(env_variable_name)
+        .into_iter()
+        .flat_map(move |paths| {
+            split_paths(&paths)
+                .map(|path| {
+                    path.into_os_string()
+                        .into_string()
+                        .unwrap_or_else(|_| panic!("{env_variable_name} isn't valid unicode"))
+                })
+                .collect::<Vec<_>>()
+        })
+}
diff --git a/src/main.rs b/src/main.rs
@@ -1,3 +1,48 @@
-pub fn main() -> std::process::ExitCode {
-    rustpython::run(|_vm| {})
+use rustpython::InterpreterConfig;
+use rustpython_vm::Settings;
+use std::env;
+use std::env::split_paths;
+use std::process::ExitCode;
+
+pub fn main() -> ExitCode {
+    let mut settings = Settings::default();
+    settings.write_bytecode = false;
+    settings.path_list.extend(get_paths("RUSTPYTHONPATH"));
+    let mut config = InterpreterConfig::new().init_stdlib().settings(settings);
+    let interp = config.interpreter();
+    let exitcode = interp.run(move |vm| {
+        let scope = vm.new_scope_with_builtins();
+        vm.run_code_string(
+            scope,
+            r#"
+import enum
+@enum._simple_enum(enum.IntFlag, boundary=enum.KEEP)
+class RegexFlag:
+    NOFLAG = 0
+    DEBUG = 1
+print(RegexFlag.NOFLAG & RegexFlag.DEBUG)
+#import ast
+#print(dir(ast))
+"#,
+            "<main>".to_string(),
+        )
+        .map(|_| ())
+    });
+
+    ExitCode::from(exitcode)
+}
+
+/// Helper function to retrieve a sequence of paths from an environment variable.
+fn get_paths(env_variable_name: &str) -> impl Iterator<Item = String> + '_ {
+    env::var_os(env_variable_name)
+        .into_iter()
+        .flat_map(move |paths| {
+            split_paths(&paths)
+                .map(|path| {
+                    path.into_os_string()
+                        .into_string()
+                        .unwrap_or_else(|_| panic!("{env_variable_name} isn't valid unicode"))
+                })
+                .collect::<Vec<_>>()
+        })
 }