runmat-vm 0.4.4

RunMat virtual machine and bytecode interpreter
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! Import and static-resolution lowering.

use crate::compiler::core::Compiler;
use crate::compiler::CompileError;

pub(crate) struct CallImportResolution {
    pub resolved: String,
    pub static_candidates: Vec<(String, String)>,
}

impl Compiler {
    fn join_import_path(parts: &[String]) -> String {
        parts.join(".")
    }

    pub(crate) fn resolve_unqualified_static_property(
        &self,
        name: &str,
    ) -> Result<Option<String>, CompileError> {
        let mut classes: Vec<String> = Vec::new();
        for (path, wildcard) in &self.imports {
            if !*wildcard || path.is_empty() {
                continue;
            }
            let cls = Self::join_import_path(path);
            if let Some((p, _owner)) = runmat_builtins::lookup_property(&cls, name) {
                if p.is_static {
                    classes.push(cls);
                }
            }
        }
        if classes.len() > 1 {
            return Err(self.compile_error(format!(
                "ambiguous unqualified static property '{}' via Class.* imports: {}",
                name,
                classes.join(", ")
            )));
        }
        Ok(classes.pop())
    }

    pub(crate) fn resolve_call_imports(
        &self,
        name: &str,
    ) -> Result<CallImportResolution, CompileError> {
        let mut resolved = name.to_string();
        let mut static_candidates: Vec<(String, String)> = Vec::new();

        if !runmat_builtins::builtin_functions()
            .iter()
            .any(|b| b.name == resolved)
        {
            let mut specific_candidates: Vec<String> = Vec::new();
            for (path, wildcard) in &self.imports {
                if *wildcard {
                    continue;
                }
                if path.last().map(|s| s.as_str()) == Some(name) {
                    let qual = Self::join_import_path(path);
                    if runmat_builtins::builtin_functions()
                        .iter()
                        .any(|b| b.name == qual)
                        || self.functions.contains_key(&qual)
                    {
                        specific_candidates.push(qual);
                    }
                }
            }
            if specific_candidates.len() > 1 {
                return Err(self.compile_error(format!(
                    "ambiguous unqualified reference '{}' via imports: {}",
                    name,
                    specific_candidates.join(", ")
                )));
            }
            if specific_candidates.len() == 1 {
                resolved = specific_candidates.remove(0);
            } else {
                let mut wildcard_candidates: Vec<String> = Vec::new();
                for (path, wildcard) in &self.imports {
                    if !*wildcard || path.is_empty() {
                        continue;
                    }
                    let cls = Self::join_import_path(path);
                    let qual = format!("{}.{}", cls, name);
                    if runmat_builtins::builtin_functions()
                        .iter()
                        .any(|b| b.name == qual)
                        || self.functions.contains_key(&qual)
                    {
                        wildcard_candidates.push(qual);
                    }
                    if let Some((m, _owner)) = runmat_builtins::lookup_method(&cls, name) {
                        if m.is_static {
                            static_candidates.push((cls.clone(), name.to_string()));
                        }
                    }
                }
                if wildcard_candidates.len() > 1 {
                    return Err(self.compile_error(format!(
                        "ambiguous unqualified reference '{}' via wildcard imports: {}",
                        name,
                        wildcard_candidates.join(", ")
                    )));
                }
                if wildcard_candidates.len() == 1 {
                    resolved = wildcard_candidates.remove(0);
                }
            }
        }

        Ok(CallImportResolution {
            resolved,
            static_candidates,
        })
    }
}