Switch to using parking_lot::Mutex instead of std::sync::Mutex

Author: coolreader18

derive/src/pyclass.rs

@@ -275,7 +275,7 @@ fn extract_impl_items(mut items: Vec<ItemIdent>) -> Result<TokenStream2, Diagnos
                 #transform(Self::#item_ident)
             };
             Some(quote! {
-                (*class.slots.write().unwrap()).#slot_ident = Some(#into_func);
+                (*class.slots.write()).#slot_ident = Some(#into_func);
             })
         }
         _ => None,

vm/src/dictdatatype.rs

@@ -3,14 +3,14 @@ use crate::pyhash;
 use crate::pyobject::{IdProtocol, IntoPyObject, PyObjectRef, PyResult};
 use crate::vm::VirtualMachine;
 use num_bigint::ToBigInt;
+use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 /// Ordered dictionary implementation.
 /// Inspired by: https://morepypy.blogspot.com/2015/01/faster-more-memory-efficient-and-more.html
 /// And: https://www.youtube.com/watch?v=p33CVV29OG8
 /// And: http://code.activestate.com/recipes/578375/
 use std::collections::{hash_map::DefaultHasher, HashMap};
 use std::hash::{Hash, Hasher};
 use std::mem::size_of;
-use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 
 /// hash value of an object returned by __hash__
 type HashValue = pyhash::PyHash;
