neyuki 0.6.2

A small Lua-like scripting language implemented in Rust
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! The scope stack.

use std::collections::HashMap;

use crate::diagnostics::span::Span;
use crate::sema::symbol::Symbol;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ScopeKind {
    Global,
    Function,
    Block,
    Loop,
}

pub struct Scope {
    pub kind: ScopeKind,
    pub symbols: HashMap<String, Symbol>,
}

impl Scope {
    pub fn new(kind: ScopeKind) -> Self {
        Self {
            kind,
            symbols: HashMap::new(),
        }
    }
}

pub struct ScopeManager {
    pub scopes: Vec<Scope>,
}

impl Default for ScopeManager {
    fn default() -> Self {
        Self::new()
    }
}

impl ScopeManager {
    pub fn new() -> Self {
        let mut manager = Self { scopes: Vec::new() };
        manager.enter_scope(ScopeKind::Global);
        manager
    }

    pub fn enter_scope(&mut self, kind: ScopeKind) {
        self.scopes.push(Scope::new(kind));
    }

    pub fn exit_scope(&mut self) -> Vec<Symbol> {
        if self.scopes.len() > 1 {
            let scope = self
                .scopes
                .pop()
                .expect("checked above: more than one scope");
            scope.symbols.into_values().collect()
        } else {
            Vec::new()
        }
    }

    pub fn define(&mut self, symbol: Symbol) -> Result<(), Span> {
        let current = self.scopes.last_mut().expect("scope stack cannot be empty");
        if let Some(existing) = current.symbols.get(&symbol.name)
            && existing.is_const
        {
            return Err(existing.span);
        }
        current.symbols.insert(symbol.name.clone(), symbol);
        Ok(())
    }

    pub fn define_global(&mut self, symbol: Symbol) -> Result<(), Span> {
        let global_scope = self
            .scopes
            .first_mut()
            .expect("scope stack cannot be empty");
        if let Some(existing) = global_scope.symbols.get(&symbol.name)
            && existing.is_const
        {
            return Err(existing.span);
        }
        global_scope.symbols.insert(symbol.name.clone(), symbol);
        Ok(())
    }

    pub fn lookup(&self, name: &str) -> Option<&Symbol> {
        for scope in self.scopes.iter().rev() {
            if let Some(sym) = scope.symbols.get(name) {
                return Some(sym);
            }
        }
        None
    }

    pub fn lookup_mut(&mut self, name: &str) -> Option<&mut Symbol> {
        for scope in self.scopes.iter_mut().rev() {
            if let Some(sym) = scope.symbols.get_mut(name) {
                return Some(sym);
            }
        }
        None
    }

    pub fn flush_all(&mut self) -> Vec<Symbol> {
        let mut all = Vec::new();
        while let Some(scope) = self.scopes.pop() {
            all.extend(scope.symbols.into_values());
        }
        all
    }

    // Check if symbol exists in an enclosing outer scope
    pub fn find_outer(&self, name: &str) -> Option<&Symbol> {
        if self.scopes.len() <= 1 {
            return None;
        }
        // Exclude the current innermost scope
        for scope in self.scopes[0..self.scopes.len() - 1].iter().rev() {
            if let Some(sym) = scope.symbols.get(name) {
                return Some(sym);
            }
        }
        None
    }

    pub fn mark_used(&mut self, name: &str) -> bool {
        for scope in self.scopes.iter_mut().rev() {
            if let Some(sym) = scope.symbols.get_mut(name) {
                sym.used = true;
                return true;
            }
        }
        false
    }
}