Skip to main content

mago_syntax/ast/ast/
static.rs

1use serde::Serialize;
2use strum::Display;
3
4use mago_span::HasSpan;
5use mago_span::Span;
6
7use crate::ast::ast::expression::Expression;
8use crate::ast::ast::keyword::Keyword;
9use crate::ast::ast::terminator::Terminator;
10use crate::ast::ast::variable::DirectVariable;
11use crate::ast::sequence::TokenSeparatedSequence;
12
13#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, PartialOrd, Ord)]
14pub struct Static<'arena> {
15    pub r#static: Keyword<'arena>,
16    pub items: TokenSeparatedSequence<'arena, StaticItem<'arena>>,
17    pub terminator: Terminator<'arena>,
18}
19
20#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, PartialOrd, Ord, Display)]
21#[serde(tag = "type", content = "value")]
22#[repr(u8)]
23pub enum StaticItem<'arena> {
24    Abstract(StaticAbstractItem<'arena>),
25    Concrete(StaticConcreteItem<'arena>),
26}
27
28#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, PartialOrd, Ord)]
29pub struct StaticAbstractItem<'arena> {
30    pub variable: DirectVariable<'arena>,
31}
32
33#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, PartialOrd, Ord)]
34pub struct StaticConcreteItem<'arena> {
35    pub variable: DirectVariable<'arena>,
36    pub equals: Span,
37    pub value: Expression<'arena>,
38}
39
40impl<'arena> StaticItem<'arena> {
41    #[must_use]
42    pub fn variable(&self) -> &DirectVariable<'arena> {
43        match self {
44            StaticItem::Abstract(item) => &item.variable,
45            StaticItem::Concrete(item) => &item.variable,
46        }
47    }
48
49    #[must_use]
50    pub fn value(&self) -> Option<&Expression<'arena>> {
51        match self {
52            StaticItem::Abstract(_) => None,
53            StaticItem::Concrete(item) => Some(&item.value),
54        }
55    }
56}
57
58impl HasSpan for Static<'_> {
59    fn span(&self) -> Span {
60        self.r#static.span().join(self.terminator.span())
61    }
62}
63
64impl HasSpan for StaticItem<'_> {
65    fn span(&self) -> Span {
66        match self {
67            StaticItem::Abstract(item) => item.span(),
68            StaticItem::Concrete(item) => item.span(),
69        }
70    }
71}
72
73impl HasSpan for StaticAbstractItem<'_> {
74    fn span(&self) -> Span {
75        self.variable.span()
76    }
77}
78
79impl HasSpan for StaticConcreteItem<'_> {
80    fn span(&self) -> Span {
81        self.variable.span().join(self.value.span())
82    }
83}