Revision control
++ // Copyright (C) 2021 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
++
++ #include "qqmldomreformatter_p.h"
++ #include "qqmldomcomments_p.h"
++
++ #include <QtQml/private/qqmljsast_p.h>
++ #include <QtQml/private/qqmljsastvisitor_p.h>
++ #include <QtQml/private/qqmljsengine_p.h>
++ #include <QtQml/private/qqmljslexer_p.h>
++
++ #include <QString>
++ #include <algorithm>
++
++ QT_BEGIN_NAMESPACE
++ namespace QQmlJS {
++ namespace Dom {
++
++ using namespace AST;
++
++ bool ScriptFormatter::preVisit(Node *n)
++ {
++ const CommentedElement *c = comments->commentForNode(n, CommentAnchor{});
++ if (!c)
++ return true;
++
++ if (!c->preComments().empty()) {
++ deferredSpaces = 0;
++ for (const auto &preComment : c->preComments())
++ lw.maybeWriteComment(preComment);
++ }
++
++ postOps[n].append([c, this]() {
++ if (!c->postComments().empty()) {
++ deferredSpaces = 0;
++ for (const auto &postComment : c->postComments())
++ lw.maybeWriteComment(postComment);
++ }
++ });
++ return true;
++ }
++
++ void ScriptFormatter::postVisit(Node *n)
++ {
++ for (auto &op : postOps[n]) {
++ op();
++ }
++ postOps.remove(n);
++ }
++
++ void ScriptFormatter::lnAcceptIndented(Node *node)
++ {
++ int indent = lw.increaseIndent(1);
++ ensureNewline();
++ accept(node);
++ lw.decreaseIndent(1, indent);
++ }
++
++ bool ScriptFormatter::acceptBlockOrIndented(Node *ast, bool finishWithSpaceOrNewline)
++ {
++ if (auto *es = cast<EmptyStatement *>(ast)) {
++ writeOutSemicolon(es);
++ return false;
++ }
++ if (cast<Block *>(ast)) {
++ ensureSpaceIfNoComment();
++ accept(ast);
++ if (finishWithSpaceOrNewline)
++ ensureSpaceIfNoComment();
++ return true;
++ } else {
++ if (finishWithSpaceOrNewline)
++ postOps[ast].append([this]() { ensureNewline(); });
++ lnAcceptIndented(ast);
++ return false;
++ }
++ }
++
++ bool ScriptFormatter::visit(ThisExpression *ast)
++ {
++ out(ast->thisToken);
++ return true;
++ }
++
++ bool ScriptFormatter::visit(NullExpression *ast)
++ {
++ out(ast->nullToken);
++ return true;
++ }
++ bool ScriptFormatter::visit(TrueLiteral *ast)
++ {
++ out(ast->trueToken);
++ return true;
++ }
++ bool ScriptFormatter::visit(FalseLiteral *ast)
++ {
++ out(ast->falseToken);
++ return true;
++ }
++
++ bool ScriptFormatter::visit(IdentifierExpression *ast)
++ {
++ out(ast->identifierToken);
++ return true;
++ }
++ bool ScriptFormatter::visit(StringLiteral *ast)
++ {
++ // correctly handle multiline literals
++ if (ast->literalToken.length == 0)
++ return true;
++ QStringView str = m_script->loc2Str(ast->literalToken);
++ if (lw.indentNextlines && str.contains(QLatin1Char('\n'))) {
++ out(str.mid(0, 1));
++ lw.indentNextlines = false;
++ out(str.mid(1));
++ lw.indentNextlines = true;
++ } else {
++ out(str);
++ }
++ return true;
++ }
++ bool ScriptFormatter::visit(NumericLiteral *ast)
++ {
++ outWithComments(ast->literalToken, ast);
++ return true;
++ }
++ bool ScriptFormatter::visit(RegExpLiteral *ast)
++ {
++ out(ast->literalToken);
++ return true;
++ }
++
++ bool ScriptFormatter::visit(ArrayPattern *ast)
++ {
++ outWithComments(ast->lbracketToken, ast);
++ int baseIndent = lw.increaseIndent(1);
++ if (ast->elements) {
++ accept(ast->elements);
++ outWithComments(ast->commaToken, ast);
++ auto lastElement = lastListElement(ast->elements);
++ if (lastElement->element && cast<ObjectPattern *>(lastElement->element->initializer)) {
++ ensureNewline();
++ }
++ } else {
++ outWithComments(ast->commaToken, ast);
++ }
++ lw.decreaseIndent(1, baseIndent);
++ outWithComments(ast->rbracketToken, ast);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(ObjectPattern *ast)
++ {
++ outWithComments(ast->lbraceToken, ast);
++ ++expressionDepth;
++ if (ast->properties) {
++ lnAcceptIndented(ast->properties);
++ ensureNewline();
++ }
++ --expressionDepth;
++ outWithComments(ast->rbraceToken, ast);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(PatternElementList *ast)
++ {
++ for (PatternElementList *it = ast; it; it = it->next) {
++ const bool isObjectInitializer =
++ it->element && cast<ObjectPattern *>(it->element->initializer);
++ if (isObjectInitializer)
++ ensureNewline();
++
++ if (it->elision) {
++ accept(it->elision);
++ if (it->element)
++ ensureSpaceIfNoComment();
++ }
++ if (it->element)
++ accept(it->element);
++ if (it->next) {
++ outWithComments(it->next->commaToken, it);
++ ensureSpaceIfNoComment();
++ if (isObjectInitializer)
++ ensureNewline();
++ }
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(PatternPropertyList *ast)
++ {
++ for (PatternPropertyList *it = ast; it; it = it->next) {
++ accept(it->property);
++ if (it->next) {
++ out(",");
++ ensureNewline();
++ }
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(AST::PatternProperty *property)
++ {
++ if (property->type == PatternElement::Getter || property->type == PatternElement::Setter
++ || property->type == PatternElement::Method) {
++ // note that MethodDefinitions and FunctionDeclarations have different syntax
++ // hence visit(FunctionDeclaration*) is not quite appropriate here
++ if (property->type == PatternProperty::Getter) {
++ out("get");
++ ensureSpaceIfNoComment();
++ } else if (property->type == PatternProperty::Setter) {
++ out("set");
++ ensureSpaceIfNoComment();
++ }
++ FunctionExpression *f = AST::cast<FunctionExpression *>(property->initializer);
++ if (f->isGenerator) {
++ out("*");
++ }
++ accept(property->name);
++ out(f->lparenToken);
++ accept(f->formals);
++ out(f->rparenToken);
++ ensureSpaceIfNoComment();
++ out(f->lbraceToken);
++ const bool scoped = f->lbraceToken.isValid();
++ if (scoped)
++ ++expressionDepth;
++ if (f->body) {
++ if (f->body->next || scoped) {
++ lnAcceptIndented(f->body);
++ lw.newline();
++ } else {
++ auto baseIndent = lw.increaseIndent(1);
++ accept(f->body);
++ lw.decreaseIndent(1, baseIndent);
++ }
++ }
++ if (scoped)
++ --expressionDepth;
++ out(f->rbraceToken);
++ return false;
++ }
++
++ // IdentifierReference[?Yield]
++ accept(property->name);
++ bool useInitializer = false;
++ const bool bindingIdentifierExist = !property->bindingIdentifier.isEmpty();
++ if (property->colonToken.isValid()) {
++ // PropertyName[?Yield] : AssignmentExpression[In, ?Yield]
++ out(":");
++ ensureSpaceIfNoComment();
++ useInitializer = true;
++ if (bindingIdentifierExist)
++ out(property->bindingIdentifier);
++ if (property->bindingTarget)
++ accept(property->bindingTarget);
++ }
++
++ if (property->initializer) {
++ // CoverInitializedName[?Yield]
++ if (bindingIdentifierExist) {
++ ensureSpaceIfNoComment();
++ out("=");
++ ensureSpaceIfNoComment();
++ useInitializer = true;
++ }
++ if (useInitializer)
++ accept(property->initializer);
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(NestedExpression *ast)
++ {
++ out(ast->lparenToken);
++ int baseIndent = lw.increaseIndent(1);
++ accept(ast->expression);
++ lw.decreaseIndent(1, baseIndent);
++ out(ast->rparenToken);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(IdentifierPropertyName *ast)
++ {
++ out(ast->id.toString());
++ return true;
++ }
++ bool ScriptFormatter::visit(StringLiteralPropertyName *ast)
++ {
++ out(ast->propertyNameToken);
++ return true;
++ }
++ bool ScriptFormatter::visit(NumericLiteralPropertyName *ast)
++ {
++ out(QString::number(ast->id));
++ return true;
++ }
++
++ bool ScriptFormatter::visit(TemplateLiteral *ast)
++ {
++ // correctly handle multiline literals
++ if (ast->literalToken.length != 0) {
++ QStringView str = m_script->loc2Str(ast->literalToken);
++ if (lw.indentNextlines && str.contains(QLatin1Char('\n'))) {
++ out(str.mid(0, 1));
++ lw.indentNextlines = false;
++ out(str.mid(1));
++ lw.indentNextlines = true;
++ } else {
++ out(str);
++ }
++ }
++ accept(ast->expression);
++ return true;
++ }
++
++ bool ScriptFormatter::visit(ArrayMemberExpression *ast)
++ {
++ accept(ast->base);
++ out(ast->optionalToken);
++ out(ast->lbracketToken);
++ int indent = lw.increaseIndent(1);
++ accept(ast->expression);
++ lw.decreaseIndent(1, indent);
++ out(ast->rbracketToken);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(FieldMemberExpression *ast)
++ {
++ accept(ast->base);
++ out(ast->dotToken);
++ out(ast->identifierToken);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(NewMemberExpression *ast)
++ {
++ out("new"); // ast->newToken
++ ensureSpaceIfNoComment();
++ accept(ast->base);
++ out(ast->lparenToken);
++ accept(ast->arguments);
++ out(ast->rparenToken);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(NewExpression *ast)
++ {
++ out("new"); // ast->newToken
++ ensureSpaceIfNoComment();
++ accept(ast->expression);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(CallExpression *ast)
++ {
++ accept(ast->base);
++ outWithComments(ast->optionalToken, ast);
++ outWithComments(ast->lparenToken, ast);
++ accept(ast->arguments);
++ outWithComments(ast->rparenToken, ast);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(PostIncrementExpression *ast)
++ {
++ accept(ast->base);
++ out(ast->incrementToken);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(PostDecrementExpression *ast)
++ {
++ accept(ast->base);
++ out(ast->decrementToken);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(PreIncrementExpression *ast)
++ {
++ out(ast->incrementToken);
++ accept(ast->expression);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(PreDecrementExpression *ast)
++ {
++ out(ast->decrementToken);
++ accept(ast->expression);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(DeleteExpression *ast)
++ {
++ out("delete"); // ast->deleteToken
++ ensureSpaceIfNoComment();
++ accept(ast->expression);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(VoidExpression *ast)
++ {
++ out("void"); // ast->voidToken
++ ensureSpaceIfNoComment();
++ accept(ast->expression);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(TypeOfExpression *ast)
++ {
++ out("typeof"); // ast->typeofToken
++ ensureSpaceIfNoComment();
++ accept(ast->expression);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(UnaryPlusExpression *ast)
++ {
++ out(ast->plusToken);
++ accept(ast->expression);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(UnaryMinusExpression *ast)
++ {
++ out(ast->minusToken);
++ accept(ast->expression);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(TildeExpression *ast)
++ {
++ out(ast->tildeToken);
++ accept(ast->expression);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(NotExpression *ast)
++ {
++ out(ast->notToken);
++ accept(ast->expression);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(BinaryExpression *ast)
++ {
++ accept(ast->left);
++ ensureSpaceIfNoComment();
++ out(ast->operatorToken);
++ ensureSpaceIfNoComment();
++ accept(ast->right);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(ConditionalExpression *ast)
++ {
++ accept(ast->expression);
++ ensureSpaceIfNoComment();
++ out("?"); // ast->questionToken
++ ensureSpaceIfNoComment();
++ accept(ast->ok);
++ ensureSpaceIfNoComment();
++ out(":"); // ast->colonToken
++ ensureSpaceIfNoComment();
++ accept(ast->ko);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(Block *ast)
++ {
++ // write comments manually because we need to indent before writing a potential post comment
++ const CommentedElement *c =
++ comments->commentForNode(ast, CommentAnchor::from(ast->lbraceToken));
++ if (c)
++ writePreComment(c);
++ out(ast->lbraceToken);
++ const int indent = lw.increaseIndent();
++ if (c)
++ writePostComment(c);
++
++ if (ast->statements) {
++ ++expressionDepth;
++ ensureNewline();
++ accept(ast->statements);
++ ensureNewline();
++ --expressionDepth;
++ }
++
++ // write comments manually because we need to write a potential pre-comment before decreasing
++ // the indentation
++ c = comments->commentForNode(ast, CommentAnchor::from(ast->rbraceToken));
++ if (c)
++ writePreComment(c);
++ lw.decreaseIndent(1, indent);
++ out(ast->rbraceToken);
++ if (c)
++ writePostComment(c);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(VariableStatement *ast)
++ {
++ out(ast->declarationKindToken);
++ ensureSpaceIfNoComment();
++ accept(ast->declarations);
++ if (addSemicolons())
++ writeOutSemicolon(ast);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(PatternElement *ast)
++ {
++ switch (ast->type) {
++ case PatternElement::Literal:
++ case PatternElement::Method:
++ case PatternElement::Binding:
++ break;
++ case PatternElement::Getter:
++ out("get");
++ ensureSpaceIfNoComment();
++ break;
++ case PatternElement::Setter:
++ out("set");
++ ensureSpaceIfNoComment();
++ break;
++ case PatternElement::SpreadElement:
++ out("...");
++ break;
++ }
++
++ accept(ast->bindingTarget);
++ if (!ast->destructuringPattern())
++ out(ast->identifierToken);
++ if (ast->initializer) {
++ if (ast->isVariableDeclaration() || ast->type == AST::PatternElement::Binding) {
++ ensureSpaceIfNoComment();
++ outWithComments(ast->equalToken, ast);
++ ensureSpaceIfNoComment();
++ }
++ accept(ast->initializer);
++ }
++ accept(ast->typeAnnotation);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(TypeAnnotation *ast)
++ {
++ out(ast->colonToken);
++ ensureSpaceIfNoComment();
++ accept(ast->type);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(Type *ast)
++ {
++ accept(ast->typeId);
++ if (ast->typeArgument) {
++ outWithComments(ast->lAngleBracketToken, ast);
++ accept(ast->typeArgument);
++ outWithComments(ast->rAngleBracketToken, ast);
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(UiQualifiedId *ast)
++ {
++ for (UiQualifiedId *it = ast; it; it = it->next) {
++ outWithComments(it->dotToken, it);
++ outWithComments(it->identifierToken, it);
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(EmptyStatement *)
++ {
++ lw.lineWriter.ensureSemicolon();
++ return false;
++ }
++
++ bool ScriptFormatter::visit(IfStatement *ast)
++ {
++ out(ast->ifToken);
++ ensureSpaceIfNoComment();
++ out(ast->lparenToken);
++ preVisit(ast->expression);
++ ast->expression->accept0(this);
++ out(ast->rparenToken);
++ postVisit(ast->expression);
++ acceptBlockOrIndented(ast->ok, ast->ko);
++ if (ast->ko) {
++ out(ast->elseToken);
++ if (cast<Block *>(ast->ko) || cast<IfStatement *>(ast->ko)) {
++ ensureSpaceIfNoComment();
++ accept(ast->ko);
++ } else {
++ lnAcceptIndented(ast->ko);
++ }
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(DoWhileStatement *ast)
++ {
++ out(ast->doToken);
++ acceptBlockOrIndented(ast->statement, true);
++ out(ast->whileToken);
++ ensureSpaceIfNoComment();
++ outWithComments(ast->lparenToken, ast);
++ accept(ast->expression);
++ outWithComments(ast->rparenToken, ast);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(WhileStatement *ast)
++ {
++ out(ast->whileToken);
++ ensureSpaceIfNoComment();
++ outWithComments(ast->lparenToken, ast);
++ accept(ast->expression);
++ outWithComments(ast->rparenToken, ast);
++ acceptBlockOrIndented(ast->statement);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(ForStatement *ast)
++ {
++ out(ast->forToken);
++ ensureSpaceIfNoComment();
++ outWithComments(ast->lparenToken, ast);
++ if (ast->initialiser) {
++ accept(ast->initialiser);
++ } else if (ast->declarations) {
++ if (auto pe = ast->declarations->declaration) {
++ out(pe->declarationKindToken);
++ ensureSpaceIfNoComment();
++ }
++ bool first = true;
++ for (VariableDeclarationList *it = ast->declarations; it; it = it->next) {
++ if (!std::exchange(first, false)) {
++ out(",");
++ ensureSpaceIfNoComment();
++ }
++ accept(it->declaration);
++ }
++ }
++ // We don't use writeOutSemicolon() here because we need a semicolon unconditionally.
++ // Repeats for the second semicolon token below.
++ out(u";"); // ast->firstSemicolonToken
++ ensureSpaceIfNoComment();
++ accept(ast->condition);
++ out(u";"); // ast->secondSemicolonToken
++ ensureSpaceIfNoComment();
++ accept(ast->expression);
++ outWithComments(ast->rparenToken, ast);
++ acceptBlockOrIndented(ast->statement);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(ForEachStatement *ast)
++ {
++ out(ast->forToken);
++ ensureSpaceIfNoComment();
++ out(ast->lparenToken);
++ if (auto pe = AST::cast<PatternElement *>(ast->lhs)) {
++ out(pe->declarationKindToken);
++ ensureSpaceIfNoComment();
++ }
++ accept(ast->lhs);
++ ensureSpaceIfNoComment();
++ out(ast->inOfToken);
++ ensureSpaceIfNoComment();
++ accept(ast->expression);
++ out(ast->rparenToken);
++ acceptBlockOrIndented(ast->statement);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(ContinueStatement *ast)
++ {
++ out(ast->continueToken);
++ if (!ast->label.isNull()) {
++ ensureSpaceIfNoComment();
++ out(ast->identifierToken);
++ }
++ if (addSemicolons())
++ writeOutSemicolon(ast);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(BreakStatement *ast)
++ {
++ out(ast->breakToken);
++ if (!ast->label.isNull()) {
++ ensureSpaceIfNoComment();
++ out(ast->identifierToken);
++ }
++ if (addSemicolons())
++ writeOutSemicolon(ast);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(ReturnStatement *ast)
++ {
++ out(ast->returnToken);
++ if (ast->expression) {
++ if (ast->returnToken.length != 0)
++ ensureSpaceIfNoComment();
++ accept(ast->expression);
++ }
++ if (ast->returnToken.length > 0 && addSemicolons())
++ writeOutSemicolon(ast);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(YieldExpression *ast)
++ {
++ out(ast->yieldToken);
++ if (ast->isYieldStar)
++ out("*");
++ if (ast->expression) {
++ if (ast->yieldToken.isValid())
++ ensureSpaceIfNoComment();
++ accept(ast->expression);
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(ThrowStatement *ast)
++ {
++ out(ast->throwToken);
++ if (ast->expression) {
++ ensureSpaceIfNoComment();
++ accept(ast->expression);
++ }
++ if (addSemicolons())
++ writeOutSemicolon(ast);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(WithStatement *ast)
++ {
++ out(ast->withToken);
++ ensureSpaceIfNoComment();
++ out(ast->lparenToken);
++ accept(ast->expression);
++ out(ast->rparenToken);
++ acceptBlockOrIndented(ast->statement);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(SwitchStatement *ast)
++ {
++ out(ast->switchToken);
++ ensureSpaceIfNoComment();
++ out(ast->lparenToken);
++ accept(ast->expression);
++ out(ast->rparenToken);
++ ensureSpaceIfNoComment();
++ accept(ast->block);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(CaseBlock *ast)
++ {
++ out(ast->lbraceToken);
++ ++expressionDepth;
++ ensureNewline();
++ accept(ast->clauses);
++ if (ast->clauses && ast->defaultClause)
++ ensureNewline();
++ accept(ast->defaultClause);
++ if (ast->moreClauses)
++ ensureNewline();
++ accept(ast->moreClauses);
++ ensureNewline();
++ --expressionDepth;
++ out(ast->rbraceToken);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(CaseClause *ast)
++ {
++ out("case"); // ast->caseToken
++ ensureSpaceIfNoComment();
++ accept(ast->expression);
++ outWithComments(ast->colonToken, ast);
++ if (ast->statements)
++ lnAcceptIndented(ast->statements);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(DefaultClause *ast)
++ {
++ out(ast->defaultToken);
++ out(ast->colonToken);
++ lnAcceptIndented(ast->statements);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(LabelledStatement *ast)
++ {
++ out(ast->identifierToken);
++ out(":"); // ast->colonToken
++ ensureSpaceIfNoComment();
++ accept(ast->statement);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(TryStatement *ast)
++ {
++ outWithComments(ast->tryToken, ast);
++ ensureSpaceIfNoComment();
++ accept(ast->statement);
++ if (ast->catchExpression) {
++ ensureSpaceIfNoComment();
++ accept(ast->catchExpression);
++ }
++ if (ast->finallyExpression) {
++ ensureSpaceIfNoComment();
++ accept(ast->finallyExpression);
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(Catch *ast)
++ {
++ outWithComments(ast->catchToken, ast);
++ ensureSpaceIfNoComment();
++ outWithComments(ast->lparenToken, ast);
++ outWithComments(ast->identifierToken, ast);
++ outWithComments(ast->rparenToken, ast);
++ ensureSpaceIfNoComment();
++ accept(ast->statement);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(Finally *ast)
++ {
++ outWithComments(ast->finallyToken, ast);
++ ensureSpaceIfNoComment();
++ accept(ast->statement);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(FunctionDeclaration *ast)
++ {
++ return ScriptFormatter::visit(static_cast<FunctionExpression *>(ast));
++ }
++
++ bool ScriptFormatter::visit(FunctionExpression *ast)
++ {
++ if (!ast->isArrowFunction) {
++ outWithComments(ast->functionToken, ast);
++ if (ast->isGenerator)
++ outWithComments(ast->starToken, ast);
++ ensureSpaceIfNoComment();
++ outWithComments(ast->identifierToken, ast);
++ }
++
++ const bool removeParentheses = ast->isArrowFunction && ast->formals && !ast->formals->next
++ && (ast->formals->element && !ast->formals->element->bindingTarget);
++
++ // note: qmlformat removes the parentheses for "(x) => x". In that case, we still need
++ // to print potential comments attached to `(` or `)` via `OnlyComments` option.
++ outWithComments(ast->lparenToken, ast, removeParentheses ? OnlyComments : TokenAndComment);
++ int baseIndent = lw.increaseIndent(1);
++ accept(ast->formals);
++ lw.decreaseIndent(1, baseIndent);
++ outWithComments(ast->rparenToken, ast, removeParentheses ? OnlyComments : TokenAndComment);
++ accept(ast->typeAnnotation);
++ ensureSpaceIfNoComment();
++ if (ast->isArrowFunction) {
++ out("=>");
++ ensureSpaceIfNoComment();
++ }
++ outWithComments(ast->lbraceToken, ast);
++ if (ast->lbraceToken.length != 0)
++ ++expressionDepth;
++ if (ast->body) {
++ if (ast->body->next || ast->lbraceToken.length != 0) {
++ lnAcceptIndented(ast->body);
++ ensureNewline();
++ } else {
++ // print a single statement in one line. E.g. x => x * 2
++ baseIndent = lw.increaseIndent(1);
++ accept(ast->body);
++ lw.decreaseIndent(1, baseIndent);
++ }
++ }
++ if (ast->lbraceToken.length != 0)
++ --expressionDepth;
++ outWithComments(ast->rbraceToken, ast);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(Elision *ast)
++ {
++ for (Elision *it = ast; it; it = it->next) {
++ if (!it->commaToken.isValid())
++ continue;
++ outWithComments(it->commaToken, it);
++ if (it->next)
++ ensureSpaceIfNoComment();
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(ArgumentList *ast)
++ {
++ for (ArgumentList *it = ast; it; it = it->next) {
++ if (it->commaToken.isValid()) {
++ outWithComments(it->commaToken, it);
++ ensureSpaceIfNoComment();
++ }
++ if (it->spreadToken.isValid())
++ outWithComments(it->spreadToken, it);
++ accept(it->expression);
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(StatementList *ast)
++ {
++ ++expressionDepth;
++ for (StatementList *it = ast; it; it = it->next) {
++ // ### work around parser bug: skip empty statements with wrong tokens
++ if (EmptyStatement *emptyStatement = cast<EmptyStatement *>(it->statement)) {
++ if (m_script->loc2Str(emptyStatement->semicolonToken) != QLatin1String(";"))
++ continue;
++ }
++
++ accept(it->statement);
++ if (it->next) {
++ // There might be a post-comment attached to the current
++ // statement or a pre-comment attached to the next
++ // statmente or both.
++ // If any of those are present they will take care of
++ // handling the spacing between the statements so we
++ // don't need to push any newline.
++ auto *commentForCurrentStatement =
++ comments->commentForNode(it->statement, CommentAnchor{});
++ auto *commentForNextStatement =
++ comments->commentForNode(it->next->statement, CommentAnchor{});
++
++ if (
++ (commentForCurrentStatement && !commentForCurrentStatement->postComments().empty())
++ || (commentForNextStatement && !commentForNextStatement->preComments().empty())
++ ) continue;
++
++ quint32 lineDelta = it->next->firstSourceLocation().startLine
++ - it->statement->lastSourceLocation().startLine;
++ lineDelta = std::clamp(lineDelta, quint32{ 1 }, quint32{ 2 });
++
++ ensureNewline(lineDelta);
++ }
++ }
++ --expressionDepth;
++ return false;
++ }
++
++ bool ScriptFormatter::visit(VariableDeclarationList *ast)
++ {
++ for (VariableDeclarationList *it = ast; it; it = it->next) {
++ accept(it->declaration);
++ if (it->next) {
++ out(","); // it->commaToken
++ ensureSpaceIfNoComment();
++ }
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(CaseClauses *ast)
++ {
++ for (CaseClauses *it = ast; it; it = it->next) {
++ accept(it->clause);
++ if (it->next)
++ ensureNewline();
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(FormalParameterList *ast)
++ {
++ for (FormalParameterList *it = ast; it; it = it->next) {
++ accept(it->element);
++ if (it->commaToken.isValid()) {
++ outWithComments(it->commaToken, it);
++ ensureSpaceIfNoComment();
++ }
++ }
++ return false;
++ }
++
++ // to check
++ bool ScriptFormatter::visit(SuperLiteral *)
++ {
++ out("super");
++ return true;
++ }
++ bool ScriptFormatter::visit(ComputedPropertyName *)
++ {
++ out("[");
++ return true;
++ }
++ bool ScriptFormatter::visit(CommaExpression *el)
++ {
++ accept(el->left);
++ out(",");
++ ensureSpaceIfNoComment();
++ accept(el->right);
++ return false;
++ }
++ bool ScriptFormatter::visit(ExpressionStatement *el)
++ {
++ if (addSemicolons())
++ postOps[el->expression].append([this, el]() { writeOutSemicolon(el); });
++ return true;
++ }
++
++ // Return false because we want to omit default function calls in accept0 implementation.
++ bool ScriptFormatter::visit(ClassDeclaration *ast)
++ {
++ out(ast->classToken);
++ ensureSpaceIfNoComment();
++ outWithComments(ast->identifierToken, ast);
++ if (ast->heritage) {
++ ensureSpaceIfNoComment();
++ out("extends");
++ ensureSpaceIfNoComment();
++ accept(ast->heritage);
++ }
++ ensureSpaceIfNoComment();
++ outWithComments(ast->lbraceToken, ast);
++ int baseIndent = lw.increaseIndent();
++ for (ClassElementList *it = ast->elements; it; it = it->next) {
++ lw.newline();
++ if (it->isStatic) {
++ out("static");
++ ensureSpaceIfNoComment();
++ }
++ accept(it->property);
++ lw.newline();
++ }
++ lw.decreaseIndent(1, baseIndent);
++ outWithComments(ast->rbraceToken, ast);
++ return false;
++ }
++
++ bool ScriptFormatter::visit(AST::ImportDeclaration *ast)
++ {
++ out(ast->importToken);
++ ensureSpaceIfNoComment();
++ if (!ast->moduleSpecifier.isNull()) {
++ out(ast->moduleSpecifierToken);
++ }
++ return true;
++ }
++
++ bool ScriptFormatter::visit(AST::ImportSpecifier *ast)
++ {
++ if (!ast->identifier.isNull()) {
++ out(ast->identifierToken);
++ ensureSpaceIfNoComment();
++ out("as");
++ ensureSpaceIfNoComment();
++ }
++ out(ast->importedBindingToken);
++ return true;
++ }
++
++ bool ScriptFormatter::visit(AST::NameSpaceImport *ast)
++ {
++ out(ast->starToken);
++ ensureSpaceIfNoComment();
++ out("as");
++ ensureSpaceIfNoComment();
++ out(ast->importedBindingToken);
++ return true;
++ }
++
++ bool ScriptFormatter::visit(AST::ImportsList *ast)
++ {
++ for (ImportsList *it = ast; it; it = it->next) {
++ accept(it->importSpecifier);
++ if (it->next) {
++ out(",");
++ ensureSpaceIfNoComment();
++ }
++ }
++ return false;
++ }
++ bool ScriptFormatter::visit(AST::NamedImports *ast)
++ {
++ out(ast->leftBraceToken);
++ if (ast->importsList) {
++ ensureSpaceIfNoComment();
++ }
++ return true;
++ }
++
++ bool ScriptFormatter::visit(AST::ImportClause *ast)
++ {
++ if (!ast->importedDefaultBinding.isNull()) {
++ out(ast->importedDefaultBindingToken);
++ if (ast->nameSpaceImport || ast->namedImports) {
++ out(",");
++ ensureSpaceIfNoComment();
++ }
++ }
++ return true;
++ }
++
++ bool ScriptFormatter::visit(AST::ExportDeclaration *ast)
++ {
++ out(ast->exportToken);
++ ensureSpaceIfNoComment();
++ if (ast->exportDefault) {
++ out("default");
++ ensureSpaceIfNoComment();
++ }
++ if (ast->exportsAll()) {
++ out("*");
++ }
++ return true;
++ }
++
++ bool ScriptFormatter::visit(AST::ExportClause *ast)
++ {
++ out(ast->leftBraceToken);
++ if (ast->exportsList) {
++ ensureSpaceIfNoComment();
++ }
++ return true;
++ }
++
++ bool ScriptFormatter::visit(AST::ExportSpecifier *ast)
++ {
++ out(ast->identifier);
++ if (ast->exportedIdentifierToken.isValid()) {
++ ensureSpaceIfNoComment();
++ out("as");
++ ensureSpaceIfNoComment();
++ out(ast->exportedIdentifier);
++ }
++ return true;
++ }
++
++ bool ScriptFormatter::visit(AST::ExportsList *ast)
++ {
++ for (ExportsList *it = ast; it; it = it->next) {
++ accept(it->exportSpecifier);
++ if (it->next) {
++ out(",");
++ ensureSpaceIfNoComment();
++ }
++ }
++ return false;
++ }
++
++ bool ScriptFormatter::visit(AST::FromClause *ast)
++ {
++ ensureSpaceIfNoComment();
++ out(ast->fromToken);
++ ensureSpaceIfNoComment();
++ out(ast->moduleSpecifierToken);
++ return true;
++ }
++
++ void ScriptFormatter::endVisit(ComputedPropertyName *)
++ {
++ out("]");
++ }
++
++ void ScriptFormatter::endVisit(AST::ExportDeclaration *ast)
++ {
++ // add a semicolon at the end of the following expressions
++ // export * FromClause
++ // export ExportClause FromClause ;
++ if (ast->fromClause) {
++ writeOutSemicolon(ast);
++ }
++
++ // add a semicolon at the end of the following expressions
++ // export ExportClause ;
++ if (ast->exportClause && !ast->fromClause) {
++ writeOutSemicolon(ast);
++ }
++
++ // add a semicolon at the end of the following expressions
++ // export default [lookahead ∉ { function, class }] AssignmentExpression;
++ if (ast->exportDefault && ast->variableStatementOrDeclaration) {
++ // lookahead ∉ { function, class }
++ if (!(ast->variableStatementOrDeclaration->kind == Node::Kind_FunctionDeclaration
++ || ast->variableStatementOrDeclaration->kind == Node::Kind_ClassDeclaration)) {
++ writeOutSemicolon(ast);
++ }
++ // ArrowFunction in QQmlJS::AST is handled with the help of FunctionDeclaration
++ // and not as part of AssignmentExpression (as per ECMA
++ if (ast->variableStatementOrDeclaration->kind == Node::Kind_FunctionDeclaration
++ && static_cast<AST::FunctionDeclaration *>(ast->variableStatementOrDeclaration)
++ ->isArrowFunction) {
++ writeOutSemicolon(ast);
++ }
++ }
++ }
++
++ void ScriptFormatter::endVisit(AST::ExportClause *ast)
++ {
++ if (ast->exportsList) {
++ ensureSpaceIfNoComment();
++ }
++ out(ast->rightBraceToken);
++ }
++
++ void ScriptFormatter::endVisit(AST::NamedImports *ast)
++ {
++ if (ast->importsList) {
++ ensureSpaceIfNoComment();
++ }
++ out(ast->rightBraceToken);
++ }
++
++ void ScriptFormatter::endVisit(AST::ImportDeclaration *id)
++ {
++ writeOutSemicolon(id);
++ }
++
++ void ScriptFormatter::throwRecursionDepthError()
++ {
++ out("/* ERROR: Hit recursion limit ScriptFormatter::visiting AST, rewrite failed */");
++ }
++
++ // Given an existing semicolon, can we safely remove it without changing
++ // behavior Restricted characters (, [, +, - and / are the only ones that can
++ // cause issues when removing a semicolon. The / is a special case because it
++ // can be the start of a comment or a division operator.
++ bool ScriptFormatter::canRemoveSemicolon(AST::Node *node)
++ {
++ const auto canRelyOnASI = [this](Node *node) {
++ auto nodeLoc = node->lastSourceLocation().offset + 1;
++ auto code = m_script->engine()->code();
++ auto it = code.begin() + nodeLoc;
++ auto end = code.end();
++ // Scan through code, skipping comments and whitespace
++ // until we find the next real token to determine if ASI will work.
++ while (it != end) {
++ QChar c = *it;
++ // Skip all whitespace and semicolons
++ if (c.isSpace() || c == u';') {
++ ++it;
++ continue;
++ }
++ // Skip comments
++ if (c == u'/' && it + 1 != end) {
++ auto next = it + 1;
++ if (*next == u'/') {
++ // Single-line comment, skip to end of line
++ it = std::find(next, end, u'\n');
++ if (it != end)
++ ++it;
++ continue;
++ } else if (*next == u'*') {
++ // Multi-line comment, skip to */
++ it = next + 1;
++ while (it != end) {
++ if (*it == u'*' && it + 1 != end && *(it + 1) == u'/') {
++ it += 2;
++ break;
++ }
++ ++it;
++ }
++ continue;
++ }
++ // If / is not followed by / or *, it's a division operator
++ return false;
++ }
++ // Check for restricted characters that can continue the expression
++ if (c == u'(' || c == u'[' || c == u'+' || c == u'-') {
++ // Cannot remove semicolon; restricted char follows
++ return false;
++ }
++ // Found any other token, safe to remove semicolon
++ return true;
++ }
++ // Reached end of code, safe to remove semicolon
++ return true;
++ };
++
++ // Check if the node is a statement that requires a semicolon to avoid ASI issues
++ switch (node->kind) {
++ case AST::Node::Kind_ExpressionStatement:
++ return canRelyOnASI(cast<ExpressionStatement *>(node));
++ case AST::Node::Kind_VariableStatement:
++ return canRelyOnASI(cast<VariableStatement *>(node));
++ case AST::Node::Kind_EmptyStatement:
++ return false;
++ case AST::Node::Kind_ContinueStatement:
++ case AST::Node::Kind_BreakStatement:
++ case AST::Node::Kind_ReturnStatement:
++ case AST::Node::Kind_ThrowStatement:
++ case AST::Node::Kind_ExportDeclaration:
++ case AST::Node::Kind_ImportDeclaration:
++ case AST::Node::Kind_FromClause:
++ case AST::Node::Kind_ExportClause:
++ default:
++ return true;
++ }
++ }
++
++ OutWriter &ScriptFormatter::writeOutSemicolon(AST::Node *node)
++ {
++ if (!node)
++ return lw;
++ switch (lw.lineWriter.options().semicolonRule) {
++ case LineWriterOptions::SemicolonRule::Essential:
++ if (!canRemoveSemicolon(node))
++ out(u";");
++ ensureNewline();
++ return lw;
++ case LineWriterOptions::SemicolonRule::Always:
++ out(u";");
++ return lw;
++ default:
++ Q_UNREACHABLE_RETURN(lw);
++ }
++ }
++
++ void reformatAst(OutWriter &lw, const QQmlJS::Dom::ScriptExpression *const script)
++ {
++ if (script)
++ ScriptFormatter formatter(lw, script);
++ }
++
++ } // namespace Dom
++ } // namespace QQmlJS
++ QT_END_NAMESPACE