Don't block on data access (#159)

* Impl DataHolder for Function

* Impl data holder for the rest

* Fix warnings

src/data_holder.rs

@@ -0,0 +1,23 @@
+use std::sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard, TryLockResult};
+
+/// Trait for structs that hold some data
+pub trait DataHolder {
+    /// The type of the data
+    type Data;
+
+    /// Create a holder for some data
+    fn new(data: Self::Data) -> Self;
+
+    /// Get a reference to the inner data
+    fn inner(&self) -> &Arc<RwLock<Self::Data>>;
+
+    /// Lock for reading
+    fn read(&self) -> TryLockResult<RwLockReadGuard<'_, Self::Data>> {
+        self.inner().try_read()
+    }
+
+    /// Lock for writing
+    fn write(&self) -> TryLockResult<RwLockWriteGuard<'_, Self::Data>> {
+        self.inner().try_write()
+    }
+}

src/hir/declarations/function.rs

@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 use std::fmt::Display;
 use std::ops::Range;
-use std::sync::{Arc, LockResult, RwLock, RwLockReadGuard, RwLockWriteGuard};
+use std::sync::{Arc, RwLock};
 
 use derive_more::From;
 use derive_visitor::DriveMut;
@@ -11,6 +11,7 @@ use crate::hir::{FunctionType, Generic, Statement, Type, TypeReference, Typed};
 use crate::mutability::Mutable;
 use crate::named::Named;
 use crate::syntax::{Identifier, Keyword, Ranged};
+use crate::DataHolder;
 
 use super::Trait;
 
@@ -20,22 +21,17 @@ pub struct Parameter {
     inner: Arc<RwLock<ParameterData>>,
 }
 
