Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant
++
++ #include <QString>
++ #include <QLocale>
++ #include "common/qqmljsdiagnosticmessage_p.h"
++ #include "common/qqmljssourcelocation_p.h"
++ #include "qqmljsast_p.h"
++
++ #include "qqmljsastvisitor_p.h"
++ #include <qlocale.h>
++
++ #include <algorithm>
++ #include <array>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace QQmlJS { namespace AST {
++
++ FunctionExpression *asAnonymousFunctionDefinition(Node *n)
++ {
++ if (!n)
++ return nullptr;
++ FunctionExpression *f = n->asFunctionDefinition();
++ if (!f || !f->name.isNull())
++ return nullptr;
++ return f;
++ }
++
++ ClassExpression *asAnonymousClassDefinition(Node *n)
++ {
++ if (!n)
++ return nullptr;
++ ClassExpression *c = n->asClassDefinition();
++ if (!c || !c->name.isNull())
++ return nullptr;
++ return c;
++ }
++
++ ExpressionNode *Node::expressionCast()
++ {
++ return nullptr;
++ }
++
++ BinaryExpression *Node::binaryExpressionCast()
++ {
++ return nullptr;
++ }
++
++ Statement *Node::statementCast()
++ {
++ return nullptr;
++ }
++
++ UiObjectMember *Node::uiObjectMemberCast()
++ {
++ return nullptr;
++ }
++
++ LeftHandSideExpression *Node::leftHandSideExpressionCast()
++ {
++ return nullptr;
++ }
++
++ Pattern *Node::patternCast()
++ {
++ return nullptr;
++ }
++
++ FunctionExpression *Node::asFunctionDefinition()
++ {
++ return nullptr;
++ }
++
++ ClassExpression *Node::asClassDefinition()
++ {
++ return nullptr;
++ }
++
++ bool Node::ignoreRecursionDepth() const
++ {
++ static const bool doIgnore = qEnvironmentVariableIsSet("QV4_CRASH_ON_STACKOVERFLOW");
++ return doIgnore;
++ }
++
++ ExpressionNode *ExpressionNode::expressionCast()
++ {
++ return this;
++ }
++
++ bool ExpressionNode::containsOptionalChain() const
++ {
++ for (const Node *node = this;;) {
++ switch (node->kind) {
++ case Kind_FieldMemberExpression: {
++ const auto *fme = AST::cast<const FieldMemberExpression*>(node);
++ if (fme->isOptional)
++ return true;
++ node = fme->base;
++ break;
++ }
++ case Kind_ArrayMemberExpression: {
++ const auto *ame = AST::cast<const ArrayMemberExpression*>(node);
++ if (ame->isOptional)
++ return true;
++ node = ame->base;
++ break;
++ }
++ case Kind_CallExpression: {
++ const auto *ce = AST::cast<const CallExpression*>(node);
++ if (ce->isOptional)
++ return true;
++ node = ce->base;
++ break;
++ }
++ case Kind_NestedExpression: {
++ const auto *ne = AST::cast<const NestedExpression*>(node);
++ node = ne->expression;
++ break;
++ }
++ default:
++ // These unhandled nodes lead to invalid lvalues anyway, so they do not need to be handled here.
++ return false;
++ }
++ }
++ return false;
++ }
++
++ FormalParameterList *ExpressionNode::reparseAsFormalParameterList(MemoryPool *pool)
++ {
++ AST::ExpressionNode *expr = this;
++ AST::FormalParameterList *f = nullptr;
++ if (AST::CommaExpression *commaExpr = AST::cast<AST::CommaExpression *>(expr)) {
++ f = commaExpr->left->reparseAsFormalParameterList(pool);
++ if (!f)
++ return nullptr;
++
++ f->commaToken = commaExpr->commaToken;
++ expr = commaExpr->right;
++ }
++
++ AST::ExpressionNode *rhs = nullptr;
++ if (AST::BinaryExpression *assign = AST::cast<AST::BinaryExpression *>(expr)) {
++ if (assign->op != QSOperator::Assign)
++ return nullptr;
++ expr = assign->left;
++ rhs = assign->right;
++ }
++ AST::PatternElement *binding = nullptr;
++ if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(expr)) {
++ binding = new (pool) AST::PatternElement(idExpr->name, /*type annotation*/nullptr, rhs);
++ binding->identifierToken = idExpr->identifierToken;
++ } else if (AST::Pattern *p = expr->patternCast()) {
++ SourceLocation loc;
++ QString s;
++ if (!p->convertLiteralToAssignmentPattern(&loc, &s))
++ return nullptr;
++ binding = new (pool) AST::PatternElement(p, rhs);
++ binding->identifierToken = p->firstSourceLocation();
++ }
++ if (!binding)
++ return nullptr;
++
++ return new (pool) AST::FormalParameterList(f, binding);
++ }
++
++ BinaryExpression *BinaryExpression::binaryExpressionCast()
++ {
++ return this;
++ }
++
++ void TypeExpression::accept0(BaseVisitor *visitor)
++ {
++ visitor->visit(this);
++ visitor->endVisit(this);
++ }
++
++ Statement *Statement::statementCast()
++ {
++ return this;
++ }
++
++ UiObjectMember *UiObjectMember::uiObjectMemberCast()
++ {
++ return this;
++ }
++
++ void NestedExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++ visitor->endVisit(this);
++ }
++
++ FunctionExpression *NestedExpression::asFunctionDefinition()
++ {
++ return expression->asFunctionDefinition();
++ }
++
++ ClassExpression *NestedExpression::asClassDefinition()
++ {
++ return expression->asClassDefinition();
++ }
++
++ void ThisExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void IdentifierExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void NullExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void TrueLiteral::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void FalseLiteral::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void SuperLiteral::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++
++ void StringLiteral::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void TemplateLiteral::accept0(BaseVisitor *visitor)
++ {
++ bool accepted = true;
++ for (TemplateLiteral *it = this; it && accepted; it = it->next) {
++ accepted = visitor->visit(it);
++ visitor->endVisit(it);
++ }
++ }
++
++ void NumericLiteral::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void RegExpLiteral::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ArrayPattern::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this))
++ accept(elements, visitor);
++
++ visitor->endVisit(this);
++ }
++
++ bool ArrayPattern::isValidArrayLiteral(SourceLocation *errorLocation) const {
++ for (PatternElementList *it = elements; it != nullptr; it = it->next) {
++ PatternElement *e = it->element;
++ if (e && e->bindingTarget != nullptr) {
++ if (errorLocation)
++ *errorLocation = e->firstSourceLocation();
++ return false;
++ }
++ }
++ return true;
++ }
++
++ void ObjectPattern::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(properties, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ /*
++ This is the grammar for AssignmentPattern that we need to convert the literal to:
++
++ AssignmentPattern:
++ ObjectAssignmentPattern
++ ArrayAssignmentPattern
++ ArrayAssignmentPattern:
++ [ ElisionOpt AssignmentRestElementOpt ]
++ [ AssignmentElementList ]
++ [ AssignmentElementList , ElisionOpt AssignmentRestElementOpt ]
++ AssignmentElementList:
++ AssignmentElisionElement
++ AssignmentElementList , AssignmentElisionElement
++ AssignmentElisionElement:
++ ElisionOpt AssignmentElement
++ AssignmentRestElement:
++ ... DestructuringAssignmentTarget
++
++ ObjectAssignmentPattern:
++ {}
++ { AssignmentPropertyList }
++ { AssignmentPropertyList, }
++ AssignmentPropertyList:
++ AssignmentProperty
++ AssignmentPropertyList , AssignmentProperty
++ AssignmentProperty:
++ IdentifierReference InitializerOpt_In
++ PropertyName:
++ AssignmentElement
++
++ AssignmentElement:
++ DestructuringAssignmentTarget InitializerOpt_In
++ DestructuringAssignmentTarget:
++ LeftHandSideExpression
++
++ It was originally parsed with the following grammar:
++
++ ArrayLiteral:
++ [ ElisionOpt ]
++ [ ElementList ]
++ [ ElementList , ElisionOpt ]
++ ElementList:
++ ElisionOpt AssignmentExpression_In
++ ElisionOpt SpreadElement
++ ElementList , ElisionOpt AssignmentExpression_In
++ ElementList , Elisionopt SpreadElement
++ SpreadElement:
++ ... AssignmentExpression_In
++ ObjectLiteral:
++ {}
++ { PropertyDefinitionList }
++ { PropertyDefinitionList , }
++ PropertyDefinitionList:
++ PropertyDefinition
++ PropertyDefinitionList , PropertyDefinition
++ PropertyDefinition:
++ IdentifierReference
++ CoverInitializedName
++ PropertyName : AssignmentExpression_In
++ MethodDefinition
++ PropertyName:
++ LiteralPropertyName
++ ComputedPropertyName
++
++ */
++ bool ArrayPattern::convertLiteralToAssignmentPattern(SourceLocation *errorLocation, QString *errorMessage)
++ {
++ if (parseMode == Binding)
++ return true;
++ for (auto *it = elements; it; it = it->next) {
++ if (!it->element)
++ continue;
++ if (it->element->type == PatternElement::SpreadElement && it->next) {
++ *errorLocation = it->element->firstSourceLocation();
++ *errorMessage = QString::fromLatin1("'...' can only appear as last element in a destructuring list.");
++ return false;
++ }
++ if (!it->element->convertLiteralToAssignmentPattern(errorLocation, errorMessage))
++ return false;
++ }
++ parseMode = Binding;
++ return true;
++ }
++
++ QList<DiagnosticMessage> ArrayPattern::warningsForAssignments() const
++ {
++ QList<DiagnosticMessage> result;
++ for (auto *it = elements; it; it = it->next) {
++ if (!it->element)
++ continue;
++ result += it->element->warningsForAssignments();
++ }
++ return result;
++ }
++
++ bool ObjectPattern::convertLiteralToAssignmentPattern(SourceLocation *errorLocation, QString *errorMessage)
++ {
++ if (parseMode == Binding)
++ return true;
++ for (auto *it = properties; it; it = it->next) {
++ if (!it->property->convertLiteralToAssignmentPattern(errorLocation, errorMessage))
++ return false;
++ }
++ parseMode = Binding;
++ return true;
++ }
++
++ QList<DiagnosticMessage> ObjectPattern::warningsForAssignments() const
++ {
++ QList<DiagnosticMessage> result;
++ for (auto *it = properties; it; it = it->next)
++ result += it->property->warningsForAssignments();
++ return result;
++ }
++
++ bool PatternElement::convertLiteralToAssignmentPattern(SourceLocation *errorLocation, QString *errorMessage)
++ {
++ Q_ASSERT(type == Literal || type == SpreadElement);
++ Q_ASSERT(bindingIdentifier.isNull());
++ Q_ASSERT(bindingTarget == nullptr);
++ Q_ASSERT(bindingTarget == nullptr);
++ Q_ASSERT(initializer);
++ ExpressionNode *init = initializer;
++
++ initializer = nullptr;
++ LeftHandSideExpression *lhs = init->leftHandSideExpressionCast();
++ if (type == SpreadElement) {
++ if (!lhs) {
++ *errorLocation = init->firstSourceLocation();
++ *errorMessage = QString::fromLatin1("Invalid lhs expression after '...' in destructuring expression.");
++ return false;
++ }
++ } else {
++ type = PatternElement::Binding;
++
++ if (BinaryExpression *b = init->binaryExpressionCast()) {
++ if (b->op != QSOperator::Assign) {
++ *errorLocation = b->operatorToken;
++ *errorMessage = QString::fromLatin1("Invalid assignment operation in destructuring expression");
++ return false;
++ }
++ lhs = b->left->leftHandSideExpressionCast();
++ initializer = b->right;
++ Q_ASSERT(lhs);
++ } else {
++ lhs = init->leftHandSideExpressionCast();
++ }
++ if (!lhs) {
++ *errorLocation = init->firstSourceLocation();
++ *errorMessage = QString::fromLatin1("Destructuring target is not a left hand side expression.");
++ return false;
++ }
++ }
++
++ if (auto *i = cast<IdentifierExpression *>(lhs)) {
++ bindingIdentifier = i->name;
++ identifierToken = i->identifierToken;
++ return true;
++ }
++
++ bindingTarget = lhs;
++ if (auto *p = lhs->patternCast()) {
++ if (!p->convertLiteralToAssignmentPattern(errorLocation, errorMessage))
++ return false;
++ }
++ return true;
++ }
++
++ QList<DiagnosticMessage> PatternElement::warningsForAssignments() const
++ {
++ LeftHandSideExpression *lhs = nullptr;
++
++ if (bindingTarget) {
++ lhs = bindingTarget->leftHandSideExpressionCast();
++ } else if (initializer) {
++ ExpressionNode *init = initializer;
++ if (BinaryExpression *b = init->binaryExpressionCast()) {
++ if (b->op == QSOperator::Assign)
++ lhs = b->left->leftHandSideExpressionCast();
++ }
++ }
++
++ if (!lhs)
++ return { };
++
++ if (auto *p = lhs->patternCast())
++ return p->warningsForAssignments();
++
++ return { };
++ }
++
++ bool PatternProperty::convertLiteralToAssignmentPattern(SourceLocation *errorLocation, QString *errorMessage)
++ {
++ Q_ASSERT(type != SpreadElement);
++ if (type == Binding)
++ return true;
++ if (type == Getter || type == Setter) {
++ *errorLocation = firstSourceLocation();
++ *errorMessage = QString::fromLatin1("Invalid getter/setter in destructuring expression.");
++ return false;
++ }
++ if (type == Method)
++ type = Literal;
++ Q_ASSERT(type == Literal);
++ return PatternElement::convertLiteralToAssignmentPattern(errorLocation, errorMessage);
++ }
++
++ QList<DiagnosticMessage> PatternProperty::warningsForAssignments() const
++ {
++ QList<DiagnosticMessage> result;
++
++ if (!colonToken.isValid()) {
++ if (const BinaryExpression *b =
++ initializer ? initializer->binaryExpressionCast() : nullptr) {
++ if (b->op == QSOperator::Assign) {
++ result.append(QQmlJS::DiagnosticMessage{
++ QString::fromLatin1("Invalid shorthand property initializer"), QtWarningMsg,
++ b->operatorToken });
++ }
++ }
++ }
++
++ result += PatternElement::warningsForAssignments();
++ return result;
++ }
++
++ void Elision::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ // ###
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void IdentifierPropertyName::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void StringLiteralPropertyName::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void NumericLiteralPropertyName::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ namespace {
++ struct LocaleWithoutZeroPadding : public QLocale
++ {
++ LocaleWithoutZeroPadding()
++ : QLocale(QLocale::C)
++ {
++ setNumberOptions(QLocale::OmitLeadingZeroInExponent | QLocale::OmitGroupSeparator);
++ }
++ };
++ }
++
++ QString NumericLiteralPropertyName::asString()const
++ {
++ // Can't use QString::number here anymore as it does zero padding by default now.
++
++ // In C++11 this initialization is thread-safe (6.7 [stmt.dcl] p4)
++ static LocaleWithoutZeroPadding locale;
++ // Because of https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83562 we can't use thread_local
++ // for the locale variable and therefore rely on toString(double) to be thread-safe.
++ return locale.toString(id, 'g', 16);
++ }
++
++ void ArrayMemberExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(base, visitor);
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void FieldMemberExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(base, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void NewMemberExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(base, visitor);
++ accept(arguments, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void NewExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void CallExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(base, visitor);
++ accept(arguments, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ArgumentList::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ for (ArgumentList *it = this; it; it = it->next) {
++ accept(it->expression, visitor);
++ }
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void PostIncrementExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(base, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void PostDecrementExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(base, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void DeleteExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void VoidExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void TypeOfExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void PreIncrementExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void PreDecrementExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UnaryPlusExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UnaryMinusExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void TildeExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void NotExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void BinaryExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(left, visitor);
++ accept(right, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ConditionalExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ accept(ok, visitor);
++ accept(ko, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void CommaExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(left, visitor);
++ accept(right, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void Block::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(statements, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void StatementList::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ for (StatementList *it = this; it; it = it->next) {
++ accept(it->statement, visitor);
++ }
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void VariableStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(declarations, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void VariableDeclarationList::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ for (VariableDeclarationList *it = this; it; it = it->next) {
++ accept(it->declaration, visitor);
++ }
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void EmptyStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ExpressionStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void IfStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ accept(ok, visitor);
++ accept(ko, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void DoWhileStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(statement, visitor);
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void WhileStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ accept(statement, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ForStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(initialiser, visitor);
++ accept(declarations, visitor);
++ accept(condition, visitor);
++ accept(expression, visitor);
++ accept(statement, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ForEachStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(lhs, visitor);
++ accept(expression, visitor);
++ accept(statement, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ContinueStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void BreakStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ReturnStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void YieldExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++
++ void WithStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ accept(statement, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void SwitchStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ accept(block, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void CaseBlock::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(clauses, visitor);
++ accept(defaultClause, visitor);
++ accept(moreClauses, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void CaseClauses::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ for (CaseClauses *it = this; it; it = it->next) {
++ accept(it->clause, visitor);
++ }
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void CaseClause::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ accept(statements, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void DefaultClause::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(statements, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void LabelledStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(statement, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ThrowStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void TryStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(statement, visitor);
++ accept(catchExpression, visitor);
++ accept(finallyExpression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void Catch::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(patternElement, visitor);
++ accept(statement, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void Finally::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(statement, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void FunctionDeclaration::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(formals, visitor);
++ accept(typeAnnotation, visitor);
++ accept(body, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void FunctionExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(formals, visitor);
++ accept(typeAnnotation, visitor);
++ accept(body, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ FunctionExpression *FunctionExpression::asFunctionDefinition()
++ {
++ return this;
++ }
++
++ BoundNames FormalParameterList::formals() const
++ {
++ BoundNames formals;
++ int i = 0;
++ for (const FormalParameterList *it = this; it; it = it->next) {
++ if (it->element) {
++ QString name = it->element->bindingIdentifier.toString();
++ int duplicateIndex = formals.indexOf(name);
++ if (duplicateIndex >= 0) {
++ // change the name of the earlier argument to enforce the lookup semantics from the spec
++ formals[duplicateIndex].id += QLatin1String("#") + QString::number(i);
++ }
++ formals += { name, it->element->firstSourceLocation(), it->element->typeAnnotation,
++ it->element->isInjectedSignalParameter ? BoundName::Injected
++ : BoundName::Declared };
++ }
++ ++i;
++ }
++ return formals;
++ }
++
++ BoundNames FormalParameterList::boundNames() const
++ {
++ BoundNames names;
++ for (const FormalParameterList *it = this; it; it = it->next) {
++ if (it->element)
++ it->element->boundNames(&names);
++ }
++ return names;
++ }
++
++ void FormalParameterList::accept0(BaseVisitor *visitor)
++ {
++ bool accepted = true;
++ for (FormalParameterList *it = this; it && accepted; it = it->next) {
++ accepted = visitor->visit(it);
++ if (accepted)
++ accept(it->element, visitor);
++ visitor->endVisit(it);
++ }
++ }
++
++ FormalParameterList *FormalParameterList::finish(QQmlJS::MemoryPool *)
++ {
++ FormalParameterList *front = next;
++ next = nullptr;
++ return front;
++ }
++
++ void Program::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(statements, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ImportSpecifier::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++
++ }
++ visitor->endVisit(this);
++ }
++
++ void ImportsList::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ for (ImportsList *it = this; it; it = it->next) {
++ accept(it->importSpecifier, visitor);
++ }
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void NamedImports::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(importsList, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void FromClause::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void NameSpaceImport::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ImportClause::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(nameSpaceImport, visitor);
++ accept(namedImports, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ImportDeclaration::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(importClause, visitor);
++ accept(fromClause, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ExportSpecifier::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ExportsList::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ for (ExportsList *it = this; it; it = it->next) {
++ accept(it->exportSpecifier, visitor);
++ }
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ExportClause::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(exportsList, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ExportDeclaration::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(exportClause, visitor);
++ accept(fromClause, visitor);
++ accept(variableStatementOrDeclaration, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ESModule::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(body, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void DebuggerStatement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiProgram::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(headers, visitor);
++ accept(members, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiPublicMember::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ // accept(annotations, visitor); // accept manually in visit if interested
++ // accept(memberType, visitor); // accept manually in visit if interested
++ accept(statement, visitor);
++ accept(binding, visitor);
++ // accept(parameters, visitor); // accept manually in visit if interested
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiObjectDefinition::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ // accept(annotations, visitor); // accept manually in visit if interested
++ accept(qualifiedTypeNameId, visitor);
++ accept(initializer, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiObjectInitializer::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(members, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiParameterList::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ // accept(type, visitor); // accept manually in visit if interested
++ }
++ visitor->endVisit(this);
++ }
++
++ void UiObjectBinding::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ // accept(annotations, visitor); // accept manually in visit if interested
++ accept(qualifiedId, visitor);
++ accept(qualifiedTypeNameId, visitor);
++ accept(initializer, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiScriptBinding::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ // accept(annotations, visitor); // accept manually in visit if interested
++ accept(qualifiedId, visitor);
++ accept(statement, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiArrayBinding::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ // accept(annotations, visitor); // accept manually in visit if interested
++ accept(qualifiedId, visitor);
++ accept(members, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiObjectMemberList::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ for (UiObjectMemberList *it = this; it; it = it->next)
++ accept(it->member, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiArrayMemberList::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ for (UiArrayMemberList *it = this; it; it = it->next)
++ accept(it->member, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiQualifiedId::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ // accept(next, visitor) // accept manually in visit if interested
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void Type::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(typeId, visitor);
++ accept(typeArgument, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void TypeAnnotation::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(type, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiImport::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(importUri, visitor);
++ // accept(version, visitor); // accept manually in visit if interested
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiPragmaValueList::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++
++ void UiPragma::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiHeaderItemList::accept0(BaseVisitor *visitor)
++ {
++ bool accepted = true;
++ for (UiHeaderItemList *it = this; it && accepted; it = it->next) {
++ accepted = visitor->visit(it);
++ if (accepted)
++ accept(it->headerItem, visitor);
++
++ visitor->endVisit(it);
++ }
++ }
++
++
++ void UiSourceElement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ // accept(annotations, visitor); // accept manually in visit if interested
++ accept(sourceElement, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiEnumDeclaration::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ // accept(annotations, visitor); // accept manually in visit if interested
++ accept(members, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiEnumMemberList::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void TaggedTemplate::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(base, visitor);
++ accept(templateLiteral, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void InitializerExpression::accept0(BaseVisitor *visitor)
++ {
++ expression->accept0(visitor);
++ }
++
++ void PatternElement::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(bindingTarget, visitor);
++ accept(typeAnnotation, visitor);
++ accept(initializer, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void PatternElement::boundNames(BoundNames *names)
++ {
++ if (bindingTarget) {
++ if (PatternElementList *e = elementList())
++ e->boundNames(names);
++ else if (PatternPropertyList *p = propertyList())
++ p->boundNames(names);
++ } else {
++ names->append({ bindingIdentifier.toString(), firstSourceLocation(), typeAnnotation,
++ isInjectedSignalParameter ? BoundName::Injected : BoundName::Declared });
++ }
++ }
++
++ void PatternElementList::accept0(BaseVisitor *visitor)
++ {
++ bool accepted = true;
++ for (PatternElementList *it = this; it && accepted; it = it->next) {
++ accepted = visitor->visit(it);
++ if (accepted) {
++ accept(it->elision, visitor);
++ accept(it->element, visitor);
++ }
++ visitor->endVisit(it);
++ }
++ }
++
++ void PatternElementList::boundNames(BoundNames *names)
++ {
++ for (PatternElementList *it = this; it; it = it->next) {
++ if (it->element)
++ it->element->boundNames(names);
++ }
++ }
++
++ void PatternProperty::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(name, visitor);
++ accept(bindingTarget, visitor);
++ accept(typeAnnotation, visitor);
++ accept(initializer, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void PatternProperty::boundNames(BoundNames *names)
++ {
++ PatternElement::boundNames(names);
++ }
++
++ void PatternPropertyList::accept0(BaseVisitor *visitor)
++ {
++ bool accepted = true;
++ for (PatternPropertyList *it = this; it && accepted; it = it->next) {
++ accepted = visitor->visit(it);
++ if (accepted)
++ accept(it->property, visitor);
++ visitor->endVisit(it);
++ }
++ }
++
++ void PatternPropertyList::boundNames(BoundNames *names)
++ {
++ for (PatternPropertyList *it = this; it; it = it->next)
++ it->property->boundNames(names);
++ }
++
++ void ComputedPropertyName::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(expression, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ClassExpression::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(heritage, visitor);
++ accept(elements, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ ClassExpression *ClassExpression::asClassDefinition()
++ {
++ return this;
++ }
++
++ void ClassDeclaration::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(heritage, visitor);
++ accept(elements, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void ClassElementList::accept0(BaseVisitor *visitor)
++ {
++ bool accepted = true;
++ for (ClassElementList *it = this; it && accepted; it = it->next) {
++ accepted = visitor->visit(it);
++ if (accepted)
++ accept(it->property, visitor);
++
++ visitor->endVisit(it);
++ }
++ }
++
++ ClassElementList *ClassElementList::finish()
++ {
++ ClassElementList *front = next;
++ next = nullptr;
++ return front;
++ }
++
++ Pattern *Pattern::patternCast()
++ {
++ return this;
++ }
++
++ LeftHandSideExpression *LeftHandSideExpression::leftHandSideExpressionCast()
++ {
++ return this;
++ }
++
++ void UiVersionSpecifier::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++ visitor->endVisit(this);
++ }
++
++ QString Type::toString() const
++ {
++ QString result;
++ toString(&result);
++ return result;
++ }
++
++ void Type::toString(QString *out) const
++ {
++ typeId->toString(out);
++
++ if (typeArgument) {
++ out->append(QLatin1Char('<'));
++ typeArgument->toString(out);
++ out->append(QLatin1Char('>'));
++ };
++ }
++
++ void UiInlineComponent::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ // accept(annotations, visitor); // accept manually in visit if interested
++ accept(component, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiRequired::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiAnnotationList::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ for (UiAnnotationList *it = this; it; it = it->next)
++ accept(it->annotation, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ void UiAnnotation::accept0(BaseVisitor *visitor)
++ {
++ if (visitor->visit(this)) {
++ accept(qualifiedTypeNameId, visitor);
++ accept(initializer, visitor);
++ }
++
++ visitor->endVisit(this);
++ }
++
++ SourceLocation UiPropertyAttributes::firstSourceLocation() const
++ {
++ return *std::min({ &m_propertyToken, &m_defaultToken, &m_readonlyToken, &m_requiredToken,
++ &m_finalToken, &m_virtualToken, &m_overrideToken },
++ compareLocationsByBegin<true>);
++ }
++
++ SourceLocation UiPropertyAttributes::lastSourceLocation() const
++ {
++ return *std::max({ &m_propertyToken, &m_defaultToken, &m_readonlyToken, &m_requiredToken,
++ &m_finalToken, &m_virtualToken, &m_overrideToken },
++ compareLocationsByBegin<false>);
++ }
++
++ } } // namespace QQmlJS::AST
++
++ QT_END_NAMESPACE
++
++