claw-resolver 0.2.6

The Claw language name and type resolver
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

use ast::TypeId;
use claw_ast as ast;

use crate::imports::ImportTypeId;

#[derive(Clone, Copy, Debug)]
pub enum ResolvedType {
    Primitive(ast::PrimitiveType),
    Import(ImportTypeId),
    Defined(TypeId),
}

impl From<TypeId> for ResolvedType {
    fn from(value: TypeId) -> Self {
        ResolvedType::Defined(value)
    }
}

pub const RESOLVED_BOOL: ResolvedType = ResolvedType::Primitive(ast::PrimitiveType::Bool);

impl std::fmt::Display for ResolvedType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ResolvedType::Primitive(p) => (p as &dyn std::fmt::Debug).fmt(f),
            ResolvedType::Import(_) => write!(f, "imported type"),
            ResolvedType::Defined(v) => (v as &dyn std::fmt::Debug).fmt(f),
        }
    }
}

impl ResolvedType {
    pub fn type_eq(&self, other: &ResolvedType, comp: &ast::Component) -> bool {
        match (*self, *other) {
            // Both primitive
            (ResolvedType::Primitive(left), ResolvedType::Primitive(right)) => left == right,
            // Both valtype
            (ResolvedType::Defined(left), ResolvedType::Defined(right)) => {
                let l_valtype = comp.get_type(left);
                let r_valtype = comp.get_type(right);
                l_valtype.eq(r_valtype, comp)
            }
            // One primitive, other valtype
            (ResolvedType::Primitive(p), ResolvedType::Defined(v))
            | (ResolvedType::Defined(v), ResolvedType::Primitive(p)) => {
                let valtype = comp.get_type(v);
                match valtype {
                    ast::ValType::Primitive(p2) => p == *p2,
                    _ => false,
                }
            }
            _ => todo!(),
        }
    }
}