Skip to main content

mirascript_vm/value/types/
module.rs

1use std::any::Any;
2
3use indexmap::IndexMap;
4
5use crate::{
6    MiraError, Result, Runtime, RuntimeErrorKind,
7    value::{MiraHandle, MiraManageable},
8};
9
10use super::{MiraValue, MiraValueKind, value::ValueTag};
11
12impl MiraValue {
13    /// Create a `MiraValue` representing a module value.
14    #[inline]
15    pub const fn module<T: MiraModule + ?Sized>(value: MiraHandle<T>) -> Self {
16        Self::handle(ValueTag::Module, value.erase_module())
17    }
18
19    /// Check whether this value is a module value.
20    #[inline]
21    pub const fn is_module(&self) -> bool {
22        matches!(self.tag(), Some(ValueTag::Module))
23    }
24
25    /// Return the module handle, or `None` for another value type.
26    #[inline]
27    pub fn as_module(&self) -> Option<MiraHandle<dyn MiraModule>> {
28        match self.kind() {
29            MiraValueKind::Module(value) => Some(value),
30            _ => None,
31        }
32    }
33}
34
35/// A named collection of MiraScript-visible values.
36pub trait MiraModule: Any {
37    /// Return the module name shown in diagnostics.
38    fn name(&self) -> &str;
39
40    /// Return the number of exports.
41    fn len(&self) -> usize;
42
43    /// Find an export's iteration index.
44    fn index_of(&self, key: &str) -> Option<usize>;
45
46    /// Read an export name by index.
47    fn key(&self, index: usize) -> Result<&str>;
48
49    /// Read an export value by index.
50    fn get(
51        &self,
52        self_handle: MiraHandle<dyn MiraModule>,
53        runtime: &Runtime,
54        index: usize,
55    ) -> Result<MiraManageable>;
56
57    /// Return whether this module has no exports.
58    fn is_empty(&self) -> bool {
59        self.len() == 0
60    }
61
62    #[doc(hidden)]
63    fn resolve<'a>(&self, runtime: &'a Runtime) -> Result<Option<&'a dyn MiraModule>> {
64        let _ = runtime;
65        Ok(None)
66    }
67}
68
69pub(crate) struct MiraMapModule {
70    name: String,
71    values: IndexMap<String, MiraValue>,
72}
73
74impl MiraMapModule {
75    pub(crate) fn new(name: impl Into<String>, values: IndexMap<String, MiraValue>) -> Self {
76        Self {
77            name: name.into(),
78            values,
79        }
80    }
81}
82
83impl MiraModule for MiraMapModule {
84    fn name(&self) -> &str {
85        &self.name
86    }
87
88    fn len(&self) -> usize {
89        self.values.len()
90    }
91
92    fn index_of(&self, key: &str) -> Option<usize> {
93        self.values.get_index_of(key)
94    }
95
96    fn key(&self, index: usize) -> Result<&str> {
97        self.values
98            .get_index(index)
99            .map(|(key, _)| key.as_str())
100            .ok_or_else(|| MiraError::runtime(RuntimeErrorKind::MissingIndexOrField))
101    }
102
103    fn get(
104        &self,
105        _self_handle: MiraHandle<dyn MiraModule>,
106        _runtime: &Runtime,
107        index: usize,
108    ) -> Result<MiraManageable> {
109        self.values
110            .get_index(index)
111            .map(|(_, value)| (*value).into())
112            .ok_or_else(|| MiraError::runtime(RuntimeErrorKind::MissingIndexOrField))
113    }
114}
115
116pub(crate) fn map_module(
117    name: impl Into<String>,
118    values: IndexMap<String, MiraValue>,
119) -> MiraManageable {
120    MiraManageable::from_module(MiraMapModule::new(name, values))
121}
122
123#[cfg(test)]
124mod tests {
125    use super::*;
126
127    fn assert_missing_index(error: &MiraError) {
128        assert!(matches!(
129            error,
130            MiraError::Runtime {
131                kind: RuntimeErrorKind::MissingIndexOrField,
132                ..
133            }
134        ));
135    }
136
137    fn assert_value(value: MiraManageable, expected: MiraValue) {
138        assert!(matches!(value, MiraManageable::Value(value) if value == expected));
139    }
140
141    #[test]
142    fn map_modules_expose_metadata_values_and_bounds() {
143        let mut runtime = Runtime::new();
144        let mut values = IndexMap::new();
145        values.insert("answer".into(), MiraValue::from(42));
146        let module = runtime
147            .insert_module(MiraMapModule::new("test", values))
148            .unwrap();
149        let value = MiraValue::module(module);
150
151        assert!(value.is_module());
152        assert_eq!(value.as_module(), Some(module.erase_module()));
153        assert!(MiraValue::NIL.as_module().is_none());
154
155        let value = runtime.get_module(module).unwrap();
156        assert_eq!(value.name(), "test");
157        assert_eq!(value.len(), 1);
158        assert!(!value.is_empty());
159        assert_eq!(value.index_of("answer"), Some(0));
160        assert_eq!(value.index_of("missing"), None);
161        assert_eq!(value.key(0).unwrap(), "answer");
162        assert_missing_index(value.key(1).unwrap_err().as_ref());
163        assert_value(
164            value.get(module.erase_module(), &runtime, 0).unwrap(),
165            42.into(),
166        );
167        assert_missing_index(
168            value
169                .get(module.erase_module(), &runtime, 1)
170                .err()
171                .unwrap()
172                .as_ref(),
173        );
174        assert!(MiraModule::resolve(value, &runtime).unwrap().is_none());
175
176        assert!(MiraMapModule::new("empty", IndexMap::new()).is_empty());
177    }
178}