qqmljslogger_p.h

Go to the documentation of this file.

// Copyright (C) 2021 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
 
#ifndef QQMLJSLOGGER_P_H
#define QQMLJSLOGGER_P_H
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists purely as an
// implementation detail.  This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
 
#include <qtqmlcompilerexports.h>
 
#include "qcoloroutput_p.h"
#include "qqmljsloggingutils_p.h"
 
#include <private/qqmljsdiagnosticmessage_p.h>
 
#include <QtCore/qhash.h>
#include <QtCore/qmap.h>
#include <QtCore/qstring.h>
#include <QtCore/qlist.h>
#include <QtCore/qset.h>
#include <QtCore/QLoggingCategory>
 
#include <optional>
 
QT_BEGIN_NAMESPACE
 
/*!
    \internal
    Used to print the line containing the location of a certain error
 */
class Q_QMLCOMPILER_EXPORT IssueLocationWithContext
{
public:
    /*!
       \internal
       \param code: The whole text of a translation unit
       \param location: The location where an error occurred.
     */
    IssueLocationWithContext(QStringView code, const QQmlJS::SourceLocation &location) {
        quint32 before = qMax(0, code.lastIndexOf(QLatin1Char('\n'), location.offset));
 
        if (before != 0 && before < location.offset)
            before++;
 
        m_beforeText = code.mid(before, location.offset - before);
        m_issueText = code.mid(location.offset, location.length);
        int after = code.indexOf(QLatin1Char('\n'), location.offset + location.length);
        m_afterText = code.mid(location.offset + location.length,
                                  after - (location.offset+location.length));
    }
 
    // returns start of the line till first character of location
    QStringView beforeText() const { return m_beforeText; }
    // returns the text at location
    QStringView issueText() const { return m_issueText; }
    // returns any text after location until the end of the line is reached
    QStringView afterText() const { return m_afterText; }
 
private:
    QStringView m_beforeText;
    QStringView m_issueText;
    QStringView m_afterText;
};
 
class Q_QMLCOMPILER_EXPORT QQmlJSFixSuggestion
{
public:
    QQmlJSFixSuggestion() = default;
    QQmlJSFixSuggestion(const QString &description, const QQmlJS::SourceLocation &location,
                        const QString &replacement = QString());
 
    QString description() const { return m_description; }
    QQmlJS::SourceLocation location() const { return m_location; }
    QString replacement() const { return m_replacement; }
 
    void setFilename(const QString &filename) { m_filename = filename; }
    QString filename() const { return m_filename; }
 
    void setAutoApplicable(bool autoApply = true) { m_autoApplicable = autoApply; }
    bool isAutoApplicable() const { return m_autoApplicable; }
 
    bool operator==(const QQmlJSFixSuggestion &) const;
    bool operator!=(const QQmlJSFixSuggestion &) const;
 
private:
    QQmlJS::SourceLocation m_location;
    QString m_description;
    QString m_replacement;
    QString m_filename;
    bool m_autoApplicable = false;
};
 
struct Message : public QQmlJS::DiagnosticMessage
{
    enum class CompilationStatus { Normal, Skip, Error };
 
    // This doesn't need to be an owning-reference since the string is expected to outlive any
    // Message object by virtue of coming from a LoggerWarningId.
    QAnyStringView id;
    std::optional<QQmlJSFixSuggestion> fixSuggestion;
    CompilationStatus compilationStatus = CompilationStatus::Normal;
    std::optional<quint32> customLineForDisabling = std::nullopt;
 
    quint32 lineForDisabling() const { return customLineForDisabling.value_or(loc.startLine); }
};
 
class Q_QMLCOMPILER_EXPORT QQmlJSLogger
{
    Q_DISABLE_COPY_MOVE(QQmlJSLogger)
public:
    QList<QQmlJS::LoggerCategory> categories() const;
    static const QList<QQmlJS::LoggerCategory> &builtinCategories();
 
