1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! `const fn`-compatible [`core::cell::RefCell`].
// `RefCell::borrow`, etc. are not `const fn` yet [ref:ref_cell_const],
// hence this stuff
use core::{
    cell::UnsafeCell,
    ops::{Deref, DerefMut},
};

/// A mutable memory location with dynamically checked borrow rules
pub struct RefCell<T: ?Sized> {
    // `Cell` isn't `const fn`-compatible either [ref:cell_const]
    borrow: UnsafeCell<BorrowFlag>,
    value: UnsafeCell<T>,
}

/// An error returned by [`RefCell::try_borrow`].
pub struct BorrowError;

/// An error returned by [`RefCell::try_borrow_mut`].
pub struct BorrowMutError;

// Positive values represent the number of `Ref` active. Negative values
// represent the number of `RefMut` active. Multiple `RefMut`s can only be
// active at a time if they refer to distinct, nonoverlapping components of a
// `RefCell` (e.g., different ranges of a slice).
type BorrowFlag = isize;
const UNUSED: BorrowFlag = 0;

impl<T> RefCell<T> {
    /// Creates a new `RefCell` containing `value`.
    pub const fn new(value: T) -> RefCell<T> {
        RefCell {
            value: UnsafeCell::new(value),
            borrow: UnsafeCell::new(UNUSED),
        }
    }

    /// Consumes the `RefCell`, returning the wrapped value.
    pub const fn into_inner(self) -> T {
        self.value.into_inner()
    }
}

impl<T: ?Sized> RefCell<T> {
    /// Immutably borrows the wrapped value.
    #[track_caller]
    pub const fn borrow(&self) -> Ref<'_, T> {
        // `Result::expect` is not `const fn` yet [ref:const_result_expect]
        if let Ok(x) = self.try_borrow() {
            x
        } else {
            panic!("already mutably borrowed")
        }
    }

    /// Immutably borrows the wrapped value, returning an error if the value is currently mutably
    /// borrowed.
    pub const fn try_borrow(&self) -> Result<Ref<'_, T>, BorrowError> {
        if unsafe { *self.borrow.get() } >= 0 {
            unsafe { *self.borrow.get() += 1 };
            Ok(Ref {
                // Safety: The borrow counting guarantees the absence of unique access.
                value: unsafe { &*self.value.get() },
                borrow: &self.borrow,
            })
        } else {
            Err(BorrowError)
        }
    }

    /// Mutably borrows the wrapped value.
    #[track_caller]
    pub const fn borrow_mut(&self) -> RefMut<'_, T> {
        // `Result::expect` is not `const fn` yet [ref:const_result_expect]
        if let Ok(x) = self.try_borrow_mut() {
            x
        } else {
            panic!("already borrowed")
        }
    }

    /// Mutably borrows the wrapped value, returning an error if the value is currently borrowed.
    pub const fn try_borrow_mut(&self) -> Result<RefMut<'_, T>, BorrowMutError> {
        if unsafe { *self.borrow.get() } == 0 {
            unsafe { *self.borrow.get() = -1 };
            Ok(RefMut {
                // Safety: The borrow counting guarantees unique access.
                value: unsafe { &mut *self.value.get() },
                borrow: &self.borrow,
            })
        } else {
            Err(BorrowMutError)
        }
    }
}

pub struct Ref<'b, T: ?Sized> {
    value: &'b T,
    borrow: &'b UnsafeCell<BorrowFlag>,
}

pub struct RefMut<'b, T: ?Sized> {
    value: &'b mut T,
    borrow: &'b UnsafeCell<BorrowFlag>,
}

impl<T: ?Sized> const Deref for Ref<'_, T> {
    type Target = T;

    fn deref(&self) -> &T {
        self.value
    }
}

impl<T: ?Sized> const Deref for RefMut<'_, T> {
    type Target = T;

    fn deref(&self) -> &T {
        self.value
    }
}

impl<T: ?Sized> const DerefMut for RefMut<'_, T> {
    fn deref_mut(&mut self) -> &mut T {
        self.value
    }
}

impl<T: ?Sized> const Drop for Ref<'_, T> {
    fn drop(&mut self) {
        unsafe { *self.borrow.get() -= 1 };
    }
}

impl<T: ?Sized> const Drop for RefMut<'_, T> {
    fn drop(&mut self) {
        unsafe { *self.borrow.get() += 1 };
    }
}