protokit_proto/
ast.rs

1#![allow(dead_code)]
2
3pub use protokit_desc::{BuiltinType, FieldNum, Frequency, ImportType, Syntax};
4
5pub type Span<'a> = nom_locate::LocatedSpan<&'a str>;
6
7#[derive(Debug, PartialEq, Eq)]
8pub enum Type<'i> {
9    Builtin(BuiltinType),
10    Map(BuiltinType, &'i str),
11    Named(&'i str),
12}
13
14#[derive(Debug, PartialEq)]
15pub enum Const<'i> {
16    Bool(bool),
17    Ident(&'i str),
18    Str(&'i str),
19    Int(i128),
20    Float(f64),
21}
22
23impl AstNode for Const<'_> {
24    fn accept<V: Visitor>(&mut self, v: &mut V) {
25        if let Const::Ident(i) = self {
26            v.visit_ident_ref(i)
27        }
28    }
29}
30
31pub trait AstNode {
32    fn accept<V: Visitor>(&mut self, v: &mut V);
33}
34
35#[derive(Debug, PartialEq)]
36pub struct Field<'i> {
37    pub frequency: Frequency,
38    pub typ: Type<'i>,
39    pub name: Span<'i>,
40    pub number: FieldNum,
41    pub opts: Vec<Opt<'i>>,
42}
43
44impl AstNode for Field<'_> {
45    fn accept<V: Visitor>(&mut self, v: &mut V) {
46        v.visit_frequency(&mut self.frequency);
47        v.visit_type(&mut self.typ);
48        v.visit_ident(&self.name);
49        v.visit_field_num(self.number);
50        for o in &mut self.opts {
51            v.visit_opt(o);
52        }
53    }
54}
55
56#[derive(Debug, PartialEq)]
57pub struct MapField<'i> {
58    pub key_type: BuiltinType,
59    pub val_type: Type<'i>,
60    pub name: Span<'i>,
61    pub number: FieldNum,
62    pub options: Vec<Opt<'i>>,
63}
64
65impl AstNode for MapField<'_> {
66    fn accept<V: Visitor>(&mut self, v: &mut V) {
67        // v.visit_type(&mut self.key_type);
68        v.visit_type(&mut self.val_type);
69        v.visit_ident(&self.name);
70        v.visit_field_num(self.number);
71        for o in &mut self.options {
72            v.visit_opt(o);
73        }
74    }
75}
76
77#[derive(Debug, PartialEq, Eq)]
78pub struct OptName<'i> {
79    pub name: Span<'i>,
80    pub field_name: Option<Span<'i>>,
81}
82
83#[derive(Debug, PartialEq)]
84pub struct Opt<'i> {
85    pub name: OptName<'i>,
86    pub value: Const<'i>,
87}
88
89impl AstNode for Opt<'_> {
90    fn accept<V: Visitor>(&mut self, v: &mut V) {
91        v.visit_ident_ref(&self.name.name);
92        // if let Some(f)
93        // v.visit_ident_ref(&mut self.name.field_name);
94        v.visit_const(&mut self.value);
95    }
96}
97
98#[derive(Debug, PartialEq)]
99pub struct EnumField<'i> {
100    pub name: Span<'i>,
101    pub value: i32,
102    pub opts: Vec<Opt<'i>>,
103}
104
105impl AstNode for EnumField<'_> {
106    fn accept<V: Visitor>(&mut self, v: &mut V) {
107        v.visit_ident(&self.name);
108        v.visit_field_num(self.value);
109        for o in &mut self.opts {
110            v.visit_opt(o);
111        }
112    }
113}
114
115#[derive(Debug, PartialEq)]
116pub enum EnumItem<'i> {
117    Field(EnumField<'i>),
118    Option(Opt<'i>),
119}
120
121impl AstNode for EnumItem<'_> {
122    fn accept<V: Visitor>(&mut self, v: &mut V) {
123        match self {
124            EnumItem::Field(f) => f.accept(v),
125            EnumItem::Option(o) => o.accept(v),
126        }
127    }
128}
129
130#[derive(Debug, PartialEq)]
131pub struct Enum<'i> {
132    pub name: Span<'i>,
133    pub items: Vec<EnumItem<'i>>,
134}
135
136impl AstNode for Enum<'_> {
137    fn accept<V: Visitor>(&mut self, v: &mut V) {
138        v.visit_ident(&self.name);
139        for i in &mut self.items {
140            match i {
141                EnumItem::Field(f) => v.visit_enum_field(f),
142                EnumItem::Option(o) => v.visit_opt(o),
143            }
144        }
145    }
146}
147
148#[derive(Debug, PartialEq)]
149pub enum OneOfItem<'i> {
150    Option(Opt<'i>),
151    Field(Field<'i>),
152    Group(Group<'i>),
153}
154
155impl AstNode for OneOfItem<'_> {
156    fn accept<V: Visitor>(&mut self, v: &mut V) {
157        match self {
158            OneOfItem::Option(o) => v.visit_opt(o),
159            OneOfItem::Field(f) => v.visit_field(f),
160            OneOfItem::Group(g) => v.visit_group(g),
161        }
162    }
163}
164
165#[derive(Debug, PartialEq)]
166pub struct OneOf<'i> {
167    pub name: Span<'i>,
168    pub items: Vec<OneOfItem<'i>>,
169}
170
171impl AstNode for OneOf<'_> {
172    fn accept<V: Visitor>(&mut self, v: &mut V) {
173        v.visit_ident(&self.name);
174        for i in &mut self.items {
175            v.visit_oneof_item(i);
176        }
177    }
178}
179
180#[derive(Debug, PartialEq, Eq)]
181pub struct ReservedRange {
182    pub from: FieldNum,
183    pub to: FieldNum,
184}
185
186#[derive(Debug, PartialEq, Eq)]
187pub enum Reserved<'i> {
188    Names(Vec<Span<'i>>),
189    Ranges(Vec<ReservedRange>),
190}
191
192impl AstNode for Reserved<'_> {
193    fn accept<V: Visitor>(&mut self, v: &mut V) {
194        match self {
195            Reserved::Names(n) => {
196                for i in n {
197                    v.visit_ident(i);
198                }
199            }
200            Reserved::Ranges(r) => {
201                for r in r {
202                    v.visit_range(r)
203                }
204            }
205        }
206    }
207}
208
209#[derive(Debug, PartialEq, Eq)]
210pub struct Extensions {
211    pub ranges: Vec<ReservedRange>,
212}
213
214impl AstNode for Extensions {
215    fn accept<V: Visitor>(&mut self, v: &mut V) {
216        for r in &mut self.ranges {
217            v.visit_range(r)
218        }
219    }
220}
221
222#[derive(Debug, PartialEq)]
223pub enum MessageItem<'i> {
224    Field(Field<'i>),
225    Enum(Enum<'i>),
226    Message(Message<'i>),
227    Option(Opt<'i>),
228    OneOf(OneOf<'i>),
229    MapField(MapField<'i>),
230    Group(Group<'i>),
231    Reserved(Reserved<'i>),
232    Extensions(Extensions),
233    Extend(Extension<'i>),
234}
235
236impl AstNode for MessageItem<'_> {
237    fn accept<V: Visitor>(&mut self, v: &mut V) {
238        match self {
239            MessageItem::Field(f) => v.visit_field(f),
240            MessageItem::Enum(e) => v.visit_enum(e),
241            MessageItem::Message(m) => v.visit_message(m),
242            MessageItem::Option(o) => v.visit_opt(o),
243            MessageItem::OneOf(o) => v.visit_oneof(o),
244            MessageItem::MapField(m) => v.visit_map_field(m),
245            MessageItem::Group(g) => v.visit_group(g),
246            MessageItem::Reserved(r) => v.visit_reserved(r),
247            MessageItem::Extensions(e) => v.visit_extensions(e),
248            MessageItem::Extend(e) => v.visit_extend(e),
249        }
250    }
251}
252
253#[derive(Debug, PartialEq)]
254pub struct Message<'i> {
255    pub name: Span<'i>,
256    pub items: Vec<MessageItem<'i>>,
257}
258
259impl AstNode for Message<'_> {
260    fn accept<V: Visitor>(&mut self, v: &mut V) {
261        v.visit_ident(&self.name);
262        for i in &mut self.items {
263            v.visit_message_item(i)
264        }
265    }
266}
267
268#[derive(Debug, PartialEq)]
269pub struct Rpc<'i> {
270    pub name: Span<'i>,
271    pub msg_type: Type<'i>,
272    pub msg_stream: bool,
273
274    pub ret_type: Type<'i>,
275    pub ret_stream: bool,
276
277    pub options: Vec<Opt<'i>>,
278}
279
280impl AstNode for Rpc<'_> {
281    fn accept<V: Visitor>(&mut self, v: &mut V) {
282        v.visit_ident(&self.name);
283        v.visit_type(&mut self.msg_type);
284        v.visit_type(&mut self.ret_type);
285        for o in &mut self.options {
286            v.visit_opt(o);
287        }
288    }
289}
290
291#[derive(Debug, PartialEq)]
292pub enum ServiceItem<'i> {
293    Option(Opt<'i>),
294    Rpc(Rpc<'i>),
295}
296
297impl AstNode for ServiceItem<'_> {
298    fn accept<V: Visitor>(&mut self, v: &mut V) {
299        match self {
300            ServiceItem::Option(o) => v.visit_opt(o),
301            ServiceItem::Rpc(r) => v.visit_rpc(r),
302        }
303    }
304}
305
306#[derive(Debug, PartialEq)]
307pub struct Service<'i> {
308    pub name: Span<'i>,
309    pub items: Vec<ServiceItem<'i>>,
310}
311
312impl AstNode for Service<'_> {
313    fn accept<V: Visitor>(&mut self, v: &mut V) {
314        v.visit_ident(&self.name);
315        for it in &mut self.items {
316            v.visit_service_item(it)
317        }
318    }
319}
320
321#[derive(Debug, PartialEq)]
322pub struct Group<'i> {
323    pub frequency: Frequency,
324    pub name: Span<'i>,
325    pub number: FieldNum,
326    pub items: Vec<MessageItem<'i>>,
327}
328
329impl AstNode for Group<'_> {
330    fn accept<V: Visitor>(&mut self, v: &mut V) {
331        v.visit_frequency(&mut self.frequency);
332        v.visit_ident(&self.name);
333        v.visit_field_num(self.number);
334        for m in &mut self.items {
335            v.visit_message_item(m);
336        }
337    }
338}
339
340#[derive(Debug, PartialEq)]
341pub enum ExtensionItem<'i> {
342    Field(Field<'i>),
343    Group(Group<'i>),
344}
345
346#[derive(Debug, PartialEq)]
347pub struct Extension<'i> {
348    pub name: Span<'i>,
349    pub items: Vec<ExtensionItem<'i>>,
350}
351
352impl AstNode for Extension<'_> {
353    fn accept<V: Visitor>(&mut self, v: &mut V) {
354        v.visit_ident_ref(&self.name);
355        for it in &mut self.items {
356            match it {
357                ExtensionItem::Field(f) => v.visit_field(f),
358                ExtensionItem::Group(g) => v.visit_group(g),
359            }
360        }
361    }
362}
363
364#[derive(Debug, PartialEq)]
365pub enum Def<'i> {
366    Message(Message<'i>),
367    Enum(Enum<'i>),
368    Service(Service<'i>),
369    Extend(Extension<'i>),
370}
371
372impl AstNode for Def<'_> {
373    fn accept<V: Visitor>(&mut self, v: &mut V) {
374        match self {
375            Def::Message(m) => v.visit_message(m),
376            Def::Enum(e) => v.visit_enum(e),
377            Def::Service(s) => v.visit_service(s),
378            Def::Extend(e) => v.visit_extend(e),
379        }
380    }
381}
382
383#[derive(Debug, PartialEq, Eq)]
384pub struct Import<'i> {
385    pub typ: ImportType,
386    pub path: Span<'i>,
387}
388
389#[derive(Debug, PartialEq, Eq)]
390pub struct Package<'i> {
391    pub path: Span<'i>,
392}
393
394#[derive(Debug, PartialEq)]
395pub enum ProtoItem<'i> {
396    Import(Import<'i>),
397    Package(Package<'i>),
398    Option(Opt<'i>),
399    Def(Def<'i>),
400}
401
402impl AstNode for ProtoItem<'_> {
403    fn accept<V: Visitor>(&mut self, v: &mut V) {
404        match self {
405            ProtoItem::Import(i) => v.visit_import(i),
406            ProtoItem::Package(p) => v.visit_package(p),
407            ProtoItem::Option(o) => v.visit_opt(o),
408            ProtoItem::Def(d) => v.visit_def(d),
409        }
410    }
411}
412
413#[derive(Debug, PartialEq)]
414pub struct Proto<'i> {
415    pub syntax: Syntax,
416    pub items: Vec<ProtoItem<'i>>,
417}
418
419impl AstNode for Proto<'_> {
420    fn accept<V: Visitor>(&mut self, v: &mut V) {
421        v.visit_syntax(&mut self.syntax);
422        for i in &mut self.items {
423            v.visit_proto_item(i);
424        }
425    }
426}
427
428#[allow(unused_variables)]
429pub trait Visitor: Sized {
430    fn visit_proto(&mut self, item: &mut Proto) {
431        item.accept(self);
432    }
433    fn visit_syntax(&mut self, syntax: &mut Syntax) {}
434    fn visit_proto_item(&mut self, item: &mut ProtoItem) {
435        item.accept(self)
436    }
437    fn visit_import(&mut self, item: &mut Import) {}
438    fn visit_package(&mut self, item: &mut Package) {}
439    fn visit_opts(&mut self, items: &mut [Opt]) {
440        for o in items {
441            self.visit_opt(o);
442        }
443    }
444    fn visit_opt(&mut self, item: &mut Opt) {
445        item.accept(self)
446    }
447    fn visit_def(&mut self, item: &mut Def) {
448        item.accept(self)
449    }
450    fn visit_message(&mut self, item: &mut Message) {
451        item.accept(self)
452    }
453    fn visit_message_item(&mut self, item: &mut MessageItem) {
454        item.accept(self)
455    }
456    fn visit_enum(&mut self, item: &mut Enum) {
457        item.accept(self)
458    }
459    fn visit_enum_item(&mut self, item: &mut EnumItem) {
460        item.accept(self)
461    }
462    fn visit_enum_field(&mut self, item: &mut EnumField) {
463        item.accept(self)
464    }
465    fn visit_oneof(&mut self, item: &mut OneOf) {
466        item.accept(self)
467    }
468    fn visit_oneof_item(&mut self, item: &mut OneOfItem) {
469        item.accept(self)
470    }
471    fn visit_field(&mut self, item: &mut Field) {
472        item.accept(self)
473    }
474    fn visit_map_field(&mut self, item: &mut MapField) {
475        item.accept(self)
476    }
477    fn visit_service(&mut self, item: &mut Service) {
478        item.accept(self)
479    }
480    fn visit_service_item(&mut self, item: &mut ServiceItem) {
481        item.accept(self)
482    }
483    fn visit_rpc(&mut self, rpc: &mut Rpc) {
484        rpc.accept(self)
485    }
486    fn visit_extend(&mut self, item: &mut Extension) {
487        item.accept(self)
488    }
489    fn visit_group(&mut self, item: &mut Group) {
490        item.accept(self)
491    }
492    fn visit_reserved(&mut self, item: &mut Reserved) {
493        item.accept(self)
494    }
495    fn visit_range(&mut self, item: &mut ReservedRange) {}
496    fn visit_extensions(&mut self, item: &mut Extensions) {
497        item.accept(self)
498    }
499    fn visit_frequency(&mut self, freq: &mut Frequency) {}
500    fn visit_field_num(&mut self, num: FieldNum) {}
501    /// Reference to a type
502    fn visit_type(&mut self, typ: &mut Type) {}
503    /// An idenditier, that is being declared
504    fn visit_ident(&mut self, ident: &str) {}
505    /// Reference to existing identifier
506    fn visit_ident_ref(&mut self, item: &str) {}
507    fn visit_const(&mut self, value: &mut Const) {
508        value.accept(self)
509    }
510}
protokit_proto/ast.rs

protokit_proto/
ast.rs
