Relocate generic_setattr into object protocol

As generic_setattr is included in object protocol, it seems more
appropriate to relocate.

Signed-off-by: snowapril <sinjihng@gmail.com>

Author: Snowapril

vm/src/builtins/object.rs

@@ -162,13 +162,13 @@ impl PyBaseObject {
         value: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        generic_setattr(&obj, name, Some(value), vm)
+        obj.generic_setattr(name, Some(value), vm)
     }
 
     /// Implement delattr(self, name).
     #[pymethod]
     fn __delattr__(obj: PyObjectRef, name: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
-        generic_setattr(&obj, name, None, vm)
+        obj.generic_setattr(name, None, vm)
     }
 
     #[pyslot]
@@ -178,7 +178,7 @@ impl PyBaseObject {
         value: Option<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        generic_setattr(&*obj, attr_name, value, vm)
+        obj.generic_setattr(attr_name, value, vm)
     }
 
     /// Return str(self).
@@ -334,48 +334,6 @@ pub fn generic_getattr(obj: PyObjectRef, attr_name: PyStrRef, vm: &VirtualMachin
     vm.generic_getattribute(obj, attr_name)
 }
 
-#[cfg_attr(feature = "flame-it", flame)]
-pub fn generic_setattr(
-    obj: &PyObject,
-    attr_name: PyStrRef,
-    value: Option<PyObjectRef>,
-    vm: &VirtualMachine,
-) -> PyResult<()> {
-    vm_trace!("object.__setattr__({:?}, {}, {:?})", obj, attr_name, value);
-
-    if let Some(attr) = obj.get_class_attr(attr_name.as_str()) {
-        let descr_set = attr.class().mro_find_map(|cls| cls.slots.descr_set.load());
-        if let Some(descriptor) = descr_set {
-            return descriptor(attr, obj.to_owned(), value, vm);
-        }
-    }
-
-    if let Some(dict) = obj.dict() {
-        if let Some(value) = value {
-            dict.set_item(attr_name, value, vm)?;
-        } else {
-            dict.del_item(attr_name.clone(), vm).map_err(|e| {
-                if e.fast_isinstance(&vm.ctx.exceptions.key_error) {
-                    vm.new_attribute_error(format!(
-                        "'{}' object has no attribute '{}'",
-                        obj.class().name(),
-                        attr_name,
-                    ))
-                } else {
-                    e
-                }
-            })?;
-        }
-        Ok(())
-    } else {
-        Err(vm.new_attribute_error(format!(
-            "'{}' object has no attribute '{}'",
-            obj.class().name(),
-            attr_name,
-        )))
-    }
-}
-
 pub fn init(ctx: &Context) {
     PyBaseObject::extend_class(ctx, &ctx.types.object_type);
 }

vm/src/protocol/object.rs

@@ -131,6 +131,47 @@ impl PyObject {
     }
 
     // int PyObject_GenericSetAttr(PyObject *o, PyObject *name, PyObject *value)
+    #[cfg_attr(feature = "flame-it", flame)]
+    pub fn generic_setattr(
+        &self,
+        attr_name: PyStrRef,
+        value: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        vm_trace!("object.__setattr__({:?}, {}, {:?})", obj, attr_name, value);
+
+        if let Some(attr) = self.get_class_attr(attr_name.as_str()) {
+            let descr_set = attr.class().mro_find_map(|cls| cls.slots.descr_set.load());
+            if let Some(descriptor) = descr_set {
+                return descriptor(attr, self.to_owned(), value, vm);
+            }
+        }
+
+        if let Some(dict) = self.dict() {
+            if let Some(value) = value {
+                dict.set_item(attr_name, value, vm)?;
+            } else {
+                dict.del_item(attr_name.clone(), vm).map_err(|e| {
+                    if e.fast_isinstance(&vm.ctx.exceptions.key_error) {
+                        vm.new_attribute_error(format!(
+                            "'{}' object has no attribute '{}'",
+                            self.class().name(),
+                            attr_name,
+                        ))
+                    } else {
+                        e
+                    }
+                })?;
+            }
+            Ok(())
+        } else {
+            Err(vm.new_attribute_error(format!(
+                "'{}' object has no attribute '{}'",
+                self.class().name(),
+                attr_name,
+            )))
+        }
+    }
 
     pub fn del_attr(&self, attr_name: impl IntoPyStrRef, vm: &VirtualMachine) -> PyResult<()> {
         let attr_name = attr_name.into_pystr_ref(vm);

vm/src/types/slot.rs

@@ -1,4 +1,4 @@
-pub use crate::builtins::object::{generic_getattr, generic_setattr};
+pub use crate::builtins::object::generic_getattr;
 use crate::common::{hash::PyHash, lock::PyRwLock};
 use crate::{
     builtins::{PyInt, PyStrRef, PyType, PyTypeRef},

vm/src/vm/mod.rs

@@ -17,7 +17,6 @@ mod vm_ops;
 use crate::{
     builtins::{
         code::{self, PyCode},
-        object,
         pystr::IntoPyStrRef,
         tuple::{PyTuple, PyTupleTyped},
         PyBaseExceptionRef, PyDictRef, PyList, PyModule, PyStrRef, PyTypeRef,
@@ -741,6 +740,6 @@ impl VirtualMachine {
         attr_value: impl Into<PyObjectRef>,
     ) -> PyResult<()> {
         let val = attr_value.into();
-        object::generic_setattr(module, attr_name.into_pystr_ref(self), Some(val), self)
+        module.generic_setattr(attr_name.into_pystr_ref(self), Some(val), self)
     }
 }