php_parser_rs/parser/ast/
enums.rs

1use schemars::JsonSchema;
2use serde::Deserialize;
3use serde::Serialize;
4
5use crate::lexer::token::Span;
6use crate::node::Node;
7use crate::parser::ast::attributes::AttributeGroup;
8use crate::parser::ast::constant::ClassishConstant;
9use crate::parser::ast::functions::ConcreteMethod;
10use crate::parser::ast::identifiers::SimpleIdentifier;
11use crate::parser::ast::Expression;
12
13use super::traits::TraitUsage;
14
15#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
16
17pub struct UnitEnumCase {
18    pub attributes: Vec<AttributeGroup>, // `#[Foo]`
19    pub start: Span,                     // `case`
20    pub name: SimpleIdentifier,          // `Bar`
21    pub end: Span,                       // `;`
22}
23
24impl Node for UnitEnumCase {
25    fn children(&mut self) -> Vec<&mut dyn Node> {
26        vec![&mut self.name]
27    }
28}
29
30#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
31#[serde(tag = "type", content = "value")]
32pub enum UnitEnumMember {
33    Case(UnitEnumCase),         // `case Bar;`
34    Method(ConcreteMethod),     // `public function foo(): void { ... }`
35    Constant(ClassishConstant), // `public const FOO = 123;`
36    TraitUsage(TraitUsage),
37}
38
39impl Node for UnitEnumMember {
40    fn children(&mut self) -> Vec<&mut dyn Node> {
41        match self {
42            UnitEnumMember::Case(case) => vec![case],
43            UnitEnumMember::Method(method) => vec![method],
44            UnitEnumMember::Constant(constant) => vec![constant],
45            UnitEnumMember::TraitUsage(trait_usage) => vec![trait_usage],
46        }
47    }
48}
49
50#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
51
52pub struct UnitEnumBody {
53    pub left_brace: Span,             // `{`
54    pub members: Vec<UnitEnumMember>, // `...`
55    pub right_brace: Span,            // `}`
56}
57
58impl Node for UnitEnumBody {
59    fn children(&mut self) -> Vec<&mut dyn Node> {
60        self.members
61            .iter_mut()
62            .map(|m| m as &mut dyn Node)
63            .collect()
64    }
65}
66
67#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
68
69pub struct UnitEnumStatement {
70    pub attributes: Vec<AttributeGroup>,   // `#[Foo]`
71    pub r#enum: Span,                      // `enum`
72    pub name: SimpleIdentifier,            // `Foo`
73    pub implements: Vec<SimpleIdentifier>, // `implements Bar`
74    pub body: UnitEnumBody,                // `{ ... }`
75}
76
77impl Node for UnitEnumStatement {
78    fn children(&mut self) -> Vec<&mut dyn Node> {
79        let mut children: Vec<&mut dyn Node> = vec![&mut self.name];
80        for implement in &mut self.implements {
81            children.push(implement);
82        }
83        children.push(&mut self.body);
84        children
85    }
86}
87
88#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
89#[serde(tag = "type", content = "value")]
90pub enum BackedEnumType {
91    String(Span, Span), // `:` + `string`
92    Int(Span, Span),    // `:` + `int`
93}
94
95impl Node for BackedEnumType {
96    //
97}
98
99#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
100
101pub struct BackedEnumCase {
102    pub attributes: Vec<AttributeGroup>, // `#[Foo]`
103    pub case: Span,                      // `case`
104    pub name: SimpleIdentifier,          // `Bar`
105    pub equals: Span,                    // `=`
106    pub value: Expression,               // `123`
107    pub semicolon: Span,                 // `;`
108}
109
110impl Node for BackedEnumCase {
111    fn children(&mut self) -> Vec<&mut dyn Node> {
112        vec![&mut self.name, &mut self.value]
113    }
114}
115
116#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
117#[serde(tag = "type", content = "value")]
118pub enum BackedEnumMember {
119    Case(BackedEnumCase),
120    Method(ConcreteMethod),
121    Constant(ClassishConstant),
122    TraitUsage(TraitUsage),
123}
124
125impl Node for BackedEnumMember {
126    fn children(&mut self) -> Vec<&mut dyn Node> {
127        match self {
128            BackedEnumMember::Case(case) => vec![case],
129            BackedEnumMember::Method(method) => vec![method],
130            BackedEnumMember::Constant(constant) => vec![constant],
131            BackedEnumMember::TraitUsage(trait_usage) => vec![trait_usage],
132        }
133    }
134}
135
136#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
137
138pub struct BackedEnumBody {
139    pub left_brace: Span,               // `{`
140    pub members: Vec<BackedEnumMember>, // `...`
141    pub right_brace: Span,              // `}`
142}
143
144impl Node for BackedEnumBody {
145    fn children(&mut self) -> Vec<&mut dyn Node> {
146        self.members
147            .iter_mut()
148            .map(|m| m as &mut dyn Node)
149            .collect()
150    }
151}
152
153#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
154
155pub struct BackedEnumStatement {
156    pub attributes: Vec<AttributeGroup>,   // `#[Foo]`
157    pub r#enum: Span,                      // `enum`
158    pub name: SimpleIdentifier,            // `Foo`
159    pub backed_type: BackedEnumType,       // `: string`
160    pub implements: Vec<SimpleIdentifier>, // `implements Bar`
161    pub body: BackedEnumBody,              // `{ ... }`
162}
163
164impl Node for BackedEnumStatement {
165    fn children(&mut self) -> Vec<&mut dyn Node> {
166        let mut children: Vec<&mut dyn Node> = vec![&mut self.name, &mut self.backed_type];
167        for implement in &mut self.implements {
168            children.push(implement);
169        }
170        children.push(&mut self.body);
171        children
172    }
173}
php_parser_rs/parser/ast/enums.rs

php_parser_rs/parser/ast/
enums.rs
