monkey-compiler 1.1.0

a compiler for monkeylang
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use std::collections::HashMap;
use std::rc::Rc;

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum SymbolScope {
    LOCAL,
    Global,
    Builtin,
    Free,
    Function,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Symbol {
    pub name: String,
    pub scope: SymbolScope,
    pub index: usize,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct SymbolTable {
    pub outer: Option<Rc<SymbolTable>>,
    symbols: HashMap<String, Rc<Symbol>>,
    pub free_symbols: Vec<Rc<Symbol>>,
    pub num_definitions: usize,
}

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

impl SymbolTable {
    pub fn new() -> SymbolTable {
        SymbolTable {
            symbols: HashMap::new(),
            free_symbols: vec![],
            num_definitions: 0,
            outer: None,
        }
    }

    pub fn new_enclosed_symbol_table(outer: SymbolTable) -> SymbolTable {
        SymbolTable {
            symbols: HashMap::new(),
            free_symbols: vec![],
            num_definitions: 0,
            outer: Some(Rc::new(outer)),
        }
    }

    pub fn define(&mut self, name: String) -> Rc<Symbol> {
        let mut scope = SymbolScope::LOCAL;
        if self.outer.is_none() {
            scope = SymbolScope::Global;
        }

        let symbol = Rc::new(Symbol {
            name: name.clone(),
            index: self.num_definitions,
            scope,
        });

        self.num_definitions += 1;
        self.symbols.insert(name.clone(), Rc::clone(&symbol));
        return symbol;
    }

    pub fn visible_names(&self) -> Vec<String> {
        let mut names = self
            .outer
            .as_ref()
            .map(|outer| outer.visible_names())
            .unwrap_or_default();
        names.extend(self.symbols.keys().cloned());
        names
    }

    /// Names defined in the outermost (global) scope, paired with their slot
    /// index. Sorted by name so reports stay deterministic.
    pub fn global_symbols(&self) -> Vec<(String, usize)> {
        let mut table = self;
        while let Some(outer) = table.outer.as_deref() {
            table = outer;
        }
        let mut globals: Vec<(String, usize)> = table
            .symbols
            .values()
            .filter(|symbol| symbol.scope == SymbolScope::Global)
            .map(|symbol| (symbol.name.clone(), symbol.index))
            .collect();
        globals.sort();
        globals
    }

    // Resolve a name in the current scope, capturing free variables from outers when needed.
    pub fn resolve(&mut self, name: String) -> Option<Rc<Symbol>> {
        if let Some(sym) = self.symbols.get(&name) {
            return Some(sym.clone());
        }

        // Resolve through every intermediate function scope. Each scope must
        // create its own free symbol so closures capture from the immediately
        // enclosing frame rather than reading a grandparent's local slot.
        let outer = self.outer.take()?;
        let mut outer_table = outer.as_ref().clone();
        let original = outer_table.resolve(name);
        self.outer = Some(Rc::new(outer_table));
        let original = original?;
        match original.scope {
            SymbolScope::Global | SymbolScope::Builtin => Some(original),
            SymbolScope::LOCAL | SymbolScope::Free | SymbolScope::Function => {
                Some(self.define_free(original))
            }
        }
    }

    pub fn define_builtin(&mut self, index: usize, name: String) -> Rc<Symbol> {
        let symbol = Rc::new(Symbol {
            name: name.clone(),
            index,
            scope: SymbolScope::Builtin,
        });
        self.symbols.insert(name.clone(), Rc::clone(&symbol));
        return symbol;
    }

    pub fn define_function_name(&mut self, name: String) -> Rc<Symbol> {
        let symbol = Rc::new(Symbol {
            name: name.clone(),
            index: 0,
            scope: SymbolScope::Function,
        });
        self.symbols.insert(name.clone(), Rc::clone(&symbol));
        return symbol;
    }

    pub fn define_free(&mut self, original: Rc<Symbol>) -> Rc<Symbol> {
        self.free_symbols.push(Rc::clone(&original));
        let symbol = Rc::new(Symbol {
            name: original.name.clone(),
            index: self.free_symbols.len() - 1,
            scope: SymbolScope::Free,
        });
        self.symbols
            .insert(original.name.clone(), Rc::clone(&symbol));
        return symbol;
    }
}