d4rt_rs 0.1.3

A Dart interpreter and runtime environment in Rust, embeddable as a library (QuickJS-style Context API)
Documentation
pub mod bigint;
pub mod collection;
pub mod date_time;
pub mod duration;
pub mod errors;
pub mod exceptions;
pub mod patern;
pub mod primitives;
pub mod regexp;
pub mod stack_trace;
pub mod string;
pub mod uri;

use super::helpers as h;
use crate::callable::NativeFunction;
use crate::env::Environment;
use crate::rt::{FunctionRuntimeType, RuntimeType};
use crate::value::Value;
use std::cell::RefCell;
use std::rc::Rc;
use std::sync::Arc;

fn define_bridge(env: &Rc<RefCell<Environment>>, bc: crate::class::BridgedClassDef) {
    let bc = Arc::new(bc);
    h::register_class(bc.clone());
    Environment::define_bridge(env, bc);
}

pub fn load_core(env: &Rc<RefCell<Environment>>) {
    define_bridge(env, primitives::object_definition());
    define_bridge(env, primitives::null_definition());
    define_bridge(env, primitives::bool_definition());
    define_bridge(env, primitives::num_definition());
    define_bridge(env, primitives::int_definition());
    define_bridge(env, primitives::double_definition());
    define_bridge(env, primitives::comparable_definition());
    define_bridge(env, primitives::function_definition());
    define_bridge(env, primitives::symbol_definition());
    define_bridge(env, primitives::type_definition());
    define_bridge(env, string::string_definition());
    define_bridge(env, string::string_buffer_definition());
    define_bridge(env, string::string_sink_definition());
    define_bridge(env, string::sink_definition());
    define_bridge(env, string::runes_definition());
    define_bridge(env, collection::list_definition());
    define_bridge(env, collection::map_definition());
    define_bridge(env, collection::map_entry_definition());
    define_bridge(env, collection::set_definition());
    define_bridge(env, collection::iterable_definition());
    define_bridge(env, collection::iterator_definition());
    define_bridge(env, patern::pattern_definition());
    define_bridge(env, patern::match_definition());
    define_bridge(env, duration::duration_definition());
    define_bridge(env, date_time::date_time_definition());
    define_bridge(env, stack_trace::stack_trace_definition());
    define_bridge(env, errors::error_definition());
    define_bridge(env, errors::assertion_error_definition());
    define_bridge(env, errors::type_error_definition());
    define_bridge(env, errors::argument_error_definition());
    define_bridge(env, errors::range_error_definition());
    define_bridge(env, exceptions::exception_definition());
    define_bridge(env, exceptions::format_exception_definition());
    define_bridge(env, regexp::regexp_definition());
    define_bridge(env, regexp::regexp_match_definition());
    define_bridge(env, uri::uri_definition());
    define_bridge(env, bigint::bigint_definition());

    let dynamic_fn = NativeFunction {
        name: Some("dynamic".to_string()),
        min_arity: 0,
        max_arity: Some(0),
        is_async: false,
        is_generator: false,
        closure: Box::new(|_v, _a, _n| Ok(Value::Type(RuntimeType::dynamic()))),
        callable_runtime_type: FunctionRuntimeType::untyped(),
    };
    Environment::define(env, "dynamic", Value::NativeFn(Rc::new(dynamic_fn)));

    let identical_fn = NativeFunction {
        name: Some("identical".to_string()),
        min_arity: 2,
        max_arity: Some(2),
        is_async: false,
        is_generator: false,
        closure: Box::new(|_v, args, _n| {
            let a = args.first().cloned().unwrap_or(Value::Null);
            let b = args.get(1).cloned().unwrap_or(Value::Null);
            Ok(Value::Bool(identical_values(&a, &b)))
        }),
        callable_runtime_type: FunctionRuntimeType::untyped(),
    };
    Environment::define(env, "identical", Value::NativeFn(Rc::new(identical_fn)));
}

fn identical_values(a: &Value, b: &Value) -> bool {
    match (a, b) {
        (Value::Int(x), Value::Int(y)) => x == y,
        (Value::Double(x), Value::Double(y)) => x.to_bits() == y.to_bits(),
        (Value::Bool(x), Value::Bool(y)) => x == y,
        (Value::Str(x), Value::Str(y)) => x == y,
        (Value::Null, Value::Null) => true,
        _ => match (a.ptr(), b.ptr()) {
            (Some(x), Some(y)) => x == y,
            _ => false,
        },
    }
}