Skip to main content

mirascript_vm/value/
module.rs

1use std::fmt;
2use std::rc::Rc;
3
4use indexmap::IndexMap;
5
6use super::MiraAny;
7
8#[derive(Debug, Clone)]
9#[doc(hidden)]
10pub struct ScriptModule {
11    pub execution: u64,
12    pub frame: usize,
13    pub exports: IndexMap<String, usize>,
14    pub name: Rc<str>,
15}
16
17#[derive(Clone)]
18/// A named collection of MiraScript-visible values.
19pub enum MiraModule {
20    /// A host-created module that may safely outlive an execution.
21    Native {
22        /// Module name used in diagnostics and debug output.
23        name: Rc<str>,
24        /// Exported values keyed by field name.
25        values: Rc<IndexMap<String, MiraAny>>,
26    },
27    #[doc(hidden)]
28    Script(Rc<ScriptModule>),
29}
30
31impl MiraModule {
32    /// Create a native module from an ordered map of exported values.
33    ///
34    /// # Examples
35    ///
36    /// ```
37    /// use indexmap::IndexMap;
38    /// use mirascript_vm::{MiraAny, MiraModule};
39    ///
40    /// let module = MiraModule::new(
41    ///     "constants",
42    ///     IndexMap::from([("answer".into(), MiraAny::Number(42.0))]),
43    /// );
44    /// assert_eq!(module.name(), "constants");
45    /// assert_eq!(module.get_native("answer"), Some(MiraAny::Number(42.0)));
46    /// ```
47    pub fn new(name: impl Into<String>, values: IndexMap<String, MiraAny>) -> Self {
48        Self::Native {
49            name: Rc::from(name.into()),
50            values: Rc::new(values),
51        }
52    }
53
54    /// Return the module name.
55    pub fn name(&self) -> &str {
56        match self {
57            Self::Native { name, .. } => name,
58            Self::Script(module) => &module.name,
59        }
60    }
61
62    /// Return exported field names in insertion order.
63    pub fn keys(&self) -> Vec<String> {
64        match self {
65            Self::Native { values, .. } => values.keys().cloned().collect(),
66            Self::Script(module) => module.exports.keys().cloned().collect(),
67        }
68    }
69
70    /// Clone an export from a native module.
71    ///
72    /// Script modules return `None`; they are resolved by the active runtime.
73    pub fn get_native(&self, key: &str) -> Option<MiraAny> {
74        match self {
75            Self::Native { values, .. } => values.get(key).cloned(),
76            Self::Script(_) => None,
77        }
78    }
79
80    pub(super) fn same(&self, other: &Self) -> bool {
81        match (self, other) {
82            (Self::Native { values: a, .. }, Self::Native { values: b, .. }) => Rc::ptr_eq(a, b),
83            (Self::Script(a), Self::Script(b)) => Rc::ptr_eq(a, b),
84            _ => false,
85        }
86    }
87}
88
89impl fmt::Debug for MiraModule {
90    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
91        f.debug_struct("MiraModule")
92            .field("name", &self.name())
93            .field("keys", &self.keys())
94            .finish()
95    }
96}