ralix 0.2.0

A simple, type-safe, tree walking interpreter
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

use std::path::PathBuf;

use crate::{
    EvalResult, Evaluator, Expression, RuntimeError, Statement, Value,
    eval::ModuleState,
    expressions::{Identifier, ImportedItem},
};

impl Evaluator<'_> {
    pub fn evaluate_import_statement(
        &mut self,
        file_module_path: PathBuf,
        imported_items: Vec<ImportedItem>,
        module_name: Identifier,
    ) -> EvalResult<Value> {
        let module = match self.ctx.module_cache.get(&file_module_path) {
            Some(module_state) => match module_state {
                ModuleState::Loaded(m) => m,
                ModuleState::Loading => {
                    return EvalResult::Err(RuntimeError::ImportCycleDetected(module_name));
                }
            },
            None => {
                let module = match self.evaluate_module(file_module_path.clone()) {
                    Ok(m) => m,
                    Err(module_err) => {
                        return EvalResult::Err(RuntimeError::ModuleExecuteError(module_err));
                    }
                };
                self.ctx
                    .module_cache
                    .insert(file_module_path.clone(), ModuleState::Loaded(module));

                match self.ctx.module_cache.get(&file_module_path).unwrap() {
                    ModuleState::Loaded(m) => m,
                    _ => unreachable!(),
                }
            }
        };

        for item in imported_items {
            self.ctx.environment.define(
                item.as_naming.unwrap_or(item.name.clone()),
                module[item.name],
            );
        }

        EvalResult::NoValue
    }

    pub fn evaluate_export_statement(&mut self, stmt: Statement) -> EvalResult<Value> {
        match stmt {
            Statement::Binding(binding) => {
                let binding_result = self.evaluate_binding(binding.ident.clone(), binding.value);
                let addr = self.ctx.get_addr(&binding.ident).unwrap();
                self.ctx.self_module.export(binding.ident, addr);
                binding_result
            }
            Statement::Alias { ident, ty } => {
                let binding_result = self.evaluate_binding(ident.clone(), Expression::Type(ty));
                let addr = self.ctx.get_addr(&ident).unwrap();
                self.ctx.self_module.export(ident, addr);
                binding_result
            }
            _ => unreachable!(),
        }
    }
}