teo_parser/ast/
type_expr.rs

1use std::cell::RefCell;
2use std::collections::BTreeMap;
3use std::fmt::{Display, Formatter};
4use crate::ast::arity::Arity;
5use crate::ast::identifier_path::IdentifierPath;
6use crate::ast::literals::EnumVariantLiteral;
7use crate::ast::span::Span;
8use crate::{declare_container_node, impl_container_node_defaults, impl_node_defaults, node_child_fn, node_children_iter, node_children_iter_fn, node_optional_child_fn};
9use crate::ast::identifier::Identifier;
10use crate::ast::node::Node;
11use crate::format::Writer;
12use crate::r#type::r#type::Type;
13use crate::traits::identifiable::Identifiable;
14use crate::traits::node_trait::NodeTrait;
15use crate::traits::resolved::Resolve;
16use crate::traits::write::Write;
17
18#[derive(Debug, Clone, Copy)]
19pub enum TypeOperator {
20    BitOr,
21}
22
23impl Display for TypeOperator {
24
25    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
26        match self {
27            TypeOperator::BitOr => f.write_str("|"),
28        }
29    }
30}
31
32declare_container_node!(TypeBinaryOperation,
33    pub(crate) lhs: usize,
34    pub op: TypeOperator,
35    pub(crate) rhs: usize,
36);
37
38impl_container_node_defaults!(TypeBinaryOperation);
39
40impl TypeBinaryOperation {
41
42    node_child_fn!(lhs, TypeExpr);
43
44    node_child_fn!(rhs, TypeExpr);
45}
46
47impl Write for TypeBinaryOperation {
48    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
49        writer.write_children(self, self.children.values());
50    }
51}
52
53declare_container_node!(TypeGroup,
54    pub(crate) type_expr: usize,
55    pub arity: Arity,
56    pub item_optional: bool,
57    pub collection_optional: bool,
58);
59
60impl_container_node_defaults!(TypeGroup);
61
62impl TypeGroup {
63
64    node_child_fn!(type_expr, TypeExpr);
65}
66
67impl Write for TypeGroup {
68    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
69        writer.write_children(self, self.children.values());
70    }
71}
72
73declare_container_node!(TypeTuple,
74    pub(crate) items: Vec<usize>,
75    pub arity: Arity,
76    pub item_optional: bool,
77    pub collection_optional: bool,
78);
79
80impl_container_node_defaults!(TypeTuple);
81
82node_children_iter!(TypeTuple, TypeExpr, ItemsIter, items);
83
84impl TypeTuple {
85
86    node_children_iter_fn!(items, ItemsIter);
87}
88
89impl Write for TypeTuple {
90    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
91        writer.write_children(self, self.children.values());
92    }
93}
94
95declare_container_node!(TypeSubscript,
96    pub(crate) container: usize,
97    pub(crate) argument: usize,
98    pub arity: Arity,
99    pub item_optional: bool,
100    pub collection_optional: bool,
101);
102
103impl_container_node_defaults!(TypeSubscript);
104
105impl TypeSubscript {
106
107    node_child_fn!(container, TypeExpr);
108
109    node_child_fn!(argument, TypeExpr);
110}
111
112impl Write for TypeSubscript {
113    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
114        writer.write_children(self, self.children.values());
115    }
116}
117
118declare_container_node!(TypeItem,
119    pub(crate) identifier_path: usize,
120    pub(crate) generics: Option<usize>,
121    pub arity: Arity,
122    pub item_optional: bool,
123    pub collection_optional: bool,
124);
125
126impl_container_node_defaults!(TypeItem);
127
128impl TypeItem {
129
130    node_child_fn!(identifier_path, IdentifierPath);
131
132    node_optional_child_fn!(generics, TypeGenerics);
133
134    pub fn generic_items(&self) -> Vec<&TypeExpr> {
135        if let Some(generics) = self.generics() {
136            generics.type_exprs().collect()
137        } else {
138            vec![]
139        }
140    }
141}
142
143impl Write for TypeItem {
144    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
145        writer.write_children(self, self.children.values());
146    }
147}
148
149declare_container_node!(TypeGenerics,
150    pub(crate) type_exprs: Vec<usize>,
151);
152
153impl_node_defaults!(TypeGenerics);
154
155node_children_iter!(TypeGenerics, TypeExpr, GenericsIter, type_exprs);
156
157impl TypeGenerics {
158    node_children_iter_fn!(type_exprs, GenericsIter);
159}
160
161impl Write for TypeGenerics {
162    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
163        writer.write_children(self, self.children.values());
164    }
165}
166
167declare_container_node!(TypedEnum,
168    pub(crate) members: Vec<usize>,
169);
170
171impl_container_node_defaults!(TypedEnum);
172
173node_children_iter!(TypedEnum, EnumVariantLiteral, TypedEnumMembersIter, members);
174
175impl TypedEnum {
176
177    node_children_iter_fn!(members, TypedEnumMembersIter);
178}
179
180impl Write for TypedEnum {
181    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
182        writer.write_children(self, self.children.values());
183    }
184}
185
186declare_container_node!(TypedShapeItem,
187    pub(crate) identifier: usize,
188    pub(crate) type_expr: usize,
189);
190
191impl_container_node_defaults!(TypedShapeItem);
192
193impl TypedShapeItem {
194    node_child_fn!(identifier, Identifier);
195    node_child_fn!(type_expr, TypeExpr);
196}
197
198impl Write for TypedShapeItem {
199    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
200        writer.write_children(self, self.children.values());
201    }
202}
203
204declare_container_node!(TypedShape,
205    pub(crate) items: Vec<usize>,
206    pub arity: Arity,
207    pub item_optional: bool,
208    pub collection_optional: bool,
209);
210
211impl_container_node_defaults!(TypedShape);
212
213node_children_iter!(TypedShape, TypedShapeItem, TypedShapeItemsIter, items);
214
215impl TypedShape {
216
217    node_children_iter_fn!(items, TypedShapeItemsIter);
218}
219
220impl Write for TypedShape {
221    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
222        writer.write_children(self, self.children.values());
223    }
224}
225
226#[derive(Debug)]
227pub enum TypeExprKind {
228    Expr(Box<TypeExprKind>),
229    BinaryOp(TypeBinaryOperation),
230    TypeItem(TypeItem),
231    TypeGroup(TypeGroup),
232    TypeTuple(TypeTuple),
233    TypeSubscript(TypeSubscript),
234    FieldName(EnumVariantLiteral),
235    TypedEnum(TypedEnum),
236    TypedShape(TypedShape),
237}
238
239impl TypeExprKind {
240
241    pub fn as_dyn_node_trait(&self) -> &dyn NodeTrait {
242        match self {
243            TypeExprKind::Expr(n) => n.as_ref(),
244            TypeExprKind::BinaryOp(n) => n,
245            TypeExprKind::TypeItem(n) => n,
246            TypeExprKind::TypeGroup(n) => n,
247            TypeExprKind::TypeTuple(n) => n,
248            TypeExprKind::TypeSubscript(n) => n,
249            TypeExprKind::FieldName(n) => n,
250            TypeExprKind::TypedEnum(n) => n,
251            TypeExprKind::TypedShape(n) => n,
252        }
253    }
254
255    pub fn is_field_name(&self) -> bool {
256        self.as_field_name().is_some()
257    }
258
259    pub fn as_field_name(&self) -> Option<&EnumVariantLiteral> {
260        match self {
261            Self::FieldName(e) => Some(e),
262            _ => None,
263        }
264    }
265}
266
267impl Identifiable for TypeExprKind {
268
269    fn path(&self) -> &Vec<usize> {
270        self.as_dyn_node_trait().path()
271    }
272}
273
274impl NodeTrait for TypeExprKind {
275    fn span(&self) -> Span {
276        self.as_dyn_node_trait().span()
277    }
278
279    fn children(&self) -> Option<&BTreeMap<usize, Node>> {
280        self.as_dyn_node_trait().children()
281    }
282}
283
284#[derive(Debug)]
285pub struct TypeExpr {
286    pub kind: TypeExprKind,
287    pub resolved: RefCell<Option<Type>>,
288}
289
290impl TypeExpr {
291    pub fn new(kind: TypeExprKind) -> Self {
292        Self { kind, resolved: RefCell::new(None) }
293    }
294}
295
296impl Identifiable for TypeExpr {
297    fn path(&self) -> &Vec<usize> {
298        self.kind.as_dyn_node_trait().path()
299    }
300}
301
302impl NodeTrait for TypeExpr {
303    fn span(&self) -> Span {
304        self.kind.as_dyn_node_trait().span()
305    }
306
307    fn children(&self) -> Option<&BTreeMap<usize, Node>> {
308        self.kind.as_dyn_node_trait().children()
309    }
310}
311
312impl Resolve<Type> for TypeExpr {
313    fn resolved_ref_cell(&self) -> &RefCell<Option<Type>> {
314        &self.resolved
315    }
316}
317
318impl Write for TypeExprKind {
319    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
320        self.as_dyn_node_trait().write(writer);
321    }
322
323    fn write_output_with_default_writer(&self) -> String {
324        self.as_dyn_node_trait().write_output_with_default_writer()
325    }
326
327    fn prefer_whitespace_before(&self) -> bool {
328        self.as_dyn_node_trait().prefer_whitespace_before()
329    }
330
331    fn prefer_whitespace_after(&self) -> bool {
332        self.as_dyn_node_trait().prefer_whitespace_after()
333    }
334
335    fn prefer_always_no_whitespace_before(&self) -> bool {
336        self.as_dyn_node_trait().prefer_always_no_whitespace_before()
337    }
338
339    fn always_start_on_new_line(&self) -> bool {
340        self.as_dyn_node_trait().always_start_on_new_line()
341    }
342
343    fn always_end_on_new_line(&self) -> bool {
344        self.as_dyn_node_trait().always_end_on_new_line()
345    }
346
347    fn is_block_start(&self) -> bool {
348        self.as_dyn_node_trait().is_block_start()
349    }
350
351    fn is_block_end(&self) -> bool {
352        self.as_dyn_node_trait().is_block_end()
353    }
354
355    fn is_block_element_delimiter(&self) -> bool {
356        self.as_dyn_node_trait().is_block_element_delimiter()
357    }
358
359    fn is_block_level_element(&self) -> bool {
360        self.as_dyn_node_trait().is_block_level_element()
361    }
362
363    fn wrap(&self, content: &str, available_length: usize) -> String {
364        self.as_dyn_node_trait().wrap(content, available_length)
365    }
366}
367
368impl Write for TypeExpr {
369    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
370        self.kind.as_dyn_node_trait().write(writer);
371    }
372
373    fn write_output_with_default_writer(&self) -> String {
374        self.kind.as_dyn_node_trait().write_output_with_default_writer()
375    }
376
377    fn prefer_whitespace_before(&self) -> bool {
378        self.kind.as_dyn_node_trait().prefer_whitespace_before()
379    }
380
381    fn prefer_whitespace_after(&self) -> bool {
382        self.kind.as_dyn_node_trait().prefer_whitespace_after()
383    }
384
385    fn prefer_always_no_whitespace_before(&self) -> bool {
386        self.kind.as_dyn_node_trait().prefer_always_no_whitespace_before()
387    }
388
389    fn always_start_on_new_line(&self) -> bool {
390        self.kind.as_dyn_node_trait().always_start_on_new_line()
391    }
392
393    fn always_end_on_new_line(&self) -> bool {
394        self.kind.as_dyn_node_trait().always_end_on_new_line()
395    }
396
397    fn is_block_start(&self) -> bool {
398        self.kind.as_dyn_node_trait().is_block_start()
399    }
400
401    fn is_block_end(&self) -> bool {
402        self.kind.as_dyn_node_trait().is_block_end()
403    }
404
405    fn is_block_element_delimiter(&self) -> bool {
406        self.kind.as_dyn_node_trait().is_block_element_delimiter()
407    }
408
409    fn is_block_level_element(&self) -> bool {
410        self.kind.as_dyn_node_trait().is_block_level_element()
411    }
412
413    fn wrap(&self, content: &str, available_length: usize) -> String {
414        self.kind.as_dyn_node_trait().wrap(content, available_length)
415    }
416}
417
418impl Display for TypeExprKind {
419    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
420        Display::fmt(self.as_dyn_node_trait(), f)
421    }
422}
423
424impl Display for TypeExpr {
425    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
426        Display::fmt(&self.kind, f)
427    }
428}
429
430impl<'a> TryFrom<&'a Node> for &'a TypeExpr {
431    type Error = &'static str;
432
433    fn try_from(value: &'a Node) -> Result<Self, Self::Error> {
434        match value {
435            Node::TypeExpr(n) => Ok(n),
436            _ => Err("convert failed"),
437        }
438    }
439}
440
441impl From<TypeExpr> for Node {
442    fn from(value: TypeExpr) -> Self {
443        Self::TypeExpr(value)
444    }
445}
teo_parser/ast/type_expr.rs

teo_parser/ast/
type_expr.rs
