Misc wrong behavior for function props, module.__init__, type.getattro

Author: coolreader18

Lib/types.py

@@ -53,7 +53,7 @@ def _m(self): pass
 
 # For Jython, the following two types are identical
 GetSetDescriptorType = type(FunctionType.__code__)
-# MemberDescriptorType = type(FunctionType.__globals__)
+MemberDescriptorType = type(FunctionType.__globals__)
 
 del sys, _f, _g, _C  # Not for export
 

vm/src/builtins/function.rs

@@ -38,8 +38,7 @@ pub struct PyFunction {
     jitted_code: OnceCell<CompiledCode>,
     globals: PyDictRef,
     closure: Option<PyTupleTyped<PyCellRef>>,
-    defaults: Option<PyTupleRef>,
-    kw_only_defaults: Option<PyDictRef>,
+    defaults_and_kwdefaults: PyMutex<(Option<PyTupleRef>, Option<PyDictRef>)>,
     name: PyMutex<PyStrRef>,
 }
 
@@ -58,8 +57,7 @@ impl PyFunction {
             jitted_code: OnceCell::new(),
             globals,
             closure,
-            defaults,
-            kw_only_defaults,
+            defaults_and_kwdefaults: PyMutex::new((defaults, kw_only_defaults)),
             name,
         }
     }
@@ -161,10 +159,20 @@ impl PyFunction {
             )));
         }
 
+        let mut defaults_and_kwdefaults = None;
+        // can't be a closure cause it returns a reference to a captured variable :/
+        macro_rules! get_defaults {
+            () => {{
+                defaults_and_kwdefaults
+                    .get_or_insert_with(|| self.defaults_and_kwdefaults.lock().clone())
+            }};
+        }
+
         // Add missing positional arguments, if we have fewer positional arguments than the
         // function definition calls for
         if nargs < nexpected_args {
-            let ndefs = self.defaults.as_ref().map_or(0, |d| d.borrow_value().len());
+            let defaults = get_defaults!().0.as_ref().map(|tup| tup.borrow_value());
+            let ndefs = defaults.map_or(0, |d| d.len());
 
             let nrequired = code.arg_count - ndefs;
 
@@ -184,9 +192,7 @@ impl PyFunction {
                 )));
             }
 
