thrift_analyzer/analyzer/
ast.rs

1use std::{any::Any, fmt::Debug, ops::Deref, rc::Rc};
2
3use crate::analyzer::base::{Position, Range};
4
5/// A trait for all AST nodes.
6pub trait Node: Debug + Any {
7    /// Returns the node as a `dyn Any`.
8    fn as_any(&self) -> &dyn Any;
9    /// Returns the range of the node.
10    fn range(&self) -> Range;
11    /// Returns the children of the node.
12    fn children(&self) -> Vec<&dyn Node>;
13}
14
15/// An enum representing all possible header nodes.
16#[derive(Debug)]
17pub enum HeaderNode {
18    Include(IncludeNode),
19    CppInclude(CppIncludeNode),
20    Namespace(NamespaceNode),
21}
22
23impl Deref for HeaderNode {
24    type Target = dyn Node;
25
26    fn deref(&self) -> &Self::Target {
27        match self {
28            HeaderNode::Include(node) => node,
29            HeaderNode::CppInclude(node) => node,
30            HeaderNode::Namespace(node) => node,
31        }
32    }
33}
34
35/// An enum representing all possible definition nodes.
36#[derive(Debug)]
37pub enum DefinitionNode {
38    Const(ConstNode),
39    Typedef(TypedefNode),
40    Enum(EnumNode),
41    Struct(StructNode),
42    Union(UnionNode),
43    Exception(ExceptionNode),
44    Service(ServiceNode),
45}
46
47impl Deref for DefinitionNode {
48    type Target = dyn Node;
49
50    fn deref(&self) -> &Self::Target {
51        match self {
52            DefinitionNode::Const(node) => node,
53            DefinitionNode::Typedef(node) => node,
54            DefinitionNode::Enum(node) => node,
55            DefinitionNode::Struct(node) => node,
56            DefinitionNode::Union(node) => node,
57            DefinitionNode::Exception(node) => node,
58            DefinitionNode::Service(node) => node,
59        }
60    }
61}
62
63impl DefinitionNode {
64    pub fn name(&self) -> &str {
65        &self.identifier().name
66    }
67
68    pub fn identifier(&self) -> &IdentifierNode {
69        match self {
70            DefinitionNode::Const(node) => &node.identifier,
71            DefinitionNode::Typedef(node) => &node.identifier,
72            DefinitionNode::Enum(node) => &node.identifier,
73            DefinitionNode::Struct(node) => &node.identifier,
74            DefinitionNode::Union(node) => &node.identifier,
75            DefinitionNode::Exception(node) => &node.identifier,
76            DefinitionNode::Service(node) => &node.identifier,
77        }
78    }
79}
80
81/// An enum representing all possible field types.
82#[derive(Debug)]
83pub enum FieldTypeNode {
84    Identifier(IdentifierNode),
85    BaseType(BaseTypeNode),
86    MapType(MapTypeNode),
87    SetType(SetTypeNode),
88    ListType(ListTypeNode),
89}
90
91impl Deref for FieldTypeNode {
92    type Target = dyn Node;
93
94    fn deref(&self) -> &Self::Target {
95        match self {
96            FieldTypeNode::Identifier(node) => node,
97            FieldTypeNode::BaseType(node) => node,
98            FieldTypeNode::MapType(node) => node,
99            FieldTypeNode::SetType(node) => node,
100            FieldTypeNode::ListType(node) => node,
101        }
102    }
103}
104
105#[derive(Debug)]
106pub struct DocumentNode {
107    pub range: Range,
108    pub headers: Vec<Rc<HeaderNode>>,
109    pub definitions: Vec<Rc<DefinitionNode>>,
110}
111
112#[derive(Debug)]
113pub struct IncludeNode {
114    pub range: Range,
115    pub literal: String,
116}
117
118#[derive(Debug)]
119pub struct CppIncludeNode {
120    pub range: Range,
121    pub literal: String,
122}
123
124#[derive(Debug)]
125pub struct NamespaceNode {
126    pub range: Range,
127    pub scope: String,
128    pub identifier: IdentifierNode,
129    pub ext: Option<ExtNode>,
130}
131
132#[derive(Debug, Clone)]
133pub struct IdentifierNode {
134    pub range: Range,
135    pub name: String,
136}
137
138impl IdentifierNode {
139    /// Check if the position is in the namespace.
140    pub fn position_in_namespace(&self, pos: Position) -> bool {
141        let dot_index = match self.name.find('.') {
142            Some(index) => index,
143            None => return false,
144        };
145
146        self.range.contains(pos)
147            && pos.column >= self.range.start.column
148            && pos.column <= self.range.start.column + dot_index as u32
149    }
150
151    /// Split the identifier by the first dot.
152    pub fn split_by_first_dot(&self) -> (Option<IdentifierNode>, IdentifierNode) {
153        let dot_index = match self.name.find('.') {
154            Some(index) => index,
155            None => return (None, self.clone()),
156        };
157
158        let namespace = IdentifierNode {
159            range: Range {
160                start: self.range.start,
161                end: Position {
162                    line: self.range.start.line,
163                    column: self.range.start.column + dot_index as u32,
164                },
165            },
166            name: self.name[..dot_index].to_string(),
167        };
168        let identifier = IdentifierNode {
169            range: Range {
170                start: Position {
171                    line: self.range.start.line,
172                    column: self.range.start.column + dot_index as u32,
173                },
174                end: self.range.end,
175            },
176            name: self.name[dot_index + 1..].to_string(),
177        };
178
179        (Some(namespace), identifier)
180    }
181}
182
183#[derive(Debug)]
184pub struct ConstNode {
185    pub range: Range,
186    pub field_type: FieldTypeNode,
187    pub identifier: IdentifierNode,
188    pub value: ConstValueNode,
189}
190
191#[derive(Debug)]
192pub struct BaseTypeNode {
193    pub range: Range,
194    pub name: String,
195}
196
197#[derive(Debug)]
198pub struct MapTypeNode {
199    pub range: Range,
200    pub cpp_type: Option<String>,
201    pub key_type: Box<FieldTypeNode>,
202    pub value_type: Box<FieldTypeNode>,
203}
204
205#[derive(Debug)]
206pub struct SetTypeNode {
207    pub range: Range,
208    pub cpp_type: Option<String>,
209    pub type_node: Box<FieldTypeNode>,
210}
211
212#[derive(Debug)]
213pub struct ListTypeNode {
214    pub range: Range,
215    pub cpp_type: Option<String>,
216    pub type_node: Box<FieldTypeNode>,
217}
218
219#[derive(Debug)]
220pub struct ConstValueNode {
221    pub range: Range,
222    pub value: String,
223}
224
225#[derive(Debug)]
226pub struct TypedefNode {
227    pub range: Range,
228    pub definition_type: FieldTypeNode, // we extended this type
229    pub identifier: IdentifierNode,
230}
231
232#[derive(Debug)]
233pub struct EnumNode {
234    pub range: Range,
235    pub identifier: IdentifierNode,
236    pub values: Vec<EnumValueNode>,
237}
238
239#[derive(Debug)]
240pub struct EnumValueNode {
241    pub range: Range,
242    pub name: String,
243    pub value: Option<i32>,
244    pub ext: Option<ExtNode>,
245}
246
247#[derive(Debug)]
248pub struct StructNode {
249    pub range: Range,
250    pub identifier: IdentifierNode,
251    pub fields: Vec<FieldNode>,
252    pub ext: Option<ExtNode>,
253}
254
255#[derive(Debug)]
256pub struct FieldNode {
257    pub range: Range,
258    pub field_id: Option<FieldIdNode>,
259    pub field_req: Option<String>,
260    pub field_type: FieldTypeNode,
261    pub identifier: IdentifierNode,
262    pub default_value: Option<ConstValueNode>,
263    pub ext: Option<ExtNode>,
264}
265
266#[derive(Debug)]
267pub struct FieldIdNode {
268    pub range: Range,
269    pub id: i32,
270}
271
272#[derive(Debug)]
273pub struct UnionNode {
274    pub range: Range,
275    pub identifier: IdentifierNode,
276    pub fields: Vec<FieldNode>,
277}
278
279#[derive(Debug)]
280pub struct ExceptionNode {
281    pub range: Range,
282    pub identifier: IdentifierNode,
283    pub fields: Vec<FieldNode>,
284}
285
286#[derive(Debug)]
287pub struct ServiceNode {
288    pub range: Range,
289    pub identifier: IdentifierNode,
290    pub extends: Option<IdentifierNode>,
291    pub functions: Vec<FunctionNode>,
292}
293
294#[derive(Debug)]
295pub struct FunctionNode {
296    pub range: Range,
297    pub is_oneway: bool,
298    pub function_type: Option<FieldTypeNode>,
299    pub identifier: IdentifierNode,
300    pub fields: Vec<FieldNode>,
301    pub throws: Option<Vec<FieldNode>>,
302    pub ext: Option<ExtNode>,
303}
304
305#[derive(Debug)]
306pub struct ExtNode {
307    pub range: Range,
308    pub kv_pairs: Vec<(String, String)>,
309}
310
311impl Node for DocumentNode {
312    fn as_any(&self) -> &dyn Any {
313        self
314    }
315
316    fn range(&self) -> Range {
317        self.range.clone()
318    }
319
320    fn children(&self) -> Vec<&dyn Node> {
321        let mut children = Vec::new();
322        children.extend(self.headers.iter().map(|h| h.as_ref().deref()));
323        children.extend(self.definitions.iter().map(|d| d.as_ref().deref()));
324        children
325    }
326}
327
328impl Node for IncludeNode {
329    fn as_any(&self) -> &dyn Any {
330        self
331    }
332
333    fn range(&self) -> Range {
334        self.range.clone()
335    }
336
337    fn children(&self) -> Vec<&dyn Node> {
338        Vec::new()
339    }
340}
341
342impl Node for CppIncludeNode {
343    fn as_any(&self) -> &dyn Any {
344        self
345    }
346
347    fn range(&self) -> Range {
348        self.range.clone()
349    }
350
351    fn children(&self) -> Vec<&dyn Node> {
352        Vec::new()
353    }
354}
355
356impl Node for NamespaceNode {
357    fn as_any(&self) -> &dyn Any {
358        self
359    }
360
361    fn range(&self) -> Range {
362        self.range.clone()
363    }
364
365    fn children(&self) -> Vec<&dyn Node> {
366        let mut children = Vec::new();
367        children.push(&self.identifier as &dyn Node);
368        if let Some(ext) = &self.ext {
369            children.push(ext as &dyn Node);
370        }
371        children
372    }
373}
374
375impl Node for IdentifierNode {
376    fn as_any(&self) -> &dyn Any {
377        self
378    }
379
380    fn range(&self) -> Range {
381        self.range.clone()
382    }
383
384    fn children(&self) -> Vec<&dyn Node> {
385        Vec::new()
386    }
387}
388
389impl Node for ConstNode {
390    fn as_any(&self) -> &dyn Any {
391        self
392    }
393
394    fn range(&self) -> Range {
395        self.range.clone()
396    }
397
398    fn children(&self) -> Vec<&dyn Node> {
399        vec![
400            self.field_type.deref(),
401            &self.identifier as &dyn Node,
402            &self.value as &dyn Node,
403        ]
404    }
405}
406
407impl Node for BaseTypeNode {
408    fn as_any(&self) -> &dyn Any {
409        self
410    }
411
412    fn range(&self) -> Range {
413        self.range.clone()
414    }
415
416    fn children(&self) -> Vec<&dyn Node> {
417        Vec::new()
418    }
419}
420
421impl Node for MapTypeNode {
422    fn as_any(&self) -> &dyn Any {
423        self
424    }
425
426    fn range(&self) -> Range {
427        self.range.clone()
428    }
429
430    fn children(&self) -> Vec<&dyn Node> {
431        vec![
432            self.key_type.as_ref().deref(),
433            self.value_type.as_ref().deref(),
434        ]
435    }
436}
437
438impl Node for SetTypeNode {
439    fn as_any(&self) -> &dyn Any {
440        self
441    }
442
443    fn range(&self) -> Range {
444        self.range.clone()
445    }
446
447    fn children(&self) -> Vec<&dyn Node> {
448        vec![self.type_node.as_ref().deref()]
449    }
450}
451
452impl Node for ListTypeNode {
453    fn as_any(&self) -> &dyn Any {
454        self
455    }
456
457    fn range(&self) -> Range {
458        self.range.clone()
459    }
460
461    fn children(&self) -> Vec<&dyn Node> {
462        vec![self.type_node.as_ref().deref()]
463    }
464}
465
466impl Node for ConstValueNode {
467    fn as_any(&self) -> &dyn Any {
468        self
469    }
470
471    fn range(&self) -> Range {
472        self.range.clone()
473    }
474
475    fn children(&self) -> Vec<&dyn Node> {
476        Vec::new()
477    }
478}
479
480impl Node for TypedefNode {
481    fn as_any(&self) -> &dyn Any {
482        self
483    }
484
485    fn range(&self) -> Range {
486        self.range.clone()
487    }
488
489    fn children(&self) -> Vec<&dyn Node> {
490        vec![self.definition_type.deref(), &self.identifier as &dyn Node]
491    }
492}
493
494impl Node for EnumNode {
495    fn as_any(&self) -> &dyn Any {
496        self
497    }
498
499    fn range(&self) -> Range {
500        self.range.clone()
501    }
502
503    fn children(&self) -> Vec<&dyn Node> {
504        let mut children = Vec::new();
505        children.push(&self.identifier as &dyn Node);
506        children.extend(self.values.iter().map(|v| v as &dyn Node));
507        children
508    }
509}
510
511impl Node for EnumValueNode {
512    fn as_any(&self) -> &dyn Any {
513        self
514    }
515
516    fn range(&self) -> Range {
517        self.range.clone()
518    }
519
520    fn children(&self) -> Vec<&dyn Node> {
521        let mut children = Vec::new();
522        if let Some(ext) = &self.ext {
523            children.push(ext as &dyn Node);
524        }
525        children
526    }
527}
528
529impl Node for StructNode {
530    fn as_any(&self) -> &dyn Any {
531        self
532    }
533
534    fn range(&self) -> Range {
535        self.range.clone()
536    }
537
538    fn children(&self) -> Vec<&dyn Node> {
539        let mut children = Vec::new();
540        children.push(&self.identifier as &dyn Node);
541        children.extend(self.fields.iter().map(|f| f as &dyn Node));
542        if let Some(ext) = &self.ext {
543            children.push(ext as &dyn Node);
544        }
545        children
546    }
547}
548
549impl Node for FieldNode {
550    fn as_any(&self) -> &dyn Any {
551        self
552    }
553
554    fn range(&self) -> Range {
555        self.range.clone()
556    }
557
558    fn children(&self) -> Vec<&dyn Node> {
559        let mut children = Vec::new();
560        if let Some(field_id) = &self.field_id {
561            children.push(field_id as &dyn Node);
562        }
563        children.push(self.field_type.deref());
564        children.push(&self.identifier as &dyn Node);
565        if let Some(default_value) = &self.default_value {
566            children.push(default_value as &dyn Node);
567        }
568        if let Some(ext) = &self.ext {
569            children.push(ext as &dyn Node);
570        }
571        children
572    }
573}
574
575impl Node for FieldIdNode {
576    fn as_any(&self) -> &dyn Any {
577        self
578    }
579
580    fn range(&self) -> Range {
581        self.range.clone()
582    }
583
584    fn children(&self) -> Vec<&dyn Node> {
585        Vec::new()
586    }
587}
588
589impl Node for UnionNode {
590    fn as_any(&self) -> &dyn Any {
591        self
592    }
593
594    fn range(&self) -> Range {
595        self.range.clone()
596    }
597
598    fn children(&self) -> Vec<&dyn Node> {
599        let mut children = Vec::new();
600        children.push(&self.identifier as &dyn Node);
601        children.extend(self.fields.iter().map(|f| f as &dyn Node));
602        children
603    }
604}
605
606impl Node for ExceptionNode {
607    fn as_any(&self) -> &dyn Any {
608        self
609    }
610
611    fn range(&self) -> Range {
612        self.range.clone()
613    }
614
615    fn children(&self) -> Vec<&dyn Node> {
616        let mut children = Vec::new();
617        children.push(&self.identifier as &dyn Node);
618        children.extend(self.fields.iter().map(|f| f as &dyn Node));
619        children
620    }
621}
622
623impl Node for ServiceNode {
624    fn as_any(&self) -> &dyn Any {
625        self
626    }
627
628    fn range(&self) -> Range {
629        self.range.clone()
630    }
631
632    fn children(&self) -> Vec<&dyn Node> {
633        let mut children = Vec::new();
634        children.push(&self.identifier as &dyn Node);
635        if let Some(extends) = &self.extends {
636            children.push(extends as &dyn Node);
637        }
638        children.extend(self.functions.iter().map(|f| f as &dyn Node));
639        children
640    }
641}
642
643impl Node for FunctionNode {
644    fn as_any(&self) -> &dyn Any {
645        self
646    }
647
648    fn range(&self) -> Range {
649        self.range.clone()
650    }
651
652    fn children(&self) -> Vec<&dyn Node> {
653        let mut children = Vec::new();
654        if let Some(function_type) = &self.function_type {
655            children.push(function_type.deref());
656        }
657        children.push(&self.identifier as &dyn Node);
658        children.extend(self.fields.iter().map(|f| f as &dyn Node));
659        if let Some(throws) = &self.throws {
660            children.extend(throws.iter().map(|f| f as &dyn Node));
661        }
662        if let Some(ext) = &self.ext {
663            children.push(ext as &dyn Node);
664        }
665        children
666    }
667}
668
669impl Node for ExtNode {
670    fn as_any(&self) -> &dyn Any {
671        self
672    }
673
674    fn range(&self) -> Range {
675        self.range.clone()
676    }
677
678    fn children(&self) -> Vec<&dyn Node> {
679        Vec::new()
680    }
681}
thrift_analyzer/analyzer/ast.rs

thrift_analyzer/analyzer/
ast.rs
