kast 0.1.0

kast programming language
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

use std::sync::{atomic::AtomicUsize, Arc};

use super::*;

mod scope;

use scope::*;
pub use scope::{Locals, ScopeType};

#[derive(Clone, PartialEq, Eq, Hash)]
pub struct InterpreterScope(Parc<Scope>);

impl InterpreterScope {
    pub fn insert(&self, symbol: &Symbol, value: Value) {
        self.0.insert(symbol.clone(), value);
    }
    /// TODO dont expose Locals?
    pub fn inspect<R>(&self, f: impl FnOnce(&Locals) -> R) -> R {
        self.0.inspect(f)
    }
    pub fn syntax_definitions(&self) -> &Mutex<Vec<Parc<ast::SyntaxDefinition>>> {
        &self.0.syntax_definitions
    }
    pub fn get(&self, symbol: &Symbol) -> Option<PlaceRef> {
        let (_symbol, value) = self
            .0
            .lookup(Lookup::Id(symbol.id()), None)
            .now_or_never()
            .unwrap()?;
        Some(value)
    }
}

#[derive(Clone, PartialEq, Eq, Hash)]
pub struct CompilerScope(Parc<Scope>);

impl CompilerScope {
    pub fn id(&self) -> Id {
        self.0.id
    }
    pub fn insert(&self, name: &str, value: Value) {
        tracing::trace!("inserting {name:?} into {:?}", self.0.id);
        self.0.insert(Symbol::new(name), value);
    }
    pub async fn lookup(&self, name: &str, hygiene: Hygiene, spawn_id: Id) -> Option<Value> {
        tracing::trace!("lookup {name:?} in {:?}", self.0.id);
        match hygiene {
            Hygiene::DefSite => {
                let (_symbol, value) = self.0.lookup(Lookup::Name(name), Some(spawn_id)).await?;
                Some(value.clone_value().unwrap())
            }
        }
    }
}

pub struct Scopes {
    pub id: Id,
    /// we get values for symbols by id
    pub interpreter: InterpreterScope,
    /// we get values by names
    pub compiler: CompilerScope,
    refcount: Arc<AtomicUsize>,
    is_weak: bool,
}

impl Clone for Scopes {
    fn clone(&self) -> Self {
        self.clone_impl(false)
    }
}

impl Scopes {
    fn clone_impl(&self, is_weak: bool) -> Self {
        let is_weak = self.is_weak || is_weak;
        if !is_weak {
            self.refcount
                .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
        }
        Self {
            id: self.id,
            interpreter: self.interpreter.clone(),
            compiler: self.compiler.clone(),
            is_weak,
            refcount: self.refcount.clone(),
        }
    }
    pub fn new(spawn_id: Id, ty: ScopeType, parent: Option<Scopes>) -> Self {
        let (iparent, cparent) = match parent {
            Some(parent) => (
                Some(parent.interpreter.0.clone()),
                Some(parent.compiler.0.clone()),
            ),
            None => (None, None),
        };
        Self {
            id: Id::new(),
            interpreter: InterpreterScope(Parc::new(Scope::new(spawn_id, ty, iparent))),
            compiler: CompilerScope(Parc::new(Scope::new(spawn_id, ty, cparent))),
            is_weak: false,
            refcount: Arc::new(AtomicUsize::new(1)),
        }
    }
    pub fn enter_def_site(&self, def_site: CompilerScope) -> Self {
        tracing::trace!("entering def site: {:?}", def_site.0.id);
        Self {
            id: Id::new(),
            interpreter: self.interpreter.clone(),
            compiler: def_site,
            // compiler: CompilerScope(Parc::new(Scope::new(self.interpreter.0.ty, Some(def_site.0)))),
            is_weak: true,
            refcount: self.refcount.clone(),
        }
    }
    pub fn weak_ref(&self) -> Self {
        self.clone_impl(true)
    }
}

impl Drop for Scopes {
    fn drop(&mut self) {
        if !self.is_weak
            && self
                .refcount
                .fetch_sub(1, std::sync::atomic::Ordering::SeqCst)
                == 1
        {
            self.interpreter.0.close();
            self.compiler.0.close();
        }
    }
}