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
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

use thiserror::Error;

use miette::Diagnostic;

pub use wit_parser::{
    Function, Interface, InterfaceId, PackageName, Resolve, Type, TypeDef, TypeDefKind, TypeId,
    TypeOwner,
};

#[derive(Error, Debug, Diagnostic)]
pub enum WitError {
    #[error("Package {package} does not exist")]
    NoSuchPackage { package: PackageName },
    #[error("Interface {interface} does not exist in package {package}")]
    NoSuchInterface {
        package: PackageName,
        interface: String,
    },
    #[error("Item {item} does not exists in interface {interface}")]
    NoSuchItem { interface: String, item: String },
}

#[derive(Debug)]
pub struct ResolvedWit {
    pub resolve: Resolve,
}

pub enum WitItem {
    Func(Function),
    Type(),
}

impl ResolvedWit {
    pub fn new(resolve: Resolve) -> Self {
        Self { resolve }
    }

    pub fn lookup_interface(
        &self,
        package_name: &PackageName,
        interface: &String,
    ) -> Result<InterfaceId, WitError> {
        let package_id = self.resolve.package_names.get(package_name);
        let package_id = match package_id {
            Some(id) => *id,
            None => {
                return Err(WitError::NoSuchPackage {
                    package: package_name.clone(),
                })
            }
        };

        let package = self.resolve.packages.get(package_id).unwrap();

        let interface_id = package.interfaces.get(interface);
        let interface_id = match interface_id {
            Some(id) => *id,
            None => {
                return Err(WitError::NoSuchInterface {
                    package: package_name.clone(),
                    interface: interface.clone(),
                })
            }
        };

        Ok(interface_id)
    }

    pub fn get_interface(&self, interface_id: InterfaceId) -> &Interface {
        self.resolve.interfaces.get(interface_id).unwrap()
    }

    pub fn lookup_func(&self, interface_id: InterfaceId, name: &str) -> Option<&Function> {
        let interface = self.get_interface(interface_id);
        interface.functions.get(name)
    }

    pub fn lookup_type(&self, interface_id: InterfaceId, name: &str) -> Option<&TypeDef> {
        let interface = self.get_interface(interface_id);
        let type_id = interface.types.get(name)?;
        Some(self.resolve.types.get(*type_id).unwrap())
    }
}