php_parser_rs/parser/ast/
interfaces.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::AbstractConstructor;
10use crate::parser::ast::functions::AbstractMethod;
11use crate::parser::ast::identifiers::SimpleIdentifier;
12use crate::parser::ast::utils::CommaSeparated;
13
14#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
15#[serde(tag = "type", content = "value")]
16pub enum InterfaceMember {
17    Constant(ClassishConstant),       // `public const FOO = 123;`
18    Constructor(AbstractConstructor), // `public function __construct(): void;`
19    Method(AbstractMethod),           // `public function foo(): void;`
20}
21
22impl Node for InterfaceMember {
23    fn children(&mut self) -> Vec<&mut dyn Node> {
24        match self {
25            InterfaceMember::Constant(constant) => vec![constant],
26            InterfaceMember::Constructor(constructor) => vec![constructor],
27            InterfaceMember::Method(method) => vec![method],
28        }
29    }
30}
31
32#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
33
34pub struct InterfaceExtends {
35    pub extends: Span,                             // `extends`
36    pub parents: CommaSeparated<SimpleIdentifier>, // `Foo`, `Bar`
37}
38
39impl Node for InterfaceExtends {
40    fn children(&mut self) -> Vec<&mut dyn Node> {
41        self.parents.children()
42    }
43}
44
45#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
46
47pub struct InterfaceBody {
48    pub left_brace: Span,              // `{`
49    pub members: Vec<InterfaceMember>, // `public const FOO = 123;`, `public function foo(): void;`
50    pub right_brace: Span,             // `}`
51}
52
53impl Node for InterfaceBody {
54    fn children(&mut self) -> Vec<&mut dyn Node> {
55        self.members
56            .iter_mut()
57            .map(|member| member as &mut dyn Node)
58            .collect()
59    }
60}
61
62#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
63
64pub struct InterfaceStatement {
65    pub attributes: Vec<AttributeGroup>,   // `#[Foo]`
66    pub interface: Span,                   // `interface`
67    pub name: SimpleIdentifier,            // `Foo`
68    pub extends: Option<InterfaceExtends>, // `extends Bar`
69    pub body: InterfaceBody,               // `{ ... }`
70}
71
72impl Node for InterfaceStatement {
73    fn children(&mut self) -> Vec<&mut dyn Node> {
74        let mut children: Vec<&mut dyn Node> = vec![&mut self.name];
75        if let Some(extends) = &mut self.extends {
76            children.push(extends);
77        }
78        children
79    }
80}