beamr 0.5.0

A Rust runtime with the BEAM's execution model, targeting Gleam
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

//! Regression test for the is_function/2 guard on erlc-compiled code.
//!
//! Opcode 115 (is_function2) carries three operands — fail label, function
//! source, and arity — but the decoder used to route it through the generic
//! two-operand `type_test` helper, dropping the arity. Every compiled
//! `is_function(F, N)` guard then crashed the process with
//! `InvalidOperand("is_function2 operands")` instead of branching.

use beamr::atom::AtomTable;
use beamr::loader::{Instruction, prepare_module};
use beamr::module::{Module, ModuleRegistry};
use beamr::native::BifRegistryImpl;
use beamr::process::{CodePosition, ExitReason, Process};
use beamr::term::Term;

use beamr::interpreter::{ExecutionResult, run};

fn load_fixture(atoms: &AtomTable) -> Module {
    let registry = ModuleRegistry::new();
    let bifs = BifRegistryImpl::new();
    let (module, _report) = prepare_module(
        include_bytes!("fixtures/is_function2_guard.beam"),
        atoms,
        &registry,
        &bifs,
    )
    .expect("is_function2 guard fixture prepares");
    module
}

fn call(module: &Module, atoms: &AtomTable, function: &str) -> Term {
    let function = atoms.intern(function);
    let label = *module.exports.get(&(function, 0)).expect("export exists");
    let entry_ip = module
        .code
        .iter()
        .position(|instruction| matches!(instruction, Instruction::Label { label: candidate } if *candidate == label))
        .expect("export label exists");
    let mut process = Process::new(1, 4096);
    process.set_code_position(Some(CodePosition {
        module: module.name,
        instruction_pointer: entry_ip,
    }));

    assert_eq!(
        run(&mut process, module),
        Ok(ExecutionResult::Exited(ExitReason::Normal))
    );
    process.x_reg(0)
}

#[test]
fn guard_passes_for_a_fun_of_the_stated_arity() {
    let atoms = AtomTable::new();
    let module = load_fixture(&atoms);
    let matched = atoms.intern("matched");
    assert_eq!(call(&module, &atoms, "matching_arity"), Term::atom(matched));
}

#[test]
fn guard_falls_through_for_a_fun_of_the_wrong_arity() {
    let atoms = AtomTable::new();
    let module = load_fixture(&atoms);
    let fallthrough = atoms.intern("fallthrough");
    assert_eq!(
        call(&module, &atoms, "wrong_arity"),
        Term::atom(fallthrough)
    );
}

#[test]
fn guard_falls_through_for_a_non_fun() {
    let atoms = AtomTable::new();
    let module = load_fixture(&atoms);
    let fallthrough = atoms.intern("fallthrough");
    assert_eq!(call(&module, &atoms, "not_a_fun"), Term::atom(fallthrough));
}