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

xidl_parser/hir/
interface.rs
