types: introduce helper type to hold token alongside slab

In the next couple commits we will replace the mutexes in the union-bound
algorithm with GhostCells. Happily, we can reuse the existing GhostToken
in types::Context as an access-control token.

However, to do this we need to refactor a couple algorithms so that we
can fish the token recursively through unify() and bind(), which naively
would require the union-bound algorithm to know about our ContextInner
type. To avoid this abstraction violation, we introduce the generic
WithContextToken wrapper, so the union-bound algorithm can work with "a
token and some arbitrary data" without knowing or understanding anything
about the arbitrary data.

Author: apoelstra

src/types/context.rs

@@ -22,7 +22,7 @@ use ghost_cell::GhostToken;
 
 use crate::dag::{Dag, DagLike};
 
-use super::{Bound, CompleteBound, Error, Final, Incomplete, Type, TypeInner};
+use super::{Bound, CompleteBound, Error, Final, Incomplete, Type, TypeInner, WithGhostToken};
 
 // Copied from ghost_cell source. See
 //     https://arhan.sh/blog/the-generativity-pattern-in-rust/
@@ -41,12 +41,11 @@ type InvariantLifetime<'brand> = PhantomData<fn(&'brand ()) -> &'brand ()>;
 /// please file an issue.
 #[derive(Clone)]
 pub struct Context<'brand> {
-    inner: Arc<Mutex<ContextInner<'brand>>>,
+    inner: Arc<Mutex<WithGhostToken<'brand, ContextInner<'brand>>>>,
 }
 
 struct ContextInner<'brand> {
     slab: Vec<Bound<'brand>>,
-    _token: GhostToken<'brand>,
 }
 
 impl fmt::Debug for Context<'_> {
@@ -78,9 +77,9 @@ impl<'brand> Context<'brand> {
     /// Creates a new empty type inference context.
     pub fn new(token: GhostToken<'brand>) -> Self {
         Context {
-            inner: Arc::new(Mutex::new(ContextInner {
-                slab: vec![],
+            inner: Arc::new(Mutex::new(WithGhostToken {
                 _token: token,
+                inner: ContextInner { slab: vec![] },
             })),
         }
     }
@@ -285,7 +284,7 @@ struct BindError<'brand> {
 /// This type is never exposed outside of this module and should only exist
 /// ephemerally within function calls into this module.
 struct LockedContext<'ctx, 'brand> {
-    inner: MutexGuard<'ctx, ContextInner<'brand>>,
+    inner: MutexGuard<'ctx, WithGhostToken<'brand, ContextInner<'brand>>>,
 }
 
 impl<'brand> LockedContext<'_, 'brand> {

src/types/mod.rs

@@ -71,7 +71,7 @@
 //     or a sum or product of other types.
 //
 
-use self::union_bound::{PointerLike, UbElement};
+use self::union_bound::{PointerLike, UbElement, WithGhostToken};
 use crate::dag::{DagLike, NoSharing};
 use crate::Tmr;
 

src/types/union_bound.rs

@@ -30,7 +30,9 @@
 //!
 
 use std::sync::{Arc, Mutex};
-use std::{cmp, fmt, mem};
+use std::{cmp, fmt, mem, ops};
+
+use ghost_cell::GhostToken;
 
 /// Trait describing objects that can be stored and manipulated by the union-bound
 /// algorithm.
@@ -56,6 +58,32 @@ impl<T> PointerLike for Arc<T> {
     }
 }
 
+/// Container which associates a ghost token with some arbitrary other data.
+///
+/// This allows the union-bound algorithm to work with a token (which is used
+/// by the algorithm) while passing data (which is -not- used by the algorithm)
+/// everywhere that needs it, without offending the borrow checker or forcing
+/// callers to manually destructure their types to separate out tokens.
+///
+/// If Rust had view types, this structure wouldn't be necessary.
+pub struct WithGhostToken<'brand, T> {
+    pub _token: GhostToken<'brand>,
+    pub inner: T,
+}
+
+impl<'brand, T> ops::Deref for WithGhostToken<'brand, T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        &self.inner
+    }
+}
+
+impl<'brand, T> ops::DerefMut for WithGhostToken<'brand, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        &mut self.inner
+    }
+}
+
 pub struct UbElement<T> {
     inner: Arc<Mutex<UbInner<T>>>,
 }