Add __name__ and __module__ fields to builtin functions

coolreader18 · coolreader18 · commit c2bbacf19aaf · 2020-06-03T16:19:28.000-05:00
diff --git a/vm/src/macros.rs b/vm/src/macros.rs
@@ -328,3 +328,17 @@ macro_rules! class_or_notimplemented {
         }
     };
 }
+
+#[macro_export]
+macro_rules! named_function {
+    ($ctx:expr, $module:ident, $func:ident) => {{
+        paste::expr! {
+            $crate::pyobject::PyContext::new_function_named(
+                &$ctx,
+                [<$module _ $func>],
+                stringify!($module).to_owned(),
+                stringify!($func).to_owned(),
+            )
+        }
+    }};
+}
diff --git a/vm/src/obj/objbuiltinfunc.rs b/vm/src/obj/objbuiltinfunc.rs
@@ -1,6 +1,7 @@
 use std::fmt;
 
 use crate::function::{OptionalArg, PyFuncArgs, PyNativeFunc};
+use crate::obj::objstr::PyStringRef;
 use crate::obj::objtype::PyClassRef;
 use crate::pyobject::{
     IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyResult, PyValue, TypeProtocol,
@@ -11,12 +12,15 @@ use crate::vm::VirtualMachine;
 #[pyclass]
 pub struct PyBuiltinFunction {
     value: PyNativeFunc,
+    module: Option<PyStringRef>,
+    name: Option<PyStringRef>,
 }
 
 impl PyValue for PyBuiltinFunction {
     fn class(vm: &VirtualMachine) -> PyClassRef {
         vm.ctx.builtin_function_or_method_type()
     }
+    const HAVE_DICT: bool = true;
 }
 
 impl fmt::Debug for PyBuiltinFunction {
@@ -27,7 +31,19 @@ impl fmt::Debug for PyBuiltinFunction {
 
 impl PyBuiltinFunction {
     pub fn new(value: PyNativeFunc) -> Self {
-        Self { value }
+        Self {
+            value,
+            module: None,
+            name: None,
+        }
+    }
+
+    pub fn new_with_name(value: PyNativeFunc, module: PyStringRef, name: PyStringRef) -> Self {
+        Self {
+            value,
+            module: Some(module),
+            name: Some(name),
+        }
     }
 
     pub fn as_func(&self) -> &PyNativeFunc {
@@ -42,7 +58,16 @@ impl SlotCall for PyBuiltinFunction {
 }
 
 #[pyimpl(with(SlotCall))]
-impl PyBuiltinFunction {}
+impl PyBuiltinFunction {
+    #[pyproperty(magic)]
+    fn module(&self) -> Option<PyStringRef> {
+        self.module.clone()
+    }
+    #[pyproperty(magic)]
+    fn name(&self) -> Option<PyStringRef> {
+        self.name.clone()
+    }
+}
 
 #[pyclass]
 pub struct PyBuiltinMethod {
@@ -64,7 +89,12 @@ impl fmt::Debug for PyBuiltinMethod {
 impl PyBuiltinMethod {
     pub fn new(value: PyNativeFunc) -> Self {
         Self {
-            function: PyBuiltinFunction { value },
+            function: PyBuiltinFunction::new(value),
+        }
+    }
+    pub fn new_with_name(value: PyNativeFunc, module: PyStringRef, name: PyStringRef) -> Self {
+        Self {
+            function: PyBuiltinFunction::new_with_name(value, module, name),
         }
     }
 
@@ -100,9 +130,14 @@ impl SlotCall for PyBuiltinMethod {
 
 #[pyimpl(with(SlotDescriptor, SlotCall))]
 impl PyBuiltinMethod {
-    // TODO: give builtin functions names
     #[pyproperty(magic)]
-    fn name(&self) {}
+    fn module(&self) -> Option<PyStringRef> {
+        self.function.module.clone()
+    }
+    #[pyproperty(magic)]
+    fn name(&self) -> Option<PyStringRef> {
+        self.function.name.clone()
+    }
 }
 
 pub fn init(context: &PyContext) {
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -138,7 +138,7 @@ impl PyContext {
         let exceptions = exceptions::ExceptionZoo::new(&types.type_type, &types.object_type);
 
         fn create_object<T: PyObjectPayload + PyValue>(payload: T, cls: &PyClassRef) -> PyRef<T> {
-            PyRef::new_ref_unchecked(PyObject::new(payload, cls.clone(), None))
+            PyRef::from_obj_unchecked(PyObject::new(payload, cls.clone(), None))
         }
 
         let none_type = create_type("NoneType", &types.type_type, &types.object_type);
@@ -492,6 +492,18 @@ impl PyContext {
         )
     }
 
+    pub fn new_function_named<F, T, R, VM>(&self, f: F, module: String, name: String) -> PyObjectRef
+    where
+        F: IntoPyNativeFunc<T, R, VM>,
+    {
+        let stringref = |s| PyRef::new_ref(objstr::PyString::from(s), self.str_type(), None);
+        PyObject::new(
+            PyBuiltinFunction::new_with_name(f.into_func(), stringref(module), stringref(name)),
+            self.builtin_function_or_method_type(),
+            None,
+        )
+    }
+
     pub fn new_method<F, T, R, VM>(&self, f: F) -> PyObjectRef
     where
         F: IntoPyNativeFunc<T, R, VM>,
@@ -695,9 +707,14 @@ impl<T> Clone for PyRef<T> {
 }
 
 impl<T: PyValue> PyRef<T> {
-    fn new_ref(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new_ref(payload: T, typ: PyClassRef, dict: Option<PyDictRef>) -> Self {
+        Self::from_obj_unchecked(PyObject::new(payload, typ, dict))
+    }
+
+    fn from_obj(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
         if obj.payload_is::<T>() {
-            Ok(Self::new_ref_unchecked(obj))
+            Ok(Self::from_obj_unchecked(obj))
         } else {
             Err(vm.new_runtime_error(format!(
                 "Unexpected payload for type {:?}",
@@ -706,7 +723,7 @@ impl<T: PyValue> PyRef<T> {
         }
     }
 
-    pub(crate) fn new_ref_unchecked(obj: PyObjectRef) -> Self {
+    pub(crate) fn from_obj_unchecked(obj: PyObjectRef) -> Self {
         PyRef {
             obj,
             _payload: PhantomData,
@@ -747,7 +764,7 @@ where
 {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         if objtype::isinstance(&obj, &T::class(vm)) {
-            PyRef::new_ref(obj, vm)
+            PyRef::from_obj(obj, vm)
         } else {
             let class = T::class(vm);
             let expected_type = vm.to_pystr(&class)?;
@@ -1084,6 +1101,12 @@ impl<T> IntoPyObject for PyRef<T> {
     }
 }
 
+impl<T> IntoPyObject for &PyRef<T> {
+    fn into_pyobject(self, _vm: &VirtualMachine) -> PyResult {
+        Ok(self.obj.clone())
+    }
+}
+
 impl IntoPyObject for PyCallable {
     fn into_pyobject(self, _vm: &VirtualMachine) -> PyResult {
         Ok(self.into_object())
@@ -1145,7 +1168,7 @@ where
     where
         T: PyValue,
     {
-        PyRef::new_ref_unchecked(self as PyObjectRef)
+        PyRef::from_obj_unchecked(self as PyObjectRef)
     }
 }
 
@@ -1210,7 +1233,7 @@ pub trait PyValue: fmt::Debug + Send + Sync + Sized + 'static {
             } else {
                 Some(vm.ctx.new_dict())
             };
-            PyRef::new_ref(PyObject::new(self, cls, dict), vm)
+            PyRef::from_obj(PyObject::new(self, cls, dict), vm)
         } else {
             let subtype = vm.to_str(&cls.obj)?;
             let basetype = vm.to_str(&class.obj)?;
@@ -1219,7 +1242,7 @@ pub trait PyValue: fmt::Debug + Send + Sync + Sized + 'static {
     }
 
     fn into_ref_with_type_unchecked(self, cls: PyClassRef, dict: Option<PyDictRef>) -> PyRef<Self> {
-        PyRef::new_ref_unchecked(PyObject::new(self, cls, dict))
+        PyRef::from_obj_unchecked(PyObject::new(self, cls, dict))
     }
 }
 
diff --git a/vm/src/types.rs b/vm/src/types.rs
@@ -338,8 +338,8 @@ fn init_type_hierarchy() -> (PyClassRef, PyClassRef) {
             type_type,
         );
 
-        let type_type = PyClassRef::new_ref_unchecked(Arc::from_raw(type_type_ptr));
-        let object_type = PyClassRef::new_ref_unchecked(Arc::from_raw(object_type_ptr));
+        let type_type = PyClassRef::from_obj_unchecked(Arc::from_raw(type_type_ptr));
+        let object_type = PyClassRef::from_obj_unchecked(Arc::from_raw(object_type_ptr));
 
         (*type_type_ptr).payload.mro = vec![object_type.clone()];
         (*type_type_ptr).payload.bases = vec![object_type.clone()];
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -1483,6 +1483,13 @@ impl VirtualMachine {
         attr_name: impl TryIntoRef<PyString>,
         attr_value: impl Into<PyObjectRef>,
     ) -> PyResult<()> {
+        // let attr_name = attr_name.try_into_ref(self)?;
+        // let value = attr_value.into();
+        // let dict = module.dict().expect("module doesn't have dict");
+        // if let Ok(module_name) = dict.get_item("__name__", self) {
+        //     let _ = self.set_attr(&value, "__module__", module_name);
+        // }
+        // dict.set_item(&attr_name, value, self)?;
         let val = attr_value.into();
         objobject::setattr(module.clone(), attr_name.try_into_ref(self)?, val, self)
     }
