xenon_codegen/
module.rs

1use core::fmt;
2
3use enum_as_inner::EnumAsInner;
4
5use crate::{
6    Visibility, attribute::Attribute, r#enum::Enum, function::Function, r#impl::Impl,
7    r#struct::Struct, r#trait::Trait, variable_definition::VariableDefinition,
8};
9
10/// A module item
11#[derive(Debug, Clone, Default, EnumAsInner)]
12pub enum ModuleItem {
13    Module(Module),
14    Struct(Struct),
15    Function(Function),
16    VariableDefinition(VariableDefinition),
17    Trait(Trait),
18    Enum(Enum),
19    Impl(Impl),
20    #[default]
21    Null,
22}
23impl ModuleItem {
24    pub fn is_valid(&self) -> bool {
25        if self.is_module() {
26            self.as_module().unwrap().is_valid()
27        } else if self.is_struct() {
28            return self.as_struct().unwrap().is_valid();
29        } else if self.is_function() {
30            return self.as_function().unwrap().is_valid();
31        } else if self.is_variable_definition() {
32            return self.as_variable_definition().unwrap().is_valid();
33        } else if self.is_trait() {
34            return self.as_trait().unwrap().is_valid();
35        } else if self.is_enum() {
36            return self.as_enum().unwrap().is_valid();
37        } else if self.is_impl() {
38            return self.as_impl().unwrap().is_valid();
39        } else {
40            return false;
41        }
42    }
43}
44impl fmt::Display for ModuleItem {
45    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
46        if self.is_module() {
47            match write!(fmt, "{}", self.as_module().unwrap()) {
48                Ok(_) => (),
49                Err(e) => return Err(e),
50            }
51        } else if self.is_struct() {
52            match write!(fmt, "{}", self.as_struct().unwrap()) {
53                Ok(_) => (),
54                Err(e) => return Err(e),
55            }
56        } else if self.is_function() {
57            match write!(fmt, "{}", self.as_function().unwrap()) {
58                Ok(_) => (),
59                Err(e) => return Err(e),
60            }
61        } else if self.is_variable_definition() {
62            match write!(
63                fmt,
64                "{} {};",
65                self.as_variable_definition().unwrap().visibility,
66                self.as_variable_definition().unwrap()
67            ) {
68                Ok(_) => (),
69                Err(e) => return Err(e),
70            }
71        } else if self.is_trait() {
72            match write!(fmt, "{}", self.as_trait().unwrap()) {
73                Ok(_) => (),
74                Err(e) => return Err(e),
75            }
76        } else if self.is_enum() {
77            match write!(fmt, "{}", self.as_enum().unwrap()) {
78                Ok(_) => (),
79                Err(e) => return Err(e),
80            }
81        } else if self.is_impl() {
82            match write!(fmt, "{}", self.as_impl().unwrap()) {
83                Ok(_) => (),
84                Err(e) => return Err(e),
85            }
86        }
87        Ok(())
88    }
89}
90
91/// Defines a module
92#[derive(Debug, Clone)]
93pub struct Module {
94    pub attrs: Vec<Attribute>,
95    /// Module Visibility
96    pub visibility: Visibility,
97    /// Module Name
98    pub name: String,
99    pub items: Vec<ModuleItem>,
100}
101impl Module {
102    pub fn new(name: String) -> Module {
103        Module {
104            attrs: vec![],
105            visibility: Visibility::Private,
106            name,
107            items: vec![],
108        }
109    }
110
111    pub fn is_valid(&self) -> bool {
112        for i in 0..self.attrs.len() {
113            if !self.attrs[i].is_valid() {
114                return false;
115            }
116        }
117        if self.name.is_empty() {
118            return false;
119        }
120        for i in 0..self.items.len() {
121            if !self.items[i].is_valid() {
122                return false;
123            }
124        }
125        true
126    }
127}
128impl fmt::Display for Module {
129    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
130        for i in 0..self.attrs.len() {
131            match write!(fmt, "{}", self.attrs[i]) {
132                Ok(_) => (),
133                Err(e) => return Err(e),
134            }
135        }
136        match write!(fmt, "{} module {} {{", self.visibility, self.name) {
137            Ok(_) => (),
138            Err(e) => return Err(e),
139        }
140        for i in 0..self.items.len() {
141            match write!(fmt, "{}", self.items[i]) {
142                Ok(_) => (),
143                Err(e) => return Err(e),
144            }
145        }
146        match write!(fmt, "}}") {
147            Ok(_) => (),
148            Err(e) => return Err(e),
149        }
150        Ok(())
151    }
152}
xenon_codegen/module.rs

xenon_codegen/
module.rs
