1 /****************************************************************************
2 **
3 ** Copyright (C) 2016 The Qt Company Ltd.
4 ** Contact: https://www.qt.io/licensing/
5 **
6 ** This file is part of Qt Creator.
7 **
8 ** Commercial License Usage
9 ** Licensees holding valid commercial Qt licenses may use this file in
10 ** accordance with the commercial license agreement provided with the
11 ** Software or, alternatively, in accordance with the terms contained in
12 ** a written agreement between you and The Qt Company. For licensing terms
13 ** and conditions see https://www.qt.io/terms-conditions. For further
14 ** information use the contact form at https://www.qt.io/contact-us.
15 **
16 ** GNU General Public License Usage
17 ** Alternatively, this file may be used under the terms of the GNU
18 ** General Public License version 3 as published by the Free Software
19 ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
20 ** included in the packaging of this file. Please review the following
21 ** information to ensure the GNU General Public License requirements will
22 ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
23 **
24 ****************************************************************************/
25
26 #include "qmljsast_p.h"
27
28 #include "qmljsastvisitor_p.h"
29
30 QT_QML_BEGIN_NAMESPACE
31
32 namespace QmlJS { namespace AST {
33
accept(Visitor * visitor)34 void Node::accept(Visitor *visitor)
35 {
36 if (visitor->preVisit(this)) {
37 accept0(visitor);
38 }
39 visitor->postVisit(this);
40 }
41
accept(Node * node,Visitor * visitor)42 void Node::accept(Node *node, Visitor *visitor)
43 {
44 if (node)
45 node->accept(visitor);
46 }
47
expressionCast()48 ExpressionNode *Node::expressionCast()
49 {
50 return 0;
51 }
52
binaryExpressionCast()53 BinaryExpression *Node::binaryExpressionCast()
54 {
55 return 0;
56 }
57
statementCast()58 Statement *Node::statementCast()
59 {
60 return 0;
61 }
62
uiObjectMemberCast()63 UiObjectMember *Node::uiObjectMemberCast()
64 {
65 return 0;
66 }
67
expressionCast()68 ExpressionNode *ExpressionNode::expressionCast()
69 {
70 return this;
71 }
72
binaryExpressionCast()73 BinaryExpression *BinaryExpression::binaryExpressionCast()
74 {
75 return this;
76 }
77
statementCast()78 Statement *Statement::statementCast()
79 {
80 return this;
81 }
82
uiObjectMemberCast()83 UiObjectMember *UiObjectMember::uiObjectMemberCast()
84 {
85 return this;
86 }
87
accept0(Visitor * visitor)88 void NestedExpression::accept0(Visitor *visitor)
89 {
90 if (visitor->visit(this)) {
91 accept(expression, visitor);
92 }
93 visitor->endVisit(this);
94 }
95
accept0(Visitor * visitor)96 void ThisExpression::accept0(Visitor *visitor)
97 {
98 if (visitor->visit(this)) {
99 }
100
101 visitor->endVisit(this);
102 }
103
accept0(Visitor * visitor)104 void IdentifierExpression::accept0(Visitor *visitor)
105 {
106 if (visitor->visit(this)) {
107 }
108
109 visitor->endVisit(this);
110 }
111
accept0(Visitor * visitor)112 void NullExpression::accept0(Visitor *visitor)
113 {
114 if (visitor->visit(this)) {
115 }
116
117 visitor->endVisit(this);
118 }
119
accept0(Visitor * visitor)120 void TrueLiteral::accept0(Visitor *visitor)
121 {
122 if (visitor->visit(this)) {
123 }
124
125 visitor->endVisit(this);
126 }
127
accept0(Visitor * visitor)128 void FalseLiteral::accept0(Visitor *visitor)
129 {
130 if (visitor->visit(this)) {
131 }
132
133 visitor->endVisit(this);
134 }
135
accept0(Visitor * visitor)136 void StringLiteral::accept0(Visitor *visitor)
137 {
138 if (visitor->visit(this)) {
139 }
140
141 visitor->endVisit(this);
142 }
143
accept0(Visitor * visitor)144 void NumericLiteral::accept0(Visitor *visitor)
145 {
146 if (visitor->visit(this)) {
147 }
148
149 visitor->endVisit(this);
150 }
151
accept0(Visitor * visitor)152 void RegExpLiteral::accept0(Visitor *visitor)
153 {
154 if (visitor->visit(this)) {
155 }
156
157 visitor->endVisit(this);
158 }
159
accept0(Visitor * visitor)160 void ArrayLiteral::accept0(Visitor *visitor)
161 {
162 if (visitor->visit(this)) {
163 accept(elements, visitor);
164 accept(elision, visitor);
165 }
166
167 visitor->endVisit(this);
168 }
169
accept0(Visitor * visitor)170 void ObjectLiteral::accept0(Visitor *visitor)
171 {
172 if (visitor->visit(this)) {
173 accept(properties, visitor);
174 }
175
176 visitor->endVisit(this);
177 }
178
accept0(Visitor * visitor)179 void ElementList::accept0(Visitor *visitor)
180 {
181 if (visitor->visit(this)) {
182 for (ElementList *it = this; it; it = it->next) {
183 accept(it->elision, visitor);
184 accept(it->expression, visitor);
185 }
186 }
187
188 visitor->endVisit(this);
189 }
190
accept0(Visitor * visitor)191 void Elision::accept0(Visitor *visitor)
192 {
193 if (visitor->visit(this)) {
194 // ###
195 }
196
197 visitor->endVisit(this);
198 }
199
accept0(Visitor * visitor)200 void PropertyNameAndValue::accept0(Visitor *visitor)
201 {
202 if (visitor->visit(this)) {
203 accept(name, visitor);
204 accept(value, visitor);
205 }
206
207 visitor->endVisit(this);
208 }
209
accept0(Visitor * visitor)210 void PropertyGetterSetter::accept0(Visitor *visitor)
211 {
212 if (visitor->visit(this)) {
213 accept(name, visitor);
214 accept(formals, visitor);
215 accept(functionBody, visitor);
216 }
217
218 visitor->endVisit(this);
219 }
220
accept0(Visitor * visitor)221 void PropertyAssignmentList::accept0(Visitor *visitor)
222 {
223 if (visitor->visit(this)) {
224 for (PropertyAssignmentList *it = this; it; it = it->next) {
225 accept(it->assignment, visitor);
226 }
227 }
228
229 visitor->endVisit(this);
230 }
231
accept0(Visitor * visitor)232 void IdentifierPropertyName::accept0(Visitor *visitor)
233 {
234 if (visitor->visit(this)) {
235 }
236
237 visitor->endVisit(this);
238 }
239
accept0(Visitor * visitor)240 void StringLiteralPropertyName::accept0(Visitor *visitor)
241 {
242 if (visitor->visit(this)) {
243 }
244
245 visitor->endVisit(this);
246 }
247
accept0(Visitor * visitor)248 void NumericLiteralPropertyName::accept0(Visitor *visitor)
249 {
250 if (visitor->visit(this)) {
251 }
252
253 visitor->endVisit(this);
254 }
255
accept0(Visitor * visitor)256 void ArrayMemberExpression::accept0(Visitor *visitor)
257 {
258 if (visitor->visit(this)) {
259 accept(base, visitor);
260 accept(expression, visitor);
261 }
262
263 visitor->endVisit(this);
264 }
265
accept0(Visitor * visitor)266 void FieldMemberExpression::accept0(Visitor *visitor)
267 {
268 if (visitor->visit(this)) {
269 accept(base, visitor);
270 }
271
272 visitor->endVisit(this);
273 }
274
accept0(Visitor * visitor)275 void NewMemberExpression::accept0(Visitor *visitor)
276 {
277 if (visitor->visit(this)) {
278 accept(base, visitor);
279 accept(arguments, visitor);
280 }
281
282 visitor->endVisit(this);
283 }
284
accept0(Visitor * visitor)285 void NewExpression::accept0(Visitor *visitor)
286 {
287 if (visitor->visit(this)) {
288 accept(expression, visitor);
289 }
290
291 visitor->endVisit(this);
292 }
293
accept0(Visitor * visitor)294 void CallExpression::accept0(Visitor *visitor)
295 {
296 if (visitor->visit(this)) {
297 accept(base, visitor);
298 accept(arguments, visitor);
299 }
300
301 visitor->endVisit(this);
302 }
303
accept0(Visitor * visitor)304 void ArgumentList::accept0(Visitor *visitor)
305 {
306 if (visitor->visit(this)) {
307 for (ArgumentList *it = this; it; it = it->next) {
308 accept(it->expression, visitor);
309 }
310 }
311
312 visitor->endVisit(this);
313 }
314
accept0(Visitor * visitor)315 void PostIncrementExpression::accept0(Visitor *visitor)
316 {
317 if (visitor->visit(this)) {
318 accept(base, visitor);
319 }
320
321 visitor->endVisit(this);
322 }
323
accept0(Visitor * visitor)324 void PostDecrementExpression::accept0(Visitor *visitor)
325 {
326 if (visitor->visit(this)) {
327 accept(base, visitor);
328 }
329
330 visitor->endVisit(this);
331 }
332
accept0(Visitor * visitor)333 void DeleteExpression::accept0(Visitor *visitor)
334 {
335 if (visitor->visit(this)) {
336 accept(expression, visitor);
337 }
338
339 visitor->endVisit(this);
340 }
341
accept0(Visitor * visitor)342 void VoidExpression::accept0(Visitor *visitor)
343 {
344 if (visitor->visit(this)) {
345 accept(expression, visitor);
346 }
347
348 visitor->endVisit(this);
349 }
350
accept0(Visitor * visitor)351 void TypeOfExpression::accept0(Visitor *visitor)
352 {
353 if (visitor->visit(this)) {
354 accept(expression, visitor);
355 }
356
357 visitor->endVisit(this);
358 }
359
accept0(Visitor * visitor)360 void PreIncrementExpression::accept0(Visitor *visitor)
361 {
362 if (visitor->visit(this)) {
363 accept(expression, visitor);
364 }
365
366 visitor->endVisit(this);
367 }
368
accept0(Visitor * visitor)369 void PreDecrementExpression::accept0(Visitor *visitor)
370 {
371 if (visitor->visit(this)) {
372 accept(expression, visitor);
373 }
374
375 visitor->endVisit(this);
376 }
377
accept0(Visitor * visitor)378 void UnaryPlusExpression::accept0(Visitor *visitor)
379 {
380 if (visitor->visit(this)) {
381 accept(expression, visitor);
382 }
383
384 visitor->endVisit(this);
385 }
386
accept0(Visitor * visitor)387 void UnaryMinusExpression::accept0(Visitor *visitor)
388 {
389 if (visitor->visit(this)) {
390 accept(expression, visitor);
391 }
392
393 visitor->endVisit(this);
394 }
395
accept0(Visitor * visitor)396 void TildeExpression::accept0(Visitor *visitor)
397 {
398 if (visitor->visit(this)) {
399 accept(expression, visitor);
400 }
401
402 visitor->endVisit(this);
403 }
404
accept0(Visitor * visitor)405 void NotExpression::accept0(Visitor *visitor)
406 {
407 if (visitor->visit(this)) {
408 accept(expression, visitor);
409 }
410
411 visitor->endVisit(this);
412 }
413
accept0(Visitor * visitor)414 void BinaryExpression::accept0(Visitor *visitor)
415 {
416 if (visitor->visit(this)) {
417 accept(left, visitor);
418 accept(right, visitor);
419 }
420
421 visitor->endVisit(this);
422 }
423
accept0(Visitor * visitor)424 void ConditionalExpression::accept0(Visitor *visitor)
425 {
426 if (visitor->visit(this)) {
427 accept(expression, visitor);
428 accept(ok, visitor);
429 accept(ko, visitor);
430 }
431
432 visitor->endVisit(this);
433 }
434
accept0(Visitor * visitor)435 void Expression::accept0(Visitor *visitor)
436 {
437 if (visitor->visit(this)) {
438 accept(left, visitor);
439 accept(right, visitor);
440 }
441
442 visitor->endVisit(this);
443 }
444
accept0(Visitor * visitor)445 void Block::accept0(Visitor *visitor)
446 {
447 if (visitor->visit(this)) {
448 accept(statements, visitor);
449 }
450
451 visitor->endVisit(this);
452 }
453
accept0(Visitor * visitor)454 void StatementList::accept0(Visitor *visitor)
455 {
456 if (visitor->visit(this)) {
457 for (StatementList *it = this; it; it = it->next) {
458 accept(it->statement, visitor);
459 }
460 }
461
462 visitor->endVisit(this);
463 }
464
accept0(Visitor * visitor)465 void VariableStatement::accept0(Visitor *visitor)
466 {
467 if (visitor->visit(this)) {
468 accept(declarations, visitor);
469 }
470
471 visitor->endVisit(this);
472 }
473
accept0(Visitor * visitor)474 void VariableDeclarationList::accept0(Visitor *visitor)
475 {
476 if (visitor->visit(this)) {
477 for (VariableDeclarationList *it = this; it; it = it->next) {
478 accept(it->declaration, visitor);
479 }
480 }
481
482 visitor->endVisit(this);
483 }
484
accept0(Visitor * visitor)485 void VariableDeclaration::accept0(Visitor *visitor)
486 {
487 if (visitor->visit(this)) {
488 accept(expression, visitor);
489 }
490
491 visitor->endVisit(this);
492 }
493
accept0(Visitor * visitor)494 void EmptyStatement::accept0(Visitor *visitor)
495 {
496 if (visitor->visit(this)) {
497 }
498
499 visitor->endVisit(this);
500 }
501
accept0(Visitor * visitor)502 void ExpressionStatement::accept0(Visitor *visitor)
503 {
504 if (visitor->visit(this)) {
505 accept(expression, visitor);
506 }
507
508 visitor->endVisit(this);
509 }
510
accept0(Visitor * visitor)511 void IfStatement::accept0(Visitor *visitor)
512 {
513 if (visitor->visit(this)) {
514 accept(expression, visitor);
515 accept(ok, visitor);
516 accept(ko, visitor);
517 }
518
519 visitor->endVisit(this);
520 }
521
accept0(Visitor * visitor)522 void DoWhileStatement::accept0(Visitor *visitor)
523 {
524 if (visitor->visit(this)) {
525 accept(statement, visitor);
526 accept(expression, visitor);
527 }
528
529 visitor->endVisit(this);
530 }
531
accept0(Visitor * visitor)532 void WhileStatement::accept0(Visitor *visitor)
533 {
534 if (visitor->visit(this)) {
535 accept(expression, visitor);
536 accept(statement, visitor);
537 }
538
539 visitor->endVisit(this);
540 }
541
accept0(Visitor * visitor)542 void ForStatement::accept0(Visitor *visitor)
543 {
544 if (visitor->visit(this)) {
545 accept(initialiser, visitor);
546 accept(condition, visitor);
547 accept(expression, visitor);
548 accept(statement, visitor);
549 }
550
551 visitor->endVisit(this);
552 }
553
accept0(Visitor * visitor)554 void LocalForStatement::accept0(Visitor *visitor)
555 {
556 if (visitor->visit(this)) {
557 accept(declarations, visitor);
558 accept(condition, visitor);
559 accept(expression, visitor);
560 accept(statement, visitor);
561 }
562
563 visitor->endVisit(this);
564 }
565
accept0(Visitor * visitor)566 void ForEachStatement::accept0(Visitor *visitor)
567 {
568 if (visitor->visit(this)) {
569 accept(initialiser, visitor);
570 accept(expression, visitor);
571 accept(statement, visitor);
572 }
573
574 visitor->endVisit(this);
575 }
576
accept0(Visitor * visitor)577 void LocalForEachStatement::accept0(Visitor *visitor)
578 {
579 if (visitor->visit(this)) {
580 accept(declaration, visitor);
581 accept(expression, visitor);
582 accept(statement, visitor);
583 }
584
585 visitor->endVisit(this);
586 }
587
accept0(Visitor * visitor)588 void ContinueStatement::accept0(Visitor *visitor)
589 {
590 if (visitor->visit(this)) {
591 }
592
593 visitor->endVisit(this);
594 }
595
accept0(Visitor * visitor)596 void BreakStatement::accept0(Visitor *visitor)
597 {
598 if (visitor->visit(this)) {
599 }
600
601 visitor->endVisit(this);
602 }
603
accept0(Visitor * visitor)604 void ReturnStatement::accept0(Visitor *visitor)
605 {
606 if (visitor->visit(this)) {
607 accept(expression, visitor);
608 }
609
610 visitor->endVisit(this);
611 }
612
accept0(Visitor * visitor)613 void WithStatement::accept0(Visitor *visitor)
614 {
615 if (visitor->visit(this)) {
616 accept(expression, visitor);
617 accept(statement, visitor);
618 }
619
620 visitor->endVisit(this);
621 }
622
accept0(Visitor * visitor)623 void SwitchStatement::accept0(Visitor *visitor)
624 {
625 if (visitor->visit(this)) {
626 accept(expression, visitor);
627 accept(block, visitor);
628 }
629
630 visitor->endVisit(this);
631 }
632
accept0(Visitor * visitor)633 void CaseBlock::accept0(Visitor *visitor)
634 {
635 if (visitor->visit(this)) {
636 accept(clauses, visitor);
637 accept(defaultClause, visitor);
638 accept(moreClauses, visitor);
639 }
640
641 visitor->endVisit(this);
642 }
643
accept0(Visitor * visitor)644 void CaseClauses::accept0(Visitor *visitor)
645 {
646 if (visitor->visit(this)) {
647 for (CaseClauses *it = this; it; it = it->next) {
648 accept(it->clause, visitor);
649 }
650 }
651
652 visitor->endVisit(this);
653 }
654
accept0(Visitor * visitor)655 void CaseClause::accept0(Visitor *visitor)
656 {
657 if (visitor->visit(this)) {
658 accept(expression, visitor);
659 accept(statements, visitor);
660 }
661
662 visitor->endVisit(this);
663 }
664
accept0(Visitor * visitor)665 void DefaultClause::accept0(Visitor *visitor)
666 {
667 if (visitor->visit(this)) {
668 accept(statements, visitor);
669 }
670
671 visitor->endVisit(this);
672 }
673
accept0(Visitor * visitor)674 void LabelledStatement::accept0(Visitor *visitor)
675 {
676 if (visitor->visit(this)) {
677 accept(statement, visitor);
678 }
679
680 visitor->endVisit(this);
681 }
682
accept0(Visitor * visitor)683 void ThrowStatement::accept0(Visitor *visitor)
684 {
685 if (visitor->visit(this)) {
686 accept(expression, visitor);
687 }
688
689 visitor->endVisit(this);
690 }
691
accept0(Visitor * visitor)692 void TryStatement::accept0(Visitor *visitor)
693 {
694 if (visitor->visit(this)) {
695 accept(statement, visitor);
696 accept(catchExpression, visitor);
697 accept(finallyExpression, visitor);
698 }
699
700 visitor->endVisit(this);
701 }
702
accept0(Visitor * visitor)703 void Catch::accept0(Visitor *visitor)
704 {
705 if (visitor->visit(this)) {
706 accept(statement, visitor);
707 }
708
709 visitor->endVisit(this);
710 }
711
accept0(Visitor * visitor)712 void Finally::accept0(Visitor *visitor)
713 {
714 if (visitor->visit(this)) {
715 accept(statement, visitor);
716 }
717
718 visitor->endVisit(this);
719 }
720
accept0(Visitor * visitor)721 void FunctionDeclaration::accept0(Visitor *visitor)
722 {
723 if (visitor->visit(this)) {
724 accept(formals, visitor);
725 accept(body, visitor);
726 }
727
728 visitor->endVisit(this);
729 }
730
accept0(Visitor * visitor)731 void FunctionExpression::accept0(Visitor *visitor)
732 {
733 if (visitor->visit(this)) {
734 accept(formals, visitor);
735 accept(body, visitor);
736 }
737
738 visitor->endVisit(this);
739 }
740
accept0(Visitor * visitor)741 void FormalParameterList::accept0(Visitor *visitor)
742 {
743 if (visitor->visit(this)) {
744 // ###
745 }
746
747 visitor->endVisit(this);
748 }
749
accept0(Visitor * visitor)750 void FunctionBody::accept0(Visitor *visitor)
751 {
752 if (visitor->visit(this)) {
753 accept(elements, visitor);
754 }
755
756 visitor->endVisit(this);
757 }
758
accept0(Visitor * visitor)759 void Program::accept0(Visitor *visitor)
760 {
761 if (visitor->visit(this)) {
762 accept(elements, visitor);
763 }
764
765 visitor->endVisit(this);
766 }
767
accept0(Visitor * visitor)768 void SourceElements::accept0(Visitor *visitor)
769 {
770 if (visitor->visit(this)) {
771 for (SourceElements *it = this; it; it = it->next) {
772 accept(it->element, visitor);
773 }
774 }
775
776 visitor->endVisit(this);
777 }
778
accept0(Visitor * visitor)779 void FunctionSourceElement::accept0(Visitor *visitor)
780 {
781 if (visitor->visit(this)) {
782 accept(declaration, visitor);
783 }
784
785 visitor->endVisit(this);
786 }
787
accept0(Visitor * visitor)788 void StatementSourceElement::accept0(Visitor *visitor)
789 {
790 if (visitor->visit(this)) {
791 accept(statement, visitor);
792 }
793
794 visitor->endVisit(this);
795 }
796
accept0(Visitor * visitor)797 void DebuggerStatement::accept0(Visitor *visitor)
798 {
799 if (visitor->visit(this)) {
800 }
801
802 visitor->endVisit(this);
803 }
804
accept0(Visitor * visitor)805 void UiProgram::accept0(Visitor *visitor)
806 {
807 if (visitor->visit(this)) {
808 accept(headers, visitor);
809 accept(members, visitor);
810 }
811
812 visitor->endVisit(this);
813 }
814
accept0(Visitor * visitor)815 void UiPublicMember::accept0(Visitor *visitor)
816 {
817 if (visitor->visit(this)) {
818 accept(statement, visitor);
819 accept(binding, visitor);
820 }
821
822 visitor->endVisit(this);
823 }
824
accept0(Visitor * visitor)825 void UiObjectDefinition::accept0(Visitor *visitor)
826 {
827 if (visitor->visit(this)) {
828 accept(qualifiedTypeNameId, visitor);
829 accept(initializer, visitor);
830 }
831
832 visitor->endVisit(this);
833 }
834
accept0(Visitor * visitor)835 void UiObjectInitializer::accept0(Visitor *visitor)
836 {
837 if (visitor->visit(this)) {
838 accept(members, visitor);
839 }
840
841 visitor->endVisit(this);
842 }
843
accept0(Visitor * visitor)844 void UiParameterList::accept0(Visitor *visitor)
845 {
846 if (visitor->visit(this)) {
847 }
848 visitor->endVisit(this);
849 }
850
accept0(Visitor * visitor)851 void UiObjectBinding::accept0(Visitor *visitor)
852 {
853 if (visitor->visit(this)) {
854 accept(qualifiedId, visitor);
855 accept(qualifiedTypeNameId, visitor);
856 accept(initializer, visitor);
857 }
858
859 visitor->endVisit(this);
860 }
861
accept0(Visitor * visitor)862 void UiScriptBinding::accept0(Visitor *visitor)
863 {
864 if (visitor->visit(this)) {
865 accept(qualifiedId, visitor);
866 accept(statement, visitor);
867 }
868
869 visitor->endVisit(this);
870 }
871
accept0(Visitor * visitor)872 void UiArrayBinding::accept0(Visitor *visitor)
873 {
874 if (visitor->visit(this)) {
875 accept(qualifiedId, visitor);
876 accept(members, visitor);
877 }
878
879 visitor->endVisit(this);
880 }
881
accept0(Visitor * visitor)882 void UiObjectMemberList::accept0(Visitor *visitor)
883 {
884 if (visitor->visit(this)) {
885 for (UiObjectMemberList *it = this; it; it = it->next)
886 accept(it->member, visitor);
887 }
888
889 visitor->endVisit(this);
890 }
891
accept0(Visitor * visitor)892 void UiArrayMemberList::accept0(Visitor *visitor)
893 {
894 if (visitor->visit(this)) {
895 for (UiArrayMemberList *it = this; it; it = it->next)
896 accept(it->member, visitor);
897 }
898
899 visitor->endVisit(this);
900 }
901
accept0(Visitor * visitor)902 void UiQualifiedId::accept0(Visitor *visitor)
903 {
904 if (visitor->visit(this)) {
905 }
906
907 visitor->endVisit(this);
908 }
909
accept0(Visitor * visitor)910 void UiImport::accept0(Visitor *visitor)
911 {
912 if (visitor->visit(this)) {
913 accept(importUri, visitor);
914 }
915
916 visitor->endVisit(this);
917 }
918
accept0(Visitor * visitor)919 void UiQualifiedPragmaId::accept0(Visitor *visitor)
920 {
921 if (visitor->visit(this)) {
922 }
923
924 visitor->endVisit(this);
925 }
926
accept0(Visitor * visitor)927 void UiPragma::accept0(Visitor *visitor)
928 {
929 if (visitor->visit(this)) {
930 accept(pragmaType, visitor);
931 }
932
933 visitor->endVisit(this);
934 }
935
accept0(Visitor * visitor)936 void UiHeaderItemList::accept0(Visitor *visitor)
937 {
938 if (visitor->visit(this)) {
939 accept(headerItem, visitor);
940 accept(next, visitor);
941 }
942
943 visitor->endVisit(this);
944 }
945
946
accept0(Visitor * visitor)947 void UiSourceElement::accept0(Visitor *visitor)
948 {
949 if (visitor->visit(this)) {
950 accept(sourceElement, visitor);
951 }
952
953 visitor->endVisit(this);
954 }
955
accept0(Visitor * visitor)956 void UiEnumDeclaration::accept0(Visitor *visitor)
957 {
958 if (visitor->visit(this)) {
959 accept(members, visitor);
960 }
961
962 visitor->endVisit(this);
963 }
964
accept0(Visitor * visitor)965 void UiEnumMemberList::accept0(Visitor *visitor)
966 {
967 if (visitor->visit(this)) {
968 }
969
970 visitor->endVisit(this);
971 }
972
973 } } // namespace QmlJS::AST
974
975 QT_QML_END_NAMESPACE
976
977
978