-            if let Some(defaults) = &self.defaults {
-                let defaults = defaults.borrow_value();
-
+            if let Some(defaults) = defaults {
                 let n = std::cmp::min(nargs, nexpected_args);
                 let i = n.saturating_sub(nrequired);
 
@@ -212,10 +218,8 @@ impl PyFunction {
                 .take(code.kwonlyarg_count)
             {
                 if slot.is_none() {
-                    if let Some(kw_only_defaults) = &self.kw_only_defaults {
-                        if let Some(default) =
-                            kw_only_defaults.get_item_option(kwarg.clone(), vm)?
-                        {
+                    if let Some(defaults) = &get_defaults!().1 {
+                        if let Some(default) = defaults.get_item_option(kwarg.clone(), vm)? {
                             *slot = Some(default);
                             continue;
                         }
@@ -311,12 +315,20 @@ impl PyFunction {
 
     #[pyproperty(magic)]
     fn defaults(&self) -> Option<PyTupleRef> {
-        self.defaults.clone()
+        self.defaults_and_kwdefaults.lock().0.clone()
+    }
+    #[pyproperty(magic, setter)]
+    fn set_defaults(&self, defaults: Option<PyTupleRef>) {
+        self.defaults_and_kwdefaults.lock().0 = defaults
     }
 
     #[pyproperty(magic)]
     fn kwdefaults(&self) -> Option<PyDictRef> {
-        self.kw_only_defaults.clone()
+        self.defaults_and_kwdefaults.lock().1.clone()
+    }
+    #[pyproperty(magic, setter)]
+    fn set_kwdefaults(&self, kwdefaults: Option<PyDictRef>) {
+        self.defaults_and_kwdefaults.lock().1 = kwdefaults
     }
 
     #[pyproperty(magic)]
@@ -425,6 +437,16 @@ impl PyBoundMethod {
         PyBoundMethod { object, function }
     }
 
+    #[pyslot]
+    fn tp_new(
+        cls: PyTypeRef,
+        function: PyObjectRef,
+        object: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyRef<Self>> {
+        PyBoundMethod::new(object, function).into_ref_with_type(vm, cls)
+    }
+
     #[pymethod(magic)]
     fn repr(&self, vm: &VirtualMachine) -> PyResult<String> {
         Ok(format!(

vm/src/builtins/function/jitfunc.rs

@@ -169,8 +169,10 @@ pub(crate) fn get_jit_args<'a>(
         }
     }
 
+    let (defaults, kwdefaults) = func.defaults_and_kwdefaults.lock().clone();
+
     // fill in positional defaults
-    if let Some(defaults) = &func.defaults {
+    if let Some(defaults) = defaults {
         let defaults = defaults.borrow_value();
         for (i, default) in defaults.iter().enumerate() {
             let arg_idx = i + func.code.arg_count - defaults.len();
@@ -181,7 +183,7 @@ pub(crate) fn get_jit_args<'a>(
     }
 
     // fill in keyword only defaults
-    if let Some(kw_only_defaults) = &func.kw_only_defaults {
+    if let Some(kw_only_defaults) = kwdefaults {
         for (i, name) in arg_names.kwonlyargs.iter().enumerate() {
             let arg_idx = i + func.code.arg_count;
             if !jit_args.is_set(arg_idx) {

vm/src/builtins/module.rs

@@ -1,7 +1,7 @@
 use super::dict::PyDictRef;
 use super::pystr::{PyStr, PyStrRef};
 use super::pytype::PyTypeRef;
-use crate::function::{FuncArgs, OptionalOption};
+use crate::function::FuncArgs;
 use crate::pyobject::{
     BorrowValue, IntoPyObject, ItemProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult,
     PyValue,
@@ -43,6 +43,14 @@ pub fn init_module_dict(
         .expect("Failed to set __spec__ on module");
 }
 
+#[derive(FromArgs)]
+struct ModuleInitArgs {
+    #[pyarg(any)]
+    name: PyStrRef,
+    #[pyarg(any, default)]
+    doc: Option<PyStrRef>,
+}
+
 #[pyimpl(with(SlotGetattro), flags(BASETYPE, HAS_DICT))]
 impl PyModule {
     #[pyslot]
@@ -51,16 +59,16 @@ impl PyModule {
     }
 
     #[pymethod(magic)]
-    fn init(zelf: PyRef<Self>, name: PyStrRef, doc: OptionalOption<PyStrRef>, vm: &VirtualMachine) {
+    fn init(zelf: PyRef<Self>, args: ModuleInitArgs, vm: &VirtualMachine) {
         debug_assert!(crate::pyobject::TypeProtocol::class(zelf.as_object())
             .slots
             .flags
             .has_feature(crate::slots::PyTpFlags::HAS_DICT));
         init_module_dict(
             vm,
             &zelf.as_object().dict().unwrap(),
-            name.into_object(),
-            doc.flatten().into_pyobject(vm),
+            args.name.into_object(),
+            args.doc.into_pyobject(vm),
         );
     }
 

vm/src/builtins/pytype.rs

@@ -536,8 +536,6 @@ impl SlotGetattro for PyType {
         } else if let Some(attr) = mcl_attr {
             drop(mcl);
             vm.call_if_get_descriptor(attr, zelf.into_object())
-        } else if let Some(ref getter) = zelf.get_attr("__getattr__") {
-            vm.invoke(getter, (PyLease::into_pyref(mcl), name_str))
         } else {
             Err(vm.new_attribute_error(format!(
                 "type object '{}' has no attribute '{}'",

vm/src/stdlib/signal.rs

@@ -164,6 +164,7 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
         "SIGINT" => ctx.new_int(libc::SIGINT as u8),
         "SIGSEGV" => ctx.new_int(libc::SIGSEGV as u8),
         "SIGTERM" => ctx.new_int(libc::SIGTERM as u8),
+        "NSIG" => ctx.new_int(NSIG),
         "default_int_handler" => int_handler.clone(),
     });
     extend_module_platform_specific(vm, &module);