lemonlang 0.0.3

an experimental, modern, purely safe, programming language.
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

use rustc_hash::FxHashMap;

use crate::{checker::types::TypeId, ir::IrBasicValue};

pub enum ScopeKind {
	Function {
		ret_type: TypeId,
	},
	Impl {
		self_name: String,
		self_type: TypeId,
	},
	Member {
		// self_value: Option<IrBasicValue>
	},
	Block,
}

pub struct Scope {
	pub kind: ScopeKind,
	pub locals: FxHashMap<String, IrBasicValue>,
	pub dont_load: FxHashMap<String, bool>,
	pub free_values: FxHashMap<String, IrBasicValue>,
}

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

impl Scope {
	pub fn new() -> Self {
		let dont_load = FxHashMap::default();
		let locals = FxHashMap::default();
		let free_values = FxHashMap::default();
		Scope { dont_load, locals, free_values, kind: ScopeKind::Block }
	}

	pub fn new_function(ret_type: TypeId) -> Self {
		let dont_load = FxHashMap::default();
		let locals = FxHashMap::default();
		let free_values = FxHashMap::default();
		Scope { dont_load, locals, free_values, kind: ScopeKind::Function { ret_type } }
	}

	pub fn new_impl(self_name: String, self_type: TypeId) -> Self {
		let dont_load = FxHashMap::default();
		let locals = FxHashMap::default();
		let free_values = FxHashMap::default();
		Scope { dont_load, locals, free_values, kind: ScopeKind::Impl { self_name, self_type } }
	}

	pub fn new_member() -> Self {
		let dont_load = FxHashMap::default();
		let locals = FxHashMap::default();
		let free_values = FxHashMap::default();
		Scope { dont_load, locals, free_values, kind: ScopeKind::Member {} }
	}

	pub fn get_ret_type(&self) -> Option<TypeId> {
		match self.kind {
			ScopeKind::Function { ret_type } => Some(ret_type),
			_ => None,
		}
	}

	pub fn add_free_value(&mut self, value: IrBasicValue) {
		self.free_values.insert(value.value.as_str().into(), value);
	}

	pub fn get_free_values(&self) -> Vec<IrBasicValue> {
		self.free_values.values().cloned().collect()
	}

	pub fn is_impl_scope(&self) -> bool {
		matches!(&self.kind, ScopeKind::Impl { .. })
	}

	pub fn is_member_scope(&self) -> bool {
		matches!(&self.kind, ScopeKind::Member {})
	}

	pub fn get_self_info(&self) -> Option<(String, TypeId)> {
		match &self.kind {
			ScopeKind::Impl { self_name, self_type, .. } => Some((self_name.clone(), *self_type)),
			_ => None,
		}
	}

	pub fn is_function_scope(&self) -> bool {
		matches!(&self.kind, ScopeKind::Function { .. })
	}

	pub fn add_dont_load(&mut self, key: impl Into<String>) {
		self.dont_load.insert(key.into(), true);
	}

	pub fn is_dont_load(&self, key: &str) -> bool {
		self.dont_load.contains_key(key)
	}

	pub fn add_local(&mut self, key: String, basic_value: IrBasicValue) {
		self.locals.insert(key, basic_value);
	}

	pub fn get_local(&self, name: &str) -> Option<&IrBasicValue> {
		self.locals.get(name)
	}

	// pub fn get_local_mut(&mut self, name: &str) -> Option<&mut IrBasicValue> {
	// 	self.locals.get_mut(name)
	// }

	// pub fn get_local_type(&self, name: &str) -> Option<&TypeId> {
	// 	self.get_local(name).map(|local| &local.type_id)
	// }
}