    void registerCategory(const QQmlJS::LoggerCategory &category);
 
    QQmlJSLogger();
    ~QQmlJSLogger() = default;
 
    bool hasWarnings() const { return m_numWarnings > 0; }
    bool hasErrors() const { return m_numErrors > 0; }
 
    qsizetype numWarnings() const { return m_numWarnings; }
    qsizetype numErrors() const { return m_numErrors; }
 
    template<typename F>
    void iterateCurrentFunctionMessages(F &&f) const
    {
        for (const Message &msg : m_currentFunctionMessages)
            f(msg);
    }
 
    template<typename F>
    void iterateAllMessages(F &&f) const
    {
        for (const Message &msg : m_archivedMessages)
            f(msg);
 
        for (const Message &msg : m_currentFunctionMessages)
            f(msg);
    }
 
    QQmlJS::WarningSeverity categorySeverity(QQmlJS::LoggerWarningId id) const
    {
        return m_categorySeverities[id.name().toString()];
    }
    void setCategorySeverity(QQmlJS::LoggerWarningId id, QQmlJS::WarningSeverity severity)
    {
        m_categorySeverities[id.name().toString()] = severity;
        m_categoryChanged[id.name().toString()] = true;
    }
 
    bool wasCategoryChanged(QQmlJS::LoggerWarningId id) const
    {
        return m_categoryChanged[id.name().toString()];
    }
 
    QQmlJS::WarningSeverity compileErrorSeverity() const { return m_compileErrorSeverity; }
    void setCompileErrorSeverity(QQmlJS::WarningSeverity severity) { m_compileErrorSeverity = severity; }
 
    QString compileErrorPrefix() const { return m_compileErrorPrefix; }
    void setCompileErrorPrefix(const QString &prefix) { m_compileErrorPrefix = prefix; }
 
    QString compileSkipPrefix() const { return m_compileSkipPrefix; }
    void setCompileSkipPrefix(const QString &prefix) { m_compileSkipPrefix = prefix; }
 
    /*! \internal
 
        Logs \a message with severity deduced from \a category. Prefer using
        this function in most cases.
 
        \sa setCategorySeverity
    */
    void log(const QString &message, QQmlJS::LoggerWarningId id,
             const QQmlJS::SourceLocation &srcLocation, bool showContext = true,
             bool showFileName = true, const std::optional<QQmlJSFixSuggestion> &suggestion = {},
             std::optional<quint32> customLineForDisabling = std::nullopt)
    {
        const auto &severityForCategory = m_categorySeverities[id.name().toString()];
        if (severityForCategory == QQmlJS::WarningSeverity::Disable)
            return;
 
        log(Message {
                QQmlJS::DiagnosticMessage {
                    message,
                    QtMsgType(severityForCategory),
                    srcLocation,
                },
                id.name(),
                suggestion,
                Message::CompilationStatus::Normal,
                customLineForDisabling
            }, showContext, showFileName);
    }
 
    void logCompileError(const QString &message, const QQmlJS::SourceLocation &srcLocation)
    {
        if (m_compileErrorSeverity == QQmlJS::WarningSeverity::Disable)
            return;
 
        if (m_inTransaction)
            m_hasPendingCompileError = true;
        else
            m_hasCompileError = true;
 
        log(Message {
                QQmlJS::DiagnosticMessage {
                    m_compileErrorPrefix + message,
                    QtMsgType(m_compileErrorSeverity), // OK, as the severity can't be Disable
                    srcLocation
                },
                qmlCompiler.name(),
                {},  // fixSuggestion
                Message::CompilationStatus::Error
            });
 
    }
 
    void logCompileSkip(const QString &message, const QQmlJS::SourceLocation &srcLocation)
    {
        if (m_compileSkipSeverity == QQmlJS::WarningSeverity::Disable)
            return;
 
        m_hasCompileSkip = true;
        log(Message {
                QQmlJS::DiagnosticMessage {
                        m_compileSkipPrefix + message,
                        QtMsgType(m_compileSkipSeverity), // OK, as the severity can't be Disable
                        srcLocation
                },
                qmlCompiler.name(),
                {},  // fixSuggestion
                Message::CompilationStatus::Skip
        });
    }
 
