run-rs 0.6.31

Run a subset of Rust as an interpreted script
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

//! A place inside a container, handed out by index, field and cell accessors.

use std::sync::Arc;

use parking_lot::Mutex;

use crate::interpreter::borrow::BorrowGuard;

use super::{List, Map, MapKey, StructData, Value};

pub enum ValueRef {
    VecElement {
        values: List,
        index: usize,
    },
    MapEntry {
        map: Map,
        key: MapKey,
    },
    StructField {
        data: Arc<StructData>,
        slot: usize,
    },
    /// from `borrow`, `borrow_mut` and `lock`
    CellSlot {
        slot: Arc<Mutex<Value>>,
        /// the live `RefCell` borrow, `None` for a `lock`
        guard: Option<Arc<BorrowGuard>>,
    },
    /// From accessors like `as_object_mut`. No mutation split here, only in place mutation goes through.
    Borrowed {
        value: Value,
    },
}

impl ValueRef {
    pub fn vec_element(values: List, index: usize) -> Self {
        Self::VecElement { values, index }
    }

    pub fn map_entry(map: Map, key: MapKey) -> Self {
        Self::MapEntry { map, key }
    }

    pub fn struct_field(data: Arc<StructData>, slot: usize) -> Self {
        Self::StructField { data, slot }
    }

    pub fn cell_slot(slot: Arc<Mutex<Value>>) -> Self {
        Self::CellSlot { slot, guard: None }
    }

    pub fn borrowed_cell_slot(slot: Arc<Mutex<Value>>, guard: Arc<BorrowGuard>) -> Self {
        Self::CellSlot {
            slot,
            guard: Some(guard),
        }
    }

    pub fn borrowed(value: Value) -> Self {
        Self::Borrowed { value }
    }

    pub fn get(&self) -> Option<Value> {
        match self {
            Self::VecElement { values, index } => values.lock().get(*index).cloned(),
            Self::MapEntry { map, key } => map.lock().get(key).cloned(),
            Self::StructField { data, slot } => data.values.lock().get(*slot).cloned(),
            Self::CellSlot { slot, .. } => Some(slot.lock().clone()),
            Self::Borrowed { value } => Some(value.clone()),
        }
    }

    /// One atomic read-modify-write under the slot lock. `None` for a dangling reference or a
    /// `Borrowed` view, then the caller runs the unfused sequence. `f` must not run user code or
    /// lock other values.
    pub fn update<T>(&self, f: impl FnOnce(&mut Value) -> T) -> Option<T> {
        match self {
            Self::VecElement { values, index } => values.lock().get_mut(*index).map(f),
            Self::MapEntry { map, key } => map.lock().get_mut(key).map(f),
            Self::StructField { data, slot } => data.values.lock().get_mut(*slot).map(f),
            Self::CellSlot { slot, .. } => Some(f(&mut slot.lock())),
            Self::Borrowed { .. } => None,
        }
    }

    /// A shared `borrow()` cannot be written through. Valid Rust never tries, so this only
    /// shows for a script that skipped `rust check`.
    pub fn writable(&self) -> bool {
        match self {
            Self::CellSlot {
                guard: Some(guard), ..
            } => guard.is_exclusive(),
            _ => true,
        }
    }

    pub fn set(&self, value: Value) -> bool {
        self.swap(value).is_some()
    }

    /// Stores the value and hands the old one back, `None` for a dangling reference.
    pub fn swap(&self, value: Value) -> Option<Value> {
        match self {
            Self::VecElement { values, index } => {
                let mut values = values.lock();
                let slot = values.get_mut(*index)?;
                Some(std::mem::replace(slot, value))
            }
            Self::MapEntry { map, key } => {
                Some(map.lock().insert(key.clone(), value).unwrap_or_default())
            }
            Self::StructField { data, slot } => {
                let mut values = data.values.lock();
                let target = values.get_mut(*slot)?;
                Some(std::mem::replace(target, value))
            }
            Self::CellSlot { slot, .. } => Some(std::mem::replace(&mut *slot.lock(), value)),
            Self::Borrowed { .. } => None,
        }
    }
}