qt/qtdeclarative/src/qmldom/qqmldomcodeformatter.cpp

Revision control

++ // Copyright (C) 2022 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 "qqmldomcodeformatter_p.h"
++
++ #include <QLoggingCategory>
++ #include <QMetaEnum>
++
++ Q_STATIC_LOGGING_CATEGORY(formatterLog, "qt.qmldom.formatter", QtWarningMsg);
++
++ QT_BEGIN_NAMESPACE
++ namespace QQmlJS {
++ namespace Dom {
++
++ using StateType = FormatTextStatus::StateType;
++ using State = FormatTextStatus::State;
++
++ State FormatTextStatus::state(int belowTop) const
++ {
++ if (belowTop < states.size())
++ return states.at(states.size() - 1 - belowTop);
++ else
++ return State();
++ }
++
++ QString FormatTextStatus::stateToString(StateType type)
++ {
++ const QMetaEnum &metaEnum =
++ staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("StateType"));
++ return QString::fromUtf8(metaEnum.valueToKey(int(type)));
++ }
++
++ void FormatPartialStatus::enterState(StateType newState)
++ {
++ int savedIndentDepth = currentIndent;
++ defaultOnEnter(newState, &currentIndent, &savedIndentDepth);
++ currentStatus.pushState(newState, savedIndentDepth);
++ qCDebug(formatterLog) << "enter state" << FormatTextStatus::stateToString(newState);
++
++ if (newState == StateType::BracketOpen)
++ enterState(StateType::BracketElementStart);
++ }
++
++ void FormatPartialStatus::leaveState(bool statementDone)
++ {
++ Q_ASSERT(currentStatus.size() > 1);
++ if (currentStatus.state().type == StateType::TopmostIntro)
++ return;
++
++ // restore indent depth
++ State poppedState = currentStatus.popState();
++ currentIndent = poppedState.savedIndentDepth;
++
++ StateType topState = currentStatus.state().type;
++
++ qCDebug(formatterLog) << "left state" << FormatTextStatus::stateToString(poppedState.type)
++ << ", now in state" << FormatTextStatus::stateToString(topState);
++
++ // if statement is done, may need to leave recursively
++ if (statementDone) {
++ if (topState == StateType::IfStatement) {
++ if (poppedState.type != StateType::MaybeElse)
++ enterState(StateType::MaybeElse);
++ else
++ leaveState(true);
++ } else if (topState == StateType::ElseClause) {
++ // leave the else *and* the surrounding if, to prevent another else
++ leaveState(false);
++ leaveState(true);
++ } else if (topState == StateType::TryStatement) {
++ if (poppedState.type != StateType::MaybeCatchOrFinally
++ && poppedState.type != StateType::FinallyStatement) {
++ enterState(StateType::MaybeCatchOrFinally);
++ } else {
++ leaveState(true);
++ }
++ } else if (!FormatTextStatus::isExpressionEndState(topState)) {
++ leaveState(true);
++ }
++ }
++ }
++
++ void FormatPartialStatus::turnIntoState(StateType newState)
++ {
++ leaveState(false);
++ enterState(newState);
++ }
++
++ const Token &FormatPartialStatus::tokenAt(int idx) const
++ {
++ static const Token empty;
++ if (idx < 0 || idx >= lineTokens.size())
++ return empty;
++ else
++ return lineTokens.at(idx);
++ }
++
++ int FormatPartialStatus::column(int index) const
++ {
++ if (index > line.size())
++ index = line.size();
++ IndentInfo indent(QStringView(line).mid(0, index), options.tabSize, indentOffset);
++ return indent.column;
++ }
++
++ QStringView FormatPartialStatus::tokenText(const Token &token) const
++ {
++ return line.mid(token.begin(), token.length);
++ }
++
++ bool FormatPartialStatus::tryInsideExpression(bool alsoExpression)
++ {
++ StateType newState = StateType::Invalid;
++ const int kind = tokenAt(tokenIndex).lexKind;
++ switch (kind) {
++ case QQmlJSGrammar::T_LPAREN:
++ newState = StateType::ParenOpen;
++ break;
++ case QQmlJSGrammar::T_LBRACKET:
++ newState = StateType::BracketOpen;
++ break;
++ case QQmlJSGrammar::T_LBRACE:
++ newState = StateType::ObjectliteralOpen;
++ break;
++ case QQmlJSGrammar::T_FUNCTION:
++ newState = StateType::FunctionStart;
++ break;
++ case QQmlJSGrammar::T_ARROW:
++ newState = StateType::LambdaStart;
++ break;
++ case QQmlJSGrammar::T_QUESTION:
++ newState = StateType::TernaryOp;
++ break;
++ }
++
++ if (newState != StateType::Invalid) {
++ if (alsoExpression)
++ enterState(StateType::Expression);
++ enterState(newState);
++ return true;
++ }
++
++ return false;
++ }
++
++ bool FormatPartialStatus::tryStatement()
++ {
++ Token t = tokenAt(tokenIndex);
++ const int kind = t.lexKind;
++ switch (kind) {
++ case QQmlJSGrammar::T_AUTOMATIC_SEMICOLON:
++ case QQmlJSGrammar::T_COMPATIBILITY_SEMICOLON:
++ case QQmlJSGrammar::T_SEMICOLON:
++ enterState(StateType::EmptyStatement);
++ leaveState(true);
++ return true;
++ case QQmlJSGrammar::T_BREAK:
++ case QQmlJSGrammar::T_CONTINUE:
++ enterState(StateType::BreakcontinueStatement);
++ return true;
++ case QQmlJSGrammar::T_THROW:
++ enterState(StateType::ThrowStatement);
++ enterState(StateType::Expression);
++ return true;
++ case QQmlJSGrammar::T_RETURN:
++ enterState(StateType::ReturnStatement);
++ enterState(StateType::Expression);
++ return true;
++ case QQmlJSGrammar::T_WHILE:
++ case QQmlJSGrammar::T_FOR:
++ case QQmlJSGrammar::T_CATCH:
++ enterState(StateType::StatementWithCondition);
++ return true;
++ case QQmlJSGrammar::T_SWITCH:
++ enterState(StateType::SwitchStatement);
++ return true;
++ case QQmlJSGrammar::T_IF:
++ enterState(StateType::IfStatement);
++ return true;
++ case QQmlJSGrammar::T_DO:
++ enterState(StateType::DoStatement);
++ enterState(StateType::Substatement);
++ return true;
++ case QQmlJSGrammar::T_CASE:
++ case QQmlJSGrammar::T_DEFAULT:
++ enterState(StateType::CaseStart);
++ return true;
++ case QQmlJSGrammar::T_TRY:
++ enterState(StateType::TryStatement);
++ return true;
++ case QQmlJSGrammar::T_LBRACE:
++ enterState(StateType::JsblockOpen);
++ return true;
++ case QQmlJSGrammar::T_VAR:
++ case QQmlJSGrammar::T_PLUS_PLUS:
++ case QQmlJSGrammar::T_MINUS_MINUS:
++ case QQmlJSGrammar::T_IMPORT:
++ case QQmlJSGrammar::T_SIGNAL:
++ case QQmlJSGrammar::T_ON:
++ case QQmlJSGrammar::T_AS:
++ case QQmlJSGrammar::T_PROPERTY:
++ case QQmlJSGrammar::T_REQUIRED:
++ case QQmlJSGrammar::T_READONLY:
++ case QQmlJSGrammar::T_FUNCTION:
++ case QQmlJSGrammar::T_NUMERIC_LITERAL:
++ case QQmlJSGrammar::T_LPAREN:
++ enterState(StateType::Expression);
++ // look at the token again
++ tokenIndex -= 1;
++ return true;
++ default:
++ if (Token::lexKindIsIdentifier(kind)) {
++ enterState(StateType::ExpressionOrLabel);
++ return true;
++ } else if (Token::lexKindIsDelimiter(kind) || Token::lexKindIsStringType(kind)) {
++ enterState(StateType::Expression);
++ // look at the token again
++ tokenIndex -= 1;
++ return true;
++ }
++ }
++ return false;
++ }
++
++ void FormatPartialStatus::dump() const
++ {
++ qCDebug(formatterLog) << "Current token index" << tokenIndex;
++ qCDebug(formatterLog) << "Current state:";
++ for (const State &s : currentStatus.states)
++ qCDebug(formatterLog) << FormatTextStatus::stateToString(s.type) << s.savedIndentDepth;
++ qCDebug(formatterLog) << "Current lexerState:" << currentStatus.lexerState.state;
++ qCDebug(formatterLog) << "Current indent:" << currentIndent;
++ }
++
++ void FormatPartialStatus::handleTokens()
++ {
++ auto enter = [this](StateType newState) { this->enterState(newState); };
++
++ auto leave = [this](bool statementDone = false) { this->leaveState(statementDone); };
++
++ auto turnInto = [this](StateType newState) { this->turnIntoState(newState); };
++
++ qCDebug(formatterLog) << "Starting to look at " << line;
++
++ for (; tokenIndex < lineTokens.size();) {
++ Token currentToken = tokenAt(tokenIndex);
++ const int kind = currentToken.lexKind;
++
++ qCDebug(formatterLog) << "Token: " << tokenText(currentToken);
++
++ if (Token::lexKindIsComment(kind)
++ && currentStatus.state().type != StateType::MultilineCommentCont
++ && currentStatus.state().type != StateType::MultilineCommentStart) {
++ tokenIndex += 1;
++ continue;
++ }
++
++ switch (currentStatus.state().type) {
++ case StateType::TopmostIntro:
++ switch (kind) {
++ case QQmlJSGrammar::T_IDENTIFIER:
++ enter(StateType::ObjectdefinitionOrJs);
++ continue;
++ case QQmlJSGrammar::T_PRAGMA:
++ case QQmlJSGrammar::T_IMPORT:
++ enter(StateType::TopQml);
++ continue;
++ case QQmlJSGrammar::T_LBRACE:
++ enter(StateType::TopJs);
++ enter(StateType::Expression);
++ continue; // if a file starts with {, it's likely json
++ default:
++ enter(StateType::TopJs);
++ continue;
++ }
++ break;
++
++ case StateType::TopQml:
++ switch (kind) {
++ case QQmlJSGrammar::T_PRAGMA:
++ enter(StateType::PragmaStart);
++ break;
++ case QQmlJSGrammar::T_IMPORT:
++ enter(StateType::ImportStart);
++ break;
++ case QQmlJSGrammar::T_IDENTIFIER:
++ enter(StateType::BindingOrObjectdefinition);
++ break;
++ default:
++ if (Token::lexKindIsIdentifier(kind))
++ enter(StateType::BindingOrObjectdefinition);
++ break;
++ }
++ break;
++
++ case StateType::TopJs:
++ tryStatement();
++ break;
++
++ case StateType::ObjectdefinitionOrJs:
++ switch (kind) {
++ case QQmlJSGrammar::T_DOT:
++ break;
++ case QQmlJSGrammar::T_LBRACE:
++ turnInto(StateType::BindingOrObjectdefinition);
++ continue;
++ default:
++ if (!Token::lexKindIsIdentifier(kind) || !line.at(currentToken.begin()).isUpper()) {
++ turnInto(StateType::TopJs);
++ continue;
++ }
++ }
++ break;
++
++ case StateType::PragmaStart:
++ switch (kind) {
++ case QQmlJSGrammar::T_IDENTIFIER:
++ turnInto(StateType::PragmaMaybeValue);
++ break;
++ default:
++ leave();
++ continue;
++ }
++ break;
++ case StateType::PragmaMaybeValue:
++ switch (kind) {
++ case QQmlJSGrammar::T_COLON:
++ turnInto(StateType::PragmaValue);
++ break;
++ default:
++ leave();
++ continue;
++ }
++ break;
++ case StateType::PragmaValue:
++ switch (kind) {
++ case QQmlJSGrammar::T_IDENTIFIER:
++ case QQmlJSGrammar::T_STRING_LITERAL:
++ turnInto(StateType::PragmaMaybeMoreValues);
++ break;
++ default:
++ leave();
++ continue;
++ }
++ break;
++ case StateType::PragmaMaybeMoreValues:
++ switch (kind) {
++ case QQmlJSGrammar::T_COMMA:
++ turnInto(StateType::PragmaValue);
++ break;
++ default:
++ leave();
++ continue;
++ }
++ break;
++
++ case StateType::ImportStart:
++ enter(StateType::ImportMaybeDotOrVersionOrAs);
++ break;
++
++ case StateType::ImportMaybeDotOrVersionOrAs:
++ switch (kind) {
++ case QQmlJSGrammar::T_DOT:
++ turnInto(StateType::ImportDot);
++ break;
++ case QQmlJSGrammar::T_AS:
++ turnInto(StateType::ImportAs);
++ break;
++ case QQmlJSGrammar::T_NUMERIC_LITERAL:
++ case QQmlJSGrammar::T_VERSION_NUMBER:
++ turnInto(StateType::ImportMaybeAs);
++ break;
++ default:
++ leave();
++ leave();
++ continue;
++ }
++ break;
++
++ case StateType::ImportMaybeAs:
++ switch (kind) {
++ case QQmlJSGrammar::T_AS:
++ turnInto(StateType::ImportAs);
++ break;
++ default:
++ leave();
++ leave();
++ continue;
++ }
++ break;
++
++ case StateType::ImportDot:
++ if (Token::lexKindIsIdentifier(kind)) {
++ turnInto(StateType::ImportMaybeDotOrVersionOrAs);
++ } else {
++ leave();
++ leave();
++ continue;
++ }
++ break;
++
++ case StateType::ImportAs:
++ if (Token::lexKindIsIdentifier(kind)) {
++ leave();
++ leave();
++ }
++ break;
++
++ case StateType::BindingOrObjectdefinition:
++ switch (kind) {
++ case QQmlJSGrammar::T_COLON:
++ enter(StateType::BindingAssignment);
++ break;
++ case QQmlJSGrammar::T_LBRACE:
++ enter(StateType::ObjectdefinitionOpen);
++ break;
++ }
++ break;
++
++ case StateType::BindingAssignment:
++ switch (kind) {
++ case QQmlJSGrammar::T_AUTOMATIC_SEMICOLON:
++ case QQmlJSGrammar::T_COMPATIBILITY_SEMICOLON:
++ case QQmlJSGrammar::T_SEMICOLON:
++ leave(true);
++ break;
++ case QQmlJSGrammar::T_IF:
++ enter(StateType::IfStatement);
++ break;
++ case QQmlJSGrammar::T_WITH:
++ enter(StateType::StatementWithCondition);
++ break;
++ case QQmlJSGrammar::T_TRY:
++ enter(StateType::TryStatement);
++ break;
++ case QQmlJSGrammar::T_SWITCH:
++ enter(StateType::SwitchStatement);
++ break;
++ case QQmlJSGrammar::T_LBRACE:
++ enter(StateType::JsblockOpen);
++ break;
++ case QQmlJSGrammar::T_ON:
++ case QQmlJSGrammar::T_AS:
++ case QQmlJSGrammar::T_IMPORT:
++ case QQmlJSGrammar::T_SIGNAL:
++ case QQmlJSGrammar::T_PROPERTY:
++ case QQmlJSGrammar::T_REQUIRED:
++ case QQmlJSGrammar::T_READONLY:
++ case QQmlJSGrammar::T_IDENTIFIER:
++ enter(StateType::ExpressionOrObjectdefinition);
++ break;
++
++ // error recovery
++ case QQmlJSGrammar::T_RBRACKET:
++ case QQmlJSGrammar::T_RPAREN:
++ leave(true);
++ break;
++
++ default:
++ enter(StateType::Expression);
++ continue;
++ }
++ break;
++
++ case StateType::ObjectdefinitionOpen:
++ switch (kind) {
++ case QQmlJSGrammar::T_RBRACE:
++ leave(true);
++ break;
++ case QQmlJSGrammar::T_DEFAULT:
++ case QQmlJSGrammar::T_READONLY:
++ enter(StateType::PropertyModifiers);
++ break;
++ case QQmlJSGrammar::T_PROPERTY:
++ enter(StateType::PropertyStart);
++ break;
++ case QQmlJSGrammar::T_REQUIRED:
++ enter(StateType::RequiredProperty);
++ break;
++ case QQmlJSGrammar::T_COMPONENT:
++ enter(StateType::ComponentStart);
++ break;
++ case QQmlJSGrammar::T_FUNCTION:
++ enter(StateType::FunctionStart);
++ break;
++ case QQmlJSGrammar::T_SIGNAL:
++ enter(StateType::SignalStart);
++ break;
++ case QQmlJSGrammar::T_ENUM:
++ enter(StateType::EnumStart);
++ break;
++ case QQmlJSGrammar::T_ON:
++ case QQmlJSGrammar::T_AS:
++ case QQmlJSGrammar::T_IMPORT:
++ enter(StateType::BindingOrObjectdefinition);
++ break;
++ default:
++ if (Token::lexKindIsIdentifier(kind))
++ enter(StateType::BindingOrObjectdefinition);
++ break;
++ }
++ break;
++
++ case StateType::PropertyModifiers:
++ switch (kind) {
++ case QQmlJSGrammar::T_PROPERTY:
++ turnInto(StateType::PropertyStart);
++ break;
++ case QQmlJSGrammar::T_DEFAULT:
++ case QQmlJSGrammar::T_READONLY:
++ break;
++ case QQmlJSGrammar::T_REQUIRED:
++ turnInto(StateType::RequiredProperty);
++ break;
++ default:
++ leave(true);
++ break;
++ }
++ break;
++
++ case StateType::PropertyStart:
++ switch (kind) {
++ case QQmlJSGrammar::T_COLON:
++ enter(StateType::BindingAssignment);
++ break; // oops, was a binding
++ case QQmlJSGrammar::T_VAR:
++ enter(StateType::PropertyName);
++ break;
++ default:
++ bool kindIsIdentifier = Token::lexKindIsIdentifier(kind);
++ if (kindIsIdentifier && tokenText(currentToken) == u"list") {
++ enter(StateType::PropertyListOpen);
++ } else if (kindIsIdentifier) {
++ enter(StateType::PropertyName);
++ } else {
++ leave(true);
++ continue;
++ }
++ }
++ break;
++
++ case StateType::RequiredProperty:
++ switch (kind) {
++ case QQmlJSGrammar::T_PROPERTY:
++ turnInto(StateType::PropertyStart);
++ break;
++ case QQmlJSGrammar::T_DEFAULT:
++ case QQmlJSGrammar::T_READONLY:
++ turnInto(StateType::PropertyModifiers);
++ break;
++ case QQmlJSGrammar::T_IDENTIFIER:
++ leave(true);
++ break;
++ default:
++ leave(true);
++ continue;
++ }
++ break;
++
++ case StateType::ComponentStart:
++ switch (kind) {
++ case QQmlJSGrammar::T_IDENTIFIER:
++ turnInto(StateType::ComponentName);
++ break;
++ default:
++ leave(true);
++ continue;
++ }
++ break;
++
++ case StateType::ComponentName:
++ switch (kind) {
++ case QQmlJSGrammar::T_COLON:
++ enter(StateType::BindingAssignment);
++ break;
++ default:
++ leave(true);
++ continue;
++ }
++ break;
++
++ case StateType::PropertyName:
++ turnInto(StateType::PropertyMaybeInitializer);
++ break;
++
++ case StateType::PropertyListOpen: {
++ const QStringView tok = tokenText(currentToken);
++ if (tok == u">")
++ turnInto(StateType::PropertyName);
++ break;
++ }
++ case StateType::PropertyMaybeInitializer:
++ switch (kind) {
++ case QQmlJSGrammar::T_COLON:
++ turnInto(StateType::BindingAssignment);
++ break;
++ default:
++ leave(true);
++ continue;
++ }
++ break;
++
++ case StateType::EnumStart:
++ switch (kind) {
++ case QQmlJSGrammar::T_LBRACE:
++ enter(StateType::ObjectliteralOpen);
++ break;
++ }
++ break;
++
++ case StateType::SignalStart:
++ switch (kind) {
++ case QQmlJSGrammar::T_COLON:
++ enter(StateType::BindingAssignment);
++ break; // oops, was a binding
++ default:
++ enter(StateType::SignalMaybeArglist);
++ break;
++ }
++ break;
++
++ case StateType::SignalMaybeArglist:
++ switch (kind) {
++ case QQmlJSGrammar::T_LPAREN:
++ turnInto(StateType::SignalArglistOpen);
++ break;
++ default:
++ leave(true);
++ continue;
++ }
++ break;
++
++ case StateType::SignalArglistOpen:
++ switch (kind) {
++ case QQmlJSGrammar::T_RPAREN:
++ leave(true);
++ break;
++ }
++ break;
++
++ case StateType::FunctionStart:
++ switch (kind) {
++ case QQmlJSGrammar::T_LPAREN:
++ enter(StateType::FunctionArglistOpen);
++ break;
++ }
++ break;
++
++ case StateType::FunctionArglistOpen:
++ switch (kind) {
++ case QQmlJSGrammar::T_COLON:
++ enter(StateType::TypeAnnotation);
++ break;
++ case QQmlJSGrammar::T_RPAREN:
++ turnInto(StateType::FunctionArglistClosed);
++ break;
++ }
++ break;
++
++ case StateType::FunctionArglistClosed:
++ switch (kind) {
++ case QQmlJSGrammar::T_COLON:
++ enter(StateType::TypeAnnotation);
++ break;
++ case QQmlJSGrammar::T_LBRACE:
++ turnInto(StateType::JsblockOpen);
++ break;
++ default:
++ leave(true);
++ continue; // error recovery
++ }
++ break;
++
++ case StateType::LambdaStart:
++ switch (kind) {
++ case QQmlJSGrammar::T_LBRACE:
++ turnInto(StateType::JsblockOpen);
++ break;
++ default:
++ turnInto(StateType::Expression);
++ }
++ break;
++
++ case StateType::TypeAnnotation:
++ switch (kind) {
++ case QQmlJSGrammar::T_IDENTIFIER:
++ case QQmlJSGrammar::T_VOID:
++ case QQmlJSGrammar::T_VAR:
++ case QQmlJSGrammar::T_DOT:
++ break;
++ case QQmlJSGrammar::T_LT:
++ turnInto(StateType::TypeParameter);
++ break;
++ default:
++ leave();
++ continue; // error recovery
++ }
++ break;
++
++ case StateType::TypeParameter:
++ switch (kind) {
++ case QQmlJSGrammar::T_LT:
++ enter(StateType::TypeParameter);
++ break;
++ case QQmlJSGrammar::T_GT:
++ leave();
++ break;
++ }
++ break;
++
++ case StateType::ExpressionOrObjectdefinition:
++ switch (kind) {
++ case QQmlJSGrammar::T_DOT:
++ break; // need to become an objectdefinition_open in cases like "width: Qt.Foo
++ // {"
++ case QQmlJSGrammar::T_LBRACE:
++ turnInto(StateType::ObjectdefinitionOpen);
++ break;
++
++ // propagate 'leave' from expression state
++ case QQmlJSGrammar::T_RBRACKET:
++ case QQmlJSGrammar::T_RPAREN:
++ leave();
++ continue;
++
++ default:
++ if (Token::lexKindIsIdentifier(kind))
++ break; // need to become an objectdefinition_open in cases like "width:
++ // Qt.Foo
++ enter(StateType::Expression);
++ continue; // really? identifier and more tokens might already be gone
++ }
++ break;
++
++ case StateType::ExpressionOrLabel:
++ switch (kind) {
++ case QQmlJSGrammar::T_COLON:
++ turnInto(StateType::LabelledStatement);
++ break;
++
++ // propagate 'leave' from expression state
++ case QQmlJSGrammar::T_RBRACKET:
++ case QQmlJSGrammar::T_RPAREN:
++ leave();
++ continue;
++
++ default:
++ enter(StateType::Expression);
++ continue;
++ }
++ break;
++
++ case StateType::TernaryOp:
++ if (kind == QQmlJSGrammar::T_COLON) {
++ enter(StateType::TernaryOpAfterColon);
++ enter(StateType::ExpressionContinuation);
++ break;
++ }
++ Q_FALLTHROUGH();
++ case StateType::TernaryOpAfterColon:
++ case StateType::Expression:
++ if (tryInsideExpression(false))
++ break;
++ switch (kind) {
++ case QQmlJSGrammar::T_COMMA:
++ leave(true);
++ break;
++ case QQmlJSGrammar::T_RBRACKET:
++ case QQmlJSGrammar::T_RPAREN:
++ leave();
++ continue;
++ case QQmlJSGrammar::T_RBRACE:
++ leave(true);
++ continue;
++ case QQmlJSGrammar::T_AUTOMATIC_SEMICOLON:
++ case QQmlJSGrammar::T_COMPATIBILITY_SEMICOLON:
++ case QQmlJSGrammar::T_SEMICOLON:
++ leave(true);
++ break;
++ default:
++ if (Token::lexKindIsDelimiter(kind))
++ enter(StateType::ExpressionContinuation);
++ break;
++ }
++ break;
++
++ case StateType::ExpressionContinuation:
++ leave();
++ continue;
++
++ case StateType::ExpressionMaybeContinuation:
++ switch (kind) {
++ case QQmlJSGrammar::T_QUESTION:
++ case QQmlJSGrammar::T_LBRACKET:
++ case QQmlJSGrammar::T_LPAREN:
++ case QQmlJSGrammar::T_LBRACE:
++ leave();
++ continue;
++ default:
++ leave(!Token::lexKindIsDelimiter(kind));
++ continue;
++ }
++ break;
++
++ case StateType::ParenOpen:
++ if (tryInsideExpression(false))
++ break;
++ switch (kind) {
++ case QQmlJSGrammar::T_RPAREN:
++ leave();
++ break;
++ }
++ break;
++
++ case StateType::BracketOpen:
++ if (tryInsideExpression(false))
++ break;
++ switch (kind) {
++ case QQmlJSGrammar::T_COMMA:
++ enter(StateType::BracketElementStart);
++ break;
++ case QQmlJSGrammar::T_RBRACKET:
++ leave();
++ break;
++ }
++ break;
++
++ case StateType::ObjectliteralOpen:
++ if (tryInsideExpression(false))
++ break;
++ switch (kind) {
++ case QQmlJSGrammar::T_COLON:
++ enter(StateType::ObjectliteralAssignment);
++ break;
++ case QQmlJSGrammar::T_RBRACKET:
++ case QQmlJSGrammar::T_RPAREN:
++ leave();
++ continue; // error recovery
++ case QQmlJSGrammar::T_RBRACE:
++ leave(true);
++ break;
++ }
++ break;
++
++ // pretty much like expression, but ends with , or }
++ case StateType::ObjectliteralAssignment:
++ if (tryInsideExpression(false))
++ break;
++ switch (kind) {
++ case QQmlJSGrammar::T_COMMA:
++ leave();
++ break;
++ case QQmlJSGrammar::T_RBRACKET:
++ case QQmlJSGrammar::T_RPAREN:
++ leave();
++ continue; // error recovery
++ case QQmlJSGrammar::T_RBRACE:
++ leave();
++ continue; // so we also leave objectliteral_open
++ default:
++ if (Token::lexKindIsDelimiter(kind))
++ enter(StateType::ExpressionContinuation);
++ break;
++ }
++ break;
++
++ case StateType::BracketElementStart:
++ if (Token::lexKindIsIdentifier(kind)) {
++ turnInto(StateType::BracketElementMaybeObjectdefinition);
++ } else {
++ leave();
++ continue;
++ }
++ break;
++
++ case StateType::BracketElementMaybeObjectdefinition:
++ switch (kind) {
++ case QQmlJSGrammar::T_LBRACE:
++ turnInto(StateType::ObjectdefinitionOpen);
++ break;
++ default:
++ leave();
++ continue;
++ }
++ break;
++
++ case StateType::JsblockOpen:
++ case StateType::SubstatementOpen:
++ if (tryStatement())
++ break;
++ switch (kind) {
++ case QQmlJSGrammar::T_RBRACE:
++ leave(true);
++ break;
++ }
++ break;
++
++ case StateType::LabelledStatement:
++ if (tryStatement())
++ break;
++ leave(true); // error recovery
++ break;
++
++ case StateType::Substatement:
++ // prefer substatement_open over block_open
++ if (kind != QQmlJSGrammar::T_LBRACE) {
++ if (tryStatement())
++ break;
++ }
++ switch (kind) {
++ case QQmlJSGrammar::T_LBRACE:
++ turnInto(StateType::SubstatementOpen);
++ break;
++ }
++ break;
++
++ case StateType::IfStatement:
++ switch (kind) {
++ case QQmlJSGrammar::T_LPAREN:
++ enter(StateType::ConditionOpen);
++ break;
++ default:
++ leave(true);
++ break; // error recovery
++ }
++ break;
++
++ case StateType::MaybeElse:
++ switch (kind) {
++ case QQmlJSGrammar::T_ELSE:
++ turnInto(StateType::ElseClause);
++ enter(StateType::Substatement);
++ break;
++ default:
++ leave(true);
++ continue;
++ }
++ break;
++
++ case StateType::MaybeCatchOrFinally:
++ switch (kind) {
++ case QQmlJSGrammar::T_CATCH:
++ turnInto(StateType::CatchStatement);
++ break;
++ case QQmlJSGrammar::T_FINALLY:
++ turnInto(StateType::FinallyStatement);
++ break;
++ default:
++ leave(true);
++ continue;
++ }
++ break;
++
++ case StateType::ElseClause:
++ // ### shouldn't happen
++ dump();
++ Q_ASSERT(false);
++ leave(true);
++ break;
++
++ case StateType::ConditionOpen:
++ if (tryInsideExpression(false))
++ break;
++ switch (kind) {
++ case QQmlJSGrammar::T_RPAREN:
++ turnInto(StateType::Substatement);
++ break;
++ }
++ break;
++
++ case StateType::SwitchStatement:
++ case StateType::CatchStatement:
++ case StateType::StatementWithCondition:
++ switch (kind) {
++ case QQmlJSGrammar::T_LPAREN:
++ enter(StateType::StatementWithConditionParenOpen);
++ break;
++ default:
++ leave(true);
++ }
++ break;
++
++ case StateType::StatementWithConditionParenOpen:
++ if (tryInsideExpression(false))
++ break;
++ switch (kind) {
++ case QQmlJSGrammar::T_RPAREN:
++ turnInto(StateType::Substatement);
++ break;
++ }
++ break;
++
++ case StateType::TryStatement:
++ case StateType::FinallyStatement:
++ switch (kind) {
++ case QQmlJSGrammar::T_LBRACE:
++ enter(StateType::JsblockOpen);
++ break;
++ default:
++ leave(true);
++ break;
++ }
++ break;
++
++ case StateType::DoStatement:
++ switch (kind) {
++ case QQmlJSGrammar::T_WHILE:
++ break;
++ case QQmlJSGrammar::T_LPAREN:
++ enter(StateType::DoStatementWhileParenOpen);
++ break;
++ default:
++ leave(true);
++ continue; // error recovery
++ }
++ break;
++
++ case StateType::DoStatementWhileParenOpen:
++ if (tryInsideExpression(false))
++ break;
++ switch (kind) {
++ case QQmlJSGrammar::T_RPAREN:
++ leave();
++ leave(true);
++ break;
++ }
++ break;
++
++ case StateType::BreakcontinueStatement:
++ if (Token ::lexKindIsIdentifier(kind)) {
++ leave(true);
++ } else {
++ leave(true);
++ continue; // try again
++ }
++ break;
++
++ case StateType::CaseStart:
++ switch (kind) {
++ case QQmlJSGrammar::T_COLON:
++ turnInto(StateType::CaseCont);
++ break;
++ }
++ break;
++
++ case StateType::CaseCont:
++ if (kind != QQmlJSGrammar::T_CASE && kind != QQmlJSGrammar::T_DEFAULT && tryStatement())
++ break;
++ switch (kind) {
++ case QQmlJSGrammar::T_RBRACE:
++ leave();
++ continue;
++ case QQmlJSGrammar::T_DEFAULT:
++ case QQmlJSGrammar::T_CASE:
++ leave();
++ continue;
++ }
++ break;
++
++ case StateType::MultilineCommentStart:
++ case StateType::MultilineCommentCont:
++ if (!Token::lexKindIsComment(kind)) {
++ leave();
++ continue;
++ } else if (tokenIndex == lineTokens.size() - 1
++ && !currentStatus.lexerState.isMultiline()) {
++ leave();
++ } else if (tokenIndex == 0) {
++ // to allow enter/leave to update the indentDepth
++ turnInto(StateType::MultilineCommentCont);
++ }
++ break;
++
++ default:
++ qWarning() << "Unhandled state" << currentStatus.state().typeStr();
++ break;
++ } // end of state switch
++
++ ++tokenIndex;
++ }
++
++ StateType topState = currentStatus.state().type;
++
++ // if there's no colon on the same line, it's not a label
++ if (topState == StateType::ExpressionOrLabel)
++ enterState(StateType::Expression);
++ // if not followed by an identifier on the same line, it's done
++ else if (topState == StateType::BreakcontinueStatement)
++ leaveState(true);
++
++ topState = currentStatus.state().type;
++
++ // some states might be continued on the next line
++ if (topState == StateType::Expression || topState == StateType::ExpressionOrObjectdefinition
++ || topState == StateType::ObjectliteralAssignment
++ || topState == StateType::TernaryOpAfterColon) {
++ enterState(StateType::ExpressionMaybeContinuation);
++ }
++ // multi-line comment start?
++ if (topState != StateType::MultilineCommentStart && topState != StateType::MultilineCommentCont
++ && currentStatus.lexerState.state.tokenKind == QQmlJSGrammar::T_PARTIAL_COMMENT) {
++ enterState(StateType::MultilineCommentStart);
++ }
++ currentStatus.finalIndent = currentIndent;
++ }
++
++ // adjusts the indentation of the current line based on the status of the previous one, and what
++ // it starts with
++ int indentForLineStartingWithToken(const FormatTextStatus &oldStatus, const FormatOptions &,
++ int tokenKind)
++ {
++ State topState = oldStatus.state();
++ State previousState = oldStatus.state(1);
++ int indentDepth = oldStatus.finalIndent;
++
++ // keep user-adjusted indent in multiline comments
++ if (topState.type == StateType::MultilineCommentStart
++ || topState.type == StateType::MultilineCommentCont) {
++ if (!Token::lexKindIsInvalid(tokenKind))
++ return -1;
++ }
++ // don't touch multi-line strings at all
++ if (oldStatus.lexerState.state.tokenKind == QQmlJSGrammar::T_PARTIAL_DOUBLE_QUOTE_STRING_LITERAL
++ || oldStatus.lexerState.state.tokenKind == QQmlJSGrammar::T_PARTIAL_SINGLE_QUOTE_STRING_LITERAL
++ || oldStatus.lexerState.state.tokenKind == QQmlJSGrammar::T_PARTIAL_TEMPLATE_HEAD
++ || oldStatus.lexerState.state.tokenKind == QQmlJSGrammar::T_PARTIAL_TEMPLATE_MIDDLE) {
++ return -1;
++ }
++
++ switch (tokenKind) {
++ case QQmlJSGrammar::T_LBRACE:
++ if (topState.type == StateType::Substatement
++ || topState.type == StateType::BindingAssignment
++ || topState.type == StateType::CaseCont) {
++ return topState.savedIndentDepth;
++ }
++ break;
++ case QQmlJSGrammar::T_RBRACE: {
++ if (topState.type == StateType::JsblockOpen && previousState.type == StateType::CaseCont) {
++ return previousState.savedIndentDepth;
++ }
++ for (int i = 0; oldStatus.state(i).type != StateType::TopmostIntro; ++i) {
++ const StateType type = oldStatus.state(i).type;
++ if (type == StateType::ObjectdefinitionOpen || type == StateType::JsblockOpen
++ || type == StateType::SubstatementOpen || type == StateType::ObjectliteralOpen) {
++ return oldStatus.state(i).savedIndentDepth;
++ }
++ }
++ break;
++ }
++ case QQmlJSGrammar::T_RBRACKET:
++ for (int i = 0; oldStatus.state(i).type != StateType::TopmostIntro; ++i) {
++ const StateType type = oldStatus.state(i).type;
++ if (type == StateType::BracketOpen) {
++ return oldStatus.state(i).savedIndentDepth;
++ }
++ }
++ break;
++ case QQmlJSGrammar::T_LBRACKET:
++ case QQmlJSGrammar::T_LPAREN:
++ if (topState.type == StateType::ExpressionMaybeContinuation)
++ return topState.savedIndentDepth;
++ break;
++ case QQmlJSGrammar::T_ELSE:
++ if (topState.type == StateType::MaybeElse) {
++ return oldStatus.state(1).savedIndentDepth;
++ } else if (topState.type == StateType::ExpressionMaybeContinuation) {
++ bool hasElse = false;
++ for (int i = 1; oldStatus.state(i).type != StateType::TopmostIntro; ++i) {
++ const StateType type = oldStatus.state(i).type;
++ if (type == StateType::ElseClause)
++ hasElse = true;
++ if (type == StateType::IfStatement) {
++ if (hasElse) {
++ hasElse = false;
++ } else {
++ return oldStatus.state(i).savedIndentDepth;
++ }
++ }
++ }
++ }
++ break;
++ case QQmlJSGrammar::T_CATCH:
++ case QQmlJSGrammar::T_FINALLY:
++ if (topState.type == StateType::MaybeCatchOrFinally)
++ return oldStatus.state(1).savedIndentDepth;
++ break;
++ case QQmlJSGrammar::T_COLON:
++ if (topState.type == StateType::TernaryOp)
++ return indentDepth - 2;
++ break;
++ case QQmlJSGrammar::T_QUESTION:
++ if (topState.type == StateType::ExpressionMaybeContinuation)
++ return topState.savedIndentDepth;
++ break;
++
++ case QQmlJSGrammar::T_DEFAULT:
++ case QQmlJSGrammar::T_CASE:
++ for (int i = 0; oldStatus.state(i).type != StateType::TopmostIntro; ++i) {
++ const StateType type = oldStatus.state(i).type;
++ if (type == StateType::SwitchStatement || type == StateType::CaseCont) {
++ return oldStatus.state(i).savedIndentDepth;
++ } else if (type == StateType::TopmostIntro) {
++ break;
++ }
++ }
++ break;
++ default:
++ if (Token::lexKindIsDelimiter(tokenKind)
++ && topState.type == StateType::ExpressionMaybeContinuation)
++ return topState.savedIndentDepth;
++
++ break;
++ }
++ return indentDepth;
++ }
++
++ // sets currentIndent to the correct indent for the current line
++ int FormatPartialStatus::indentLine()
++ {
++ Q_ASSERT(currentStatus.size() >= 1);
++ int firstToken = (lineTokens.isEmpty() ? QQmlJSGrammar::T_NONE : tokenAt(0).lexKind);
++ int indent = indentForLineStartingWithToken(initialStatus, options, firstToken);
++ recalculateWithIndent(indent);
++ return indent;
++ }
++
++ int FormatPartialStatus::indentForNewLineAfter() const
++ {
++ // should be just currentIndent?
++ int indent = indentForLineStartingWithToken(currentStatus, options, QQmlJSGrammar::T_NONE);
++ if (indent < 0)
++ return currentIndent;
++ return indent;
++ }
++
++ void FormatPartialStatus::recalculateWithIndent(int indent)
++ {
++ if (indent >= 0) {
++ indentOffset = 0;
++ int i = 0;
++ while (i < line.size() && line.at(i).isSpace())
++ ++i;
++ indentOffset = indent - column(i);
++ }
++ currentIndent = initialStatus.finalIndent;
++ auto lexerState = currentStatus.lexerState;
++ currentStatus = initialStatus;
++ currentStatus.lexerState = lexerState;
++ tokenIndex = 0;
++ handleTokens();
++ }
++
++ FormatPartialStatus formatCodeLine(QStringView line, const FormatOptions &options,
++ const FormatTextStatus &initialStatus)
++ {
++ FormatPartialStatus status(line, options, initialStatus);
++
++ status.handleTokens();
++
++ return status;
++ }
++
++ void FormatPartialStatus::defaultOnEnter(StateType newState, int *indentDepth,
++ int *savedIndentDepth) const
++ {
++ const State &parentState = currentStatus.state();
++ const Token &tk = tokenAt(tokenIndex);
++ const int tokenPosition = column(tk.begin());
++ const bool firstToken = (tokenIndex == 0);
++ const bool lastToken = (tokenIndex == lineTokens.size() - 1);
++
++ switch (newState) {
++ case StateType::ObjectdefinitionOpen: {
++ // special case for things like "gradient: Gradient {"
++ if (parentState.type == StateType::BindingAssignment)
++ *savedIndentDepth = currentStatus.state(1).savedIndentDepth;
++
++ if (firstToken)
++ *savedIndentDepth = tokenPosition;
++
++ *indentDepth = *savedIndentDepth + options.indentSize;
++ break;
++ }
++
++ case StateType::BindingOrObjectdefinition:
++ if (firstToken)
++ *indentDepth = *savedIndentDepth = tokenPosition;
++ break;
++
++ case StateType::BindingAssignment:
++ case StateType::ObjectliteralAssignment:
++ if (lastToken)
++ *indentDepth = *savedIndentDepth + options.indentSize;
++ else
++ *indentDepth = column(tokenAt(tokenIndex + 1).begin());
++ break;
++
++ case StateType::ExpressionOrObjectdefinition:
++ *indentDepth = tokenPosition;
++ break;
++
++ case StateType::ExpressionOrLabel:
++ if (*indentDepth == tokenPosition)
++ *indentDepth += 2 * options.indentSize;
++ else
++ *indentDepth = tokenPosition;
++ break;
++
++ case StateType::Expression:
++ if (*indentDepth == tokenPosition) {
++ // expression_or_objectdefinition doesn't want the indent
++ // expression_or_label already has it
++ if (parentState.type != StateType::ExpressionOrObjectdefinition
++ && parentState.type != StateType::ExpressionOrLabel
++ && parentState.type != StateType::BindingAssignment) {
++ *indentDepth += 2 * options.indentSize;
++ }
++ }
++ // expression_or_objectdefinition and expression_or_label have already consumed the
++ // first token
++ else if (parentState.type != StateType::ExpressionOrObjectdefinition
++ && parentState.type != StateType::ExpressionOrLabel) {
++ *indentDepth = tokenPosition;
++ }
++ break;
++
++ case StateType::ExpressionMaybeContinuation:
++ // set indent depth to indent we'd get if the expression ended here
++ for (int i = 1; currentStatus.state(i).type != StateType::TopmostIntro; ++i) {
++ const StateType type = currentStatus.state(i).type;
++ if (FormatTextStatus::isExpressionEndState(type)
++ && !FormatTextStatus::isBracelessState(type)) {
++ *indentDepth = currentStatus.state(i - 1).savedIndentDepth;
++ break;
++ }
++ }
++ break;
++
++ case StateType::BracketOpen:
++ if (parentState.type == StateType::Expression
++ && currentStatus.state(1).type == StateType::BindingAssignment) {
++ *savedIndentDepth = currentStatus.state(2).savedIndentDepth;
++ *indentDepth = *savedIndentDepth + options.indentSize;
++ } else if (parentState.type == StateType::ObjectliteralAssignment) {
++ *savedIndentDepth = parentState.savedIndentDepth;
++ *indentDepth = *savedIndentDepth + options.indentSize;
++ } else if (!lastToken) {
++ *indentDepth = tokenPosition + 1;
++ } else {
++ *indentDepth = *savedIndentDepth + options.indentSize;
++ }
++ break;
++
++ case StateType::LambdaStart:
++ case StateType::FunctionStart:
++ // align to the beginning of the line
++ *savedIndentDepth = *indentDepth = column(tokenAt(0).begin());
++ break;
++
++ case StateType::DoStatementWhileParenOpen:
++ case StateType::StatementWithConditionParenOpen:
++ case StateType::SignalArglistOpen:
++ case StateType::FunctionArglistOpen:
++ case StateType::ParenOpen:
++ if (!lastToken)
++ *indentDepth = tokenPosition + 1;
++ else
++ *indentDepth += options.indentSize;
++ break;
++
++ case StateType::TernaryOp:
++ if (!lastToken)
++ *indentDepth = tokenPosition + tk.length + 1;
++ else
++ *indentDepth += options.indentSize;
++ break;
++
++ case StateType::JsblockOpen:
++ // closing brace should be aligned to case
++ if (parentState.type == StateType::CaseCont) {
++ *savedIndentDepth = parentState.savedIndentDepth;
++ break;
++ }
++ Q_FALLTHROUGH();
++ case StateType::SubstatementOpen:
++ // special case for "foo: {" and "property int foo: {"
++ if (parentState.type == StateType::BindingAssignment)
++ *savedIndentDepth = currentStatus.state(1).savedIndentDepth;
++ *indentDepth = *savedIndentDepth + options.indentSize;
++ break;
++
++ case StateType::Substatement:
++ *indentDepth += options.indentSize;
++ break;
++
++ case StateType::ObjectliteralOpen:
++ if (parentState.type == StateType::Expression
++ || parentState.type == StateType::ObjectliteralAssignment) {
++ // undo the continuation indent of the expression
++ if (currentStatus.state(1).type == StateType::ExpressionOrLabel)
++ *indentDepth = currentStatus.state(1).savedIndentDepth;
++ else
++ *indentDepth = parentState.savedIndentDepth;
++ *savedIndentDepth = *indentDepth;
++ }
++ *indentDepth += options.indentSize;
++ break;
++
++ case StateType::StatementWithCondition:
++ case StateType::TryStatement:
++ case StateType::CatchStatement:
++ case StateType::FinallyStatement:
++ case StateType::IfStatement:
++ case StateType::DoStatement:
++ case StateType::SwitchStatement:
++ if (firstToken || parentState.type == StateType::BindingAssignment)
++ *savedIndentDepth = tokenPosition;
++ // ### continuation
++ *indentDepth = *savedIndentDepth; // + 2*options.indentSize;
++ // special case for 'else if'
++ if (!firstToken && newState == StateType::IfStatement
++ && parentState.type == StateType::Substatement
++ && currentStatus.state(1).type == StateType::ElseClause) {
++ *indentDepth = currentStatus.state(1).savedIndentDepth;
++ *savedIndentDepth = *indentDepth;
++ }
++ break;
++
++ case StateType::MaybeElse:
++ case StateType::MaybeCatchOrFinally: {
++ // set indent to where leave(true) would put it
++ int lastNonEndState = 0;
++ while (!FormatTextStatus::isExpressionEndState(
++ currentStatus.state(lastNonEndState + 1).type))
++ ++lastNonEndState;
++ *indentDepth = currentStatus.state(lastNonEndState).savedIndentDepth;
++ break;
++ }
++
++ case StateType::ConditionOpen:
++ // fixed extra indent when continuing 'if (', but not for 'else if ('
++ if (tokenPosition <= *indentDepth + options.indentSize)
++ *indentDepth += 2 * options.indentSize;
++ else
++ *indentDepth = tokenPosition + 1;
++ break;
++
++ case StateType::CaseStart:
++ *savedIndentDepth = tokenPosition;
++ break;
++
++ case StateType::CaseCont:
++ *indentDepth += options.indentSize;
++ break;
++
++ case StateType::MultilineCommentStart:
++ *indentDepth = tokenPosition + 2;
++ break;
++
++ case StateType::MultilineCommentCont:
++ *indentDepth = tokenPosition;
++ break;
++ default:
++ break;
++ }
++ }
++
++ } // namespace Dom
++ } // namespace QQmlJS
++ QT_END_NAMESPACE