    void processMessages(QSpan<const QQmlJS::DiagnosticMessage> messages,
                         const QQmlJS::LoggerWarningId id,
                         const QQmlJS::SourceLocation &sourceLocation = QQmlJS::SourceLocation{});
 
    void ignoreWarnings(uint32_t line, const QSet<QString> &categories)
    {
        m_ignoredWarnings[line] = categories;
    }
 
    void setSilent(bool silent) { m_output.setSilent(silent); }
    bool isSilent() const { return m_output.isSilent(); }
 
    /*!
    \internal
    The logger is disabled when warnings are not relevant, for example when the import visitor runs
    on a dependency of a linted file. In that case, the warnings should not be created, and
    expensive QQmlJSUtils::didYouMean call can be saved.
 
    setSilent() has a different behavior: a silent logger can still be used to process messages as
    JSON, for example, while a disabled logger won't contain any message.
    */
    void setIsDisabled(bool isDisabled) { m_isDisabled = isDisabled; }
    bool isDisabled() const { return m_isDisabled; }
 
    void setCode(const QString &code) { m_code = code; }
    QString code() const { return m_code; }
 
    void setFilePath(const QString &filePath) { m_filePath =  filePath; }
    QString filePath() const { return m_filePath; }
 
    bool currentFunctionHasCompileError() const
    {
        return m_hasCompileError || m_hasPendingCompileError;
    }
 
    bool currentFunctionWasSkipped() const
    {
        return m_hasCompileSkip;
    }
 
    bool currentFunctionHasErrorOrSkip() const
    {
        return currentFunctionHasCompileError() || currentFunctionWasSkipped();
    }
 
    QString currentFunctionCompileErrorMessage() const
    {
        for (const Message &message : m_currentFunctionMessages) {
            if (message.compilationStatus == Message::CompilationStatus::Error)
                return message.message;
        }
 
        return QString();
    }
 
    QString currentFunctionCompileSkipMessage() const
    {
        for (const Message &message : m_currentFunctionMessages) {
            if (message.compilationStatus == Message::CompilationStatus::Skip)
                return message.message;
        }
 
        return QString();
    }
 
    void startTransaction();
    void commit();
    void rollback();
 
    void finalizeFunction();
 
private:
    QMap<QString, QQmlJS::LoggerCategory> m_categories;
 
    void printContext(const QQmlJS::SourceLocation &location);
    void printFix(const QQmlJSFixSuggestion &fix);
 
    void log(Message &&diagMsg, bool showContext = false, bool showFileName = true);
 
    void countMessage(const Message &message);
 
    QString m_filePath;
    QString m_code;
 
    QColorOutput m_output;
 
    QHash<QString, QQmlJS::WarningSeverity> m_categorySeverities;
    QHash<QString, bool> m_categoryChanged;
 
    QList<Message> m_pendingMessages;
    QList<Message> m_currentFunctionMessages;
    QList<Message> m_archivedMessages;
    QHash<uint32_t, QSet<QString>> m_ignoredWarnings;
 
    QString m_compileErrorPrefix;
    QString m_compileSkipPrefix;
 
    qsizetype m_numWarnings = 0;
    qsizetype m_numErrors = 0;
    bool m_inTransaction = false;
    bool m_hasCompileError = false;
    bool m_hasPendingCompileError = false;
    bool m_hasCompileSkip = false;
    bool m_isDisabled = false;
 
    QQmlJS::WarningSeverity m_compileErrorSeverity = QQmlJS::WarningSeverity::Warning;
    QQmlJS::WarningSeverity m_compileSkipSeverity = QQmlJS::WarningSeverity::Info;
};
 
QT_END_NAMESPACE
 
#endif // QQMLJSLOGGER_P_H