swamp_modules/
symtbl.rs

1/*
2 * Copyright (c) Peter Bjorklund. All rights reserved. https://github.com/swamp/swamp
3 * Licensed under the MIT License. See LICENSE in the project root for license information.
4 */
5use crate::modules::ModuleRef;
6use seq_map::SeqMap;
7use source_map_node::Node;
8use std::fmt::Debug;
9use std::rc::Rc;
10use swamp_refs::ModuleSymbolReferences;
11use swamp_semantic::prelude::*;
12use swamp_symbol::TopLevelSymbolId;
13use swamp_types::TypeRef;
14use swamp_types::prelude::*;
15
16#[derive(Debug, Clone)]
17pub enum FuncDef {
18    Internal(InternalFunctionDefinitionRef),
19    Intrinsic(IntrinsicFunctionDefinitionRef),
20    External(ExternalFunctionDefinitionRef),
21}
22
23impl FuncDef {
24    #[must_use]
25    pub fn symbol_id(&self) -> TopLevelSymbolId {
26        match self {
27            Self::Internal(internal) => internal.symbol_id,
28            Self::Intrinsic(_) => TopLevelSymbolId::new_illegal(),
29            Self::External(_) => TopLevelSymbolId::new_illegal(),
30        }
31    }
32}
33
34impl FuncDef {
35    #[must_use]
36    pub fn signature(&self) -> &Signature {
37        match self {
38            Self::Internal(internal) => &internal.signature,
39            Self::Intrinsic(intrinsic_fn) => &intrinsic_fn.signature,
40            Self::External(host_fn) => &host_fn.signature,
41        }
42    }
43}
44
45#[derive(Clone, Eq, PartialEq, Debug)]
46pub struct TypeParameterName {
47    pub resolved_node: Node,
48    pub assigned_name: String,
49}
50
51#[derive(Debug)]
52pub struct TypeParameter {
53    pub ty: TypeRef,
54    pub debug_name: String,
55}
56
57#[derive(Clone, Debug)]
58pub struct AliasType {
59    pub symbol_id: TopLevelSymbolId,
60    pub name: Node,
61    pub assigned_name: String,
62    pub ty: TypeRef,
63}
64
65#[derive(Clone, Debug)]
66pub enum ModuleDefinitionKind {
67    Type(TopLevelSymbolId, TypeRef),
68    Module(ModuleRef),
69    Constant(ConstantRef),
70    FunctionDefinition(FuncDef),
71    Alias(AliasType),
72}
73
74impl ModuleDefinitionKind {
75    #[must_use]
76    pub const fn is_basic_type(&self) -> bool {
77        matches!(
78            self,
79            Self::Type(..) | Self::Alias(..) | Self::FunctionDefinition(..)
80        )
81    }
82
83    #[must_use]
84    pub const fn is_alias_type(&self) -> bool {
85        matches!(self, Self::Alias(..))
86    }
87
88    pub(crate) const fn is_function(&self) -> bool {
89        matches!(self, Self::FunctionDefinition(..))
90    }
91}
92
93#[derive(Debug, Clone)]
94pub struct ModuleDefinition {
95    pub kind: ModuleDefinitionKind,
96    pub range: Node,
97    pub name: Node,
98}
99
100impl ModuleDefinition {
101    #[must_use]
102    pub const fn is_basic_type(&self) -> bool {
103        self.kind.is_basic_type()
104    }
105
106    #[must_use]
107    pub const fn is_alias_type(&self) -> bool {
108        self.kind.is_alias_type()
109    }
110
111    pub(crate) const fn is_function(&self) -> bool {
112        self.kind.is_function()
113    }
114}
115
116#[derive(Debug, Clone)]
117pub struct DefinitionTable {
118    definitions: SeqMap<String, ModuleDefinition>,
119    pub refs: ModuleSymbolReferences,
120    module_path: Vec<String>,
121}
122
123impl DefinitionTable {
124    #[must_use]
125    pub fn internal_functions(&self) -> Vec<InternalFunctionDefinitionRef> {
126        let mut v = Vec::new();
127
128        for (_name, sym) in &self.definitions {
129            if let ModuleDefinitionKind::FunctionDefinition(func_def) = &sym.kind
130                && let FuncDef::Internal(internal) = func_def
131            {
132                v.push(internal.clone());
133            }
134        }
135
136        v
137    }
138}
139
140impl DefinitionTable {
141    #[must_use]
142    pub fn module_path(&self) -> Vec<String> {
143        self.module_path.clone()
144    }
145}
146
147pub type SymbolTableRef = Rc<DefinitionTable>;
148
149impl DefinitionTable {
150    #[must_use]
151    pub fn new(module_path: &[String]) -> Self {
152        Self {
153            refs: ModuleSymbolReferences::new(),
154            definitions: SeqMap::default(),
155            module_path: module_path.to_vec(),
156        }
157    }
158
159    #[must_use]
160    pub fn is_empty(&self) -> bool {
161        self.definitions.is_empty()
162    }
163
164    #[must_use]
165    pub const fn definitions(&self) -> &SeqMap<String, ModuleDefinition> {
166        &self.definitions
167    }
168
169    #[must_use]
170    pub fn structs(&self) -> SeqMap<String, NamedStructType> {
171        let mut structs = SeqMap::new();
172
173        for (name, symbol) in &self.definitions {
174            if let ModuleDefinitionKind::Type(_, ty) = &symbol.kind
175                && let TypeKind::NamedStruct(struct_ref) = &*ty.kind
176            {
177                structs
178                    .insert(name.to_string(), struct_ref.clone())
179                    .unwrap();
180            }
181        }
182
183        structs
184    }
185
186    #[must_use]
187    pub fn enums(&self) -> SeqMap<String, EnumType> {
188        let mut enums = SeqMap::new();
189
190        for (name, symbol) in &self.definitions {
191            if let ModuleDefinitionKind::Type(_, ty) = &symbol.kind
192                && let TypeKind::Enum(enum_type) = &*ty.kind
193            {
194                enums.insert(name.to_string(), enum_type.clone()).unwrap();
195            }
196        }
197
198        enums
199    }
200
201    /// # Errors
202    ///
203    pub fn extend_from(&mut self, symbol_table: &Self) -> Result<(), SemanticError> {
204        for (name, symbol) in symbol_table.definitions() {
205            self.add_symbol(name, symbol.clone())?;
206        }
207        Ok(())
208    }
209
210    /// # Errors
211    ///
212    pub fn extend_basic_from(&mut self, symbol_table: &Self) -> Result<(), SemanticError> {
213        for (name, symbol) in symbol_table.definitions() {
214            if symbol.is_basic_type() {
215                self.add_symbol(name, symbol.clone())?;
216            }
217        }
218        Ok(())
219    }
220
221    /// # Errors
222    ///
223    pub fn extend_alias_from(&mut self, symbol_table: &Self) -> Result<(), SemanticError> {
224        for (name, symbol) in symbol_table.definitions() {
225            if symbol.is_alias_type() || symbol.is_function() {
226                self.add_symbol(name, symbol.clone())?;
227            }
228        }
229        Ok(())
230    }
231
232    pub fn extend_intrinsic_functions_from(
233        &mut self,
234        symbol_table: &Self,
235    ) -> Result<(), SemanticError> {
236        for (name, symbol) in symbol_table.definitions() {
237            if let ModuleDefinitionKind::FunctionDefinition(func_def) = &symbol.kind
238                && let FuncDef::Intrinsic(_intrinsic_def) = func_def
239            {
240                self.add_symbol(name, symbol.clone())?;
241            }
242        }
243        Ok(())
244    }
245
246    /// # Errors
247    ///
248    pub fn add_constant(&mut self, constant: Constant) -> Result<ConstantRef, SemanticError> {
249        let constant_ref = Rc::new(constant);
250
251        self.add_constant_link(constant_ref.clone())?;
252
253        Ok(constant_ref)
254    }
255
256    /// # Errors
257    ///
258    pub fn add_constant_link(&mut self, constant_ref: ConstantRef) -> Result<(), SemanticError> {
259        self.insert(
260            &constant_ref.assigned_name,
261            &constant_ref.name,
262            &constant_ref.name,
263            ModuleDefinitionKind::Constant(constant_ref.clone()),
264        )
265    }
266
267    pub fn insert(
268        &mut self,
269        name: &str,
270        name_node: &Node,
271        range: &Node,
272        kind: ModuleDefinitionKind,
273    ) -> Result<(), SemanticError> {
274        let mod_def = ModuleDefinition {
275            kind,
276            range: range.clone(),
277            name: name_node.clone(),
278        };
279
280        self.definitions
281            .insert(name.to_string(), mod_def)
282            .map_err(|_| SemanticError::DuplicateDefinition(name.to_string()))
283    }
284
285    /// # Errors
286    ///
287    pub fn add_alias(&mut self, alias_type: AliasType) -> Result<AliasType, SemanticError> {
288        self.add_alias_link(alias_type.clone())?;
289        Ok(alias_type)
290    }
291
292    /// # Errors
293    ///
294    pub fn add_alias_link(&mut self, alias_type_ref: AliasType) -> Result<(), SemanticError> {
295        self.insert(
296            &alias_type_ref.assigned_name,
297            &alias_type_ref.name,
298            &alias_type_ref.name,
299            ModuleDefinitionKind::Alias(alias_type_ref.clone()),
300        )
301    }
302
303    pub fn add_internal_function(
304        &mut self,
305        name: &str,
306        function: InternalFunctionDefinition,
307    ) -> Result<InternalFunctionDefinitionRef, SemanticError> {
308        let function_ref = Rc::new(function);
309
310        self.insert(
311            &function_ref.assigned_name,
312            &function_ref.name.0,
313            &function_ref.name.0,
314            ModuleDefinitionKind::FunctionDefinition(FuncDef::Internal(function_ref.clone())),
315        )?;
316
317        Ok(function_ref)
318    }
319
320    pub fn add_internal_function_link(
321        &mut self,
322        name: &str,
323        function_ref: InternalFunctionDefinitionRef,
324    ) -> Result<(), SemanticError> {
325        self.insert(
326            &function_ref.assigned_name,
327            &function_ref.name.0,
328            &function_ref.name.0,
329            ModuleDefinitionKind::FunctionDefinition(FuncDef::Internal(function_ref.clone())),
330        )
331    }
332
333    #[must_use]
334    pub fn get_symbol(&self, name: &str) -> Option<&ModuleDefinition> {
335        self.definitions.get(&name.to_string())
336    }
337
338    pub fn add_symbol(
339        &mut self,
340        name: &str,
341        symbol: ModuleDefinition,
342    ) -> Result<(), SemanticError> {
343        self.definitions
344            .insert(name.to_string(), symbol)
345            .map_err(|_| SemanticError::DuplicateSymbolName(name.to_string()))
346    }
347
348    #[must_use]
349    pub fn get_type(&self, name: &str) -> Option<&TypeRef> {
350        if let ModuleDefinitionKind::Type(_, type_ref) = &self.get_symbol(name)?.kind {
351            Some(type_ref)
352        } else {
353            None
354        }
355    }
356
357    #[must_use]
358    pub fn get_struct(&self, name: &str) -> Option<&TypeRef> {
359        self.get_type(name)
360    }
361
362    #[must_use]
363    pub fn get_enum(&self, name: &str) -> Option<&TypeRef> {
364        self.get_type(name)
365    }
366
367    #[must_use]
368    pub fn get_enum_variant_type(
369        &self,
370        enum_type_name: &str,
371        variant_name: &str,
372    ) -> Option<EnumVariantType> {
373        self.get_enum(enum_type_name).as_ref().map_or_else(
374            || None,
375            |found_type| {
376                if let TypeKind::Enum(found_enum) = &*found_type.kind {
377                    found_enum.variants.get(&variant_name.to_string()).cloned()
378                } else {
379                    panic!("internal error: expected enum type")
380                }
381            },
382        )
383    }
384
385    #[must_use]
386    pub fn get_constant(&self, name: &str) -> Option<&ConstantRef> {
387        match &self.get_symbol(name)?.kind {
388            ModuleDefinitionKind::Constant(constant) => Some(constant),
389            _ => None,
390        }
391    }
392
393    // Functions
394
395    #[must_use]
396    pub fn get_function(&self, name: &str) -> Option<&FuncDef> {
397        match &self.get_symbol(name)?.kind {
398            ModuleDefinitionKind::FunctionDefinition(func_def) => Some(func_def),
399            _ => None,
400        }
401    }
402
403    #[must_use]
404    pub fn get_internal_function(&self, name: &str) -> Option<&InternalFunctionDefinitionRef> {
405        match self.get_function(name)? {
406            FuncDef::Internal(internal_fn) => Some(internal_fn),
407            FuncDef::External(_) => None,
408            FuncDef::Intrinsic(_) => None,
409        }
410    }
411
412    #[must_use]
413    pub fn get_intrinsic_function(&self, name: &str) -> Option<&IntrinsicFunctionDefinitionRef> {
414        match self.get_function(name)? {
415            FuncDef::Intrinsic(intrinsic_fn) => Some(intrinsic_fn),
416            _ => None,
417        }
418    }
419
420    #[must_use]
421    pub fn get_external_function_declaration(
422        &self,
423        name: &str,
424    ) -> Option<&ExternalFunctionDefinitionRef> {
425        match self.get_function(name)? {
426            FuncDef::External(external_def) => Some(external_def),
427            _ => None,
428        }
429    }
430
431    fn insert_definition(
432        &mut self,
433        name: &str,
434        symbol: ModuleDefinition,
435    ) -> Result<(), SemanticError> {
436        self.definitions
437            .insert(name.to_string(), symbol)
438            .map_err(|_| SemanticError::DuplicateSymbolName(name.to_string()))
439    }
440
441    pub fn add_named_type(&mut self, ty: TypeRef) -> Result<(), SemanticError> {
442        let name = match &*ty.kind {
443            TypeKind::NamedStruct(named) => named.assigned_name.clone(),
444            TypeKind::Enum(enum_type) => enum_type.assigned_name.clone(),
445            _ => panic!("not a named type"),
446        };
447
448        let symbol_id = match &*ty.kind {
449            TypeKind::NamedStruct(named) => named.symbol_id,
450            TypeKind::Enum(enum_type) => enum_type.symbol_id,
451            _ => panic!("not a named type"),
452        };
453
454        let name_node = match &*ty.kind {
455            TypeKind::NamedStruct(named) => &named.name,
456            TypeKind::Enum(enum_type) => &enum_type.name,
457            _ => panic!("not a named type"),
458        };
459
460        self.insert(
461            &name,
462            name_node,
463            name_node,
464            ModuleDefinitionKind::Type(symbol_id, ty.clone()),
465        )
466    }
467
468    pub fn add_external_function_declaration(
469        &mut self,
470        decl: ExternalFunctionDefinition,
471    ) -> Result<ExternalFunctionDefinitionRef, SemanticError> {
472        let decl_ref = Rc::new(decl);
473
474        self.add_external_function_declaration_link(decl_ref.clone())?;
475
476        Ok(decl_ref)
477    }
478
479    pub fn add_external_function_declaration_link(
480        &mut self,
481        decl_ref: ExternalFunctionDefinitionRef,
482    ) -> Result<(), SemanticError> {
483        self.insert(
484            &decl_ref.assigned_name,
485            &decl_ref.name,
486            &decl_ref.name,
487            ModuleDefinitionKind::FunctionDefinition(FuncDef::External(decl_ref.clone())),
488        )
489        .map_err(|_| {
490            SemanticError::DuplicateExternalFunction(decl_ref.assigned_name.to_string())
491        })?;
492        Ok(())
493    }
494
495    pub fn add_module_link(
496        &mut self,
497        name: &str,
498        name_node: &Node,
499        ns: ModuleRef,
500    ) -> Result<(), SemanticError> {
501        self.insert(name, name_node, name_node, ModuleDefinitionKind::Module(ns))
502    }
503
504    #[must_use]
505    pub fn get_module_link(&self, name: &str) -> Option<&ModuleRef> {
506        match &self.get_symbol(name)?.kind {
507            ModuleDefinitionKind::Module(module_ref) => Some(module_ref),
508            _ => None,
509        }
510    }
511
512    pub fn add_intrinsic_function(
513        &mut self,
514        function: IntrinsicFunctionDefinition,
515    ) -> Result<IntrinsicFunctionDefinitionRef, SemanticError> {
516        let function_ref = Rc::new(function);
517        let fake_node = Node::new_unknown();
518        self.insert(
519            &function_ref.name,
520            &fake_node,
521            &fake_node,
522            ModuleDefinitionKind::FunctionDefinition(FuncDef::Intrinsic(function_ref.clone())),
523        )
524        .expect("todo: add seqmap error handling");
525
526        Ok(function_ref)
527    }
528}
swamp_modules/symtbl.rs

swamp_modules/
symtbl.rs
