php_parser_rs/parser/ast/
classes.rs

1use std::slice::Iter;
2
3use schemars::JsonSchema;
4use serde::Deserialize;
5use serde::Serialize;
6
7use crate::lexer::token::Span;
8use crate::node::Node;
9use crate::parser::ast::attributes::AttributeGroup;
10use crate::parser::ast::constant::ClassishConstant;
11use crate::parser::ast::functions::AbstractConstructor;
12use crate::parser::ast::functions::AbstractMethod;
13use crate::parser::ast::functions::ConcreteConstructor;
14use crate::parser::ast::functions::ConcreteMethod;
15use crate::parser::ast::identifiers::SimpleIdentifier;
16use crate::parser::ast::modifiers::ClassModifierGroup;
17use crate::parser::ast::properties::Property;
18use crate::parser::ast::properties::VariableProperty;
19use crate::parser::ast::traits::TraitUsage;
20use crate::parser::ast::utils::CommaSeparated;
21
22#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
23
24pub struct ClassBody {
25    pub left_brace: Span, // `{`
26    pub members: Vec<ClassMember>,
27    pub right_brace: Span, // `}`
28}
29
30impl ClassBody {
31    pub fn iter(&self) -> Iter<'_, ClassMember> {
32        self.members.iter()
33    }
34}
35
36impl IntoIterator for ClassBody {
37    type Item = ClassMember;
38    type IntoIter = std::vec::IntoIter<Self::Item>;
39
40    fn into_iter(self) -> Self::IntoIter {
41        self.members.into_iter()
42    }
43}
44
45impl Node for ClassBody {
46    fn children(&mut self) -> Vec<&mut dyn Node> {
47        self.members
48            .iter_mut()
49            .map(|member| member as &mut dyn Node)
50            .collect()
51    }
52}
53
54#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
55
56pub struct ClassStatement {
57    pub attributes: Vec<AttributeGroup>, // `#[Qux]`
58    #[serde(flatten)]
59    pub modifiers: ClassModifierGroup, // `abstract`, `final`
60    pub class: Span,                     // `class`
61    pub name: SimpleIdentifier,          // `Foo`
62    pub extends: Option<ClassExtends>,   // `extends Foo`
63    pub implements: Option<ClassImplements>, // `implements Bar, Baz`
64    pub body: ClassBody,                 // `{ ... }`
65}
66
67impl Node for ClassStatement {
68    fn children(&mut self) -> Vec<&mut dyn Node> {
69        let mut children: Vec<&mut dyn Node> = vec![&mut self.name];
70        if let Some(extends) = &mut self.extends {
71            children.push(extends);
72        }
73        if let Some(implements) = &mut self.implements {
74            children.push(implements);
75        }
76        children.push(&mut self.body);
77        children
78    }
79}
80
81#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
82
83pub struct AnonymousClassBody {
84    pub left_brace: Span, // `{`
85    pub members: Vec<AnonymousClassMember>,
86    pub right_brace: Span, // `}`
87}
88
89impl AnonymousClassBody {
90    pub fn iter(&self) -> Iter<'_, AnonymousClassMember> {
91        self.members.iter()
92    }
93}
94
95impl IntoIterator for AnonymousClassBody {
96    type Item = AnonymousClassMember;
97    type IntoIter = std::vec::IntoIter<Self::Item>;
98
99    fn into_iter(self) -> Self::IntoIter {
100        self.members.into_iter()
101    }
102}
103
104impl Node for AnonymousClassBody {
105    fn children(&mut self) -> Vec<&mut dyn Node> {
106        self.members
107            .iter_mut()
108            .map(|member| member as &mut dyn Node)
109            .collect()
110    }
111}
112
113#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
114
115pub struct AnonymousClassExpression {
116    pub attributes: Vec<AttributeGroup>,     // `#[Qux]`
117    pub class: Span,                         // `class`
118    pub extends: Option<ClassExtends>,       // `extends Foo`
119    pub implements: Option<ClassImplements>, // `implements Baz, Baz`
120    pub body: AnonymousClassBody,            // `{ ... }`
121}
122
123impl Node for AnonymousClassExpression {
124    fn children(&mut self) -> Vec<&mut dyn Node> {
125        let mut children: Vec<&mut dyn Node> = vec![];
126        if let Some(extends) = &mut self.extends {
127            children.push(extends);
128        }
129        if let Some(implements) = &mut self.implements {
130            children.push(implements);
131        }
132        children.push(&mut self.body);
133        children
134    }
135}
136
137#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
138
139pub struct ClassExtends {
140    pub extends: Span,            // `extends`
141    pub parent: SimpleIdentifier, // `Foo`
142}
143
144impl Node for ClassExtends {
145    fn children(&mut self) -> Vec<&mut dyn Node> {
146        vec![&mut self.parent]
147    }
148}
149
150#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
151
152pub struct ClassImplements {
153    pub implements: Span,                             // `implements`
154    pub interfaces: CommaSeparated<SimpleIdentifier>, // `Bar, Baz`
155}
156
157impl ClassImplements {
158    pub fn iter(&self) -> Iter<'_, SimpleIdentifier> {
159        self.interfaces.iter()
160    }
161}
162
163impl IntoIterator for ClassImplements {
164    type Item = SimpleIdentifier;
165    type IntoIter = std::vec::IntoIter<Self::Item>;
166
167    fn into_iter(self) -> Self::IntoIter {
168        self.interfaces.into_iter()
169    }
170}
171
172impl Node for ClassImplements {
173    fn children(&mut self) -> Vec<&mut dyn Node> {
174        self.interfaces.children()
175    }
176}
177
178#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
179#[serde(tag = "type", content = "value")]
180pub enum ClassMember {
181    Constant(ClassishConstant),
182    TraitUsage(TraitUsage),
183    Property(Property),
184    VariableProperty(VariableProperty),
185    AbstractMethod(AbstractMethod),
186    AbstractConstructor(AbstractConstructor),
187    ConcreteMethod(ConcreteMethod),
188    ConcreteConstructor(ConcreteConstructor),
189}
190
191impl Node for ClassMember {
192    fn children(&mut self) -> Vec<&mut dyn Node> {
193        match self {
194            ClassMember::Constant(constant) => vec![constant],
195            ClassMember::TraitUsage(usage) => vec![usage],
196            ClassMember::Property(property) => vec![property],
197            ClassMember::VariableProperty(property) => vec![property],
198            ClassMember::AbstractMethod(method) => vec![method],
199            ClassMember::AbstractConstructor(method) => vec![method],
200            ClassMember::ConcreteMethod(method) => vec![method],
201            ClassMember::ConcreteConstructor(method) => vec![method],
202        }
203    }
204}
205
206#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
207#[serde(tag = "type", content = "value")]
208pub enum AnonymousClassMember {
209    Constant(ClassishConstant),
210    TraitUsage(TraitUsage),
211    Property(Property),
212    VariableProperty(VariableProperty),
213    ConcreteMethod(ConcreteMethod),
214    ConcreteConstructor(ConcreteConstructor),
215}
216
217impl Node for AnonymousClassMember {
218    fn children(&mut self) -> Vec<&mut dyn Node> {
219        match self {
220            AnonymousClassMember::Constant(constant) => vec![constant],
221            AnonymousClassMember::TraitUsage(usage) => vec![usage],
222            AnonymousClassMember::Property(property) => vec![property],
223            AnonymousClassMember::VariableProperty(property) => vec![property],
224            AnonymousClassMember::ConcreteMethod(method) => vec![method],
225            AnonymousClassMember::ConcreteConstructor(method) => vec![method],
226        }
227    }
228}
php_parser_rs/parser/ast/classes.rs

php_parser_rs/parser/ast/
classes.rs
