xidl_parser/hir/
interface.rs

1use super::*;
2use serde::{Deserialize, Serialize};
3
4#[derive(Debug, Serialize, Deserialize, Clone)]
5pub struct InterfaceDcl {
6    pub annotations: Vec<Annotation>,
7    pub decl: InterfaceDclInner,
8}
9
10#[derive(Debug, Serialize, Deserialize, Clone)]
11pub enum InterfaceDclInner {
12    InterfaceForwardDcl(InterfaceForwardDcl),
13    InterfaceDef(InterfaceDef),
14}
15
16#[derive(Debug, Serialize, Deserialize, Clone)]
17pub struct InterfaceForwardDcl {
18    pub ident: String,
19}
20
21#[derive(Debug, Serialize, Deserialize, Clone)]
22pub struct InterfaceDef {
23    pub header: InterfaceHeader,
24    pub interface_body: Option<InterfaceBody>,
25}
26
27#[derive(Debug, Serialize, Deserialize, Clone)]
28pub struct InterfaceHeader {
29    pub ident: String,
30    pub parent: Option<InterfaceInheritanceSpec>,
31}
32
33#[derive(Debug, Serialize, Deserialize, Clone)]
34pub struct InterfaceInheritanceSpec(pub Vec<InterfaceName>);
35
36#[derive(Debug, Serialize, Deserialize, Clone)]
37pub struct InterfaceName(pub ScopedName);
38
39#[derive(Debug, Serialize, Deserialize, Clone)]
40pub struct InterfaceBody(pub Vec<Export>);
41
42#[derive(Debug, Serialize, Deserialize, Clone)]
43pub enum Export {
44    OpDcl(OpDcl),
45    AttrDcl(AttrDcl),
46    TypeDcl(TypeDcl),
47    ConstDcl(ConstDcl),
48    ExceptDcl(ExceptDcl),
49}
50
51#[derive(Debug, Serialize, Deserialize, Clone)]
52pub struct OpDcl {
53    pub annotations: Vec<Annotation>,
54    pub ty: OpTypeSpec,
55    pub ident: String,
56    pub parameter: Option<ParameterDcls>,
57    pub raises: Option<RaisesExpr>,
58}
59
60#[derive(Debug, Serialize, Deserialize, Clone)]
61#[allow(clippy::large_enum_variant)]
62pub enum OpTypeSpec {
63    Void,
64    TypeSpec(TypeSpec),
65}
66
67#[derive(Debug, Serialize, Deserialize, Clone)]
68pub struct ParameterDcls(pub Vec<ParamDcl>);
69
70#[derive(Debug, Serialize, Deserialize, Clone)]
71pub struct ParamDcl {
72    pub annotations: Vec<Annotation>,
73    pub attr: Option<ParamAttribute>,
74    pub ty: TypeSpec,
75    pub declarator: SimpleDeclarator,
76}
77
78#[derive(Debug, Serialize, Deserialize, Clone)]
79pub struct ParamAttribute(pub String);
80
81#[derive(Debug, Serialize, Deserialize, Clone)]
82pub struct RaisesExpr(pub Vec<ScopedName>);
83
84#[derive(Debug, Serialize, Deserialize, Clone)]
85pub struct AttrDcl {
86    pub annotations: Vec<Annotation>,
87    pub decl: AttrDclInner,
88}
89
90#[derive(Debug, Serialize, Deserialize, Clone)]
91pub enum AttrDclInner {
92    ReadonlyAttrSpec(ReadonlyAttrSpec),
93    AttrSpec(AttrSpec),
94}
95
96#[derive(Debug, Serialize, Deserialize, Clone)]
97pub struct ReadonlyAttrSpec {
98    pub ty: TypeSpec,
99    pub declarator: ReadonlyAttrDeclarator,
100}
101
102#[derive(Debug, Serialize, Deserialize, Clone)]
103pub enum ReadonlyAttrDeclarator {
104    SimpleDeclarator(SimpleDeclarator),
105    RaisesExpr(RaisesExpr),
106}
107
108#[derive(Debug, Serialize, Deserialize, Clone)]
109pub struct AttrSpec {
110    pub ty: TypeSpec,
111    pub declarator: AttrDeclarator,
112}
113
114#[derive(Debug, Serialize, Deserialize, Clone)]
115pub enum AttrDeclarator {
116    SimpleDeclarator(Vec<SimpleDeclarator>),
117    WithRaises {
118        declarator: SimpleDeclarator,
119        raises: AttrRaisesExpr,
120    },
121}
122
123#[derive(Debug, Serialize, Deserialize, Clone)]
124pub enum AttrRaisesExpr {
125    Case1(GetExcepExpr, Option<SetExcepExpr>),
126    SetExcepExpr(SetExcepExpr),
127}
128
129#[derive(Debug, Serialize, Deserialize, Clone)]
130pub struct GetExcepExpr {
131    pub expr: ExceptionList,
132}
133
134#[derive(Debug, Serialize, Deserialize, Clone)]
135pub struct SetExcepExpr {
136    pub expr: ExceptionList,
137}
138
139#[derive(Debug, Serialize, Deserialize, Clone)]
140pub struct ExceptionList(pub Vec<ScopedName>);
141
142impl From<crate::typed_ast::InterfaceDcl> for InterfaceDcl {
143    fn from(value: crate::typed_ast::InterfaceDcl) -> Self {
144        Self {
145            annotations: expand_annotations(value.annotations),
146            decl: value.decl.into(),
147        }
148    }
149}
150
151impl From<crate::typed_ast::InterfaceDclInner> for InterfaceDclInner {
152    fn from(value: crate::typed_ast::InterfaceDclInner) -> Self {
153        match value {
154            crate::typed_ast::InterfaceDclInner::InterfaceForwardDcl(forward) => {
155                Self::InterfaceForwardDcl(forward.into())
156            }
157            crate::typed_ast::InterfaceDclInner::InterfaceDef(def) => {
158                Self::InterfaceDef(def.into())
159            }
160        }
161    }
162}
163
164impl From<crate::typed_ast::InterfaceForwardDcl> for InterfaceForwardDcl {
165    fn from(value: crate::typed_ast::InterfaceForwardDcl) -> Self {
166        Self {
167            ident: value.ident.0,
168        }
169    }
170}
171
172impl From<crate::typed_ast::InterfaceDef> for InterfaceDef {
173    fn from(value: crate::typed_ast::InterfaceDef) -> Self {
174        Self {
175            header: value.header.into(),
176            interface_body: value.interface_body.map(Into::into),
177        }
178    }
179}
180
181impl From<crate::typed_ast::InterfaceHeader> for InterfaceHeader {
182    fn from(value: crate::typed_ast::InterfaceHeader) -> Self {
183        Self {
184            ident: value.ident.0,
185            parent: value.parent.map(Into::into),
186        }
187    }
188}
189
190impl From<crate::typed_ast::InterfaceInheritanceSpec> for InterfaceInheritanceSpec {
191    fn from(value: crate::typed_ast::InterfaceInheritanceSpec) -> Self {
192        Self(value.0.into_iter().map(Into::into).collect())
193    }
194}
195
196impl From<crate::typed_ast::InterfaceName> for InterfaceName {
197    fn from(value: crate::typed_ast::InterfaceName) -> Self {
198        Self(value.0.into())
199    }
200}
201
202impl From<crate::typed_ast::InterfaceBody> for InterfaceBody {
203    fn from(value: crate::typed_ast::InterfaceBody) -> Self {
204        Self(value.0.into_iter().map(Into::into).collect())
205    }
206}
207
208impl From<crate::typed_ast::Export> for Export {
209    fn from(value: crate::typed_ast::Export) -> Self {
210        match value {
211            crate::typed_ast::Export::OpDcl(op_dcl) => Self::OpDcl(op_dcl.into()),
212            crate::typed_ast::Export::AttrDcl(attr_dcl) => Self::AttrDcl(attr_dcl.into()),
213            crate::typed_ast::Export::TypeDcl(type_dcl) => Self::TypeDcl(type_dcl.into()),
214            crate::typed_ast::Export::ConstDcl(const_dcl) => Self::ConstDcl(const_dcl.into()),
215            crate::typed_ast::Export::ExceptDcl(except_dcl) => Self::ExceptDcl(except_dcl.into()),
216        }
217    }
218}
219
220impl From<crate::typed_ast::OpDcl> for OpDcl {
221    fn from(value: crate::typed_ast::OpDcl) -> Self {
222        Self {
223            annotations: expand_annotations(value.annotations),
224            ty: value.ty.into(),
225            ident: value.ident.0,
226            parameter: value.parameter.map(Into::into),
227            raises: value.raises.map(Into::into),
228        }
229    }
230}
231
232impl From<crate::typed_ast::OpTypeSpec> for OpTypeSpec {
233    fn from(value: crate::typed_ast::OpTypeSpec) -> Self {
234        match value {
235            crate::typed_ast::OpTypeSpec::Void => Self::Void,
236            crate::typed_ast::OpTypeSpec::TypeSpec(ty) => Self::TypeSpec(ty.into()),
237        }
238    }
239}
240
241impl From<crate::typed_ast::ParameterDcls> for ParameterDcls {
242    fn from(value: crate::typed_ast::ParameterDcls) -> Self {
243        Self(value.0.into_iter().map(Into::into).collect())
244    }
245}
246
247impl From<crate::typed_ast::ParamDcl> for ParamDcl {
248    fn from(value: crate::typed_ast::ParamDcl) -> Self {
249        Self {
250            annotations: expand_annotations(value.annotations),
251            attr: value.attr.map(Into::into),
252            ty: value.ty.into(),
253            declarator: value.declarator.into(),
254        }
255    }
256}
257
258impl From<crate::typed_ast::ParamAttribute> for ParamAttribute {
259    fn from(value: crate::typed_ast::ParamAttribute) -> Self {
260        Self(value.0)
261    }
262}
263
264impl From<crate::typed_ast::RaisesExpr> for RaisesExpr {
265    fn from(value: crate::typed_ast::RaisesExpr) -> Self {
266        Self(value.0.into_iter().map(Into::into).collect())
267    }
268}
269
270impl From<crate::typed_ast::AttrDcl> for AttrDcl {
271    fn from(value: crate::typed_ast::AttrDcl) -> Self {
272        Self {
273            annotations: expand_annotations(value.annotations),
274            decl: value.decl.into(),
275        }
276    }
277}
278
279impl From<crate::typed_ast::AttrDclInner> for AttrDclInner {
280    fn from(value: crate::typed_ast::AttrDclInner) -> Self {
281        match value {
282            crate::typed_ast::AttrDclInner::ReadonlyAttrSpec(spec) => {
283                Self::ReadonlyAttrSpec(spec.into())
284            }
285            crate::typed_ast::AttrDclInner::AttrSpec(spec) => Self::AttrSpec(spec.into()),
286        }
287    }
288}
289
290impl From<crate::typed_ast::ReadonlyAttrSpec> for ReadonlyAttrSpec {
291    fn from(value: crate::typed_ast::ReadonlyAttrSpec) -> Self {
292        Self {
293            ty: value.ty.into(),
294            declarator: value.declarator.into(),
295        }
296    }
297}
298
299impl From<crate::typed_ast::ReadonlyAttrDeclarator> for ReadonlyAttrDeclarator {
300    fn from(value: crate::typed_ast::ReadonlyAttrDeclarator) -> Self {
301        match value {
302            crate::typed_ast::ReadonlyAttrDeclarator::SimpleDeclarator(declarator) => {
303                Self::SimpleDeclarator(declarator.into())
304            }
305            crate::typed_ast::ReadonlyAttrDeclarator::RaisesExpr(raises_expr) => {
306                Self::RaisesExpr(raises_expr.into())
307            }
308        }
309    }
310}
311
312impl From<crate::typed_ast::AttrSpec> for AttrSpec {
313    fn from(value: crate::typed_ast::AttrSpec) -> Self {
314        Self {
315            ty: value.type_spec.into(),
316            declarator: value.declarator.into(),
317        }
318    }
319}
320
321impl From<crate::typed_ast::AttrDeclarator> for AttrDeclarator {
322    fn from(value: crate::typed_ast::AttrDeclarator) -> Self {
323        match value {
324            crate::typed_ast::AttrDeclarator::SimpleDeclarator(declarator) => {
325                Self::SimpleDeclarator(declarator.into_iter().map(Into::into).collect())
326            }
327            crate::typed_ast::AttrDeclarator::WithRaises { declarator, raises } => {
328                Self::WithRaises {
329                    declarator: declarator.into(),
330                    raises: raises.into(),
331                }
332            }
333        }
334    }
335}
336
337impl From<crate::typed_ast::AttrRaisesExpr> for AttrRaisesExpr {
338    fn from(value: crate::typed_ast::AttrRaisesExpr) -> Self {
339        match value {
340            crate::typed_ast::AttrRaisesExpr::Case1(get, set) => {
341                Self::Case1(get.into(), set.map(Into::into))
342            }
343            crate::typed_ast::AttrRaisesExpr::SetExcepExpr(set) => Self::SetExcepExpr(set.into()),
344        }
345    }
346}
347
348impl From<crate::typed_ast::GetExcepExpr> for GetExcepExpr {
349    fn from(value: crate::typed_ast::GetExcepExpr) -> Self {
350        Self {
351            expr: value.expr.into(),
352        }
353    }
354}
355
356impl From<crate::typed_ast::SetExcepExpr> for SetExcepExpr {
357    fn from(value: crate::typed_ast::SetExcepExpr) -> Self {
358        Self {
359            expr: value.expr.into(),
360        }
361    }
362}
363
364impl From<crate::typed_ast::ExceptionList> for ExceptionList {
365    fn from(value: crate::typed_ast::ExceptionList) -> Self {
366        Self(value.0.into_iter().map(Into::into).collect())
367    }
368}
xidl_parser/hir/interface.rs

xidl_parser/hir/
interface.rs