@@ -42,7 +42,7 @@ impl<T: Clone> Clone for InnerDict<T> {
 impl<T: Clone> Clone for Dict<T> {
     fn clone(&self) -> Self {
         Dict {
-            inner: RwLock::new(self.inner.read().unwrap().clone()),
+            inner: RwLock::new(self.inner.read().clone()),
         }
     }
 }
@@ -83,11 +83,11 @@ pub struct DictSize {
 
 impl<T: Clone> Dict<T> {
     fn borrow_value(&self) -> RwLockReadGuard<'_, InnerDict<T>> {
-        self.inner.read().unwrap()
+        self.inner.read()
     }
 
     fn borrow_value_mut(&self) -> RwLockWriteGuard<'_, InnerDict<T>> {
-        self.inner.write().unwrap()
+        self.inner.write()
     }
 
     fn resize(&self) {

vm/src/exceptions.rs

@@ -14,10 +14,10 @@ use crate::types::create_type;
 use crate::VirtualMachine;
 
 use itertools::Itertools;
+use parking_lot::RwLock;
 use std::fmt;
 use std::fs::File;
 use std::io::{self, BufRead, BufReader, Write};
-use std::sync::RwLock;
 
 use crossbeam_utils::atomic::AtomicCell;
 
@@ -66,50 +66,50 @@ impl PyBaseException {
 
     #[pymethod(name = "__init__")]
     fn init(&self, args: PyFuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-        *self.args.write().unwrap() = PyTuple::from(args.args).into_ref(vm);
+        *self.args.write() = PyTuple::from(args.args).into_ref(vm);
         Ok(())
     }
 
     #[pyproperty]
     pub fn args(&self) -> PyTupleRef {
-        self.args.read().unwrap().clone()
+        self.args.read().clone()
     }
 
     #[pyproperty(setter)]
     fn set_args(&self, args: PyIterable, vm: &VirtualMachine) -> PyResult<()> {
         let args = args.iter(vm)?.collect::<PyResult<Vec<_>>>()?;
-        *self.args.write().unwrap() = PyTuple::from(args).into_ref(vm);
+        *self.args.write() = PyTuple::from(args).into_ref(vm);
         Ok(())
     }
 
     #[pyproperty(name = "__traceback__")]
     pub fn traceback(&self) -> Option<PyTracebackRef> {
-        self.traceback.read().unwrap().clone()
+        self.traceback.read().clone()
     }
 
     #[pyproperty(name = "__traceback__", setter)]
     pub fn set_traceback(&self, traceback: Option<PyTracebackRef>) {
-        *self.traceback.write().unwrap() = traceback;
+        *self.traceback.write() = traceback;
     }
 
     #[pyproperty(name = "__cause__")]
     pub fn cause(&self) -> Option<PyBaseExceptionRef> {
-        self.cause.read().unwrap().clone()
+        self.cause.read().clone()
     }
 
     #[pyproperty(name = "__cause__", setter)]
     pub fn set_cause(&self, cause: Option<PyBaseExceptionRef>) {
-        *self.cause.write().unwrap() = cause;
+        *self.cause.write() = cause;
     }
 
     #[pyproperty(name = "__context__")]
     pub fn context(&self) -> Option<PyBaseExceptionRef> {
-        self.context.read().unwrap().clone()
+        self.context.read().clone()
     }
 
     #[pyproperty(name = "__context__", setter)]
     pub fn set_context(&self, context: Option<PyBaseExceptionRef>) {
-        *self.context.write().unwrap() = context;
+        *self.context.write() = context;
     }
 
     #[pyproperty(name = "__suppress_context__")]
@@ -124,7 +124,7 @@ impl PyBaseException {
 
     #[pymethod]
     fn with_traceback(zelf: PyRef<Self>, tb: Option<PyTracebackRef>) -> PyResult {
-        *zelf.traceback.write().unwrap() = tb;
+        *zelf.traceback.write() = tb;
         Ok(zelf.as_object().clone())
     }
 
@@ -216,7 +216,7 @@ pub fn write_exception_inner<W: Write>(
     vm: &VirtualMachine,
     exc: &PyBaseExceptionRef,
 ) -> io::Result<()> {
-    if let Some(tb) = exc.traceback.read().unwrap().clone() {
+    if let Some(tb) = exc.traceback.read().clone() {
         writeln!(output, "Traceback (most recent call last):")?;
         for tb in tb.iter() {
             write_traceback_entry(output, &tb)?;
@@ -430,7 +430,7 @@ impl ExceptionZoo {
     pub fn new(type_type: &PyClassRef, object_type: &PyClassRef) -> Self {
         let create_exception_type = |name: &str, base: &PyClassRef| {
             let typ = create_type(name, type_type, base);
-            typ.slots.write().unwrap().flags |= PyTpFlags::BASETYPE;
+            typ.slots.write().flags |= PyTpFlags::BASETYPE;
             typ
         };
         // Sorted By Hierarchy then alphabetized.
@@ -609,7 +609,6 @@ fn make_arg_getter(idx: usize) -> impl Fn(PyBaseExceptionRef, &VirtualMachine) -
     move |exc, vm| {
         exc.args
             .read()
-            .unwrap()
             .as_slice()
             .get(idx)
             .cloned()

vm/src/frame.rs

@@ -1,9 +1,9 @@
 use std::fmt;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::Mutex;
 
 use indexmap::IndexMap;
 use itertools::Itertools;
+use parking_lot::Mutex;
 
 use crate::builtins::builtin_isinstance;
 use crate::bytecode;
@@ -173,7 +173,7 @@ impl Frame {
 
 impl FrameRef {
     fn with_exec<R>(&self, f: impl FnOnce(ExecutingFrame) -> R) -> R {
-        let mut state = self.state.lock().unwrap();
+        let mut state = self.state.lock();
         let exec = ExecutingFrame {
             code: &self.code,
             scope: &self.scope,
@@ -1491,10 +1491,7 @@ impl ExecutingFrame<'_> {
 
 impl fmt::Debug for Frame {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let state = match self.state.lock() {
-            Ok(state) => state,
-            Err(_posion) => return f.pad("Frame Object {{ poisoned }}"),
-        };
+        let state = self.state.lock();
         let stack_str = state
             .stack
             .iter()

vm/src/macros.rs

@@ -37,7 +37,7 @@ macro_rules! py_class {
         {
             let py_class = $ctx.new_class($class_name, $class_base);
             // FIXME: setting flag here probably wrong
-            py_class.slots.write().unwrap().flags |= $crate::slots::PyTpFlags::BASETYPE;
+            py_class.slots.write().flags |= $crate::slots::PyTpFlags::BASETYPE;
             $crate::extend_class!($ctx, &py_class, { $($name => $value),* });
             py_class
         }
@@ -54,7 +54,7 @@ macro_rules! extend_class {
     };
 
     (@set_attr($ctx:expr, $class:expr, (slot $slot_name:ident), $value:expr)) => {
-        $class.slots.write().unwrap().$slot_name = Some(
+        $class.slots.write().$slot_name = Some(
             $crate::function::IntoPyNativeFunc::into_func($value)
         );
     };

vm/src/obj/objbytearray.rs

@@ -1,10 +1,10 @@
 //! Implementation of the python bytearray object.
 use bstr::ByteSlice;
 use crossbeam_utils::atomic::AtomicCell;
+use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 use std::convert::TryFrom;
 use std::mem::size_of;
 use std::str::FromStr;
-use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 
 use super::objbyteinner::{
     ByteInnerFindOptions, ByteInnerNewOptions, ByteInnerPaddingOptions, ByteInnerSplitOptions,
@@ -58,11 +58,11 @@ impl PyByteArray {
     }
 
     pub fn borrow_value(&self) -> RwLockReadGuard<'_, PyByteInner> {
-        self.inner.read().unwrap()
+        self.inner.read()
     }
 
     pub fn borrow_value_mut(&self) -> RwLockWriteGuard<'_, PyByteInner> {
-        self.inner.write().unwrap()
+        self.inner.write()
     }
 }
 

vm/src/obj/objcoroinner.rs

@@ -5,7 +5,7 @@ use crate::pyobject::{PyObjectRef, PyResult};
 use crate::vm::VirtualMachine;
 
 use crossbeam_utils::atomic::AtomicCell;
-use std::sync::RwLock;
+use parking_lot::RwLock;
 
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum Variant {
@@ -69,10 +69,10 @@ impl Coro {
         let curr_exception_stack_len = vm.exceptions.borrow().len();
         vm.exceptions
             .borrow_mut()
-            .append(&mut self.exceptions.write().unwrap());
+            .append(&mut self.exceptions.write());
         let result = vm.with_frame(self.frame.clone(), func);
         std::mem::swap(
-            &mut *self.exceptions.write().unwrap(),
+            &mut *self.exceptions.write(),
             &mut vm
                 .exceptions
                 .borrow_mut()

vm/src/obj/objenumerate.rs

@@ -1,5 +1,5 @@
+use parking_lot::RwLock;
 use std::ops::AddAssign;
-use std::sync::RwLock;
 
 use num_bigint::BigInt;
 use num_traits::Zero;
@@ -50,7 +50,7 @@ impl PyEnumerate {
     #[pymethod(name = "__next__")]
     fn next(&self, vm: &VirtualMachine) -> PyResult<(BigInt, PyObjectRef)> {
         let next_obj = objiter::call_next(vm, &self.iterator)?;
-        let mut counter = self.counter.write().unwrap();
+        let mut counter = self.counter.write();
         let position = counter.clone();
         AddAssign::add_assign(&mut counter as &mut BigInt, 1);
         Ok((position, next_obj))

vm/src/obj/objlist.rs

@@ -1,11 +1,11 @@
 use std::fmt;
 use std::mem::size_of;
 use std::ops::{DerefMut, Range};
-use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 
 use crossbeam_utils::atomic::AtomicCell;
 use num_bigint::{BigInt, ToBigInt};
 use num_traits::{One, Signed, ToPrimitive, Zero};
+use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 
 use super::objbool;
 use super::objbyteinner;
@@ -55,11 +55,11 @@ impl PyValue for PyList {
 
 impl PyList {
     pub fn borrow_elements(&self) -> RwLockReadGuard<'_, Vec<PyObjectRef>> {
-        self.elements.read().unwrap()
+        self.elements.read()
     }
 
     pub fn borrow_elements_mut(&self) -> RwLockWriteGuard<'_, Vec<PyObjectRef>> {
-        self.elements.write().unwrap()
+        self.elements.write()
     }
 
     pub(crate) fn get_byte_inner(

vm/src/obj/objmappingproxy.rs

@@ -87,7 +87,7 @@ impl PyMappingProxy {
             MappingProxyInner::Dict(d) => d.clone(),
             MappingProxyInner::Class(c) => {
                 // TODO: something that's much more efficient than this
-                PyDictRef::from_attributes(c.attributes.read().unwrap().clone(), vm)?.into_object()
+                PyDictRef::from_attributes(c.attributes.read().clone(), vm)?.into_object()
             }
         };
         objiter::get_iter(vm, &obj)
@@ -97,7 +97,7 @@ impl PyMappingProxy {
         let obj = match &self.mapping {
             MappingProxyInner::Dict(d) => d.clone(),
             MappingProxyInner::Class(c) => {
-                PyDictRef::from_attributes(c.attributes.read().unwrap().clone(), vm)?.into_object()
+                PyDictRef::from_attributes(c.attributes.read().clone(), vm)?.into_object()
             }
         };
         vm.call_method(&obj, "items", vec![])
@@ -107,7 +107,7 @@ impl PyMappingProxy {
         let obj = match &self.mapping {
             MappingProxyInner::Dict(d) => d.clone(),
             MappingProxyInner::Class(c) => {
-                PyDictRef::from_attributes(c.attributes.read().unwrap().clone(), vm)?.into_object()
+                PyDictRef::from_attributes(c.attributes.read().clone(), vm)?.into_object()
             }
         };
         vm.call_method(&obj, "keys", vec![])
@@ -117,7 +117,7 @@ impl PyMappingProxy {
         let obj = match &self.mapping {
             MappingProxyInner::Dict(d) => d.clone(),
             MappingProxyInner::Class(c) => {
-                PyDictRef::from_attributes(c.attributes.read().unwrap().clone(), vm)?.into_object()
+                PyDictRef::from_attributes(c.attributes.read().clone(), vm)?.into_object()
             }
         };
         vm.call_method(&obj, "values", vec![])

vm/src/obj/objproperty.rs

@@ -1,7 +1,7 @@
 /*! Python `property` descriptor class.
 
 */
-use std::sync::RwLock;
+use parking_lot::RwLock;
 
 use super::objtype::PyClassRef;
 use crate::function::OptionalArg;
@@ -141,11 +141,11 @@ impl PyProperty {
     }
 
     fn doc_getter(&self) -> Option<PyObjectRef> {
-        self.doc.read().unwrap().clone()
+        self.doc.read().clone()
     }
 
     fn doc_setter(&self, value: PyObjectRef, vm: &VirtualMachine) {
-        *self.doc.write().unwrap() = py_none_to_option(vm, &value);
+        *self.doc.write() = py_none_to_option(vm, &value);
     }
 
     // Python builder functions