aldrin_parser/ast/
type_name.rs

1use super::{ArrayLen, NamedRef};
2use crate::Span;
3use crate::error::{
4    ExpectedTypeFoundConst, ExpectedTypeFoundService, InvalidKeyType, TypeNotFound,
5};
6use crate::grammar::Rule;
7use crate::validate::Validate;
8use pest::iterators::Pair;
9use std::fmt;
10
11#[derive(Debug, Clone)]
12pub struct TypeName {
13    span: Span,
14    kind: TypeNameKind,
15}
16
17impl TypeName {
18    pub(crate) fn parse(pair: Pair<Rule>) -> Self {
19        assert_eq!(pair.as_rule(), Rule::type_name);
20
21        let span = Span::from_pair(&pair);
22
23        let mut pairs = pair.into_inner();
24        let pair = pairs.next().unwrap();
25        let kind = TypeNameKind::parse(pair);
26
27        Self { span, kind }
28    }
29
30    pub(crate) fn validate(&self, is_key_type: bool, validate: &mut Validate) {
31        self.kind.validate(is_key_type, validate);
32    }
33
34    pub fn span(&self) -> Span {
35        self.span
36    }
37
38    pub fn kind(&self) -> &TypeNameKind {
39        &self.kind
40    }
41}
42
43#[derive(Debug, Clone)]
44pub enum TypeNameKind {
45    Bool,
46    U8,
47    I8,
48    U16,
49    I16,
50    U32,
51    I32,
52    U64,
53    I64,
54    F32,
55    F64,
56    String,
57    Uuid,
58    ObjectId,
59    ServiceId,
60    Value,
61    Option(Box<TypeName>),
62    Box(Box<TypeName>),
63    Vec(Box<TypeName>),
64    Bytes,
65    Map(Box<TypeName>, Box<TypeName>),
66    Set(Box<TypeName>),
67    Sender(Box<TypeName>),
68    Receiver(Box<TypeName>),
69    Lifetime,
70    Unit,
71    Result(Box<TypeName>, Box<TypeName>),
72    Array(Box<TypeName>, ArrayLen),
73    Ref(NamedRef),
74}
75
76impl TypeNameKind {
77    fn parse(pair: Pair<Rule>) -> Self {
78        #[expect(clippy::wildcard_enum_match_arm)]
79        match pair.as_rule() {
80            Rule::kw_bool => Self::Bool,
81            Rule::kw_u8 => Self::U8,
82            Rule::kw_i8 => Self::I8,
83            Rule::kw_u16 => Self::U16,
84            Rule::kw_i16 => Self::I16,
85            Rule::kw_u32 => Self::U32,
86            Rule::kw_i32 => Self::I32,
87            Rule::kw_u64 => Self::U64,
88            Rule::kw_i64 => Self::I64,
89            Rule::kw_f32 => Self::F32,
90            Rule::kw_f64 => Self::F64,
91            Rule::kw_string => Self::String,
92            Rule::kw_uuid => Self::Uuid,
93            Rule::kw_object_id => Self::ObjectId,
94            Rule::kw_service_id => Self::ServiceId,
95            Rule::kw_value => Self::Value,
96            Rule::kw_lifetime => Self::Lifetime,
97            Rule::kw_unit => Self::Unit,
98
99            Rule::option_type => {
100                let mut pairs = pair.into_inner();
101                pairs.next().unwrap(); // Skip keyword.
102                pairs.next().unwrap(); // Skip <.
103                let pair = pairs.next().unwrap();
104
105                Self::Option(Box::new(TypeName::parse(pair)))
106            }
107
108            Rule::box_type => {
109                let mut pairs = pair.into_inner();
110                pairs.next().unwrap(); // Skip keyword.
111                pairs.next().unwrap(); // Skip <.
112                let pair = pairs.next().unwrap();
113
114                Self::Box(Box::new(TypeName::parse(pair)))
115            }
116
117            Rule::vec_type => {
118                let mut pairs = pair.into_inner();
119                pairs.next().unwrap(); // Skip keyword.
120                pairs.next().unwrap(); // Skip <.
121                let pair = pairs.next().unwrap();
122
123                Self::Vec(Box::new(TypeName::parse(pair)))
124            }
125
126            Rule::kw_bytes => Self::Bytes,
127
128            Rule::map_type => {
129                let mut pairs = pair.into_inner();
130                pairs.next().unwrap(); // Skip keyword.
131                pairs.next().unwrap(); // Skip <.
132                let key_pair = pairs.next().unwrap();
133                pairs.next().unwrap(); // Skip ->.
134                let type_pair = pairs.next().unwrap();
135
136                Self::Map(
137                    Box::new(TypeName::parse(key_pair)),
138                    Box::new(TypeName::parse(type_pair)),
139                )
140            }
141
142            Rule::set_type => {
143                let mut pairs = pair.into_inner();
144                pairs.next().unwrap(); // Skip keyword.
145                pairs.next().unwrap(); // Skip <.
146                let pair = pairs.next().unwrap();
147
148                Self::Set(Box::new(TypeName::parse(pair)))
149            }
150
151            Rule::sender_type => {
152                let mut pairs = pair.into_inner();
153                pairs.next().unwrap(); // Skip keyword.
154                pairs.next().unwrap(); // Skip <.
155                let pair = pairs.next().unwrap();
156
157                Self::Sender(Box::new(TypeName::parse(pair)))
158            }
159
160            Rule::receiver_type => {
161                let mut pairs = pair.into_inner();
162                pairs.next().unwrap(); // Skip keyword.
163                pairs.next().unwrap(); // Skip <.
164                let pair = pairs.next().unwrap();
165
166                Self::Receiver(Box::new(TypeName::parse(pair)))
167            }
168
169            Rule::result_type => {
170                let mut pairs = pair.into_inner();
171                pairs.next().unwrap(); // Skip keyword.
172                pairs.next().unwrap(); // Skip <.
173                let ok_pair = pairs.next().unwrap();
174                pairs.next().unwrap(); // Skip ,.
175                let err_pair = pairs.next().unwrap();
176
177                Self::Result(
178                    Box::new(TypeName::parse(ok_pair)),
179                    Box::new(TypeName::parse(err_pair)),
180                )
181            }
182
183            Rule::array_type => {
184                let mut pairs = pair.into_inner();
185                pairs.next().unwrap(); // Skip [.
186                let type_pair = pairs.next().unwrap();
187                pairs.next().unwrap(); // Skip ;.
188                let len_pair = pairs.next().unwrap();
189
190                Self::Array(
191                    Box::new(TypeName::parse(type_pair)),
192                    ArrayLen::parse(len_pair),
193                )
194            }
195
196            Rule::named_ref => Self::Ref(NamedRef::parse(pair)),
197
198            _ => unreachable!(),
199        }
200    }
201
202    fn validate(&self, is_key_type: bool, validate: &mut Validate) {
203        match self {
204            Self::Option(ty)
205            | Self::Box(ty)
206            | Self::Vec(ty)
207            | Self::Sender(ty)
208            | Self::Receiver(ty) => ty.validate(false, validate),
209
210            Self::Map(k, t) => {
211                InvalidKeyType::validate(k, validate);
212                k.validate(true, validate);
213                t.validate(false, validate);
214            }
215
216            Self::Set(ty) => {
217                InvalidKeyType::validate(ty, validate);
218                ty.validate(true, validate);
219            }
220
221            Self::Result(ok, err) => {
222                ok.validate(false, validate);
223                err.validate(false, validate);
224            }
225
226            Self::Array(ty, len) => {
227                ty.validate(false, validate);
228                len.validate(validate);
229            }
230
231            Self::Ref(ty) => {
232                TypeNotFound::validate(ty, is_key_type, validate);
233                ExpectedTypeFoundService::validate(ty, is_key_type, validate);
234                ExpectedTypeFoundConst::validate(ty, is_key_type, validate);
235                ty.validate(validate);
236            }
237
238            Self::Bool
239            | Self::U8
240            | Self::I8
241            | Self::U16
242            | Self::I16
243            | Self::U32
244            | Self::I32
245            | Self::U64
246            | Self::I64
247            | Self::F32
248            | Self::F64
249            | Self::String
250            | Self::Uuid
251            | Self::ObjectId
252            | Self::ServiceId
253            | Self::Value
254            | Self::Bytes
255            | Self::Lifetime
256            | Self::Unit => {}
257        }
258    }
259}
260
261impl fmt::Display for TypeNameKind {
262    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
263        match self {
264            Self::Bool => write!(f, "bool"),
265            Self::U8 => write!(f, "u8"),
266            Self::I8 => write!(f, "i8"),
267            Self::U16 => write!(f, "u16"),
268            Self::I16 => write!(f, "i16"),
269            Self::U32 => write!(f, "u32"),
270            Self::I32 => write!(f, "i32"),
271            Self::U64 => write!(f, "u64"),
272            Self::I64 => write!(f, "i64"),
273            Self::F32 => write!(f, "f32"),
274            Self::F64 => write!(f, "f64"),
275            Self::String => write!(f, "string"),
276            Self::Uuid => write!(f, "uuid"),
277            Self::ObjectId => write!(f, "object_id"),
278            Self::ServiceId => write!(f, "service_id"),
279            Self::Value => write!(f, "value"),
280            Self::Option(ty) => write!(f, "option<{}>", ty.kind()),
281            Self::Box(ty) => write!(f, "box<{}>", ty.kind()),
282            Self::Vec(ty) => write!(f, "vec<{}>", ty.kind()),
283            Self::Bytes => write!(f, "bytes"),
284            Self::Map(k, t) => write!(f, "map<{} -> {}>", k.kind(), t.kind()),
285            Self::Set(ty) => write!(f, "set<{}>", ty.kind()),
286            Self::Sender(ty) => write!(f, "sender<{}>", ty.kind()),
287            Self::Receiver(ty) => write!(f, "receiver<{}>", ty.kind()),
288            Self::Lifetime => write!(f, "lifetime"),
289            Self::Unit => write!(f, "unit"),
290            Self::Result(ok, err) => write!(f, "result<{}, {}>", ok.kind(), err.kind()),
291            Self::Array(ty, len) => write!(f, "[{}; {}]", ty.kind(), len.value()),
292            Self::Ref(ty) => ty.kind().fmt(f),
293        }
294    }
295}
aldrin_parser/ast/type_name.rs

aldrin_parser/ast/
type_name.rs
