mirascript-vm 0.1.87

Native Rust virtual machine for MiraScript
Documentation
use std::collections::{BTreeMap, HashMap};
use std::hash::{BuildHasher, Hash};

use indexmap::IndexMap;

use crate::{MiraError, Result};

use super::{MiraAny, MiraBridge, MiraFunction, MiraModule, MiraNativeFn, MiraShared};

impl From<()> for MiraAny {
    fn from(_: ()) -> Self {
        Self::Nil
    }
}

impl From<bool> for MiraAny {
    fn from(value: bool) -> Self {
        Self::Boolean(value)
    }
}

impl From<String> for MiraAny {
    fn from(value: String) -> Self {
        Self::String(value)
    }
}

impl From<&str> for MiraAny {
    fn from(value: &str) -> Self {
        Self::String(value.to_owned())
    }
}

macro_rules! number_from {
    ($($ty:ty),* $(,)?) => {$ (
        impl From<$ty> for MiraAny {
            fn from(value: $ty) -> Self {
                Self::Number(value as f64)
            }
        }
    )* };
}

number_from!(u8, u16, u32, u64, usize, i8, i16, i32, i64, isize, f32, f64);

impl<T: Into<MiraAny>> From<Option<T>> for MiraAny {
    fn from(value: Option<T>) -> Self {
        value.map(Into::into).unwrap_or(Self::Nil)
    }
}

impl<T: Into<MiraAny>> From<Vec<T>> for MiraAny {
    fn from(value: Vec<T>) -> Self {
        Self::Array(value.into_iter().map(Into::into).collect())
    }
}

impl<T: Into<MiraAny>, const N: usize> From<[T; N]> for MiraAny {
    fn from(value: [T; N]) -> Self {
        Self::Array(value.into_iter().map(Into::into).collect())
    }
}

impl<T: Into<MiraAny>> From<IndexMap<String, T>> for MiraAny {
    fn from(value: IndexMap<String, T>) -> Self {
        Self::Record(
            value
                .into_iter()
                .map(|(key, value)| (key, value.into()))
                .collect(),
        )
    }
}

impl<K, T, S> From<HashMap<K, T, S>> for MiraAny
where
    K: Into<String> + Eq + Hash,
    T: Into<MiraAny>,
    S: BuildHasher,
{
    fn from(value: HashMap<K, T, S>) -> Self {
        let mut entries: Vec<_> = value
            .into_iter()
            .map(|(key, value)| (key.into(), value.into()))
            .collect();
        entries.sort_by(|a, b| a.0.cmp(&b.0));
        Self::Record(entries.into_iter().collect())
    }
}

impl<K, T> From<BTreeMap<K, T>> for MiraAny
where
    K: Into<String> + Ord,
    T: Into<MiraAny>,
{
    fn from(value: BTreeMap<K, T>) -> Self {
        Self::Record(
            value
                .into_iter()
                .map(|(key, value)| (key.into(), value.into()))
                .collect(),
        )
    }
}

impl From<MiraNativeFn> for MiraAny {
    fn from(value: MiraNativeFn) -> Self {
        Self::Function(MiraFunction::Native(value))
    }
}

impl From<MiraModule> for MiraAny {
    fn from(value: MiraModule) -> Self {
        Self::Module(value)
    }
}

impl<T: MiraBridge> From<MiraShared<T>> for MiraAny {
    fn from(value: MiraShared<T>) -> Self {
        T::into_mira_shared(value)
    }
}

impl TryFrom<MiraAny> for bool {
    type Error = MiraError;

    fn try_from(value: MiraAny) -> Result<Self> {
        match value {
            MiraAny::Boolean(value) => Ok(value),
            value => Err(MiraError::conversion("bool", &value)),
        }
    }
}

impl TryFrom<MiraAny> for String {
    type Error = MiraError;

    fn try_from(value: MiraAny) -> Result<Self> {
        match value {
            MiraAny::String(value) => Ok(value),
            value => Err(MiraError::conversion("String", &value)),
        }
    }
}

