Minor fixes to get compiling on master

RustPython · rodrigocam · Aug 7, 2021 · Oct 29, 2020 · Oct 31, 2020 · Oct 31, 2020
commit b88e544d22626d7bbaab5b7199d9b2153362ab63
diff --git a/vm/src/stdlib/ctypes/basics.rs b/vm/src/stdlib/ctypes/basics.rs
@@ -10,8 +10,7 @@ use crate::common::lock::{
 };
 use crate::function::OptionalArg;
 use crate::pyobject::{
-    BorrowValue, PyObjectRc, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject,
-    TypeProtocol,
+    BorrowValue, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol,
 };
 use crate::slots::BufferProtocol;
 use crate::VirtualMachine;
@@ -34,7 +33,7 @@ fn at_address(cls: &PyTypeRef, buf: usize, vm: &VirtualMachine) -> PyResult<Vec<
             Ok(b) if !b => {
                 let len = vm
                     .get_attribute(cls.as_object().to_owned(), "_length_")
-                    .map_or(Ok(1), |o: PyObjectRc| {
+                    .map_or(Ok(1), |o: PyObjectRef| {
                         match i64::try_from_object(vm, o.clone()) {
                             Ok(v_int) => {
                                 if v_int < 0 {
@@ -233,36 +232,37 @@ impl<'a> BorrowValue<'a> for PyCData {
 
 impl BufferProtocol for PyCData {
     fn get_buffer(zelf: &PyRef<Self>, _vm: &VirtualMachine) -> PyResult<Box<dyn Buffer>> {
-        Ok(Box::new(zelf.clone()))
+        Ok(Box::new(PyCDataBuffer {
+            data: zelf.clone(),
+            options: BufferOptions {
+                readonly: false,
+                len: zelf._buffer.read().len(),
+                ..Default::default()
+            },
+        }))
     }
 }
 
+#[derive(Debug)]
+struct PyCDataBuffer {
+    data: PyCDataRef,
+    options: BufferOptions,
+}
+
 // This trait will be used by all types
-impl Buffer for PyCDataRef {
+impl Buffer for PyCDataBuffer {
     fn obj_bytes(&self) -> BorrowedValue<[u8]> {
-        PyRwLockReadGuard::map(self.borrow_value(), |x| x.as_slice()).into()
+        PyRwLockReadGuard::map(self.data.borrow_value(), |x| x.as_slice()).into()
     }
 
     fn obj_bytes_mut(&self) -> BorrowedValueMut<[u8]> {
-        PyRwLockWriteGuard::map(self.borrow_value_mut(), |x| x.as_mut_slice()).into()
+        PyRwLockWriteGuard::map(self.data.borrow_value_mut(), |x| x.as_mut_slice()).into()
     }
 
     fn release(&self) {}
 
-    fn get_options(&self) -> BorrowedValue<BufferOptions> {
-        let guard = self.buffer_options.upgradable_read();
-        let guard = if guard.is_none() {
-            let mut w = PyRwLockUpgradableReadGuard::upgrade(guard);
-            *w = Some(Box::new(BufferOptions {
-                readonly: false,
-                len: self._buffer.read().len(),
-                ..Default::default()
-            }));
-            PyRwLockWriteGuard::downgrade(w)
-        } else {
-            PyRwLockUpgradableReadGuard::downgrade(guard)
-        };
-        PyRwLockReadGuard::map(guard, |x| x.as_ref().unwrap().as_ref()).into()
+    fn get_options(&self) -> &BufferOptions {
+        &self.options
     }
 }
 
@@ -271,9 +271,8 @@ impl Buffer for PyCDataRef {
 // PyCArray_Type, PyCSimple_Type, PyCFuncPtr_Type
 #[pyclass(module = "_ctypes", name = "_CData")]
 pub struct PyCData {
-    _objects: AtomicCell<Vec<PyObjectRc>>,
+    _objects: AtomicCell<Vec<PyObjectRef>>,
     _buffer: PyRwLock<Vec<u8>>,
-    buffer_options: PyRwLock<Option<Box<BufferOptions>>>,
 }
 
 pub type PyCDataRef = PyRef<PyCData>;
@@ -291,11 +290,10 @@ impl PyValue for PyCData {
 }
 
 impl PyCData {
-    fn new(objs: Option<Vec<PyObjectRc>>, buffer: Option<Vec<u8>>) -> Self {
+    fn new(objs: Option<Vec<PyObjectRef>>, buffer: Option<Vec<u8>>) -> Self {
         PyCData {
             _objects: AtomicCell::new(objs.unwrap_or_default()),
             _buffer: PyRwLock::new(buffer.unwrap_or_default()),
-            buffer_options: PyRwLock::new(None),
         }
     }
 

diff --git a/vm/src/stdlib/ctypes/dll.rs b/vm/src/stdlib/ctypes/dll.rs
@@ -2,12 +2,12 @@ extern crate libloading;
 
 use crate::builtins::pystr::PyStrRef;
 use crate::builtins::PyIntRef;
-use crate::pyobject::{PyObjectRc, PyResult, TryFromObject};
+use crate::pyobject::{PyResult, TryFromObject};
 use crate::VirtualMachine;
 
 use crate::stdlib::ctypes::shared_lib::LIBCACHE;
 
-pub fn dlopen(lib_path: PyStrRef, vm: &VirtualMachine) -> PyResult<PyObjectRc> {
+pub fn dlopen(lib_path: PyStrRef, vm: &VirtualMachine) -> PyResult {
     let mut data_cache = LIBCACHE.write();
 
     let result = data_cache.get_or_insert_lib(lib_path.as_ref(), vm);
@@ -21,7 +21,7 @@ pub fn dlopen(lib_path: PyStrRef, vm: &VirtualMachine) -> PyResult<PyObjectRc> {
     }
 }
 
-pub fn dlsym(slib: PyIntRef, str_ref: PyStrRef, vm: &VirtualMachine) -> PyResult<PyObjectRc> {
+pub fn dlsym(slib: PyIntRef, str_ref: PyStrRef, vm: &VirtualMachine) -> PyResult {
     let func_name = str_ref.as_ref();
     let data_cache = LIBCACHE.read();
 

diff --git a/vm/src/stdlib/ctypes/function.rs b/vm/src/stdlib/ctypes/function.rs
@@ -16,7 +16,7 @@ use crate::common::lock::PyRwLock;
 
 use crate::function::FuncArgs;
 use crate::pyobject::{
-    PyObjectRc, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol,
+    PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol,
 };
 use crate::VirtualMachine;
 
@@ -167,11 +167,7 @@ impl Function {
         (*self.return_type.as_mut()) = str_to_type(ret);
     }
 
-    pub fn call(
-        &mut self,
-        arg_ptrs: Vec<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyObjectRc> {
+    pub fn call(&mut self, arg_ptrs: Vec<PyObjectRef>, vm: &VirtualMachine) -> PyResult {
         let result = unsafe {
             prep_cif(
                 &mut self.cif,
@@ -266,7 +262,7 @@ pub struct PyCFuncPtr {
     pub _name_: String,
     pub _argtypes_: AtomicCell<Vec<PyObjectRef>>,
     pub _restype_: AtomicCell<PyObjectRef>,
-    _handle: PyObjectRc,
+    _handle: PyObjectRef,
     _f: PyRwLock<Function>,
 }
 

diff --git a/vm/src/stdlib/ctypes/primitive.rs b/vm/src/stdlib/ctypes/primitive.rs
@@ -9,7 +9,7 @@ use crate::builtins::{
 };
 use crate::function::OptionalArg;
 use crate::pyobject::{
-    PyObjectRc, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol,
+    PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol,
 };
 use crate::VirtualMachine;
 
@@ -20,7 +20,7 @@ use crate::stdlib::ctypes::pointer::PyCPointer;
 
 pub const SIMPLE_TYPE_CHARS: &str = "cbBhHiIlLdfguzZqQ?";
 
-fn set_primitive(_type_: &str, value: &PyObjectRc, vm: &VirtualMachine) -> PyResult<PyObjectRc> {
+fn set_primitive(_type_: &str, value: &PyObjectRef, vm: &VirtualMachine) -> PyResult {
     match _type_ {
         "c" => {
             if value
@@ -260,7 +260,7 @@ fn new_simple_type(cls: &PyTypeRef, vm: &VirtualMachine) -> PyResult<PySimpleTyp
 #[pyclass(module = "_ctypes", name = "_SimpleCData", base = "PyCData")]
 pub struct PySimpleType {
     _type_: String,
-    value: AtomicCell<PyObjectRc>,
+    value: AtomicCell<PyObjectRef>,
     __abstract__: bool,
 }