-impl Parameter {
-    /// Create a new parameter from its data
-    pub fn new(data: ParameterData) -> Self {
+impl DataHolder for Parameter {
+    type Data = ParameterData;
+
+    fn new(data: Self::Data) -> Self {
         Self {
             inner: Arc::new(RwLock::new(data)),
         }
     }
 
-    /// Lock variable for reading
-    pub fn read(&self) -> LockResult<RwLockReadGuard<'_, ParameterData>> {
-        self.inner.read()
-    }
-
-    /// Lock variable for writing
-    pub fn write(&self) -> LockResult<RwLockWriteGuard<'_, ParameterData>> {
-        self.inner.write()
+    fn inner(&self) -> &Arc<RwLock<Self::Data>> {
+        &self.inner
     }
 }
 
@@ -179,22 +175,17 @@ pub struct Function {
     inner: Arc<RwLock<FunctionData>>,
 }
 
-impl Function {
-    /// Create a new function from its data
-    pub fn new(data: FunctionData) -> Self {
-        Function {
+impl DataHolder for Function {
+    type Data = FunctionData;
+
+    fn new(data: Self::Data) -> Self {
+        Self {
             inner: Arc::new(RwLock::new(data)),
         }
     }
 
-    /// Lock function for reading
-    pub fn read(&self) -> LockResult<RwLockReadGuard<'_, FunctionData>> {
-        self.inner.read()
-    }
-
-    /// Lock function for writing
-    pub fn write(&self) -> LockResult<RwLockWriteGuard<'_, FunctionData>> {
-        self.inner.write()
+    fn inner(&self) -> &Arc<RwLock<Self::Data>> {
+        &self.inner
     }
 }
 
@@ -548,6 +539,7 @@ mod tests {
         },
         semantics::ToHIR,
         syntax::{Identifier, Keyword},
+        DataHolder,
     };
 
     use pretty_assertions::assert_eq;

src/hir/declarations/mod.rs

@@ -19,6 +19,8 @@ use derive_more::Display;
 
 use crate::{named::Named, syntax::Ranged};
 
+use crate::DataHolder;
+
 /// Any PPL declaration
 #[derive(Debug, Display, PartialEq, Eq, Clone, From, TryInto, DriveMut)]
 pub enum Declaration {

src/hir/declarations/trait.rs

@@ -3,7 +3,7 @@ use std::{
     fmt::Display,
     hash::{Hash, Hasher},
     ops::Range,
-    sync::{Arc, LockResult, RwLock, RwLockReadGuard, RwLockWriteGuard},
+    sync::{Arc, RwLock},
 };
 
 use derive_visitor::DriveMut;
@@ -17,29 +17,25 @@ use crate::{
 };
 
 use super::Function;
+use crate::DataHolder;
 
 /// Trait data holder
 #[derive(Debug, Clone)]
 pub struct Trait {
     inner: Arc<RwLock<TraitData>>,
 }
 
-impl Trait {
-    /// Create a new function from its data
-    pub fn new(data: TraitData) -> Self {
+impl DataHolder for Trait {
+    type Data = TraitData;
+
+    fn new(data: Self::Data) -> Self {
         Self {
             inner: Arc::new(RwLock::new(data)),
         }
     }
 
-    /// Lock function for reading
-    pub fn read(&self) -> LockResult<RwLockReadGuard<'_, TraitData>> {
-        self.inner.read()
-    }
-
-    /// Lock function for writing
-    pub fn write(&self) -> LockResult<RwLockWriteGuard<'_, TraitData>> {
-        self.inner.write()
+    fn inner(&self) -> &Arc<RwLock<Self::Data>> {
+        &self.inner
     }
 }
 

src/hir/declarations/types.rs

@@ -4,7 +4,7 @@ use std::{
     hash::Hash,
     ops::Range,
     str::FromStr,
-    sync::{Arc, LockResult, RwLock, RwLockReadGuard, RwLockWriteGuard},
+    sync::{Arc, RwLock},
 };
 
 use derive_visitor::DriveMut;
@@ -17,28 +17,25 @@ use crate::{
     AddSourceLocation,
 };
 
+use crate::DataHolder;
+
 /// Member data holder
 #[derive(Debug, Clone)]
 pub struct Member {
     inner: Arc<RwLock<MemberData>>,
 }
 
-impl Member {
-    /// Create a new member from its data
-    pub fn new(data: MemberData) -> Self {
+impl DataHolder for Member {
+    type Data = MemberData;
+
+    fn new(data: Self::Data) -> Self {
         Self {
             inner: Arc::new(RwLock::new(data)),
         }
     }
 
-    /// Lock Member for reading
-    pub fn read(&self) -> LockResult<RwLockReadGuard<'_, MemberData>> {
-        self.inner.read()
-    }
-
-    /// Lock Member for writing
-    pub fn write(&self) -> LockResult<RwLockWriteGuard<'_, MemberData>> {
-        self.inner.write()
+    fn inner(&self) -> &Arc<RwLock<Self::Data>> {
+        &self.inner
     }
 }
 
@@ -187,24 +184,21 @@ pub struct Class {
     inner: Arc<RwLock<ClassData>>,
 }
 
-impl Class {
-    /// Create a new class from its data
-    pub fn new(data: ClassData) -> Self {
+impl DataHolder for Class {
+    type Data = ClassData;
+
+    fn new(data: Self::Data) -> Self {
         Class {
             inner: Arc::new(RwLock::new(data)),
         }
     }
 
-    /// Lock class for reading
-    pub fn read(&self) -> LockResult<RwLockReadGuard<'_, ClassData>> {
-        self.inner.read()
-    }
-
-    /// Lock class for writing
-    pub fn write(&self) -> LockResult<RwLockWriteGuard<'_, ClassData>> {
-        self.inner.write()
+    fn inner(&self) -> &Arc<RwLock<Self::Data>> {
+        &self.inner
     }
+}
 
+impl Class {
     /// Is this a builtin type?
     pub fn is_builtin(&self) -> bool {
         self.read().unwrap().is_builtin()

src/hir/declarations/variable.rs

@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 use std::fmt::Display;
-use std::sync::{Arc, LockResult, RwLock, RwLockReadGuard, RwLockWriteGuard};
+use std::sync::{Arc, RwLock};
 
 use derive_visitor::DriveMut;
 
@@ -9,30 +9,29 @@ use crate::mutability::{Mutability, Mutable};
 use crate::named::Named;
 use crate::syntax::{Identifier, Keyword, Ranged};
 
+use crate::DataHolder;
+
 /// Variable data holder
 #[derive(Debug, Clone)]
 pub struct Variable {
     inner: Arc<RwLock<VariableData>>,
 }
 
-impl Variable {
-    /// Create a new variable from its data
-    pub fn new(data: VariableData) -> Self {
+impl DataHolder for Variable {
+    type Data = VariableData;
+
+    fn new(data: Self::Data) -> Self {
         Self {
             inner: Arc::new(RwLock::new(data)),
         }
     }
 
-    /// Lock variable for reading
-    pub fn read(&self) -> LockResult<RwLockReadGuard<'_, VariableData>> {
-        self.inner.read()
-    }
-
-    /// Lock variable for writing
-    pub fn write(&self) -> LockResult<RwLockWriteGuard<'_, VariableData>> {
-        self.inner.write()
+    fn inner(&self) -> &Arc<RwLock<Self::Data>> {
+        &self.inner
     }
+}
 
+impl Variable {
     /// Is this a temporary variable?
     pub fn is_temporary(&self) -> bool {
         self.read().unwrap().is_temporary()

src/hir/expressions/call.rs

@@ -6,6 +6,8 @@ use crate::syntax::Ranged;
 use std::fmt::Display;
 use std::ops::Range;
 
+use crate::DataHolder;
+
 /// AST for function call
 #[derive(Debug, PartialEq, Eq, Clone, DriveMut)]
 pub struct Call {

src/hir/expressions/variable.rs

@@ -5,6 +5,7 @@ use crate::hir::{Generic, Parameter, ParameterData, Type, Typed, Variable, Varia
 use crate::mutability::Mutable;
 use crate::named::Named;
 use crate::syntax::Ranged;
+use crate::DataHolder;
 use std::borrow::Cow;
 use std::fmt::Display;
 

src/hir/module.rs

@@ -8,6 +8,7 @@ use miette::NamedSource;
 
 use crate::hir::{Statement, Variable};
 use crate::named::Named;
+use crate::DataHolder;
 use crate::SourceFile;
 
 use super::{Class, Function, Trait, Type};

src/hir/specialize.rs

@@ -2,6 +2,8 @@ use std::collections::HashMap;
 
 use super::{Class, ClassData, FunctionType, Generic, Member, MemberData, Type, Typed};
 
+use crate::DataHolder;
+
 /// Specialize type using given mapping
 pub trait Specialize
 where

src/hir/types.rs

@@ -14,6 +14,8 @@ use derive_more::{Display, From, TryInto};
 use derive_visitor::DriveMut;
 use enum_dispatch::enum_dispatch;
 
+use crate::DataHolder;
+
 use super::Expression;
 
 /// PPL's Function type

src/ir/to_ir.rs

@@ -12,6 +12,7 @@ use crate::ir::Initializer;
 use crate::mutability::Mutable;
 use crate::named::Named;
 use crate::syntax::Ranged;
+use crate::DataHolder;
 
 use super::Context;
 use super::FunctionContext;

src/lib.rs

@@ -39,5 +39,8 @@ pub use reporter::*;
 mod err_vec;
 pub use err_vec::*;
 
+mod data_holder;
+pub use data_holder::*;
+
 #[cfg(test)]
 mod tests;

src/semantics/contexts/context.rs

@@ -8,6 +8,8 @@ use crate::{
 
 use super::BuiltinContext;
 
+use crate::DataHolder;
+
 /// Trait for various AST lowering contexts
 pub trait Context: FindDeclaration + AddDeclaration + Display {
     /// Get parent context

src/semantics/contexts/function.rs

@@ -4,6 +4,7 @@ use crate::{
     hir::{Class, Function, ParameterOrVariable, Trait, Type, Variable},
     named::Named,
     semantics::{AddDeclaration, FindDeclaration, FindDeclarationHere},
+    DataHolder,
 };
 
 use super::Context;

src/semantics/contexts/trait.rs

@@ -8,6 +8,8 @@ use crate::{
 
 use super::Context;
 
+use crate::DataHolder;
+
 /// Context for lowering body of trait
 pub struct TraitContext<'p> {
     /// Trait, which is being lowered

src/semantics/convert.rs

@@ -11,6 +11,8 @@ use super::{
     Context, Implements, Implicit,
 };
 
+use crate::DataHolder;
+
 /// Trait to check if one type is convertible to another
 pub trait ConvertibleTo
 where

src/semantics/declare.rs

@@ -15,6 +15,8 @@ use super::{
     TraitContext,
 };
 
+use crate::DataHolder;
+
 /// Trait to pre-declare something
 pub trait Declare {
     type Declaration;