Skip to main content

tsz_parser/parser/
node_arena.rs

1//! `NodeArena` creation methods (`add_*` methods).
2//!
3//! This module contains all node creation and initialization methods for `NodeArena`.
4
5use super::base::{NodeIndex, NodeList};
6use super::node::{
7    AccessExprData, AccessorData, ArrayTypeData, BinaryExprData, BindingElementData,
8    BindingPatternData, BlockData, CallExprData, CaseClauseData, CatchClauseData, ClassData,
9    CompositeTypeData, ComputedPropertyData, ConditionalExprData, ConditionalTypeData,
10    ConstructorData, DecoratorData, EnumData, EnumMemberData, ExportAssignmentData, ExportDeclData,
11    ExprStatementData, ExprWithTypeArgsData, ExtendedNodeInfo, ForInOfData, FunctionData,
12    FunctionTypeData, HeritageData, IdentifierData, IfStatementData, ImportAttributeData,
13    ImportAttributesData, ImportClauseData, ImportDeclData, IndexSignatureData,
14    IndexedAccessTypeData, InferTypeData, InterfaceData, JsxAttributeData, JsxAttributesData,
15    JsxClosingData, JsxElementData, JsxExpressionData, JsxFragmentData, JsxNamespacedNameData,
16    JsxOpeningData, JsxSpreadAttributeData, JsxTextData, JumpData, LabeledData, LiteralData,
17    LiteralExprData, LiteralTypeData, LoopData, MappedTypeData, MethodDeclData, ModuleBlockData,
18    ModuleData, NamedImportsData, NamedTupleMemberData, Node, NodeArena, ParameterData,
19    ParenthesizedData, PropertyAssignmentData, PropertyDeclData, QualifiedNameData, ReturnData,
20    ShorthandPropertyData, SignatureData, SourceFileData, SpecifierData, SpreadData, SwitchData,
21    TaggedTemplateData, TemplateExprData, TemplateLiteralTypeData, TemplateSpanData, TryData,
22    TupleTypeData, TypeAliasData, TypeAssertionData, TypeLiteralData, TypeOperatorData,
23    TypeParameterData, TypePredicateData, TypeQueryData, TypeRefData, UnaryExprData,
24    UnaryExprDataEx, VariableData, VariableDeclarationData, WithData, WrappedTypeData,
25};
26
27use tsz_common::interner::{Atom, Interner};
28
29impl NodeArena {
30    /// Maximum pre-allocation to avoid capacity overflow in huge files.
31    const MAX_NODE_PREALLOC: usize = 5_000_000;
32    #[must_use]
33    pub fn new() -> Self {
34        Self::default()
35    }
36
37    /// Set the interner (called after parsing to transfer ownership from scanner)
38    pub fn set_interner(&mut self, interner: Interner) {
39        self.interner = interner;
40    }
41
42    /// Get a reference to the interner
43    #[must_use]
44    pub const fn interner(&self) -> &Interner {
45        &self.interner
46    }
47
48    /// Resolve an identifier text using `Atom` (fast) or `escaped_text` (fallback).
49    #[inline]
50    #[must_use]
51    pub fn resolve_identifier_text<'a>(&'a self, data: &'a IdentifierData) -> &'a str {
52        if data.atom == Atom::NONE {
53            &data.escaped_text
54        } else {
55            self.interner.resolve(data.atom)
56        }
57    }
58
59    /// Create an arena with pre-allocated capacity.
60    /// Uses heuristic ratios based on typical TypeScript AST composition.
61    #[must_use]
62    pub fn with_capacity(capacity: usize) -> Self {
63        let safe_capacity = capacity.min(Self::MAX_NODE_PREALLOC);
64        // Use Default for all the new pools, just set capacity for main ones
65        Self {
66            nodes: Vec::with_capacity(safe_capacity),
67            extended_info: Vec::with_capacity(safe_capacity),
68            identifiers: Vec::with_capacity(safe_capacity / 4), // ~25% identifiers
69            literals: Vec::with_capacity(safe_capacity / 8),    // ~12% literals
70            binary_exprs: Vec::with_capacity(safe_capacity / 8), // ~12% binary
71            call_exprs: Vec::with_capacity(safe_capacity / 8),  // ~12% calls
72            access_exprs: Vec::with_capacity(safe_capacity / 8), // ~12% property access
73            blocks: Vec::with_capacity(safe_capacity / 8),      // ~12% blocks
74            variables: Vec::with_capacity(safe_capacity / 16),  // ~6% variables
75            functions: Vec::with_capacity(safe_capacity / 16),  // ~6% functions
76            type_refs: Vec::with_capacity(safe_capacity / 8),   // ~12% type refs
77            source_files: Vec::with_capacity(1),                // Usually 1
78            ..Default::default()
79        }
80    }
81
82    pub fn clear(&mut self) {
83        macro_rules! clear_vecs {
84            ($($field:ident),+ $(,)?) => {
85                $(self.$field.clear();)+
86            };
87        }
88
89        clear_vecs!(
90            nodes,
91            identifiers,
92            qualified_names,
93            computed_properties,
94            literals,
95            binary_exprs,
96            unary_exprs,
97            call_exprs,
98            access_exprs,
99            conditional_exprs,
100            literal_exprs,
101            parenthesized,
102            unary_exprs_ex,
103            type_assertions,
104            template_exprs,
105            template_spans,
106            tagged_templates,
107            functions,
108            classes,
109            interfaces,
110            type_aliases,
111            enums,
112            enum_members,
113            modules,
114            module_blocks,
115            signatures,
116            index_signatures,
117            property_decls,
118            method_decls,
119            constructors,
120            accessors,
121            parameters,
122            type_parameters,
123            decorators,
124            heritage_clauses,
125            expr_with_type_args,
126            if_statements,
127            loops,
128            blocks,
129            variables,
130            return_data,
131            expr_statements,
132            switch_data,
133            case_clauses,
134            try_data,
135            catch_clauses,
136            labeled_data,
137            jump_data,
138            with_data,
139            type_refs,
140            composite_types,
141            function_types,
142            type_queries,
143            type_literals,
144            array_types,
145            tuple_types,
146            wrapped_types,
147            conditional_types,
148            infer_types,
149            type_operators,
150            indexed_access_types,
151            mapped_types,
152            literal_types,
153            template_literal_types,
154            named_tuple_members,
155            type_predicates,
156            import_decls,
157            import_clauses,
158            named_imports,
159            specifiers,
160            export_decls,
161            export_assignments,
162            import_attributes,
163            import_attribute,
164            binding_patterns,
165            binding_elements,
166            property_assignments,
167            shorthand_properties,
168            spread_data,
169            variable_declarations,
170            for_in_of,
171            jsx_elements,
172            jsx_opening,
173            jsx_closing,
174            jsx_fragments,
175            jsx_attributes,
176            jsx_attribute,
177            jsx_spread_attributes,
178            jsx_expressions,
179            jsx_text,
180            jsx_namespaced_names,
181            source_files,
182            extended_info,
183        );
184    }
185
186    #[inline]
187    #[must_use]
188    fn len_u32(&self, len: usize) -> u32 {
189        let _ = self;
190        u32::try_from(len).expect("node arena length exceeds u32::MAX")
191    }
192
193    // ============================================================================
194    // Parent Mapping Helpers
195    // ============================================================================
196
197    /// Set the parent for a single child node.
198    /// This is called during node creation to maintain parent pointers.
199    #[inline]
200    fn set_parent(&mut self, child: NodeIndex, parent: NodeIndex) {
201        if child.is_some() {
202            // Safety: child index is guaranteed to be valid and < current index
203            // because we build bottom-up (children are created before parents).
204            if let Some(info) = self.extended_info.get_mut(child.0 as usize) {
205                info.parent = parent;
206            }
207        }
208    }
209
210    /// Set the parent for a list of children.
211    #[inline]
212    fn set_parent_list(&mut self, list: &NodeList, parent: NodeIndex) {
213        for &child in &list.nodes {
214            self.set_parent(child, parent);
215        }
216    }
217
218    /// Set the parent for an optional list of children.
219    #[inline]
220    fn set_parent_opt_list(&mut self, list: Option<&NodeList>, parent: NodeIndex) {
221        if let Some(l) = list {
222            self.set_parent_list(l, parent);
223        }
224    }
225
226    // ============================================================================
227    // Node Creation Methods
228    // ============================================================================
229
230    /// Add a token node (no additional data)
231    pub fn add_token(&mut self, kind: u16, pos: u32, end: u32) -> NodeIndex {
232        let index = self.len_u32(self.nodes.len());
233        self.nodes.push(Node::new(kind, pos, end));
234        self.extended_info.push(ExtendedNodeInfo::default());
235        NodeIndex(index)
236    }
237
238    /// Create a modifier token (static, public, private, etc.)
239    pub fn create_modifier(&mut self, kind: tsz_scanner::SyntaxKind, pos: u32) -> NodeIndex {
240        // Modifiers are simple tokens, their kind IS the modifier type
241        // End position is pos + keyword length
242        let end = pos
243            + match kind {
244                tsz_scanner::SyntaxKind::AsyncKeyword | tsz_scanner::SyntaxKind::ConstKeyword => 5,
245                tsz_scanner::SyntaxKind::StaticKeyword
246                | tsz_scanner::SyntaxKind::PublicKeyword
247                | tsz_scanner::SyntaxKind::ExportKeyword => 6,
248                tsz_scanner::SyntaxKind::PrivateKeyword
249                | tsz_scanner::SyntaxKind::DefaultKeyword
250                | tsz_scanner::SyntaxKind::DeclareKeyword => 7,
251                tsz_scanner::SyntaxKind::ReadonlyKeyword
252                | tsz_scanner::SyntaxKind::AbstractKeyword
253                | tsz_scanner::SyntaxKind::OverrideKeyword => 8,
254                tsz_scanner::SyntaxKind::ProtectedKeyword => 9,
255                _ => 0,
256            };
257        self.add_token(kind as u16, pos, end)
258    }
259
260    /// Add an identifier node
261    pub fn add_identifier(
262        &mut self,
263        kind: u16,
264        pos: u32,
265        end: u32,
266        data: IdentifierData,
267    ) -> NodeIndex {
268        let data_index = self.len_u32(self.identifiers.len());
269        self.identifiers.push(data);
270        let index = self.len_u32(self.nodes.len());
271        self.nodes.push(Node::with_data(kind, pos, end, data_index));
272        self.extended_info.push(ExtendedNodeInfo::default());
273        NodeIndex(index)
274    }
275
276    /// Add a literal node
277    pub fn add_literal(&mut self, kind: u16, pos: u32, end: u32, data: LiteralData) -> NodeIndex {
278        let data_index = self.len_u32(self.literals.len());
279        self.literals.push(data);
280        let index = self.len_u32(self.nodes.len());
281        self.nodes.push(Node::with_data(kind, pos, end, data_index));
282        self.extended_info.push(ExtendedNodeInfo::default());
283        NodeIndex(index)
284    }
285
286    /// Add a binary expression
287    pub fn add_binary_expr(
288        &mut self,
289        kind: u16,
290        pos: u32,
291        end: u32,
292        data: BinaryExprData,
293    ) -> NodeIndex {
294        let left = data.left;
295        let right = data.right;
296
297        let data_index = self.len_u32(self.binary_exprs.len());
298        self.binary_exprs.push(data);
299        let index = self.len_u32(self.nodes.len());
300        self.nodes.push(Node::with_data(kind, pos, end, data_index));
301        self.extended_info.push(ExtendedNodeInfo::default());
302
303        let parent = NodeIndex(index);
304        self.set_parent(left, parent);
305        self.set_parent(right, parent);
306
307        parent
308    }
309
310    /// Add a call expression
311    pub fn add_call_expr(
312        &mut self,
313        kind: u16,
314        pos: u32,
315        end: u32,
316        data: CallExprData,
317    ) -> NodeIndex {
318        let expression = data.expression;
319        let type_arguments = data.type_arguments.clone();
320        let arguments = data.arguments.clone();
321
322        let data_index = self.len_u32(self.call_exprs.len());
323        self.call_exprs.push(data);
324        let index = self.len_u32(self.nodes.len());
325        self.nodes.push(Node::with_data(kind, pos, end, data_index));
326        self.extended_info.push(ExtendedNodeInfo::default());
327
328        let parent = NodeIndex(index);
329        self.set_parent(expression, parent);
330        self.set_parent_opt_list(type_arguments.as_ref(), parent);
331        self.set_parent_opt_list(arguments.as_ref(), parent);
332
333        parent
334    }
335
336    /// Add a function node
337    pub fn add_function(&mut self, kind: u16, pos: u32, end: u32, data: FunctionData) -> NodeIndex {
338        let modifiers = data.modifiers.clone();
339        let name = data.name;
340        let type_parameters = data.type_parameters.clone();
341        let parameters = data.parameters.clone();
342        let type_annotation = data.type_annotation;
343        let body = data.body;
344
345        let data_index = self.len_u32(self.functions.len());
346        self.functions.push(data);
347        let index = self.len_u32(self.nodes.len());
348        self.nodes.push(Node::with_data(kind, pos, end, data_index));
349        self.extended_info.push(ExtendedNodeInfo::default());
350
351        let parent = NodeIndex(index);
352        self.set_parent_opt_list(modifiers.as_ref(), parent);
353        self.set_parent(name, parent);
354        self.set_parent_opt_list(type_parameters.as_ref(), parent);
355        self.set_parent_list(&parameters, parent);
356        self.set_parent(type_annotation, parent);
357        self.set_parent(body, parent);
358
359        parent
360    }
361
362    /// Add a class node
363    pub fn add_class(&mut self, kind: u16, pos: u32, end: u32, data: ClassData) -> NodeIndex {
364        let modifiers = data.modifiers.clone();
365        let name = data.name;
366        let type_parameters = data.type_parameters.clone();
367        let heritage_clauses = data.heritage_clauses.clone();
368        let members = data.members.clone();
369
370        let data_index = self.len_u32(self.classes.len());
371        self.classes.push(data);
372        let index = self.len_u32(self.nodes.len());
373        self.nodes.push(Node::with_data(kind, pos, end, data_index));
374        self.extended_info.push(ExtendedNodeInfo::default());
375
376        let parent = NodeIndex(index);
377        self.set_parent_opt_list(modifiers.as_ref(), parent);
378        self.set_parent(name, parent);
379        self.set_parent_opt_list(type_parameters.as_ref(), parent);
380        self.set_parent_opt_list(heritage_clauses.as_ref(), parent);
381        self.set_parent_list(&members, parent);
382
383        parent
384    }
385
386    /// Add a block node
387    pub fn add_block(&mut self, kind: u16, pos: u32, end: u32, data: BlockData) -> NodeIndex {
388        let statements = data.statements.clone();
389
390        let data_index = self.len_u32(self.blocks.len());
391        self.blocks.push(data);
392        let index = self.len_u32(self.nodes.len());
393        self.nodes.push(Node::with_data(kind, pos, end, data_index));
394        self.extended_info.push(ExtendedNodeInfo::default());
395
396        let parent = NodeIndex(index);
397        self.set_parent_list(&statements, parent);
398
399        parent
400    }
401
402    /// Add a source file node
403    pub fn add_source_file(&mut self, pos: u32, end: u32, data: SourceFileData) -> NodeIndex {
404        use super::syntax_kind_ext::SOURCE_FILE;
405        let statements = data.statements.clone();
406        let end_of_file_token = data.end_of_file_token;
407
408        let data_index = self.len_u32(self.source_files.len());
409        self.source_files.push(data);
410        let index = self.len_u32(self.nodes.len());
411        self.nodes
412            .push(Node::with_data(SOURCE_FILE, pos, end, data_index));
413        self.extended_info.push(ExtendedNodeInfo::default());
414
415        let parent = NodeIndex(index);
416        self.set_parent_list(&statements, parent);
417        self.set_parent(end_of_file_token, parent);
418
419        parent
420    }
421
422    // ==========================================================================
423    // Additional add_* methods for all data pools
424    // ==========================================================================
425
426    /// Add a qualified name node
427    pub fn add_qualified_name(
428        &mut self,
429        kind: u16,
430        pos: u32,
431        end: u32,
432        data: QualifiedNameData,
433    ) -> NodeIndex {
434        let left = data.left;
435        let right = data.right;
436
437        let data_index = self.len_u32(self.qualified_names.len());
438        self.qualified_names.push(data);
439        let index = self.len_u32(self.nodes.len());
440        self.nodes.push(Node::with_data(kind, pos, end, data_index));
441        self.extended_info.push(ExtendedNodeInfo::default());
442
443        let parent = NodeIndex(index);
444        self.set_parent(left, parent);
445        self.set_parent(right, parent);
446
447        parent
448    }
449
450    /// Add a computed property name node
451    pub fn add_computed_property(
452        &mut self,
453        kind: u16,
454        pos: u32,
455        end: u32,
456        data: ComputedPropertyData,
457    ) -> NodeIndex {
458        let expression = data.expression;
459
460        let data_index = self.len_u32(self.computed_properties.len());
461        self.computed_properties.push(data);
462        let index = self.len_u32(self.nodes.len());
463        self.nodes.push(Node::with_data(kind, pos, end, data_index));
464        self.extended_info.push(ExtendedNodeInfo::default());
465        let parent = NodeIndex(index);
466        self.set_parent(expression, parent);
467        parent
468    }
469
470    /// Add a unary expression node
471    pub fn add_unary_expr(
472        &mut self,
473        kind: u16,
474        pos: u32,
475        end: u32,
476        data: UnaryExprData,
477    ) -> NodeIndex {
478        let operand = data.operand;
479
480        let data_index = self.len_u32(self.unary_exprs.len());
481        self.unary_exprs.push(data);
482        let index = self.len_u32(self.nodes.len());
483        self.nodes.push(Node::with_data(kind, pos, end, data_index));
484        self.extended_info.push(ExtendedNodeInfo::default());
485
486        let parent = NodeIndex(index);
487        self.set_parent(operand, parent);
488
489        parent
490    }
491
492    /// Add a property/element access expression node
493    pub fn add_access_expr(
494        &mut self,
495        kind: u16,
496        pos: u32,
497        end: u32,
498        data: AccessExprData,
499    ) -> NodeIndex {
500        let expression = data.expression;
501        let name_or_argument = data.name_or_argument;
502
503        let data_index = self.len_u32(self.access_exprs.len());
504        self.access_exprs.push(data);
505        let index = self.len_u32(self.nodes.len());
506        self.nodes.push(Node::with_data(kind, pos, end, data_index));
507        self.extended_info.push(ExtendedNodeInfo::default());
508
509        let parent = NodeIndex(index);
510        self.set_parent(expression, parent);
511        self.set_parent(name_or_argument, parent);
512
513        parent
514    }
515
516    /// Add a conditional expression node (a ? b : c)
517    pub fn add_conditional_expr(
518        &mut self,
519        kind: u16,
520        pos: u32,
521        end: u32,
522        data: ConditionalExprData,
523    ) -> NodeIndex {
524        let condition = data.condition;
525        let when_true = data.when_true;
526        let when_false = data.when_false;
527
528        let data_index = self.len_u32(self.conditional_exprs.len());
529        self.conditional_exprs.push(data);
530        let index = self.len_u32(self.nodes.len());
531        self.nodes.push(Node::with_data(kind, pos, end, data_index));
532        self.extended_info.push(ExtendedNodeInfo::default());
533        let parent = NodeIndex(index);
534        self.set_parent(condition, parent);
535        self.set_parent(when_true, parent);
536        self.set_parent(when_false, parent);
537        parent
538    }
539
540    /// Add an object/array literal expression node
541    pub fn add_literal_expr(
542        &mut self,
543        kind: u16,
544        pos: u32,
545        end: u32,
546        data: LiteralExprData,
547    ) -> NodeIndex {
548        let elements = data.elements.clone();
549
550        let data_index = self.len_u32(self.literal_exprs.len());
551        self.literal_exprs.push(data);
552        let index = self.len_u32(self.nodes.len());
553        self.nodes.push(Node::with_data(kind, pos, end, data_index));
554        self.extended_info.push(ExtendedNodeInfo::default());
555        let parent = NodeIndex(index);
556        self.set_parent_list(&elements, parent);
557        parent
558    }
559
560    /// Add a parenthesized expression node
561    pub fn add_parenthesized(
562        &mut self,
563        kind: u16,
564        pos: u32,
565        end: u32,
566        data: ParenthesizedData,
567    ) -> NodeIndex {
568        let expression = data.expression;
569        let data_index = self.len_u32(self.parenthesized.len());
570        self.parenthesized.push(data);
571        let index = self.len_u32(self.nodes.len());
572        self.nodes.push(Node::with_data(kind, pos, end, data_index));
573        self.extended_info.push(ExtendedNodeInfo::default());
574        let parent = NodeIndex(index);
575        self.set_parent(expression, parent);
576        parent
577    }
578
579    /// Add a spread/await/yield expression node
580    pub fn add_unary_expr_ex(
581        &mut self,
582        kind: u16,
583        pos: u32,
584        end: u32,
585        data: UnaryExprDataEx,
586    ) -> NodeIndex {
587        let expression = data.expression;
588        let data_index = self.len_u32(self.unary_exprs_ex.len());
589        self.unary_exprs_ex.push(data);
590        let index = self.len_u32(self.nodes.len());
591        self.nodes.push(Node::with_data(kind, pos, end, data_index));
592        self.extended_info.push(ExtendedNodeInfo::default());
593        let parent = NodeIndex(index);
594        self.set_parent(expression, parent);
595        parent
596    }
597
598    /// Add a type assertion expression node
599    pub fn add_type_assertion(
600        &mut self,
601        kind: u16,
602        pos: u32,
603        end: u32,
604        data: TypeAssertionData,
605    ) -> NodeIndex {
606        let expression = data.expression;
607        let type_node = data.type_node;
608        let data_index = self.len_u32(self.type_assertions.len());
609        self.type_assertions.push(data);
610        let index = self.len_u32(self.nodes.len());
611        self.nodes.push(Node::with_data(kind, pos, end, data_index));
612        self.extended_info.push(ExtendedNodeInfo::default());
613
614        let parent = NodeIndex(index);
615        self.set_parent(expression, parent);
616        self.set_parent(type_node, parent);
617        parent
618    }
619
620    /// Add a template expression node
621    pub fn add_template_expr(
622        &mut self,
623        kind: u16,
624        pos: u32,
625        end: u32,
626        data: TemplateExprData,
627    ) -> NodeIndex {
628        let head = data.head;
629        let template_spans = data.template_spans.clone();
630
631        let data_index = self.len_u32(self.template_exprs.len());
632        self.template_exprs.push(data);
633        let index = self.len_u32(self.nodes.len());
634        self.nodes.push(Node::with_data(kind, pos, end, data_index));
635        self.extended_info.push(ExtendedNodeInfo::default());
636
637        let parent = NodeIndex(index);
638        self.set_parent(head, parent);
639        self.set_parent_list(&template_spans, parent);
640
641        parent
642    }
643
644    /// Add a template span node
645    pub fn add_template_span(
646        &mut self,
647        kind: u16,
648        pos: u32,
649        end: u32,
650        data: TemplateSpanData,
651    ) -> NodeIndex {
652        let expression = data.expression;
653        let literal = data.literal;
654
655        let data_index = self.len_u32(self.template_spans.len());
656        self.template_spans.push(data);
657        let index = self.len_u32(self.nodes.len());
658        self.nodes.push(Node::with_data(kind, pos, end, data_index));
659        self.extended_info.push(ExtendedNodeInfo::default());
660
661        let parent = NodeIndex(index);
662        self.set_parent(expression, parent);
663        self.set_parent(literal, parent);
664
665        parent
666    }
667
668    /// Add a tagged template expression node
669    pub fn add_tagged_template(
670        &mut self,
671        kind: u16,
672        pos: u32,
673        end: u32,
674        data: TaggedTemplateData,
675    ) -> NodeIndex {
676        let tag = data.tag;
677        let type_arguments = data.type_arguments.clone();
678        let template = data.template;
679
680        let data_index = self.len_u32(self.tagged_templates.len());
681        self.tagged_templates.push(data);
682        let index = self.len_u32(self.nodes.len());
683        self.nodes.push(Node::with_data(kind, pos, end, data_index));
684        self.extended_info.push(ExtendedNodeInfo::default());
685
686        let parent = NodeIndex(index);
687        self.set_parent(tag, parent);
688        self.set_parent_opt_list(type_arguments.as_ref(), parent);
689        self.set_parent(template, parent);
690
691        parent
692    }
693
694    /// Add an interface declaration node
695    pub fn add_interface(
696        &mut self,
697        kind: u16,
698        pos: u32,
699        end: u32,
700        data: InterfaceData,
701    ) -> NodeIndex {
702        let modifiers = data.modifiers.clone();
703        let name = data.name;
704        let type_parameters = data.type_parameters.clone();
705        let heritage_clauses = data.heritage_clauses.clone();
706        let members = data.members.clone();
707
708        let data_index = self.len_u32(self.interfaces.len());
709        self.interfaces.push(data);
710        let index = self.len_u32(self.nodes.len());
711        self.nodes.push(Node::with_data(kind, pos, end, data_index));
712        self.extended_info.push(ExtendedNodeInfo::default());
713
714        let parent = NodeIndex(index);
715        self.set_parent_opt_list(modifiers.as_ref(), parent);
716        self.set_parent(name, parent);
717        self.set_parent_opt_list(type_parameters.as_ref(), parent);
718        self.set_parent_opt_list(heritage_clauses.as_ref(), parent);
719        self.set_parent_list(&members, parent);
720
721        parent
722    }
723
724    /// Add a type alias declaration node
725    pub fn add_type_alias(
726        &mut self,
727        kind: u16,
728        pos: u32,
729        end: u32,
730        data: TypeAliasData,
731    ) -> NodeIndex {
732        let modifiers = data.modifiers.clone();
733        let name = data.name;
734        let type_parameters = data.type_parameters.clone();
735        let type_node = data.type_node;
736
737        let data_index = self.len_u32(self.type_aliases.len());
738        self.type_aliases.push(data);
739        let index = self.len_u32(self.nodes.len());
740        self.nodes.push(Node::with_data(kind, pos, end, data_index));
741        self.extended_info.push(ExtendedNodeInfo::default());
742
743        let parent = NodeIndex(index);
744        self.set_parent_opt_list(modifiers.as_ref(), parent);
745        self.set_parent(name, parent);
746        self.set_parent_opt_list(type_parameters.as_ref(), parent);
747        self.set_parent(type_node, parent);
748
749        parent
750    }
751
752    /// Add an enum declaration node
753    pub fn add_enum(&mut self, kind: u16, pos: u32, end: u32, data: EnumData) -> NodeIndex {
754        let modifiers = data.modifiers.clone();
755        let name = data.name;
756        let members = data.members.clone();
757
758        let data_index = self.len_u32(self.enums.len());
759        self.enums.push(data);
760        let index = self.len_u32(self.nodes.len());
761        self.nodes.push(Node::with_data(kind, pos, end, data_index));
762        self.extended_info.push(ExtendedNodeInfo::default());
763
764        let parent = NodeIndex(index);
765        self.set_parent_opt_list(modifiers.as_ref(), parent);
766        self.set_parent(name, parent);
767        self.set_parent_list(&members, parent);
768
769        parent
770    }
771
772    /// Add an enum member node
773    pub fn add_enum_member(
774        &mut self,
775        kind: u16,
776        pos: u32,
777        end: u32,
778        data: EnumMemberData,
779    ) -> NodeIndex {
780        let name = data.name;
781        let initializer = data.initializer;
782
783        let data_index = self.len_u32(self.enum_members.len());
784        self.enum_members.push(data);
785        let index = self.len_u32(self.nodes.len());
786        self.nodes.push(Node::with_data(kind, pos, end, data_index));
787        self.extended_info.push(ExtendedNodeInfo::default());
788
789        let parent = NodeIndex(index);
790        self.set_parent(name, parent);
791        self.set_parent(initializer, parent);
792
793        parent
794    }
795
796    /// Add a module declaration node
797    pub fn add_module(&mut self, kind: u16, pos: u32, end: u32, data: ModuleData) -> NodeIndex {
798        let modifiers = data.modifiers.clone();
799        let name = data.name;
800        let body = data.body;
801
802        let data_index = self.len_u32(self.modules.len());
803        self.modules.push(data);
804        let index = self.len_u32(self.nodes.len());
805        self.nodes.push(Node::with_data(kind, pos, end, data_index));
806        self.extended_info.push(ExtendedNodeInfo::default());
807
808        let parent = NodeIndex(index);
809        self.set_parent_opt_list(modifiers.as_ref(), parent);
810        self.set_parent(name, parent);
811        self.set_parent(body, parent);
812
813        parent
814    }
815
816    /// Add a module block node: { statements }
817    pub fn add_module_block(
818        &mut self,
819        kind: u16,
820        pos: u32,
821        end: u32,
822        data: ModuleBlockData,
823    ) -> NodeIndex {
824        let statements = data.statements.clone();
825
826        let data_index = self.len_u32(self.module_blocks.len());
827        self.module_blocks.push(data);
828        let index = self.len_u32(self.nodes.len());
829        self.nodes.push(Node::with_data(kind, pos, end, data_index));
830        self.extended_info.push(ExtendedNodeInfo::default());
831
832        let parent = NodeIndex(index);
833        self.set_parent_opt_list(statements.as_ref(), parent);
834
835        parent
836    }
837
838    /// Add a signature node (property/method signature)
839    pub fn add_signature(
840        &mut self,
841        kind: u16,
842        pos: u32,
843        end: u32,
844        data: SignatureData,
845    ) -> NodeIndex {
846        let modifiers = data.modifiers.clone();
847        let name = data.name;
848        let type_parameters = data.type_parameters.clone();
849        let parameters = data.parameters.clone();
850        let type_annotation = data.type_annotation;
851
852        let data_index = self.len_u32(self.signatures.len());
853        self.signatures.push(data);
854        let index = self.len_u32(self.nodes.len());
855        self.nodes.push(Node::with_data(kind, pos, end, data_index));
856        self.extended_info.push(ExtendedNodeInfo::default());
857
858        let parent = NodeIndex(index);
859        self.set_parent_opt_list(modifiers.as_ref(), parent);
860        self.set_parent(name, parent);
861        self.set_parent_opt_list(type_parameters.as_ref(), parent);
862        self.set_parent_opt_list(parameters.as_ref(), parent);
863        self.set_parent(type_annotation, parent);
864
865        parent
866    }
867
868    /// Add an index signature node
869    pub fn add_index_signature(
870        &mut self,
871        kind: u16,
872        pos: u32,
873        end: u32,
874        data: IndexSignatureData,
875    ) -> NodeIndex {
876        let modifiers = data.modifiers.clone();
877        let parameters = data.parameters.clone();
878        let type_annotation = data.type_annotation;
879
880        let data_index = self.len_u32(self.index_signatures.len());
881        self.index_signatures.push(data);
882        let index = self.len_u32(self.nodes.len());
883        self.nodes.push(Node::with_data(kind, pos, end, data_index));
884        self.extended_info.push(ExtendedNodeInfo::default());
885
886        let parent = NodeIndex(index);
887        self.set_parent_opt_list(modifiers.as_ref(), parent);
888        self.set_parent_list(&parameters, parent);
889        self.set_parent(type_annotation, parent);
890
891        parent
892    }
893
894    /// Add a property declaration node
895    pub fn add_property_decl(
896        &mut self,
897        kind: u16,
898        pos: u32,
899        end: u32,
900        data: PropertyDeclData,
901    ) -> NodeIndex {
902        let modifiers = data.modifiers.clone();
903        let name = data.name;
904        let type_annotation = data.type_annotation;
905        let initializer = data.initializer;
906
907        let data_index = self.len_u32(self.property_decls.len());
908        self.property_decls.push(data);
909        let index = self.len_u32(self.nodes.len());
910        self.nodes.push(Node::with_data(kind, pos, end, data_index));
911        self.extended_info.push(ExtendedNodeInfo::default());
912        let parent = NodeIndex(index);
913        self.set_parent_opt_list(modifiers.as_ref(), parent);
914        self.set_parent(name, parent);
915        self.set_parent(type_annotation, parent);
916        self.set_parent(initializer, parent);
917        parent
918    }
919
920    /// Add a method declaration node
921    pub fn add_method_decl(
922        &mut self,
923        kind: u16,
924        pos: u32,
925        end: u32,
926        data: MethodDeclData,
927    ) -> NodeIndex {
928        let modifiers = data.modifiers.clone();
929        let name = data.name;
930        let type_parameters = data.type_parameters.clone();
931        let parameters = data.parameters.clone();
932        let type_annotation = data.type_annotation;
933        let body = data.body;
934
935        let data_index = self.len_u32(self.method_decls.len());
936        self.method_decls.push(data);
937        let index = self.len_u32(self.nodes.len());
938        self.nodes.push(Node::with_data(kind, pos, end, data_index));
939        self.extended_info.push(ExtendedNodeInfo::default());
940        let parent = NodeIndex(index);
941        self.set_parent_opt_list(modifiers.as_ref(), parent);
942        self.set_parent(name, parent);
943        self.set_parent_opt_list(type_parameters.as_ref(), parent);
944        self.set_parent_list(&parameters, parent);
945        self.set_parent(type_annotation, parent);
946        self.set_parent(body, parent);
947        parent
948    }
949
950    /// Add a constructor declaration node
951    pub fn add_constructor(
952        &mut self,
953        kind: u16,
954        pos: u32,
955        end: u32,
956        data: ConstructorData,
957    ) -> NodeIndex {
958        let modifiers = data.modifiers.clone();
959        let type_parameters = data.type_parameters.clone();
960        let parameters = data.parameters.clone();
961        let body = data.body;
962
963        let data_index = self.len_u32(self.constructors.len());
964        self.constructors.push(data);
965        let index = self.len_u32(self.nodes.len());
966        self.nodes.push(Node::with_data(kind, pos, end, data_index));
967        self.extended_info.push(ExtendedNodeInfo::default());
968        let parent = NodeIndex(index);
969        self.set_parent_opt_list(modifiers.as_ref(), parent);
970        self.set_parent_opt_list(type_parameters.as_ref(), parent);
971        self.set_parent_list(&parameters, parent);
972        self.set_parent(body, parent);
973        parent
974    }
975
976    /// Add an accessor declaration node (get/set)
977    pub fn add_accessor(&mut self, kind: u16, pos: u32, end: u32, data: AccessorData) -> NodeIndex {
978        let modifiers = data.modifiers.clone();
979        let name = data.name;
980        let type_parameters = data.type_parameters.clone();
981        let parameters = data.parameters.clone();
982        let type_annotation = data.type_annotation;
983        let body = data.body;
984
985        let data_index = self.len_u32(self.accessors.len());
986        self.accessors.push(data);
987        let index = self.len_u32(self.nodes.len());
988        self.nodes.push(Node::with_data(kind, pos, end, data_index));
989        self.extended_info.push(ExtendedNodeInfo::default());
990
991        let parent = NodeIndex(index);
992        self.set_parent_opt_list(modifiers.as_ref(), parent);
993        self.set_parent(name, parent);
994        self.set_parent_opt_list(type_parameters.as_ref(), parent);
995        self.set_parent_list(&parameters, parent);
996        self.set_parent(type_annotation, parent);
997        self.set_parent(body, parent);
998
999        parent
1000    }
1001
1002    /// Add a parameter declaration node
1003    pub fn add_parameter(
1004        &mut self,
1005        kind: u16,
1006        pos: u32,
1007        end: u32,
1008        data: ParameterData,
1009    ) -> NodeIndex {
1010        let name = data.name;
1011        let type_annotation = data.type_annotation;
1012        let initializer = data.initializer;
1013        let modifiers = data.modifiers.clone();
1014        let data_index = self.len_u32(self.parameters.len());
1015        self.parameters.push(data);
1016        let index = self.len_u32(self.nodes.len());
1017        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1018        self.extended_info.push(ExtendedNodeInfo::default());
1019        let parent = NodeIndex(index);
1020        // Set parent pointers for children
1021        self.set_parent(name, parent);
1022        self.set_parent(type_annotation, parent);
1023        self.set_parent(initializer, parent);
1024        self.set_parent_opt_list(modifiers.as_ref(), parent);
1025        parent
1026    }
1027
1028    /// Add a type parameter declaration node
1029    pub fn add_type_parameter(
1030        &mut self,
1031        kind: u16,
1032        pos: u32,
1033        end: u32,
1034        data: TypeParameterData,
1035    ) -> NodeIndex {
1036        let modifiers = data.modifiers.clone();
1037        let name = data.name;
1038        let constraint = data.constraint;
1039        let default = data.default;
1040
1041        let data_index = self.len_u32(self.type_parameters.len());
1042        self.type_parameters.push(data);
1043        let index = self.len_u32(self.nodes.len());
1044        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1045        self.extended_info.push(ExtendedNodeInfo::default());
1046
1047        let parent = NodeIndex(index);
1048        self.set_parent_opt_list(modifiers.as_ref(), parent);
1049        self.set_parent(name, parent);
1050        self.set_parent(constraint, parent);
1051        self.set_parent(default, parent);
1052
1053        parent
1054    }
1055
1056    /// Add a decorator node
1057    pub fn add_decorator(
1058        &mut self,
1059        kind: u16,
1060        pos: u32,
1061        end: u32,
1062        data: DecoratorData,
1063    ) -> NodeIndex {
1064        let expression = data.expression;
1065        let data_index = self.len_u32(self.decorators.len());
1066        self.decorators.push(data);
1067        let index = self.len_u32(self.nodes.len());
1068        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1069        self.extended_info.push(ExtendedNodeInfo::default());
1070        let parent = NodeIndex(index);
1071        self.set_parent(expression, parent);
1072        parent
1073    }
1074
1075    /// Add a heritage clause node
1076    pub fn add_heritage(&mut self, kind: u16, pos: u32, end: u32, data: HeritageData) -> NodeIndex {
1077        let types = data.types.clone();
1078        let data_index = self.len_u32(self.heritage_clauses.len());
1079        self.heritage_clauses.push(data);
1080        let index = self.len_u32(self.nodes.len());
1081        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1082        self.extended_info.push(ExtendedNodeInfo::default());
1083        let parent = NodeIndex(index);
1084        self.set_parent_list(&types, parent);
1085        parent
1086    }
1087
1088    /// Add an expression with type arguments node
1089    pub fn add_expr_with_type_args(
1090        &mut self,
1091        kind: u16,
1092        pos: u32,
1093        end: u32,
1094        data: ExprWithTypeArgsData,
1095    ) -> NodeIndex {
1096        let expression = data.expression;
1097        let type_arguments = data.type_arguments.clone();
1098        let data_index = self.len_u32(self.expr_with_type_args.len());
1099        self.expr_with_type_args.push(data);
1100        let index = self.len_u32(self.nodes.len());
1101        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1102        self.extended_info.push(ExtendedNodeInfo::default());
1103        let parent = NodeIndex(index);
1104        self.set_parent(expression, parent);
1105        self.set_parent_opt_list(type_arguments.as_ref(), parent);
1106        parent
1107    }
1108
1109    /// Add an if statement node
1110    pub fn add_if_statement(
1111        &mut self,
1112        kind: u16,
1113        pos: u32,
1114        end: u32,
1115        data: IfStatementData,
1116    ) -> NodeIndex {
1117        let expression = data.expression;
1118        let then_statement = data.then_statement;
1119        let else_statement = data.else_statement;
1120
1121        let data_index = self.len_u32(self.if_statements.len());
1122        self.if_statements.push(data);
1123        let index = self.len_u32(self.nodes.len());
1124        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1125        self.extended_info.push(ExtendedNodeInfo::default());
1126
1127        let parent = NodeIndex(index);
1128        self.set_parent(expression, parent);
1129        self.set_parent(then_statement, parent);
1130        self.set_parent(else_statement, parent);
1131
1132        parent
1133    }
1134
1135    /// Add a loop node (for/while/do)
1136    pub fn add_loop(&mut self, kind: u16, pos: u32, end: u32, data: LoopData) -> NodeIndex {
1137        let initializer = data.initializer;
1138        let condition = data.condition;
1139        let incrementor = data.incrementor;
1140        let statement = data.statement;
1141        let data_index = self.len_u32(self.loops.len());
1142        self.loops.push(data);
1143        let index = self.len_u32(self.nodes.len());
1144        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1145        self.extended_info.push(ExtendedNodeInfo::default());
1146        let parent = NodeIndex(index);
1147        self.set_parent(initializer, parent);
1148        self.set_parent(condition, parent);
1149        self.set_parent(incrementor, parent);
1150        self.set_parent(statement, parent);
1151        parent
1152    }
1153
1154    /// Add a variable statement/declaration list node
1155    pub fn add_variable(&mut self, kind: u16, pos: u32, end: u32, data: VariableData) -> NodeIndex {
1156        self.add_variable_with_flags(kind, pos, end, data, 0)
1157    }
1158
1159    /// Add a variable statement/declaration list node with flags
1160    pub fn add_variable_with_flags(
1161        &mut self,
1162        kind: u16,
1163        pos: u32,
1164        end: u32,
1165        data: VariableData,
1166        flags: u16,
1167    ) -> NodeIndex {
1168        let modifiers = data.modifiers.clone();
1169        let declarations = data.declarations.clone();
1170
1171        let data_index = self.len_u32(self.variables.len());
1172        self.variables.push(data);
1173        let index = self.len_u32(self.nodes.len());
1174        self.nodes
1175            .push(Node::with_data_and_flags(kind, pos, end, data_index, flags));
1176        self.extended_info.push(ExtendedNodeInfo::default());
1177
1178        let parent = NodeIndex(index);
1179        self.set_parent_opt_list(modifiers.as_ref(), parent);
1180        self.set_parent_list(&declarations, parent);
1181
1182        parent
1183    }
1184
1185    /// Add a return/throw statement node
1186    pub fn add_return(&mut self, kind: u16, pos: u32, end: u32, data: ReturnData) -> NodeIndex {
1187        let expression = data.expression;
1188
1189        let data_index = self.len_u32(self.return_data.len());
1190        self.return_data.push(data);
1191        let index = self.len_u32(self.nodes.len());
1192        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1193        self.extended_info.push(ExtendedNodeInfo::default());
1194
1195        let parent = NodeIndex(index);
1196        self.set_parent(expression, parent);
1197
1198        parent
1199    }
1200
1201    /// Add an expression statement node
1202    pub fn add_expr_statement(
1203        &mut self,
1204        kind: u16,
1205        pos: u32,
1206        end: u32,
1207        data: ExprStatementData,
1208    ) -> NodeIndex {
1209        let expression = data.expression;
1210        let data_index = self.len_u32(self.expr_statements.len());
1211        self.expr_statements.push(data);
1212        let index = self.len_u32(self.nodes.len());
1213        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1214        self.extended_info.push(ExtendedNodeInfo::default());
1215        let parent = NodeIndex(index);
1216        self.set_parent(expression, parent);
1217        parent
1218    }
1219
1220    /// Add a switch statement node
1221    pub fn add_switch(&mut self, kind: u16, pos: u32, end: u32, data: SwitchData) -> NodeIndex {
1222        let expression = data.expression;
1223        let case_block = data.case_block;
1224        let data_index = self.len_u32(self.switch_data.len());
1225        self.switch_data.push(data);
1226        let index = self.len_u32(self.nodes.len());
1227        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1228        self.extended_info.push(ExtendedNodeInfo::default());
1229        let parent = NodeIndex(index);
1230        self.set_parent(expression, parent);
1231        self.set_parent(case_block, parent);
1232        parent
1233    }
1234
1235    /// Add a case/default clause node
1236    pub fn add_case_clause(
1237        &mut self,
1238        kind: u16,
1239        pos: u32,
1240        end: u32,
1241        data: CaseClauseData,
1242    ) -> NodeIndex {
1243        let expression = data.expression;
1244        let statements = data.statements.clone();
1245        let data_index = self.len_u32(self.case_clauses.len());
1246        self.case_clauses.push(data);
1247        let index = self.len_u32(self.nodes.len());
1248        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1249        self.extended_info.push(ExtendedNodeInfo::default());
1250        let parent = NodeIndex(index);
1251        self.set_parent(expression, parent);
1252        self.set_parent_list(&statements, parent);
1253        parent
1254    }
1255
1256    /// Add a try statement node
1257    pub fn add_try(&mut self, kind: u16, pos: u32, end: u32, data: TryData) -> NodeIndex {
1258        let try_block = data.try_block;
1259        let catch_clause = data.catch_clause;
1260        let finally_block = data.finally_block;
1261        let data_index = self.len_u32(self.try_data.len());
1262        self.try_data.push(data);
1263        let index = self.len_u32(self.nodes.len());
1264        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1265        self.extended_info.push(ExtendedNodeInfo::default());
1266
1267        let parent = NodeIndex(index);
1268        self.set_parent(try_block, parent);
1269        self.set_parent(catch_clause, parent);
1270        self.set_parent(finally_block, parent);
1271        parent
1272    }
1273
1274    /// Add a catch clause node
1275    pub fn add_catch_clause(
1276        &mut self,
1277        kind: u16,
1278        pos: u32,
1279        end: u32,
1280        data: CatchClauseData,
1281    ) -> NodeIndex {
1282        let variable_declaration = data.variable_declaration;
1283        let block = data.block;
1284        let data_index = self.len_u32(self.catch_clauses.len());
1285        self.catch_clauses.push(data);
1286        let index = self.len_u32(self.nodes.len());
1287        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1288        self.extended_info.push(ExtendedNodeInfo::default());
1289
1290        let parent = NodeIndex(index);
1291        self.set_parent(variable_declaration, parent);
1292        self.set_parent(block, parent);
1293
1294        parent
1295    }
1296
1297    /// Add a labeled statement node
1298    pub fn add_labeled(&mut self, kind: u16, pos: u32, end: u32, data: LabeledData) -> NodeIndex {
1299        let label = data.label;
1300        let statement = data.statement;
1301        let data_index = self.len_u32(self.labeled_data.len());
1302        self.labeled_data.push(data);
1303        let index = self.len_u32(self.nodes.len());
1304        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1305        self.extended_info.push(ExtendedNodeInfo::default());
1306
1307        let parent = NodeIndex(index);
1308        self.set_parent(label, parent);
1309        self.set_parent(statement, parent);
1310        parent
1311    }
1312
1313    /// Add a break/continue statement node
1314    pub fn add_jump(&mut self, kind: u16, pos: u32, end: u32, data: JumpData) -> NodeIndex {
1315        let label = data.label;
1316        let data_index = self.len_u32(self.jump_data.len());
1317        self.jump_data.push(data);
1318        let index = self.len_u32(self.nodes.len());
1319        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1320        self.extended_info.push(ExtendedNodeInfo::default());
1321
1322        let parent = NodeIndex(index);
1323        self.set_parent(label, parent);
1324        parent
1325    }
1326
1327    /// Add a with statement node
1328    pub fn add_with(&mut self, kind: u16, pos: u32, end: u32, data: WithData) -> NodeIndex {
1329        let expression = data.expression;
1330        let statement = data.statement;
1331        let data_index = self.len_u32(self.with_data.len());
1332        self.with_data.push(data);
1333        let index = self.len_u32(self.nodes.len());
1334        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1335        self.extended_info.push(ExtendedNodeInfo::default());
1336
1337        let parent = NodeIndex(index);
1338        self.set_parent(expression, parent);
1339        self.set_parent(statement, parent);
1340        parent
1341    }
1342
1343    /// Add a type reference node
1344    pub fn add_type_ref(&mut self, kind: u16, pos: u32, end: u32, data: TypeRefData) -> NodeIndex {
1345        let type_name = data.type_name;
1346        let type_arguments = data.type_arguments.clone();
1347        let data_index = self.len_u32(self.type_refs.len());
1348        self.type_refs.push(data);
1349        let index = self.len_u32(self.nodes.len());
1350        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1351        self.extended_info.push(ExtendedNodeInfo::default());
1352        let parent = NodeIndex(index);
1353        self.set_parent(type_name, parent);
1354        self.set_parent_opt_list(type_arguments.as_ref(), parent);
1355        parent
1356    }
1357
1358    /// Add a union/intersection type node
1359    pub fn add_composite_type(
1360        &mut self,
1361        kind: u16,
1362        pos: u32,
1363        end: u32,
1364        data: CompositeTypeData,
1365    ) -> NodeIndex {
1366        let types = data.types.clone();
1367
1368        let data_index = self.len_u32(self.composite_types.len());
1369        self.composite_types.push(data);
1370        let index = self.len_u32(self.nodes.len());
1371        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1372        self.extended_info.push(ExtendedNodeInfo::default());
1373
1374        let parent = NodeIndex(index);
1375        self.set_parent_list(&types, parent);
1376
1377        parent
1378    }
1379
1380    /// Add a function/constructor type node
1381    pub fn add_function_type(
1382        &mut self,
1383        kind: u16,
1384        pos: u32,
1385        end: u32,
1386        data: FunctionTypeData,
1387    ) -> NodeIndex {
1388        let type_parameters = data.type_parameters.clone();
1389        let parameters = data.parameters.clone();
1390        let type_annotation = data.type_annotation;
1391
1392        let data_index = self.len_u32(self.function_types.len());
1393        self.function_types.push(data);
1394        let index = self.len_u32(self.nodes.len());
1395        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1396        self.extended_info.push(ExtendedNodeInfo::default());
1397
1398        let parent = NodeIndex(index);
1399        self.set_parent_opt_list(type_parameters.as_ref(), parent);
1400        self.set_parent_list(&parameters, parent);
1401        self.set_parent(type_annotation, parent);
1402
1403        parent
1404    }
1405
1406    /// Add a type query node (typeof)
1407    pub fn add_type_query(
1408        &mut self,
1409        kind: u16,
1410        pos: u32,
1411        end: u32,
1412        data: TypeQueryData,
1413    ) -> NodeIndex {
1414        let expr_name = data.expr_name;
1415        let type_arguments = data.type_arguments.clone();
1416        let data_index = self.len_u32(self.type_queries.len());
1417        self.type_queries.push(data);
1418        let index = self.len_u32(self.nodes.len());
1419        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1420        self.extended_info.push(ExtendedNodeInfo::default());
1421        let parent = NodeIndex(index);
1422        self.set_parent(expr_name, parent);
1423        self.set_parent_opt_list(type_arguments.as_ref(), parent);
1424        parent
1425    }
1426
1427    /// Add a type literal node
1428    pub fn add_type_literal(
1429        &mut self,
1430        kind: u16,
1431        pos: u32,
1432        end: u32,
1433        data: TypeLiteralData,
1434    ) -> NodeIndex {
1435        let members = data.members.clone();
1436        let data_index = self.len_u32(self.type_literals.len());
1437        self.type_literals.push(data);
1438        let index = self.len_u32(self.nodes.len());
1439        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1440        self.extended_info.push(ExtendedNodeInfo::default());
1441        let parent = NodeIndex(index);
1442        self.set_parent_list(&members, parent);
1443        parent
1444    }
1445
1446    /// Add an array type node
1447    pub fn add_array_type(
1448        &mut self,
1449        kind: u16,
1450        pos: u32,
1451        end: u32,
1452        data: ArrayTypeData,
1453    ) -> NodeIndex {
1454        let element_type = data.element_type;
1455        let data_index = self.len_u32(self.array_types.len());
1456        self.array_types.push(data);
1457        let index = self.len_u32(self.nodes.len());
1458        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1459        self.extended_info.push(ExtendedNodeInfo::default());
1460        let parent = NodeIndex(index);
1461        self.set_parent(element_type, parent);
1462        parent
1463    }
1464
1465    /// Add a tuple type node
1466    pub fn add_tuple_type(
1467        &mut self,
1468        kind: u16,
1469        pos: u32,
1470        end: u32,
1471        data: TupleTypeData,
1472    ) -> NodeIndex {
1473        let elements = data.elements.clone();
1474        let data_index = self.len_u32(self.tuple_types.len());
1475        self.tuple_types.push(data);
1476        let index = self.len_u32(self.nodes.len());
1477        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1478        self.extended_info.push(ExtendedNodeInfo::default());
1479        let parent = NodeIndex(index);
1480        self.set_parent_list(&elements, parent);
1481        parent
1482    }
1483
1484    /// Add an optional/rest type node
1485    pub fn add_wrapped_type(
1486        &mut self,
1487        kind: u16,
1488        pos: u32,
1489        end: u32,
1490        data: WrappedTypeData,
1491    ) -> NodeIndex {
1492        let type_node = data.type_node;
1493        let data_index = self.len_u32(self.wrapped_types.len());
1494        self.wrapped_types.push(data);
1495        let index = self.len_u32(self.nodes.len());
1496        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1497        self.extended_info.push(ExtendedNodeInfo::default());
1498        let parent = NodeIndex(index);
1499        self.set_parent(type_node, parent);
1500        parent
1501    }
1502
1503    /// Add a conditional type node
1504    pub fn add_conditional_type(
1505        &mut self,
1506        kind: u16,
1507        pos: u32,
1508        end: u32,
1509        data: ConditionalTypeData,
1510    ) -> NodeIndex {
1511        let check_type = data.check_type;
1512        let extends_type = data.extends_type;
1513        let true_type = data.true_type;
1514        let false_type = data.false_type;
1515        let data_index = self.len_u32(self.conditional_types.len());
1516        self.conditional_types.push(data);
1517        let index = self.len_u32(self.nodes.len());
1518        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1519        self.extended_info.push(ExtendedNodeInfo::default());
1520        let parent = NodeIndex(index);
1521        self.set_parent(check_type, parent);
1522        self.set_parent(extends_type, parent);
1523        self.set_parent(true_type, parent);
1524        self.set_parent(false_type, parent);
1525        parent
1526    }
1527
1528    /// Add an infer type node
1529    pub fn add_infer_type(
1530        &mut self,
1531        kind: u16,
1532        pos: u32,
1533        end: u32,
1534        data: InferTypeData,
1535    ) -> NodeIndex {
1536        let type_parameter = data.type_parameter;
1537        let data_index = self.len_u32(self.infer_types.len());
1538        self.infer_types.push(data);
1539        let index = self.len_u32(self.nodes.len());
1540        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1541        self.extended_info.push(ExtendedNodeInfo::default());
1542        let parent = NodeIndex(index);
1543        self.set_parent(type_parameter, parent);
1544        parent
1545    }
1546
1547    /// Add a type operator node (keyof, unique, readonly)
1548    pub fn add_type_operator(
1549        &mut self,
1550        kind: u16,
1551        pos: u32,
1552        end: u32,
1553        data: TypeOperatorData,
1554    ) -> NodeIndex {
1555        let type_node = data.type_node;
1556        let data_index = self.len_u32(self.type_operators.len());
1557        self.type_operators.push(data);
1558        let index = self.len_u32(self.nodes.len());
1559        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1560        self.extended_info.push(ExtendedNodeInfo::default());
1561        let parent = NodeIndex(index);
1562        self.set_parent(type_node, parent);
1563        parent
1564    }
1565
1566    /// Add an indexed access type node
1567    pub fn add_indexed_access_type(
1568        &mut self,
1569        kind: u16,
1570        pos: u32,
1571        end: u32,
1572        data: IndexedAccessTypeData,
1573    ) -> NodeIndex {
1574        let object_type = data.object_type;
1575        let index_type = data.index_type;
1576        let data_index = self.len_u32(self.indexed_access_types.len());
1577        self.indexed_access_types.push(data);
1578        let index = self.len_u32(self.nodes.len());
1579        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1580        self.extended_info.push(ExtendedNodeInfo::default());
1581        let parent = NodeIndex(index);
1582        self.set_parent(object_type, parent);
1583        self.set_parent(index_type, parent);
1584        parent
1585    }
1586
1587    /// Add a mapped type node
1588    pub fn add_mapped_type(
1589        &mut self,
1590        kind: u16,
1591        pos: u32,
1592        end: u32,
1593        data: MappedTypeData,
1594    ) -> NodeIndex {
1595        let readonly_token = data.readonly_token;
1596        let type_parameter = data.type_parameter;
1597        let name_type = data.name_type;
1598        let question_token = data.question_token;
1599        let type_node = data.type_node;
1600        let members = data.members.clone();
1601        let data_index = self.len_u32(self.mapped_types.len());
1602        self.mapped_types.push(data);
1603        let index = self.len_u32(self.nodes.len());
1604        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1605        self.extended_info.push(ExtendedNodeInfo::default());
1606        let parent = NodeIndex(index);
1607        self.set_parent(readonly_token, parent);
1608        self.set_parent(type_parameter, parent);
1609        self.set_parent(name_type, parent);
1610        self.set_parent(question_token, parent);
1611        self.set_parent(type_node, parent);
1612        self.set_parent_opt_list(members.as_ref(), parent);
1613        parent
1614    }
1615
1616    /// Add a literal type node
1617    pub fn add_literal_type(
1618        &mut self,
1619        kind: u16,
1620        pos: u32,
1621        end: u32,
1622        data: LiteralTypeData,
1623    ) -> NodeIndex {
1624        let literal = data.literal;
1625        let data_index = self.len_u32(self.literal_types.len());
1626        self.literal_types.push(data);
1627        let index = self.len_u32(self.nodes.len());
1628        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1629        self.extended_info.push(ExtendedNodeInfo::default());
1630        let parent = NodeIndex(index);
1631        self.set_parent(literal, parent);
1632        parent
1633    }
1634
1635    /// Add a template literal type node
1636    pub fn add_template_literal_type(
1637        &mut self,
1638        kind: u16,
1639        pos: u32,
1640        end: u32,
1641        data: TemplateLiteralTypeData,
1642    ) -> NodeIndex {
1643        let head = data.head;
1644        let template_spans = data.template_spans.clone();
1645        let data_index = self.len_u32(self.template_literal_types.len());
1646        self.template_literal_types.push(data);
1647        let index = self.len_u32(self.nodes.len());
1648        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1649        self.extended_info.push(ExtendedNodeInfo::default());
1650        let parent = NodeIndex(index);
1651        self.set_parent(head, parent);
1652        self.set_parent_list(&template_spans, parent);
1653        parent
1654    }
1655
1656    /// Add a named tuple member node
1657    pub fn add_named_tuple_member(
1658        &mut self,
1659        kind: u16,
1660        pos: u32,
1661        end: u32,
1662        data: NamedTupleMemberData,
1663    ) -> NodeIndex {
1664        let name = data.name;
1665        let type_node = data.type_node;
1666
1667        let data_index = self.len_u32(self.named_tuple_members.len());
1668        self.named_tuple_members.push(data);
1669        let index = self.len_u32(self.nodes.len());
1670        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1671        self.extended_info.push(ExtendedNodeInfo::default());
1672        let parent = NodeIndex(index);
1673        self.set_parent(name, parent);
1674        self.set_parent(type_node, parent);
1675        parent
1676    }
1677
1678    /// Add a type predicate node
1679    pub fn add_type_predicate(
1680        &mut self,
1681        kind: u16,
1682        pos: u32,
1683        end: u32,
1684        data: TypePredicateData,
1685    ) -> NodeIndex {
1686        let parameter_name = data.parameter_name;
1687        let type_node = data.type_node;
1688
1689        let data_index = self.len_u32(self.type_predicates.len());
1690        self.type_predicates.push(data);
1691        let index = self.len_u32(self.nodes.len());
1692        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1693        self.extended_info.push(ExtendedNodeInfo::default());
1694        let parent = NodeIndex(index);
1695        self.set_parent(parameter_name, parent);
1696        self.set_parent(type_node, parent);
1697        parent
1698    }
1699
1700    /// Add an import declaration node
1701    pub fn add_import_decl(
1702        &mut self,
1703        kind: u16,
1704        pos: u32,
1705        end: u32,
1706        data: ImportDeclData,
1707    ) -> NodeIndex {
1708        let modifiers = data.modifiers.clone();
1709        let import_clause = data.import_clause;
1710        let module_specifier = data.module_specifier;
1711        let attributes = data.attributes;
1712
1713        let data_index = self.len_u32(self.import_decls.len());
1714        self.import_decls.push(data);
1715        let index = self.len_u32(self.nodes.len());
1716        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1717        self.extended_info.push(ExtendedNodeInfo::default());
1718        let parent = NodeIndex(index);
1719        self.set_parent_opt_list(modifiers.as_ref(), parent);
1720        self.set_parent(import_clause, parent);
1721        self.set_parent(module_specifier, parent);
1722        self.set_parent(attributes, parent);
1723        parent
1724    }
1725
1726    /// Add an import clause node
1727    pub fn add_import_clause(
1728        &mut self,
1729        kind: u16,
1730        pos: u32,
1731        end: u32,
1732        data: ImportClauseData,
1733    ) -> NodeIndex {
1734        let name = data.name;
1735        let named_bindings = data.named_bindings;
1736
1737        let data_index = self.len_u32(self.import_clauses.len());
1738        self.import_clauses.push(data);
1739        let index = self.len_u32(self.nodes.len());
1740        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1741        self.extended_info.push(ExtendedNodeInfo::default());
1742        let parent = NodeIndex(index);
1743        self.set_parent(name, parent);
1744        self.set_parent(named_bindings, parent);
1745        parent
1746    }
1747
1748    /// Add a namespace/named imports node
1749    pub fn add_named_imports(
1750        &mut self,
1751        kind: u16,
1752        pos: u32,
1753        end: u32,
1754        data: NamedImportsData,
1755    ) -> NodeIndex {
1756        let name = data.name;
1757        let elements = data.elements.clone();
1758
1759        let data_index = self.len_u32(self.named_imports.len());
1760        self.named_imports.push(data);
1761        let index = self.len_u32(self.nodes.len());
1762        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1763        self.extended_info.push(ExtendedNodeInfo::default());
1764        let parent = NodeIndex(index);
1765        self.set_parent(name, parent);
1766        self.set_parent_list(&elements, parent);
1767        parent
1768    }
1769
1770    /// Add an import/export specifier node
1771    pub fn add_specifier(
1772        &mut self,
1773        kind: u16,
1774        pos: u32,
1775        end: u32,
1776        data: SpecifierData,
1777    ) -> NodeIndex {
1778        let property_name = data.property_name;
1779        let name = data.name;
1780
1781        let data_index = self.len_u32(self.specifiers.len());
1782        self.specifiers.push(data);
1783        let index = self.len_u32(self.nodes.len());
1784        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1785        self.extended_info.push(ExtendedNodeInfo::default());
1786        let parent = NodeIndex(index);
1787        self.set_parent(property_name, parent);
1788        self.set_parent(name, parent);
1789        parent
1790    }
1791
1792    /// Add an export declaration node
1793    pub fn add_export_decl(
1794        &mut self,
1795        kind: u16,
1796        pos: u32,
1797        end: u32,
1798        data: ExportDeclData,
1799    ) -> NodeIndex {
1800        let modifiers = data.modifiers.clone();
1801        let export_clause = data.export_clause;
1802        let module_specifier = data.module_specifier;
1803        let attributes = data.attributes;
1804
1805        let data_index = self.len_u32(self.export_decls.len());
1806        self.export_decls.push(data);
1807        let index = self.len_u32(self.nodes.len());
1808        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1809        self.extended_info.push(ExtendedNodeInfo::default());
1810        let parent = NodeIndex(index);
1811        self.set_parent_opt_list(modifiers.as_ref(), parent);
1812        self.set_parent(export_clause, parent);
1813        self.set_parent(module_specifier, parent);
1814        self.set_parent(attributes, parent);
1815        parent
1816    }
1817    /// Add an export assignment node
1818    pub fn add_export_assignment(
1819        &mut self,
1820        kind: u16,
1821        pos: u32,
1822        end: u32,
1823        data: ExportAssignmentData,
1824    ) -> NodeIndex {
1825        let modifiers = data.modifiers.clone();
1826        let expression = data.expression;
1827
1828        let data_index = self.len_u32(self.export_assignments.len());
1829        self.export_assignments.push(data);
1830        let index = self.len_u32(self.nodes.len());
1831        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1832        self.extended_info.push(ExtendedNodeInfo::default());
1833        let parent = NodeIndex(index);
1834        self.set_parent_opt_list(modifiers.as_ref(), parent);
1835        self.set_parent(expression, parent);
1836        parent
1837    }
1838
1839    /// Add an import attributes node
1840    pub fn add_import_attributes(
1841        &mut self,
1842        kind: u16,
1843        pos: u32,
1844        end: u32,
1845        data: ImportAttributesData,
1846    ) -> NodeIndex {
1847        let elements = data.elements.clone();
1848
1849        let data_index = self.len_u32(self.import_attributes.len());
1850        self.import_attributes.push(data);
1851        let index = self.len_u32(self.nodes.len());
1852        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1853        self.extended_info.push(ExtendedNodeInfo::default());
1854        let parent = NodeIndex(index);
1855        self.set_parent_list(&elements, parent);
1856        parent
1857    }
1858
1859    /// Add an import attribute node
1860    pub fn add_import_attribute(
1861        &mut self,
1862        kind: u16,
1863        pos: u32,
1864        end: u32,
1865        data: ImportAttributeData,
1866    ) -> NodeIndex {
1867        let name = data.name;
1868        let value = data.value;
1869
1870        let data_index = self.len_u32(self.import_attribute.len());
1871        self.import_attribute.push(data);
1872        let index = self.len_u32(self.nodes.len());
1873        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1874        self.extended_info.push(ExtendedNodeInfo::default());
1875        let parent = NodeIndex(index);
1876        self.set_parent(name, parent);
1877        self.set_parent(value, parent);
1878        parent
1879    }
1880
1881    /// Add a binding pattern node
1882    pub fn add_binding_pattern(
1883        &mut self,
1884        kind: u16,
1885        pos: u32,
1886        end: u32,
1887        data: BindingPatternData,
1888    ) -> NodeIndex {
1889        let elements = data.elements.clone();
1890
1891        let data_index = self.len_u32(self.binding_patterns.len());
1892        self.binding_patterns.push(data);
1893        let index = self.len_u32(self.nodes.len());
1894        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1895        self.extended_info.push(ExtendedNodeInfo::default());
1896        let parent = NodeIndex(index);
1897        self.set_parent_list(&elements, parent);
1898        parent
1899    }
1900
1901    /// Add a binding element node
1902    pub fn add_binding_element(
1903        &mut self,
1904        kind: u16,
1905        pos: u32,
1906        end: u32,
1907        data: BindingElementData,
1908    ) -> NodeIndex {
1909        let property_name = data.property_name;
1910        let name = data.name;
1911        let initializer = data.initializer;
1912
1913        let data_index = self.len_u32(self.binding_elements.len());
1914        self.binding_elements.push(data);
1915        let index = self.len_u32(self.nodes.len());
1916        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1917        self.extended_info.push(ExtendedNodeInfo::default());
1918        let parent = NodeIndex(index);
1919        self.set_parent(property_name, parent);
1920        self.set_parent(name, parent);
1921        self.set_parent(initializer, parent);
1922        parent
1923    }
1924
1925    /// Add a property assignment node
1926    pub fn add_property_assignment(
1927        &mut self,
1928        kind: u16,
1929        pos: u32,
1930        end: u32,
1931        data: PropertyAssignmentData,
1932    ) -> NodeIndex {
1933        let modifiers = data.modifiers.clone();
1934        let name = data.name;
1935        let initializer = data.initializer;
1936
1937        let data_index = self.len_u32(self.property_assignments.len());
1938        self.property_assignments.push(data);
1939        let index = self.len_u32(self.nodes.len());
1940        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1941        self.extended_info.push(ExtendedNodeInfo::default());
1942        let parent = NodeIndex(index);
1943        self.set_parent_opt_list(modifiers.as_ref(), parent);
1944        self.set_parent(name, parent);
1945        self.set_parent(initializer, parent);
1946        parent
1947    }
1948
1949    /// Add a shorthand property assignment node
1950    pub fn add_shorthand_property(
1951        &mut self,
1952        kind: u16,
1953        pos: u32,
1954        end: u32,
1955        data: ShorthandPropertyData,
1956    ) -> NodeIndex {
1957        let modifiers = data.modifiers.clone();
1958        let name = data.name;
1959        let object_assignment_initializer = data.object_assignment_initializer;
1960
1961        let data_index = self.len_u32(self.shorthand_properties.len());
1962        self.shorthand_properties.push(data);
1963        let index = self.len_u32(self.nodes.len());
1964        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1965        self.extended_info.push(ExtendedNodeInfo::default());
1966        let parent = NodeIndex(index);
1967        self.set_parent_opt_list(modifiers.as_ref(), parent);
1968        self.set_parent(name, parent);
1969        self.set_parent(object_assignment_initializer, parent);
1970        parent
1971    }
1972
1973    /// Add a spread assignment node
1974    pub fn add_spread(&mut self, kind: u16, pos: u32, end: u32, data: SpreadData) -> NodeIndex {
1975        let expression = data.expression;
1976
1977        let data_index = self.len_u32(self.spread_data.len());
1978        self.spread_data.push(data);
1979        let index = self.len_u32(self.nodes.len());
1980        self.nodes.push(Node::with_data(kind, pos, end, data_index));
1981        self.extended_info.push(ExtendedNodeInfo::default());
1982        let parent = NodeIndex(index);
1983        self.set_parent(expression, parent);
1984        parent
1985    }
1986
1987    /// Add a JSX element node
1988    pub fn add_jsx_element(
1989        &mut self,
1990        kind: u16,
1991        pos: u32,
1992        end: u32,
1993        data: JsxElementData,
1994    ) -> NodeIndex {
1995        let opening_element = data.opening_element;
1996        let children = data.children.clone();
1997        let closing_element = data.closing_element;
1998
1999        let data_index = self.len_u32(self.jsx_elements.len());
2000        self.jsx_elements.push(data);
2001        let index = self.len_u32(self.nodes.len());
2002        self.nodes.push(Node::with_data(kind, pos, end, data_index));
2003        self.extended_info.push(ExtendedNodeInfo::default());
2004
2005        let parent = NodeIndex(index);
2006        self.set_parent(opening_element, parent);
2007        self.set_parent_list(&children, parent);
2008        self.set_parent(closing_element, parent);
2009        parent
2010    }
2011
2012    /// Add a JSX opening/self-closing element node
2013    pub fn add_jsx_opening(
2014        &mut self,
2015        kind: u16,
2016        pos: u32,
2017        end: u32,
2018        data: JsxOpeningData,
2019    ) -> NodeIndex {
2020        let tag_name = data.tag_name;
2021        let type_arguments = data.type_arguments.clone();
2022        let attributes = data.attributes;
2023
2024        let data_index = self.len_u32(self.jsx_opening.len());
2025        self.jsx_opening.push(data);
2026        let index = self.len_u32(self.nodes.len());
2027        self.nodes.push(Node::with_data(kind, pos, end, data_index));
2028        self.extended_info.push(ExtendedNodeInfo::default());
2029
2030        let parent = NodeIndex(index);
2031        self.set_parent(tag_name, parent);
2032        self.set_parent_opt_list(type_arguments.as_ref(), parent);
2033        self.set_parent(attributes, parent);
2034        parent
2035    }
2036
2037    /// Add a JSX closing element node
2038    pub fn add_jsx_closing(
2039        &mut self,
2040        kind: u16,
2041        pos: u32,
2042        end: u32,
2043        data: JsxClosingData,
2044    ) -> NodeIndex {
2045        let tag_name = data.tag_name;
2046
2047        let data_index = self.len_u32(self.jsx_closing.len());
2048        self.jsx_closing.push(data);
2049        let index = self.len_u32(self.nodes.len());
2050        self.nodes.push(Node::with_data(kind, pos, end, data_index));
2051        self.extended_info.push(ExtendedNodeInfo::default());
2052
2053        let parent = NodeIndex(index);
2054        self.set_parent(tag_name, parent);
2055        parent
2056    }
2057
2058    /// Add a JSX fragment node
2059    pub fn add_jsx_fragment(
2060        &mut self,
2061        kind: u16,
2062        pos: u32,
2063        end: u32,
2064        data: JsxFragmentData,
2065    ) -> NodeIndex {
2066        let opening_fragment = data.opening_fragment;
2067        let children = data.children.clone();
2068        let closing_fragment = data.closing_fragment;
2069
2070        let data_index = self.len_u32(self.jsx_fragments.len());
2071        self.jsx_fragments.push(data);
2072        let index = self.len_u32(self.nodes.len());
2073        self.nodes.push(Node::with_data(kind, pos, end, data_index));
2074        self.extended_info.push(ExtendedNodeInfo::default());
2075
2076        let parent = NodeIndex(index);
2077        self.set_parent(opening_fragment, parent);
2078        self.set_parent_list(&children, parent);
2079        self.set_parent(closing_fragment, parent);
2080        parent
2081    }
2082
2083    /// Add a JSX attributes node
2084    pub fn add_jsx_attributes(
2085        &mut self,
2086        kind: u16,
2087        pos: u32,
2088        end: u32,
2089        data: JsxAttributesData,
2090    ) -> NodeIndex {
2091        let properties = data.properties.clone();
2092
2093        let data_index = self.len_u32(self.jsx_attributes.len());
2094        self.jsx_attributes.push(data);
2095        let index = self.len_u32(self.nodes.len());
2096        self.nodes.push(Node::with_data(kind, pos, end, data_index));
2097        self.extended_info.push(ExtendedNodeInfo::default());
2098
2099        let parent = NodeIndex(index);
2100        self.set_parent_list(&properties, parent);
2101        parent
2102    }
2103
2104    /// Add a JSX attribute node
2105    pub fn add_jsx_attribute(
2106        &mut self,
2107        kind: u16,
2108        pos: u32,
2109        end: u32,
2110        data: JsxAttributeData,
2111    ) -> NodeIndex {
2112        let name = data.name;
2113        let initializer = data.initializer;
2114
2115        let data_index = self.len_u32(self.jsx_attribute.len());
2116        self.jsx_attribute.push(data);
2117        let index = self.len_u32(self.nodes.len());
2118        self.nodes.push(Node::with_data(kind, pos, end, data_index));
2119        self.extended_info.push(ExtendedNodeInfo::default());
2120
2121        let parent = NodeIndex(index);
2122        self.set_parent(name, parent);
2123        self.set_parent(initializer, parent);
2124        parent
2125    }
2126
2127    /// Add a JSX spread attribute node
2128    pub fn add_jsx_spread_attribute(
2129        &mut self,
2130        kind: u16,
2131        pos: u32,
2132        end: u32,
2133        data: JsxSpreadAttributeData,
2134    ) -> NodeIndex {
2135        let expression = data.expression;
2136
2137        let data_index = self.len_u32(self.jsx_spread_attributes.len());
2138        self.jsx_spread_attributes.push(data);
2139        let index = self.len_u32(self.nodes.len());
2140        self.nodes.push(Node::with_data(kind, pos, end, data_index));
2141        self.extended_info.push(ExtendedNodeInfo::default());
2142
2143        let parent = NodeIndex(index);
2144        self.set_parent(expression, parent);
2145        parent
2146    }
2147
2148    /// Add a JSX expression node
2149    pub fn add_jsx_expression(
2150        &mut self,
2151        kind: u16,
2152        pos: u32,
2153        end: u32,
2154        data: JsxExpressionData,
2155    ) -> NodeIndex {
2156        let expression = data.expression;
2157
2158        let data_index = self.len_u32(self.jsx_expressions.len());
2159        self.jsx_expressions.push(data);
2160        let index = self.len_u32(self.nodes.len());
2161        self.nodes.push(Node::with_data(kind, pos, end, data_index));
2162        self.extended_info.push(ExtendedNodeInfo::default());
2163
2164        let parent = NodeIndex(index);
2165        self.set_parent(expression, parent);
2166        parent
2167    }
2168
2169    /// Add a JSX text node
2170    pub fn add_jsx_text(&mut self, kind: u16, pos: u32, end: u32, data: JsxTextData) -> NodeIndex {
2171        let data_index = self.len_u32(self.jsx_text.len());
2172        self.jsx_text.push(data);
2173        let index = self.len_u32(self.nodes.len());
2174        self.nodes.push(Node::with_data(kind, pos, end, data_index));
2175        self.extended_info.push(ExtendedNodeInfo::default());
2176        NodeIndex(index)
2177    }
2178
2179    /// Add a JSX namespaced name node
2180    pub fn add_jsx_namespaced_name(
2181        &mut self,
2182        kind: u16,
2183        pos: u32,
2184        end: u32,
2185        data: JsxNamespacedNameData,
2186    ) -> NodeIndex {
2187        let namespace = data.namespace;
2188        let name = data.name;
2189
2190        let data_index = self.len_u32(self.jsx_namespaced_names.len());
2191        self.jsx_namespaced_names.push(data);
2192        let index = self.len_u32(self.nodes.len());
2193        self.nodes.push(Node::with_data(kind, pos, end, data_index));
2194        self.extended_info.push(ExtendedNodeInfo::default());
2195
2196        let parent = NodeIndex(index);
2197        self.set_parent(namespace, parent);
2198        self.set_parent(name, parent);
2199        parent
2200    }
2201
2202    /// Add a variable declaration node (individual)
2203    pub fn add_variable_declaration(
2204        &mut self,
2205        kind: u16,
2206        pos: u32,
2207        end: u32,
2208        data: VariableDeclarationData,
2209    ) -> NodeIndex {
2210        let name = data.name;
2211        let type_annotation = data.type_annotation;
2212        let initializer = data.initializer;
2213
2214        let data_index = self.len_u32(self.variable_declarations.len());
2215        self.variable_declarations.push(data);
2216        let index = self.len_u32(self.nodes.len());
2217        self.nodes.push(Node::with_data(kind, pos, end, data_index));
2218        self.extended_info.push(ExtendedNodeInfo::default());
2219
2220        let parent = NodeIndex(index);
2221        self.set_parent(name, parent);
2222        self.set_parent(type_annotation, parent);
2223        self.set_parent(initializer, parent);
2224
2225        parent
2226    }
2227
2228    /// Add a for-in/for-of statement node
2229    pub fn add_for_in_of(&mut self, kind: u16, pos: u32, end: u32, data: ForInOfData) -> NodeIndex {
2230        let initializer = data.initializer;
2231        let expression = data.expression;
2232        let statement = data.statement;
2233        let data_index = self.len_u32(self.for_in_of.len());
2234        self.for_in_of.push(data);
2235        let index = self.len_u32(self.nodes.len());
2236        self.nodes.push(Node::with_data(kind, pos, end, data_index));
2237        self.extended_info.push(ExtendedNodeInfo::default());
2238        let parent = NodeIndex(index);
2239        self.set_parent(initializer, parent);
2240        self.set_parent(expression, parent);
2241        self.set_parent(statement, parent);
2242        parent
2243    }
2244}