mirascript-vm 0.1.87

Native Rust virtual machine for MiraScript
Documentation
use super::*;

pub(crate) fn has(value: &MiraAny, key: &MiraAny) -> Result<bool> {
    assert_initialized(value)?;
    let key = to_string(key)?;
    match value {
        MiraAny::Nil
        | MiraAny::Boolean(_)
        | MiraAny::Number(_)
        | MiraAny::String(_)
        | MiraAny::Function(_)
        | MiraAny::Uninitialized => Ok(false),
        MiraAny::Array(_) | MiraAny::RustArray(_) => {
            let Ok(index) = key.parse::<usize>() else {
                return Ok(false);
            };
            Ok(index < value.array_len()?.unwrap_or(0))
        }
        MiraAny::Record(_) | MiraAny::RustRecord(_) => Ok(value
            .record_keys()?
            .is_some_and(|keys| keys.iter().any(|candidate| candidate == &key))),
        MiraAny::Extern(value) => value.has(&key),
        MiraAny::Module(module) => Ok(module.keys().iter().any(|candidate| candidate == &key)),
    }
}

pub(crate) fn get(value: &MiraAny, key: &str) -> Result<MiraAny> {
    get_value(value, &MiraAny::String(key.to_owned()))
}

pub(crate) fn get_value(value: &MiraAny, key: &MiraAny) -> Result<MiraAny> {
    assert_initialized(value)?;
    if matches!(value, MiraAny::Array(_) | MiraAny::RustArray(_)) {
        let index = match to_number(key) {
            Ok(index) if index.is_finite() => index.trunc() as isize,
            _ => return Ok(MiraAny::Nil),
        };
        let length = value.array_len()?.unwrap_or(0);
        let index = if index < 0 {
            length.checked_add_signed(index)
        } else {
            Some(index as usize)
        };
        return match index {
            Some(index) if index < length => value
                .array_get(index)?
                .unwrap_or(MiraAny::Nil)
                .into_element(),
            _ => Ok(MiraAny::Nil),
        };
    }

    let key = to_string(key)?;
    match value {
        MiraAny::Record(_) | MiraAny::RustRecord(_) => value
            .record_get(&key)?
            .unwrap_or(MiraAny::Nil)
            .into_element(),
        MiraAny::Extern(value) => {
            let result = value.get(&key)?.unwrap_or(MiraAny::Nil);
            assert_initialized(&result)?;
            Ok(result)
        }
        MiraAny::Module(module) => {
            let result = module.get_native(&key).unwrap_or(MiraAny::Nil);
            assert_initialized(&result)?;
            Ok(result)
        }
        _ => Ok(MiraAny::Nil),
    }
}

pub(crate) fn set(value: &MiraAny, key: &MiraAny, new_value: MiraAny) -> Result<()> {
    assert_initialized(value)?;
    assert_initialized(&new_value)?;
    let MiraAny::Extern(value) = value else {
        return Err(MiraError::runtime(format!(
            "Expected extern, got {}",
            display(value)
        )));
    };
    let key = to_string(key)?;
    if value.set(&key, new_value)? {
        Ok(())
    } else {
        Err(MiraError::runtime(format!(
            "Extern field `{key}` is missing or read-only"
        )))
    }
}

pub(crate) fn pick(value: &MiraAny, keys: &[String]) -> Result<MiraAny> {
    assert_initialized(value)?;
    if !matches!(value, MiraAny::Record(_) | MiraAny::RustRecord(_)) {
        return Ok(MiraAny::Record(IndexMap::new()));
    }
    let mut result = IndexMap::new();
    for key in keys {
        if has(value, &MiraAny::String(key.clone()))? {
            result.insert(key.clone(), get(value, key)?);
        }
    }
    Ok(MiraAny::Record(result))
}

pub(crate) fn omit(value: &MiraAny, keys: &[String]) -> Result<MiraAny> {
    assert_initialized(value)?;
    if !matches!(value, MiraAny::Record(_) | MiraAny::RustRecord(_)) {
        return Ok(MiraAny::Record(IndexMap::new()));
    }
    let mut result = IndexMap::new();
    for key in value.record_keys()?.unwrap_or_default() {
        if !keys.contains(&key) {
            result.insert(key.clone(), get(value, &key)?);
        }
    }
    Ok(MiraAny::Record(result))
}