mirascript-vm 0.1.105

Native Rust virtual machine for MiraScript
Documentation
use std::{iter::FusedIterator, ops::Range};

use crate::{MiraError, MiraModuleHandle, MiraValue, Result, Runtime, RuntimeErrorKind};

#[derive(Clone, Copy)]
pub(crate) struct ModuleEntry {
    handle: MiraModuleHandle,
    index: usize,
}

impl ModuleEntry {
    pub(crate) fn key(self, runtime: &Runtime) -> Result<&str> {
        self.handle.key(runtime, self.index)
    }

    pub(crate) fn get(self, runtime: &mut Runtime) -> Result<MiraValue> {
        self.handle.get(runtime, self.index)
    }
}

#[derive(Clone)]
pub(crate) struct ModuleIter {
    handle: MiraModuleHandle,
    indices: Range<usize>,
}

impl Iterator for ModuleIter {
    type Item = ModuleEntry;

    fn next(&mut self) -> Option<Self::Item> {
        self.indices.next().map(|index| ModuleEntry {
            handle: self.handle,
            index,
        })
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.indices.size_hint()
    }
}

impl DoubleEndedIterator for ModuleIter {
    fn next_back(&mut self) -> Option<Self::Item> {
        self.indices.next_back().map(|index| ModuleEntry {
            handle: self.handle,
            index,
        })
    }
}

impl ExactSizeIterator for ModuleIter {}
impl FusedIterator for ModuleIter {}

pub(crate) fn iterate_module(runtime: &Runtime, value: MiraValue) -> Result<ModuleIter> {
    let Some(handle) = value.as_module() else {
        return Err(MiraError::runtime(RuntimeErrorKind::TypeMismatch {
            expected: "module",
            actual: value.value_type(),
        }));
    };
    let length = handle.len(runtime)?;
    Ok(ModuleIter {
        handle,
        indices: 0..length,
    })
}

#[cfg(test)]
mod tests {
    use std::{cell::Cell, rc::Rc};

    use crate::{MiraHandle, MiraManageable, MiraModule};

    use super::*;

    struct CountingModule {
        keys: Rc<Cell<usize>>,
        reads: Rc<Cell<usize>>,
    }

    impl MiraModule for CountingModule {
        fn name(&self) -> &str {
            "counting"
        }

        fn len(&self) -> usize {
            4
        }

        fn index_of(&self, key: &str) -> Option<usize> {
            ["a", "b", "c", "d"]
                .iter()
                .position(|candidate| *candidate == key)
        }

        fn key(&self, index: usize) -> Result<&str> {
            self.keys.set(self.keys.get() + 1);
            ["a", "b", "c", "d"]
                .get(index)
                .copied()
                .ok_or_else(|| MiraError::runtime(RuntimeErrorKind::MissingIndexOrField))
        }

        fn get(
            &self,
            _self_handle: MiraHandle<dyn MiraModule>,
            _runtime: &Runtime,
            index: usize,
        ) -> Result<MiraManageable> {
            self.reads.set(self.reads.get() + 1);
            (index < 4)
                .then(|| MiraValue::number(index as f64).into())
                .ok_or_else(|| MiraError::runtime(RuntimeErrorKind::MissingIndexOrField))
        }
    }

    #[test]
    fn iterator_does_not_borrow_runtime_and_only_resolves_visited_entries() {
        let keys = Rc::new(Cell::new(0));
        let reads = Rc::new(Cell::new(0));
        let mut runtime = Runtime::new();
        let value = runtime
            .insert(MiraManageable::from_module(CountingModule {
                keys: keys.clone(),
                reads: reads.clone(),
            }))
            .unwrap();

        let iter = iterate_module(&runtime, value).unwrap();
        assert_eq!(iter.len(), 4);
        let visited = iter
            .take(2)
            .enumerate()
            .map(|(index, entry)| {
                let key = entry.key(&runtime)?.to_owned();
                let value = entry.get(&mut runtime)?.as_number_unchecked();
                Ok((index, key, value))
            })
            .collect::<Result<Vec<_>>>()
            .unwrap();

        assert_eq!(visited, vec![(0, "a".into(), 0.0), (1, "b".into(), 1.0)]);
        assert_eq!(keys.get(), 2);
        assert_eq!(reads.get(), 2);
    }
}