Revision control
++ // Copyright (C) 2023 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
++ // Qt-Security score:significant
++
++ #include "qqmljsloggingutils_p.h"
++
++ #include <QtQmlToolingSettings/private/qqmltoolingsettings_p.h>
++ #include <QtCore/qcommandlineparser.h>
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++
++ /*!
++ \enum QQmlSA::WarningSeverity
++ \inmodule QtQmlCompiler
++ \since 6.12
++
++ \brief Holds the possible severity levels of diagnostics messages for a logging category.
++ \value Error Messages emitted by this logging category will cause an error.
++ \value Warning Messages emitted by this logging category are warnings. No error is produced unless the \l{qmllint#Settings}{MaxWarnings} setting is set and exceeded.
++ \value Info Messages emitted by this logging category are purely informative and do not count towards \l{qmllint#Settings}{MaxWarnings}.
++ \value Disable This logging category will not emit any messages.
++ */
++
++ /*!
++ \class QQmlSA::LoggerWarningId
++ \inmodule QtQmlCompiler
++
++ \brief A wrapper around a string literal to uniquely identify
++ warning categories in the \c{QQmlSA} framework.
++ */
++
++ /*!
++ \fn QQmlSA::LoggerWarningId::LoggerWarningId(QAnyStringView name)
++ Constructs a LoggerWarningId object with logging catergory name \a name.
++ */
++
++ /*!
++ \fn QAnyStringView QQmlSA::LoggerWarningId::name() const
++ Returns the name of the wrapped warning category.
++ */
++
++ namespace QQmlSA {
++
++ static_assert(int(WarningSeverity::Disable) != int(QtMsgType::QtInfoMsg));
++ static_assert(int(WarningSeverity::Disable) != int(QtMsgType::QtWarningMsg));
++ static_assert(int(WarningSeverity::Disable) != int(QtMsgType::QtCriticalMsg));
++
++ } // namespace QQmlSA
++
++ namespace QQmlJS {
++
++ LoggerCategory::LoggerCategory() : d_ptr{ new LoggerCategoryPrivate } { }
++
++ LoggerCategory::LoggerCategory(
++ const QString &name, const QString &settingsName, const QString &description,
++ WarningSeverity severity, Essentiality essentiality)
++ : d_ptr{ new LoggerCategoryPrivate(name, settingsName, description, severity, essentiality) }
++ {
++ }
++
++ LoggerCategory::LoggerCategory(const LoggerCategory &other)
++ : d_ptr{ new LoggerCategoryPrivate{ *other.d_func() } }
++ {
++ }
++
++ LoggerCategory::LoggerCategory(LoggerCategory &&) noexcept = default;
++
++ LoggerCategory &LoggerCategory::operator=(const LoggerCategory &other)
++ {
++ *d_func() = *other.d_func();
++ return *this;
++ }
++
++ LoggerCategory &LoggerCategory::operator=(LoggerCategory &&) noexcept = default;
++
++ LoggerCategory::~LoggerCategory() = default;
++
++ QString LoggerCategory::name() const
++ {
++ Q_D(const LoggerCategory);
++ return d->name();
++ }
++
++ QString LoggerCategory::settingsName() const
++ {
++ Q_D(const LoggerCategory);
++ return d->settingsName();
++ }
++
++ QString LoggerCategory::description() const
++ {
++ Q_D(const LoggerCategory);
++ return d->description();
++ }
++
++ WarningSeverity LoggerCategory::severity() const
++ {
++ Q_D(const LoggerCategory);
++ return d->severity();
++ }
++
++ bool LoggerCategory::isEssential() const
++ {
++ Q_D(const LoggerCategory);
++ return d->isEssential();
++ }
++
++ LoggerWarningId LoggerCategory::id() const
++ {
++ Q_D(const LoggerCategory);
++ return d->id();
++ }
++
++ void LoggerCategory::setSeverity(WarningSeverity severity)
++ {
++ Q_D(LoggerCategory);
++ d->setSeverity(severity);
++ }
++
++ LoggerCategoryPrivate::LoggerCategoryPrivate(const QString &name, const QString &settingsName,
++ const QString &description, WarningSeverity severity,
++ LoggerCategory::Essentiality essentiality)
++ : m_name(name), m_settingsName(settingsName), m_description(description), m_severity(severity)
++ , m_isEssential(essentiality == LoggerCategory::Essential)
++ {
++ }
++
++ void LoggerCategoryPrivate::setSeverity(WarningSeverity severity)
++ {
++ if (m_severity == severity)
++ return;
++
++ m_severity = severity;
++ m_changed = true;
++ }
++
++ LoggerCategoryPrivate *LoggerCategoryPrivate::get(LoggerCategory *loggerCategory)
++ {
++ Q_ASSERT(loggerCategory);
++ return loggerCategory->d_func();
++ }
++
++ namespace LoggingUtils {
++
++ QString severityToString(QQmlJS::WarningSeverity severity)
++ {
++ switch (severity) {
++ case QQmlJS::WarningSeverity::Disable:
++ return QStringLiteral("disable");
++ case QQmlJS::WarningSeverity::Info:
++ return QStringLiteral("info");
++ case QQmlJS::WarningSeverity::Warning:
++ return QStringLiteral("warning");
++ case QQmlJS::WarningSeverity::Error:
++ return QStringLiteral("error");
++ default:
++ Q_UNREACHABLE();
++ break;
++ }
++ };
++
++ static QStringList settingsNamesForCategory(const LoggerCategory &category)
++ {
++ const QString name = category.settingsName();
++ QStringList result{ QStringLiteral("Warnings/") + name };
++ const QString sliced = "Warnings/"_L1 + name.sliced(name.indexOf(u'.') + 1);
++ if (sliced != result.last())
++ result.append(sliced);
++ return result;
++ }
++
++ static QString lookInSettings(const LoggerCategory &category, const QQmlToolingSettings &settings,
++ const QString &settingsName)
++ {
++ if (settings.isSet(settingsName))
++ return settings.value(settingsName).toString();
++ static constexpr QLatin1String propertyAliasCyclesKey = "Warnings/PropertyAliasCycles"_L1;
++
++ // keep compatibility to deprecated settings
++ if (category.name() == qmlAliasCycle.name() || category.name() == qmlUnresolvedAlias.name()) {
++ if (settings.isSet(propertyAliasCyclesKey)) {
++ qWarning()
++ << "Detected deprecated setting name \"PropertyAliasCycles\". Use %1 or %2 instead."_L1
++ .arg(qmlAliasCycle.name(), qmlUnresolvedAlias.name());
++ return settings.value(propertyAliasCyclesKey).toString();
++ }
++ }
++ return {};
++ }
++
++ static QString severityValueForCategory(const LoggerCategory &category,
++ const QQmlToolingSettings &settings,
++ QCommandLineParser *parser)
++ {
++ const QString key = category.id().name().toString();
++ if (parser && parser->isSet(key))
++ return parser->value(key);
++
++ const QStringList settingsName = settingsNamesForCategory(category);
++ for (const QString &settingsName : settingsName) {
++ const QString value = lookInSettings(category, settings, settingsName);
++ if (value.isEmpty())
++ continue;
++
++ // Do not try to set the severity if it's due to a default config option.
++ // This way we can tell which options have actually been overwritten by the user.
++ if (severityToString(category.severity()) == value)
++ return QString();
++
++ return value;
++ }
++ return QString();
++ }
++
++ std::optional<QQmlJS::WarningSeverity> severityFromString(const QString &s)
++ {
++ if (s == "disable"_L1)
++ return QQmlJS::WarningSeverity::Disable;
++ if (s == "info"_L1)
++ return QQmlJS::WarningSeverity::Info;
++ if (s == "warning"_L1)
++ return QQmlJS::WarningSeverity::Warning;
++ if (s == "error"_L1)
++ return QQmlJS::WarningSeverity::Error;
++ return {};
++ }
++
++ static constexpr bool less(WarningSeverity lhs, WarningSeverity rhs)
++ {
++ const auto orderedValue = [](WarningSeverity s) {
++ switch (s) {
++ case WarningSeverity::Error:
++ return 3;
++ case WarningSeverity::Warning:
++ return 2;
++ case WarningSeverity::Info:
++ return 1;
++ case WarningSeverity::Disable:
++ return 0;
++ }
++ Q_UNREACHABLE();
++ };
++ return orderedValue(lhs) < orderedValue(rhs);
++ }
++
++ /*!
++ \internal
++ Sets the category severity from a settings file and an optional parser.
++ Calls \c {parser->showHelp(-1)} for an invalid logging severity.
++ */
++ void updateLogSeverities(QList<LoggerCategory> &categories,
++ const QQmlToolingSettings &settings,
++ QCommandLineParser *parser,
++ CategorySelection categorySelection)
++ {
++ bool success = true;
++ for (auto &category : categories) {
++ // Disable all non-essential categories, they may still be overriden by settings or command line options
++ if (categorySelection == CategorySelection::Explicit && !category.isEssential())
++ category.setSeverity(QQmlSA::WarningSeverity::Disable);
++
++ const QString value = severityValueForCategory(category, settings, parser);
++ if (value.isEmpty())
++ continue;
++
++ const QString &name = category.id().name().toString();
++ const std::optional<QQmlJS::WarningSeverity> severity = severityFromString(value);
++ if (!severity.has_value()) {
++ qWarning() << "Invalid logging severity" << value << "provided for" << name
++ << "(allowed are: disable, info, warning, error).";
++ success = false;
++ continue;
++ }
++
++ if (category.isEssential() && less(severity.value(), category.severity())) {
++ qWarning() << "In order to ensure the proper function of qmllint, the severity of the "
++ "essential category %1 cannot be lowered."_L1.arg(name);
++ continue;
++ }
++
++ category.setSeverity(*severity);
++ }
++
++ if (!success && parser)
++ parser->showHelp(-1);
++ }
++ } // namespace LoggingUtils
++
++ } // namespace QQmlJS
++
++ QT_END_NAMESPACE