1	// Copyright (C) 2016 The Qt Company Ltd.
2	// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4	#include <QString>
5	#include <QLocale>
6	#include "common/qqmljssourcelocation_p.h"
7	#include "qqmljsast_p.h"
8
9	#include "qqmljsastvisitor_p.h"
10	#include <qlocale.h>
11
12	#include <algorithm>
13	#include <array>
14
15	QT_BEGIN_NAMESPACE
16
17	namespace QQmlJS { namespace AST {
18
19	FunctionExpression *asAnonymousFunctionDefinition(Node *n)
20	{
21	if (!n)
22	return nullptr;
23	FunctionExpression *f = n->asFunctionDefinition();
24	if (!f || !f->name.isNull())
25	return nullptr;
26	return f;
27	}
28
29	ClassExpression *asAnonymousClassDefinition(Node *n)
30	{
31	if (!n)
32	return nullptr;
33	ClassExpression *c = n->asClassDefinition();
34	if (!c || !c->name.isNull())
35	return nullptr;
36	return c;
37	}
38
39	ExpressionNode *Node::expressionCast()
40	{
41	return nullptr;
42	}
43
44	BinaryExpression *Node::binaryExpressionCast()
45	{
46	return nullptr;
47	}
48
49	Statement *Node::statementCast()
50	{
51	return nullptr;
52	}
53
54	UiObjectMember *Node::uiObjectMemberCast()
55	{
56	return nullptr;
57	}
58
59	LeftHandSideExpression *Node::leftHandSideExpressionCast()
60	{
61	return nullptr;
62	}
63
64	Pattern *Node::patternCast()
65	{
66	return nullptr;
67	}
68
69	FunctionExpression *Node::asFunctionDefinition()
70	{
71	return nullptr;
72	}
73
74	ClassExpression *Node::asClassDefinition()
75	{
76	return nullptr;
77	}
78
79	bool Node::ignoreRecursionDepth() const
80	{
81	static const bool doIgnore = qEnvironmentVariableIsSet(varName: "QV4_CRASH_ON_STACKOVERFLOW");
82	return doIgnore;
83	}
84
85	ExpressionNode *ExpressionNode::expressionCast()
86	{
87	return this;
88	}
89
90	bool ExpressionNode::containsOptionalChain() const
91	{
92	for (const Node *node = this;;) {
93	switch (node->kind) {
94	case Kind_FieldMemberExpression: {
95	const auto *fme = AST::cast<const FieldMemberExpression*>(ast: node);
96	if (fme->isOptional)
97	return true;
98	node = fme->base;
99	break;
100	}
101	case Kind_ArrayMemberExpression: {
102	const auto *ame = AST::cast<const ArrayMemberExpression*>(ast: node);
103	if (ame->isOptional)
104	return true;
105	node = ame->base;
106	break;
107	}
108	case Kind_CallExpression: {
109	const auto *ce = AST::cast<const CallExpression*>(ast: node);
110	if (ce->isOptional)
111	return true;
112	node = ce->base;
113	break;
114	}
115	case Kind_NestedExpression: {
116	const auto *ne = AST::cast<const NestedExpression*>(ast: node);
117	node = ne->expression;
118	break;
119	}
120	default:
121	// These unhandled nodes lead to invalid lvalues anyway, so they do not need to be handled here.
122	return false;
123	}
124	}
125	return false;
126	}
127
128	FormalParameterList *ExpressionNode::reparseAsFormalParameterList(MemoryPool *pool)
129	{
130	AST::ExpressionNode *expr = this;
131	AST::FormalParameterList *f = nullptr;
132	if (AST::Expression *commaExpr = AST::cast<AST::Expression *>(ast: expr)) {
133	f = commaExpr->left->reparseAsFormalParameterList(pool);
134	if (!f)
135	return nullptr;
136
137	expr = commaExpr->right;
138	}
139
140	AST::ExpressionNode *rhs = nullptr;
141	if (AST::BinaryExpression *assign = AST::cast<AST::BinaryExpression *>(ast: expr)) {
142	if (assign->op != QSOperator::Assign)
143	return nullptr;
144	expr = assign->left;
145	rhs = assign->right;
146	}
147	AST::PatternElement *binding = nullptr;
148	if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(ast: expr)) {
149	binding = new (pool) AST::PatternElement(idExpr->name, /*type annotation*/nullptr, rhs);
150	binding->identifierToken = idExpr->identifierToken;
151	} else if (AST::Pattern *p = expr->patternCast()) {
152	SourceLocation loc;
153	QString s;
154	if (!p->convertLiteralToAssignmentPattern(pool, errorLocation: &loc, errorMessage: &s))
155	return nullptr;
156	binding = new (pool) AST::PatternElement(p, rhs);
157	binding->identifierToken = p->firstSourceLocation();
158	}
159	if (!binding)
160	return nullptr;
161	return new (pool) AST::FormalParameterList(f, binding);
162	}
163
164	BinaryExpression *BinaryExpression::binaryExpressionCast()
165	{
166	return this;
167	}
168
169	void TypeExpression::accept0(BaseVisitor *visitor)
170	{
171	visitor->visit(this);
172	visitor->endVisit(this);
173	}
174
175	Statement *Statement::statementCast()
176	{
177	return this;
178	}
179
180	UiObjectMember *UiObjectMember::uiObjectMemberCast()
181	{
182	return this;
183	}
184
185	void NestedExpression::accept0(BaseVisitor *visitor)
186	{
187	if (visitor->visit(this)) {
188	accept(node: expression, visitor);
189	}
190	visitor->endVisit(this);
191	}
192
193	FunctionExpression *NestedExpression::asFunctionDefinition()
194	{
195	return expression->asFunctionDefinition();
196	}
197
198	ClassExpression *NestedExpression::asClassDefinition()
199	{
200	return expression->asClassDefinition();
201	}
202
203	void ThisExpression::accept0(BaseVisitor *visitor)
204	{
205	if (visitor->visit(this)) {
206	}
207
208	visitor->endVisit(this);
209	}
210
211	void IdentifierExpression::accept0(BaseVisitor *visitor)
212	{
213	if (visitor->visit(this)) {
214	}
215
216	visitor->endVisit(this);
217	}
218
219	void NullExpression::accept0(BaseVisitor *visitor)
220	{
221	if (visitor->visit(this)) {
222	}
223
224	visitor->endVisit(this);
225	}
226
227	void TrueLiteral::accept0(BaseVisitor *visitor)
228	{
229	if (visitor->visit(this)) {
230	}
231
232	visitor->endVisit(this);
233	}
234
235	void FalseLiteral::accept0(BaseVisitor *visitor)
236	{
237	if (visitor->visit(this)) {
238	}
239
240	visitor->endVisit(this);
241	}
242
243	void SuperLiteral::accept0(BaseVisitor *visitor)
244	{
245	if (visitor->visit(this)) {
246	}
247
248	visitor->endVisit(this);
249	}
250
251
252	void StringLiteral::accept0(BaseVisitor *visitor)
253	{
254	if (visitor->visit(this)) {
255	}
256
257	visitor->endVisit(this);
258	}
259
260	void TemplateLiteral::accept0(BaseVisitor *visitor)
261	{
262	bool accepted = true;
263	for (TemplateLiteral *it = this; it && accepted; it = it->next) {
264	accepted = visitor->visit(it);
265	visitor->endVisit(it);
266	}
267	}
268
269	void NumericLiteral::accept0(BaseVisitor *visitor)
270	{
271	if (visitor->visit(this)) {
272	}
273
274	visitor->endVisit(this);
275	}
276
277	void RegExpLiteral::accept0(BaseVisitor *visitor)
278	{
279	if (visitor->visit(this)) {
280	}
281
282	visitor->endVisit(this);
283	}
284
285	void ArrayPattern::accept0(BaseVisitor *visitor)
286	{
287	if (visitor->visit(this))
288	accept(node: elements, visitor);
289
290	visitor->endVisit(this);
291	}
292
293	bool ArrayPattern::isValidArrayLiteral(SourceLocation *errorLocation) const {
294	for (PatternElementList *it = elements; it != nullptr; it = it->next) {
295	PatternElement *e = it->element;
296	if (e && e->bindingTarget != nullptr) {
297	if (errorLocation)
298	*errorLocation = e->firstSourceLocation();
299	return false;
300	}
301	}
302	return true;
303	}
304
305	void ObjectPattern::accept0(BaseVisitor *visitor)
306	{
307	if (visitor->visit(this)) {
308	accept(node: properties, visitor);
309	}
310
311	visitor->endVisit(this);
312	}
313
314	/*
315	This is the grammar for AssignmentPattern that we need to convert the literal to:
316
317	AssignmentPattern:
318	ObjectAssignmentPattern
319	ArrayAssignmentPattern
320	ArrayAssignmentPattern:
321	[ ElisionOpt AssignmentRestElementOpt ]
322	[ AssignmentElementList ]
323	[ AssignmentElementList , ElisionOpt AssignmentRestElementOpt ]
324	AssignmentElementList:
325	AssignmentElisionElement
326	AssignmentElementList , AssignmentElisionElement
327	AssignmentElisionElement:
328	ElisionOpt AssignmentElement
329	AssignmentRestElement:
330	... DestructuringAssignmentTarget
331
332	ObjectAssignmentPattern:
333	{}
334	{ AssignmentPropertyList }
335	{ AssignmentPropertyList, }
336	AssignmentPropertyList:
337	AssignmentProperty
338	AssignmentPropertyList , AssignmentProperty
339	AssignmentProperty:
340	IdentifierReference InitializerOpt_In
341	PropertyName:
342	AssignmentElement
343
344	AssignmentElement:
345	DestructuringAssignmentTarget InitializerOpt_In
346	DestructuringAssignmentTarget:
347	LeftHandSideExpression
348
349	It was originally parsed with the following grammar:
350
351	ArrayLiteral:
352	[ ElisionOpt ]
353	[ ElementList ]
354	[ ElementList , ElisionOpt ]
355	ElementList:
356	ElisionOpt AssignmentExpression_In
357	ElisionOpt SpreadElement
358	ElementList , ElisionOpt AssignmentExpression_In
359	ElementList , Elisionopt SpreadElement
360	SpreadElement:
361	... AssignmentExpression_In
362	ObjectLiteral:
363	{}
364	{ PropertyDefinitionList }
365	{ PropertyDefinitionList , }
366	PropertyDefinitionList:
367	PropertyDefinition
368	PropertyDefinitionList , PropertyDefinition
369	PropertyDefinition:
370	IdentifierReference
371	CoverInitializedName
372	PropertyName : AssignmentExpression_In
373	MethodDefinition
374	PropertyName:
375	LiteralPropertyName
376	ComputedPropertyName
377
378	*/
379	bool ArrayPattern::convertLiteralToAssignmentPattern(MemoryPool *pool, SourceLocation *errorLocation, QString *errorMessage)
380	{
381	if (parseMode == Binding)
382	return true;
383	for (auto *it = elements; it; it = it->next) {
384	if (!it->element)
385	continue;
386	if (it->element->type == PatternElement::SpreadElement && it->next) {
387	*errorLocation = it->element->firstSourceLocation();
388	*errorMessage = QString::fromLatin1(ba: "'...' can only appear as last element in a destructuring list.");
389	return false;
390	}
391	if (!it->element->convertLiteralToAssignmentPattern(pool, errorLocation, errorMessage))
392	return false;
393	}
394	parseMode = Binding;
395	return true;
396	}
397
398	bool ObjectPattern::convertLiteralToAssignmentPattern(MemoryPool *pool, SourceLocation *errorLocation, QString *errorMessage)
399	{
400	if (parseMode == Binding)
401	return true;
402	for (auto *it = properties; it; it = it->next) {
403	if (!it->property->convertLiteralToAssignmentPattern(pool, errorLocation, errorMessage))
404	return false;
405	}
406	parseMode = Binding;
407	return true;
408	}
409
410	bool PatternElement::convertLiteralToAssignmentPattern(MemoryPool *pool, SourceLocation *errorLocation, QString *errorMessage)
411	{
412	Q_ASSERT(type == Literal || type == SpreadElement);
413	Q_ASSERT(bindingIdentifier.isNull());
414	Q_ASSERT(bindingTarget == nullptr);
415	Q_ASSERT(bindingTarget == nullptr);
416	Q_ASSERT(initializer);
417	ExpressionNode *init = initializer;
418
419	initializer = nullptr;
420	LeftHandSideExpression *lhs = init->leftHandSideExpressionCast();
421	if (type == SpreadElement) {
422	if (!lhs) {
423	*errorLocation = init->firstSourceLocation();
424	*errorMessage = QString::fromLatin1(ba: "Invalid lhs expression after '...' in destructuring expression.");
425	return false;
426	}
427	} else {
428	type = PatternElement::Binding;
429
430	if (BinaryExpression *b = init->binaryExpressionCast()) {
431	if (b->op != QSOperator::Assign) {
432	*errorLocation = b->operatorToken;
433	*errorMessage = QString::fromLatin1(ba: "Invalid assignment operation in destructuring expression");
434	return false;
435	}
436	lhs = b->left->leftHandSideExpressionCast();
437	initializer = b->right;
438	Q_ASSERT(lhs);
439	} else {
440	lhs = init->leftHandSideExpressionCast();
441	}
442	if (!lhs) {
443	*errorLocation = init->firstSourceLocation();
444	*errorMessage = QString::fromLatin1(ba: "Destructuring target is not a left hand side expression.");
445	return false;
446	}
447	}
448
449	if (auto *i = cast<IdentifierExpression *>(ast: lhs)) {
450	bindingIdentifier = i->name;
451	identifierToken = i->identifierToken;
452	return true;
453	}
454
455	bindingTarget = lhs;
456	if (auto *p = lhs->patternCast()) {
457	if (!p->convertLiteralToAssignmentPattern(pool, errorLocation, errorMessage))
458	return false;
459	}
460	return true;
461	}
462
463	bool PatternProperty::convertLiteralToAssignmentPattern(MemoryPool *pool, SourceLocation *errorLocation, QString *errorMessage)
464	{
465	Q_ASSERT(type != SpreadElement);
466	if (type == Binding)
467	return true;
468	if (type == Getter || type == Setter) {
469	*errorLocation = firstSourceLocation();
470	*errorMessage = QString::fromLatin1(ba: "Invalid getter/setter in destructuring expression.");
471	return false;
472	}
473	if (type == Method)
474	type = Literal;
475	Q_ASSERT(type == Literal);
476	return PatternElement::convertLiteralToAssignmentPattern(pool, errorLocation, errorMessage);
477	}
478
479
480	void Elision::accept0(BaseVisitor *visitor)
481	{
482	if (visitor->visit(this)) {
483	// ###
484	}
485
486	visitor->endVisit(this);
487	}
488
489	void IdentifierPropertyName::accept0(BaseVisitor *visitor)
490	{
491	if (visitor->visit(this)) {
492	}
493
494	visitor->endVisit(this);
495	}
496
497	void StringLiteralPropertyName::accept0(BaseVisitor *visitor)
498	{
499	if (visitor->visit(this)) {
500	}
501
502	visitor->endVisit(this);
503	}
504
505	void NumericLiteralPropertyName::accept0(BaseVisitor *visitor)
506	{
507	if (visitor->visit(this)) {
508	}
509
510	visitor->endVisit(this);
511	}
512
513	namespace {
514	struct LocaleWithoutZeroPadding : public QLocale
515	{
516	LocaleWithoutZeroPadding()
517	: QLocale(QLocale::C)
518	{
519	setNumberOptions(QLocale::OmitLeadingZeroInExponent | QLocale::OmitGroupSeparator);
520	}
521	};
522	}
523
524	QString NumericLiteralPropertyName::asString()const
525	{
526	// Can't use QString::number here anymore as it does zero padding by default now.
527
528	// In C++11 this initialization is thread-safe (6.7 [stmt.dcl] p4)
529	static LocaleWithoutZeroPadding locale;
530	// Because of https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83562 we can't use thread_local
531	// for the locale variable and therefore rely on toString(double) to be thread-safe.
532	return locale.toString(f: id, format: 'g', precision: 16);
533	}
534
535	void ArrayMemberExpression::accept0(BaseVisitor *visitor)
536	{
537	if (visitor->visit(this)) {
538	accept(node: base, visitor);
539	accept(node: expression, visitor);
540	}
541
542	visitor->endVisit(this);
543	}
544
545	void FieldMemberExpression::accept0(BaseVisitor *visitor)
546	{
547	if (visitor->visit(this)) {
548	accept(node: base, visitor);
549	}
550
551	visitor->endVisit(this);
552	}
553
554	void NewMemberExpression::accept0(BaseVisitor *visitor)
555	{
556	if (visitor->visit(this)) {
557	accept(node: base, visitor);
558	accept(node: arguments, visitor);
559	}
560
561	visitor->endVisit(this);
562	}
563
564	void NewExpression::accept0(BaseVisitor *visitor)
565	{
566	if (visitor->visit(this)) {
567	accept(node: expression, visitor);
568	}
569
570	visitor->endVisit(this);
571	}
572
573	void CallExpression::accept0(BaseVisitor *visitor)
574	{
575	if (visitor->visit(this)) {
576	accept(node: base, visitor);
577	accept(node: arguments, visitor);
578	}
579
580	visitor->endVisit(this);
581	}
582
583	void ArgumentList::accept0(BaseVisitor *visitor)
584	{
585	if (visitor->visit(this)) {
586	for (ArgumentList *it = this; it; it = it->next) {
587	accept(node: it->expression, visitor);
588	}
589	}
590
591	visitor->endVisit(this);
592	}
593
594	void PostIncrementExpression::accept0(BaseVisitor *visitor)
595	{
596	if (visitor->visit(this)) {
597	accept(node: base, visitor);
598	}
599
600	visitor->endVisit(this);
601	}
602
603	void PostDecrementExpression::accept0(BaseVisitor *visitor)
604	{
605	if (visitor->visit(this)) {
606	accept(node: base, visitor);
607	}
608
609	visitor->endVisit(this);
610	}
611
612	void DeleteExpression::accept0(BaseVisitor *visitor)
613	{
614	if (visitor->visit(this)) {
615	accept(node: expression, visitor);
616	}
617
618	visitor->endVisit(this);
619	}
620
621	void VoidExpression::accept0(BaseVisitor *visitor)
622	{
623	if (visitor->visit(this)) {
624	accept(node: expression, visitor);
625	}
626
627	visitor->endVisit(this);
628	}
629
630	void TypeOfExpression::accept0(BaseVisitor *visitor)
631	{
632	if (visitor->visit(this)) {
633	accept(node: expression, visitor);
634	}
635
636	visitor->endVisit(this);
637	}
638
639	void PreIncrementExpression::accept0(BaseVisitor *visitor)
640	{
641	if (visitor->visit(this)) {
642	accept(node: expression, visitor);
643	}
644
645	visitor->endVisit(this);
646	}
647
648	void PreDecrementExpression::accept0(BaseVisitor *visitor)
649	{
650	if (visitor->visit(this)) {
651	accept(node: expression, visitor);
652	}
653
654	visitor->endVisit(this);
655	}
656
657	void UnaryPlusExpression::accept0(BaseVisitor *visitor)
658	{
659	if (visitor->visit(this)) {
660	accept(node: expression, visitor);
661	}
662
663	visitor->endVisit(this);
664	}
665
666	void UnaryMinusExpression::accept0(BaseVisitor *visitor)
667	{
668	if (visitor->visit(this)) {
669	accept(node: expression, visitor);
670	}
671
672	visitor->endVisit(this);
673	}
674
675	void TildeExpression::accept0(BaseVisitor *visitor)
676	{
677	if (visitor->visit(this)) {
678	accept(node: expression, visitor);
679	}
680
681	visitor->endVisit(this);
682	}
683
684	void NotExpression::accept0(BaseVisitor *visitor)
685	{
686	if (visitor->visit(this)) {
687	accept(node: expression, visitor);
688	}
689
690	visitor->endVisit(this);
691	}
692
693	void BinaryExpression::accept0(BaseVisitor *visitor)
694	{
695	if (visitor->visit(this)) {
696	accept(node: left, visitor);
697	accept(node: right, visitor);
698	}
699
700	visitor->endVisit(this);
701	}
702
703	void ConditionalExpression::accept0(BaseVisitor *visitor)
704	{
705	if (visitor->visit(this)) {
706	accept(node: expression, visitor);
707	accept(node: ok, visitor);
708	accept(node: ko, visitor);
709	}
710
711	visitor->endVisit(this);
712	}
713
714	void Expression::accept0(BaseVisitor *visitor)
715	{
716	if (visitor->visit(this)) {
717	accept(node: left, visitor);
718	accept(node: right, visitor);
719	}
720
721	visitor->endVisit(this);
722	}
723
724	void Block::accept0(BaseVisitor *visitor)
725	{
726	if (visitor->visit(this)) {
727	accept(node: statements, visitor);
728	}
729
730	visitor->endVisit(this);
731	}
732
733	void StatementList::accept0(BaseVisitor *visitor)
734	{
735	if (visitor->visit(this)) {
736	for (StatementList *it = this; it; it = it->next) {
737	accept(node: it->statement, visitor);
738	}
739	}
740
741	visitor->endVisit(this);
742	}
743
744	void VariableStatement::accept0(BaseVisitor *visitor)
745	{
746	if (visitor->visit(this)) {
747	accept(node: declarations, visitor);
748	}
749
750	visitor->endVisit(this);
751	}
752
753	void VariableDeclarationList::accept0(BaseVisitor *visitor)
754	{
755	if (visitor->visit(this)) {
756	for (VariableDeclarationList *it = this; it; it = it->next) {
757	accept(node: it->declaration, visitor);
758	}
759	}
760
761	visitor->endVisit(this);
762	}
763
764	void EmptyStatement::accept0(BaseVisitor *visitor)
765	{
766	if (visitor->visit(this)) {
767	}
768
769	visitor->endVisit(this);
770	}
771
772	void ExpressionStatement::accept0(BaseVisitor *visitor)
773	{
774	if (visitor->visit(this)) {
775	accept(node: expression, visitor);
776	}
777
778	visitor->endVisit(this);
779	}
780
781	void IfStatement::accept0(BaseVisitor *visitor)
782	{
783	if (visitor->visit(this)) {
784	accept(node: expression, visitor);
785	accept(node: ok, visitor);
786	accept(node: ko, visitor);
787	}
788
789	visitor->endVisit(this);
790	}
791
792	void DoWhileStatement::accept0(BaseVisitor *visitor)
793	{
794	if (visitor->visit(this)) {
795	accept(node: statement, visitor);
796	accept(node: expression, visitor);
797	}
798
799	visitor->endVisit(this);
800	}
801
802	void WhileStatement::accept0(BaseVisitor *visitor)
803	{
804	if (visitor->visit(this)) {
805	accept(node: expression, visitor);
806	accept(node: statement, visitor);
807	}
808
809	visitor->endVisit(this);
810	}
811
812	void ForStatement::accept0(BaseVisitor *visitor)
813	{
814	if (visitor->visit(this)) {
815	accept(node: initialiser, visitor);
816	accept(node: declarations, visitor);
817	accept(node: condition, visitor);
818	accept(node: expression, visitor);
819	accept(node: statement, visitor);
820	}
821
822	visitor->endVisit(this);
823	}
824
825	void ForEachStatement::accept0(BaseVisitor *visitor)
826	{
827	if (visitor->visit(this)) {
828	accept(node: lhs, visitor);
829	accept(node: expression, visitor);
830	accept(node: statement, visitor);
831	}
832
833	visitor->endVisit(this);
834	}
835
836	void ContinueStatement::accept0(BaseVisitor *visitor)
837	{
838	if (visitor->visit(this)) {
839	}
840
841	visitor->endVisit(this);
842	}
843
844	void BreakStatement::accept0(BaseVisitor *visitor)
845	{
846	if (visitor->visit(this)) {
847	}
848
849	visitor->endVisit(this);
850	}
851
852	void ReturnStatement::accept0(BaseVisitor *visitor)
853	{
854	if (visitor->visit(this)) {
855	accept(node: expression, visitor);
856	}
857
858	visitor->endVisit(this);
859	}
860
861	void YieldExpression::accept0(BaseVisitor *visitor)
862	{
863	if (visitor->visit(this)) {
864	accept(node: expression, visitor);
865	}
866
867	visitor->endVisit(this);
868	}
869
870
871	void WithStatement::accept0(BaseVisitor *visitor)
872	{
873	if (visitor->visit(this)) {
874	accept(node: expression, visitor);
875	accept(node: statement, visitor);
876	}
877
878	visitor->endVisit(this);
879	}
880
881	void SwitchStatement::accept0(BaseVisitor *visitor)
882	{
883	if (visitor->visit(this)) {
884	accept(node: expression, visitor);
885	accept(node: block, visitor);
886	}
887
888	visitor->endVisit(this);
889	}
890
891	void CaseBlock::accept0(BaseVisitor *visitor)
892	{
893	if (visitor->visit(this)) {
894	accept(node: clauses, visitor);
895	accept(node: defaultClause, visitor);
896	accept(node: moreClauses, visitor);
897	}
898
899	visitor->endVisit(this);
900	}
901
902	void CaseClauses::accept0(BaseVisitor *visitor)
903	{
904	if (visitor->visit(this)) {
905	for (CaseClauses *it = this; it; it = it->next) {
906	accept(node: it->clause, visitor);
907	}
908	}
909
910	visitor->endVisit(this);
911	}
912
913	void CaseClause::accept0(BaseVisitor *visitor)
914	{
915	if (visitor->visit(this)) {
916	accept(node: expression, visitor);
917	accept(node: statements, visitor);
918	}
919
920	visitor->endVisit(this);
921	}
922
923	void DefaultClause::accept0(BaseVisitor *visitor)
924	{
925	if (visitor->visit(this)) {
926	accept(node: statements, visitor);
927	}
928
929	visitor->endVisit(this);
930	}
931
932	void LabelledStatement::accept0(BaseVisitor *visitor)
933	{
934	if (visitor->visit(this)) {
935	accept(node: statement, visitor);
936	}
937
938	visitor->endVisit(this);
939	}
940
941	void ThrowStatement::accept0(BaseVisitor *visitor)
942	{
943	if (visitor->visit(this)) {
944	accept(node: expression, visitor);
945	}
946
947	visitor->endVisit(this);
948	}
949
950	void TryStatement::accept0(BaseVisitor *visitor)
951	{
952	if (visitor->visit(this)) {
953	accept(node: statement, visitor);
954	accept(node: catchExpression, visitor);
955	accept(node: finallyExpression, visitor);
956	}
957
958	visitor->endVisit(this);
959	}
960
961	void Catch::accept0(BaseVisitor *visitor)
962	{
963	if (visitor->visit(this)) {
964	accept(node: patternElement, visitor);
965	accept(node: statement, visitor);
966	}
967
968	visitor->endVisit(this);
969	}
970
971	void Finally::accept0(BaseVisitor *visitor)
972	{
973	if (visitor->visit(this)) {
974	accept(node: statement, visitor);
975	}
976
977	visitor->endVisit(this);
978	}
979
980	void FunctionDeclaration::accept0(BaseVisitor *visitor)
981	{
982	if (visitor->visit(this)) {
983	accept(node: formals, visitor);
984	accept(node: typeAnnotation, visitor);
985	accept(node: body, visitor);
986	}
987
988	visitor->endVisit(this);
989	}
990
991	void FunctionExpression::accept0(BaseVisitor *visitor)
992	{
993	if (visitor->visit(this)) {
994	accept(node: formals, visitor);
995	accept(node: typeAnnotation, visitor);
996	accept(node: body, visitor);
997	}
998
999	visitor->endVisit(this);
1000	}
1001
1002	FunctionExpression *FunctionExpression::asFunctionDefinition()
1003	{
1004	return this;
1005	}
1006
1007	BoundNames FormalParameterList::formals() const
1008	{
1009	BoundNames formals;
1010	int i = 0;
1011	for (const FormalParameterList *it = this; it; it = it->next) {
1012	if (it->element) {
1013	QString name = it->element->bindingIdentifier.toString();
1014	int duplicateIndex = formals.indexOf(name);
1015	if (duplicateIndex >= 0) {
1016	// change the name of the earlier argument to enforce the lookup semantics from the spec
1017	formals[duplicateIndex].id += QLatin1String("#") + QString::number(i);
1018	}
1019	formals += { name, it->element->firstSourceLocation(), it->element->typeAnnotation,
1020	it->element->isInjectedSignalParameter ? BoundName::Injected
1021	: BoundName::Declared };
1022	}
1023	++i;
1024	}
1025	return formals;
1026	}
1027
1028	BoundNames FormalParameterList::boundNames() const
1029	{
1030	BoundNames names;
1031	for (const FormalParameterList *it = this; it; it = it->next) {
1032	if (it->element)
1033	it->element->boundNames(names: &names);
1034	}
1035	return names;
1036	}
1037
1038	void FormalParameterList::accept0(BaseVisitor *visitor)
1039	{
1040	bool accepted = true;
1041	for (FormalParameterList *it = this; it && accepted; it = it->next) {
1042	accepted = visitor->visit(it);
1043	if (accepted)
1044	accept(node: it->element, visitor);
1045	visitor->endVisit(it);
1046	}
1047	}
1048
1049	FormalParameterList *FormalParameterList::finish(QQmlJS::MemoryPool *)
1050	{
1051	FormalParameterList *front = next;
1052	next = nullptr;
1053	return front;
1054	}
1055
1056	void Program::accept0(BaseVisitor *visitor)
1057	{
1058	if (visitor->visit(this)) {
1059	accept(node: statements, visitor);
1060	}
1061
1062	visitor->endVisit(this);
1063	}
1064
1065	void ImportSpecifier::accept0(BaseVisitor *visitor)
1066	{
1067	if (visitor->visit(this)) {
1068
1069	}
1070	visitor->endVisit(this);
1071	}
1072
1073	void ImportsList::accept0(BaseVisitor *visitor)
1074	{
1075	if (visitor->visit(this)) {
1076	for (ImportsList *it = this; it; it = it->next) {
1077	accept(node: it->importSpecifier, visitor);
1078	}
1079	}
1080
1081	visitor->endVisit(this);
1082	}
1083
1084	void NamedImports::accept0(BaseVisitor *visitor)
1085	{
1086	if (visitor->visit(this)) {
1087	accept(node: importsList, visitor);
1088	}
1089
1090	visitor->endVisit(this);
1091	}
1092
1093	void FromClause::accept0(BaseVisitor *visitor)
1094	{
1095	if (visitor->visit(this)) {
1096	}
1097
1098	visitor->endVisit(this);
1099	}
1100
1101	void NameSpaceImport::accept0(BaseVisitor *visitor)
1102	{
1103	if (visitor->visit(this)) {
1104	}
1105
1106	visitor->endVisit(this);
1107	}
1108
1109	void ImportClause::accept0(BaseVisitor *visitor)
1110	{
1111	if (visitor->visit(this)) {
1112	accept(node: nameSpaceImport, visitor);
1113	accept(node: namedImports, visitor);
1114	}
1115
1116	visitor->endVisit(this);
1117	}
1118
1119	void ImportDeclaration::accept0(BaseVisitor *visitor)
1120	{
1121	if (visitor->visit(this)) {
1122	accept(node: importClause, visitor);
1123	accept(node: fromClause, visitor);
1124	}
1125
1126	visitor->endVisit(this);
1127	}
1128
1129	void ExportSpecifier::accept0(BaseVisitor *visitor)
1130	{
1131	if (visitor->visit(this)) {
1132
1133	}
1134
1135	visitor->endVisit(this);
1136	}
1137
1138	void ExportsList::accept0(BaseVisitor *visitor)
1139	{
1140	if (visitor->visit(this)) {
1141	for (ExportsList *it = this; it; it = it->next) {
1142	accept(node: it->exportSpecifier, visitor);
1143	}
1144	}
1145
1146	visitor->endVisit(this);
1147	}
1148
1149	void ExportClause::accept0(BaseVisitor *visitor)
1150	{
1151	if (visitor->visit(this)) {
1152	accept(node: exportsList, visitor);
1153	}
1154
1155	visitor->endVisit(this);
1156	}
1157
1158	void ExportDeclaration::accept0(BaseVisitor *visitor)
1159	{
1160	if (visitor->visit(this)) {
1161	accept(node: exportClause, visitor);
1162	accept(node: fromClause, visitor);
1163	accept(node: variableStatementOrDeclaration, visitor);
1164	}
1165
1166	visitor->endVisit(this);
1167	}
1168
1169	void ESModule::accept0(BaseVisitor *visitor)
1170	{
1171	if (visitor->visit(this)) {
1172	accept(node: body, visitor);
1173	}
1174
1175	visitor->endVisit(this);
1176	}
1177
1178	void DebuggerStatement::accept0(BaseVisitor *visitor)
1179	{
1180	if (visitor->visit(this)) {
1181	}
1182
1183	visitor->endVisit(this);
1184	}
1185
1186	void UiProgram::accept0(BaseVisitor *visitor)
1187	{
1188	if (visitor->visit(this)) {
1189	accept(node: headers, visitor);
1190	accept(node: members, visitor);
1191	}
1192
1193	visitor->endVisit(this);
1194	}
1195
1196	void UiPublicMember::accept0(BaseVisitor *visitor)
1197	{
1198	if (visitor->visit(this)) {
1199	// accept(annotations, visitor); // accept manually in visit if interested
1200	// accept(memberType, visitor); // accept manually in visit if interested
1201	accept(node: statement, visitor);
1202	accept(node: binding, visitor);
1203	// accept(parameters, visitor); // accept manually in visit if interested
1204	}
1205
1206	visitor->endVisit(this);
1207	}
1208
1209	void UiObjectDefinition::accept0(BaseVisitor *visitor)
1210	{
1211	if (visitor->visit(this)) {
1212	// accept(annotations, visitor); // accept manually in visit if interested
1213	accept(node: qualifiedTypeNameId, visitor);
1214	accept(node: initializer, visitor);
1215	}
1216
1217	visitor->endVisit(this);
1218	}
1219
1220	void UiObjectInitializer::accept0(BaseVisitor *visitor)
1221	{
1222	if (visitor->visit(this)) {
1223	accept(node: members, visitor);
1224	}
1225
1226	visitor->endVisit(this);
1227	}
1228
1229	void UiParameterList::accept0(BaseVisitor *visitor)
1230	{
1231	if (visitor->visit(this)) {
1232	// accept(type, visitor); // accept manually in visit if interested
1233	}
1234	visitor->endVisit(this);
1235	}
1236
1237	void UiObjectBinding::accept0(BaseVisitor *visitor)
1238	{
1239	if (visitor->visit(this)) {
1240	// accept(annotations, visitor); // accept manually in visit if interested
1241	accept(node: qualifiedId, visitor);
1242	accept(node: qualifiedTypeNameId, visitor);
1243	accept(node: initializer, visitor);
1244	}
1245
1246	visitor->endVisit(this);
1247	}
1248
1249	void UiScriptBinding::accept0(BaseVisitor *visitor)
1250	{
1251	if (visitor->visit(this)) {
1252	// accept(annotations, visitor); // accept manually in visit if interested
1253	accept(node: qualifiedId, visitor);
1254	accept(node: statement, visitor);
1255	}
1256
1257	visitor->endVisit(this);
1258	}
1259
1260	void UiArrayBinding::accept0(BaseVisitor *visitor)
1261	{
1262	if (visitor->visit(this)) {
1263	// accept(annotations, visitor); // accept manually in visit if interested
1264	accept(node: qualifiedId, visitor);
1265	accept(node: members, visitor);
1266	}
1267
1268	visitor->endVisit(this);
1269	}
1270
1271	void UiObjectMemberList::accept0(BaseVisitor *visitor)
1272	{
1273	if (visitor->visit(this)) {
1274	for (UiObjectMemberList *it = this; it; it = it->next)
1275	accept(node: it->member, visitor);
1276	}
1277
1278	visitor->endVisit(this);
1279	}
1280
1281	void UiArrayMemberList::accept0(BaseVisitor *visitor)
1282	{
1283	if (visitor->visit(this)) {
1284	for (UiArrayMemberList *it = this; it; it = it->next)
1285	accept(node: it->member, visitor);
1286	}
1287
1288	visitor->endVisit(this);
1289	}
1290
1291	void UiQualifiedId::accept0(BaseVisitor *visitor)
1292	{
1293	if (visitor->visit(this)) {
1294	// accept(next, visitor) // accept manually in visit if interested
1295	}
1296
1297	visitor->endVisit(this);
1298	}
1299
1300	void Type::accept0(BaseVisitor *visitor)
1301	{
1302	if (visitor->visit(this)) {
1303	accept(node: typeId, visitor);
1304	accept(node: typeArgument, visitor);
1305	}
1306
1307	visitor->endVisit(this);
1308	}
1309
1310	void TypeAnnotation::accept0(BaseVisitor *visitor)
1311	{
1312	if (visitor->visit(this)) {
1313	accept(node: type, visitor);
1314	}
1315
1316	visitor->endVisit(this);
1317	}
1318
1319	void UiImport::accept0(BaseVisitor *visitor)
1320	{
1321	if (visitor->visit(this)) {
1322	accept(node: importUri, visitor);
1323	// accept(version, visitor); // accept manually in visit if interested
1324	}
1325
1326	visitor->endVisit(this);
1327	}
1328
1329	void UiPragmaValueList::accept0(BaseVisitor *visitor)
1330	{
1331	if (visitor->visit(this)) {
1332	}
1333
1334	visitor->endVisit(this);
1335	}
1336
1337
1338	void UiPragma::accept0(BaseVisitor *visitor)
1339	{
1340	if (visitor->visit(this)) {
1341	}
1342
1343	visitor->endVisit(this);
1344	}
1345
1346	void UiHeaderItemList::accept0(BaseVisitor *visitor)
1347	{
1348	bool accepted = true;
1349	for (UiHeaderItemList *it = this; it && accepted; it = it->next) {
1350	accepted = visitor->visit(it);
1351	if (accepted)
1352	accept(node: it->headerItem, visitor);
1353
1354	visitor->endVisit(it);
1355	}
1356	}
1357
1358
1359	void UiSourceElement::accept0(BaseVisitor *visitor)
1360	{
1361	if (visitor->visit(this)) {
1362	// accept(annotations, visitor); // accept manually in visit if interested
1363	accept(node: sourceElement, visitor);
1364	}
1365
1366	visitor->endVisit(this);
1367	}
1368
1369	void UiEnumDeclaration::accept0(BaseVisitor *visitor)
1370	{
1371	if (visitor->visit(this)) {
1372	// accept(annotations, visitor); // accept manually in visit if interested
1373	accept(node: members, visitor);
1374	}
1375
1376	visitor->endVisit(this);
1377	}
1378
1379	void UiEnumMemberList::accept0(BaseVisitor *visitor)
1380	{
1381	if (visitor->visit(this)) {
1382	}
1383
1384	visitor->endVisit(this);
1385	}
1386
1387	void TaggedTemplate::accept0(BaseVisitor *visitor)
1388	{
1389	if (visitor->visit(this)) {
1390	accept(node: base, visitor);
1391	accept(node: templateLiteral, visitor);
1392	}
1393
1394	visitor->endVisit(this);
1395	}
1396
1397	void InitializerExpression::accept0(BaseVisitor *visitor)
1398	{
1399	expression->accept0(visitor);
1400	}
1401
1402	void PatternElement::accept0(BaseVisitor *visitor)
1403	{
1404	if (visitor->visit(this)) {
1405	accept(node: bindingTarget, visitor);
1406	accept(node: typeAnnotation, visitor);
1407	accept(node: initializer, visitor);
1408	}
1409
1410	visitor->endVisit(this);
1411	}
1412
1413	void PatternElement::boundNames(BoundNames *names)
1414	{
1415	if (bindingTarget) {
1416	if (PatternElementList *e = elementList())
1417	e->boundNames(names);
1418	else if (PatternPropertyList *p = propertyList())
1419	p->boundNames(names);
1420	} else {
1421	names->append(t: { bindingIdentifier.toString(), firstSourceLocation(), typeAnnotation,
1422	isInjectedSignalParameter ? BoundName::Injected : BoundName::Declared });
1423	}
1424	}
1425
1426	void PatternElementList::accept0(BaseVisitor *visitor)
1427	{
1428	bool accepted = true;
1429	for (PatternElementList *it = this; it && accepted; it = it->next) {
1430	accepted = visitor->visit(it);
1431	if (accepted) {
1432	accept(node: it->elision, visitor);
1433	accept(node: it->element, visitor);
1434	}
1435	visitor->endVisit(it);
1436	}
1437	}
1438
1439	void PatternElementList::boundNames(BoundNames *names)
1440	{
1441	for (PatternElementList *it = this; it; it = it->next) {
1442	if (it->element)
1443	it->element->boundNames(names);
1444	}
1445	}
1446
1447	void PatternProperty::accept0(BaseVisitor *visitor)
1448	{
1449	if (visitor->visit(this)) {
1450	accept(node: name, visitor);
1451	accept(node: bindingTarget, visitor);
1452	accept(node: typeAnnotation, visitor);
1453	accept(node: initializer, visitor);
1454	}
1455
1456	visitor->endVisit(this);
1457	}
1458
1459	void PatternProperty::boundNames(BoundNames *names)
1460	{
1461	PatternElement::boundNames(names);
1462	}
1463
1464	void PatternPropertyList::accept0(BaseVisitor *visitor)
1465	{
1466	bool accepted = true;
1467	for (PatternPropertyList *it = this; it && accepted; it = it->next) {
1468	accepted = visitor->visit(it);
1469	if (accepted)
1470	accept(node: it->property, visitor);
1471	visitor->endVisit(it);
1472	}
1473	}
1474
1475	void PatternPropertyList::boundNames(BoundNames *names)
1476	{
1477	for (PatternPropertyList *it = this; it; it = it->next)
1478	it->property->boundNames(names);
1479	}
1480
1481	void ComputedPropertyName::accept0(BaseVisitor *visitor)
1482	{
1483	if (visitor->visit(this)) {
1484	accept(node: expression, visitor);
1485	}
1486
1487	visitor->endVisit(this);
1488	}
1489
1490	void ClassExpression::accept0(BaseVisitor *visitor)
1491	{
1492	if (visitor->visit(this)) {
1493	accept(node: heritage, visitor);
1494	accept(node: elements, visitor);
1495	}
1496
1497	visitor->endVisit(this);
1498	}
1499
1500	ClassExpression *ClassExpression::asClassDefinition()
1501	{
1502	return this;
1503	}
1504
1505	void ClassDeclaration::accept0(BaseVisitor *visitor)
1506	{
1507	if (visitor->visit(this)) {
1508	accept(node: heritage, visitor);
1509	accept(node: elements, visitor);
1510	}
1511
1512	visitor->endVisit(this);
1513	}
1514
1515	void ClassElementList::accept0(BaseVisitor *visitor)
1516	{
1517	bool accepted = true;
1518	for (ClassElementList *it = this; it && accepted; it = it->next) {
1519	accepted = visitor->visit(it);
1520	if (accepted)
1521	accept(node: it->property, visitor);
1522
1523	visitor->endVisit(it);
1524	}
1525	}
1526
1527	ClassElementList *ClassElementList::finish()
1528	{
1529	ClassElementList *front = next;
1530	next = nullptr;
1531	return front;
1532	}
1533
1534	Pattern *Pattern::patternCast()
1535	{
1536	return this;
1537	}
1538
1539	LeftHandSideExpression *LeftHandSideExpression::leftHandSideExpressionCast()
1540	{
1541	return this;
1542	}
1543
1544	void UiVersionSpecifier::accept0(BaseVisitor *visitor)
1545	{
1546	if (visitor->visit(this)) {
1547	}
1548	visitor->endVisit(this);
1549	}
1550
1551	QString Type::toString() const
1552	{
1553	QString result;
1554	toString(out: &result);
1555	return result;
1556	}
1557
1558	void Type::toString(QString *out) const
1559	{
1560	typeId->toString(out);
1561
1562	if (typeArgument) {
1563	out->append(c: QLatin1Char('<'));
1564	typeArgument->toString(out);
1565	out->append(c: QLatin1Char('>'));
1566	};
1567	}
1568
1569	void UiInlineComponent::accept0(BaseVisitor *visitor)
1570	{
1571	if (visitor->visit(this)) {
1572	// accept(annotations, visitor); // accept manually in visit if interested
1573	accept(node: component, visitor);
1574	}
1575
1576	visitor->endVisit(this);
1577	}
1578
1579	void UiRequired::accept0(BaseVisitor *visitor)
1580	{
1581	if (visitor->visit(this)) {
1582	}
1583
1584	visitor->endVisit(this);
1585	}
1586
1587	void UiAnnotationList::accept0(BaseVisitor *visitor)
1588	{
1589	if (visitor->visit(this)) {
1590	for (UiAnnotationList *it = this; it; it = it->next)
1591	accept(node: it->annotation, visitor);
1592	}
1593
1594	visitor->endVisit(this);
1595	}
1596
1597	void UiAnnotation::accept0(BaseVisitor *visitor)
1598	{
1599	if (visitor->visit(this)) {
1600	accept(node: qualifiedTypeNameId, visitor);
1601	accept(node: initializer, visitor);
1602	}
1603
1604	visitor->endVisit(this);
1605	}
1606
1607	SourceLocation UiPropertyAttributes::firstSourceLocation() const
1608	{
1609	std::array<const SourceLocation *, 4> tokens {&m_propertyToken, &m_defaultToken, &m_readonlyToken, &m_requiredToken};
1610	const auto it = std::min_element(first: tokens.begin(), last: tokens.end(), comp: compareLocationsByBegin<true>);
1611	return **it;
1612	}
1613
1614	SourceLocation UiPropertyAttributes::lastSourceLocation() const
1615	{
1616	std::array<const SourceLocation *, 4> tokens {&m_propertyToken, &m_defaultToken, &m_readonlyToken, &m_requiredToken};
1617	const auto it = std::max_element(first: tokens.begin(), last: tokens.end(), comp: compareLocationsByBegin<false>);
1618	return **it;
1619	}
1620
1621	} } // namespace QQmlJS::AST
1622
1623	QT_END_NAMESPACE
1624
1625
1626