witx-codegen 0.11.4

WITX code generator for WebAssembly guest modules.
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

use crate::astype::*;

pub trait Normalize {
    fn as_str(&self) -> &str;

    fn as_link(&self) -> String {
        let s = self.as_str().trim().to_lowercase();
        let s = s.trim_matches(|c: char| !(c.is_alphanumeric() || c == '_' || c == '-'));
        format!("#{}", s)
    }

    fn as_type(&self) -> String {
        format!("_[`{}`]({})_", self.as_str(), self.as_link())
    }

    fn as_fn(&self) -> String {
        format!("[`{}()`]({})", self.as_str(), self.as_link())
    }

    fn as_fn_suffix(&self) -> String {
        self.as_str().to_string()
    }

    fn as_var(&self) -> String {
        format!("**`{}`**", self.as_str())
    }

    fn as_const(&self) -> String {
        format!("**`{}`**", self.as_str())
    }

    fn as_namespace(&self) -> String {
        format!("**[`{}`]({})**", self.as_str(), self.as_link())
    }
}

impl<T: AsRef<str>> Normalize for T {
    fn as_str(&self) -> &str {
        self.as_ref()
    }
}

pub trait ToLanguageRepresentation {
    fn as_astype(&self) -> &ASType;

    fn to_string(&self) -> String {
        self.as_lang()
    }

    fn as_lang(&self) -> String {
        match self.as_astype() {
            ASType::Alias(alias) => alias.name.as_type(),
            ASType::Bool => "`bool`".to_string(),
            ASType::Char32 => "`char32`".to_string(),
            ASType::Char8 => "`char8`".to_string(),
            ASType::F32 => "`f32`".to_string(),
            ASType::F64 => "`f64`".to_string(),
            ASType::Handle(_resource_name) => "`handle`".to_string(),
            ASType::ConstPtr(pointee) => format!("{} pointer", pointee.to_string()),
            ASType::MutPtr(pointee) => format!("{} mutable pointer", pointee.to_string()),
            ASType::Option(_) => todo!(),
            ASType::Result(_) => todo!(),
            ASType::S8 => "`i8`".to_string(),
            ASType::S16 => "`i16`".to_string(),
            ASType::S32 => "`i32`".to_string(),
            ASType::S64 => "`i64`".to_string(),
            ASType::U8 => "`u8`".to_string(),
            ASType::U16 => "`u16`".to_string(),
            ASType::U32 => "`u32`".to_string(),
            ASType::U64 => "`u64`".to_string(),
            ASType::USize => "`usize`".to_string(),
            ASType::Void => "_(empty)_".to_string(),
            ASType::Constants(_) => unimplemented!(),
            ASType::Enum(enum_) => {
                format!("{} enumeration", enum_.repr.as_ref().as_lang())
            }
            ASType::Struct(_) => unimplemented!(),
            ASType::Tuple(tuple_members) => {
                let tuple_types: Vec<_> =
                    tuple_members.iter().map(|x| x.type_.to_string()).collect();
                format!("({})", tuple_types.join(", "))
            }
            ASType::Union(_) => unimplemented!(),
            ASType::Slice(element_type) => format!("{} mutable slice", element_type.as_lang()),
            ASType::String(_) => "`string`".to_string(),
            ASType::ReadBuffer(element_type) => format!("{} slice", element_type.as_lang()),
            ASType::WriteBuffer(element_type) => {
                format!("{} mutable slice", element_type.to_string())
            }
        }
    }
}

impl ToLanguageRepresentation for ASType {
    fn as_astype(&self) -> &ASType {
        self
    }
}