impl<T> TryFrom<MiraAny> for Option<T>
where
    T: TryFrom<MiraAny, Error = MiraError>,
{
    type Error = MiraError;

    fn try_from(value: MiraAny) -> Result<Self> {
        if value == MiraAny::Nil {
            Ok(None)
        } else {
            T::try_from(value).map(Some)
        }
    }
}

impl<T> TryFrom<MiraAny> for Vec<T>
where
    T: TryFrom<MiraAny, Error = MiraError>,
{
    type Error = MiraError;

    fn try_from(value: MiraAny) -> Result<Self> {
        let MiraAny::Array(values) = value else {
            return Err(MiraError::conversion("Vec", &value));
        };
        values
            .into_iter()
            .enumerate()
            .map(|(index, value)| {
                T::try_from(value).map_err(|error| error.at_path(index.to_string()))
            })
            .collect()
    }
}

impl<T, const N: usize> TryFrom<MiraAny> for [T; N]
where
    T: TryFrom<MiraAny, Error = MiraError>,
{
    type Error = MiraError;

    fn try_from(value: MiraAny) -> Result<Self> {
        let values = Vec::<T>::try_from(value)?;
        let actual = values.len();
        values.try_into().map_err(|_| MiraError::Conversion {
            expected: format!("array of length {N}"),
            actual: format!("array of length {actual}"),
            path: None,
        })
    }
}

impl<T> TryFrom<MiraAny> for IndexMap<String, T>
where
    T: TryFrom<MiraAny, Error = MiraError>,
{
    type Error = MiraError;

    fn try_from(value: MiraAny) -> Result<Self> {
        let MiraAny::Record(values) = value else {
            return Err(MiraError::conversion("record", &value));
        };
        values
            .into_iter()
            .map(|(key, value)| {
                T::try_from(value)
                    .map(|value| (key.clone(), value))
                    .map_err(|error| error.at_path(key))
            })
            .collect()
    }
}

macro_rules! unsigned_integer_try_from {
    ($($ty:ty),* $(,)?) => {$ (
        impl TryFrom<MiraAny> for $ty {
            type Error = MiraError;

            fn try_from(value: MiraAny) -> Result<Self> {
                let MiraAny::Number(number) = value else {
                    return Err(MiraError::conversion(stringify!($ty), &value));
                };
                if !number.is_finite()
                    || number.trunc() != number
                    || number < 0.0
                    || number >= 2_f64.powi(<$ty>::BITS as i32)
                {
                    return Err(MiraError::Conversion {
                        expected: stringify!($ty).into(),
                        actual: format!("number {number}"),
                        path: None,
                    });
                }
                Ok(number as $ty)
            }
        }
    )* };
}

macro_rules! signed_integer_try_from {
    ($($ty:ty),* $(,)?) => {$ (
        impl TryFrom<MiraAny> for $ty {
            type Error = MiraError;

            fn try_from(value: MiraAny) -> Result<Self> {
                let MiraAny::Number(number) = value else {
                    return Err(MiraError::conversion(stringify!($ty), &value));
                };
                let limit = 2_f64.powi(<$ty>::BITS as i32 - 1);
                if !number.is_finite()
                    || number.trunc() != number
                    || number < -limit
                    || number >= limit
                {
                    return Err(MiraError::Conversion {
                        expected: stringify!($ty).into(),
                        actual: format!("number {number}"),
                        path: None,
                    });
                }
                Ok(number as $ty)
            }
        }
    )* };
}

unsigned_integer_try_from!(u8, u16, u32, u64, usize);
signed_integer_try_from!(i8, i16, i32, i64, isize);

impl TryFrom<MiraAny> for f64 {
    type Error = MiraError;

    fn try_from(value: MiraAny) -> Result<Self> {
        match value {
            MiraAny::Number(value) => Ok(value),
            value => Err(MiraError::conversion("f64", &value)),
        }
    }
}

impl TryFrom<MiraAny> for f32 {
    type Error = MiraError;

    fn try_from(value: MiraAny) -> Result<Self> {
        let value = f64::try_from(value)?;
        if value.is_finite() && (value < f32::MIN as f64 || value > f32::MAX as f64) {
            return Err(MiraError::Conversion {
                expected: "f32".into(),
                actual: format!("number {value}"),
                path: None,
            });
        }
        Ok(value as f32)
    }
}