qqmldomerrormessage.cpp

Go to the documentation of this file.

// Copyright (C) 2020 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 "qqmldomitem_p.h"
#include "qqmldomstringdumper_p.h"
#include "qqmldomattachedinfo_p.h"
 
#include <QtCore/QCborMap>
#include <QtCore/QMutex>
#include <QtCore/QMutexLocker>
 
QT_BEGIN_NAMESPACE
 
namespace QQmlJS {
namespace Dom {
 
Q_LOGGING_CATEGORY(domLog, "qt.qmldom", QtWarningMsg);
 
enum {
    FatalMsgMaxLen=511
};
 
void ErrorGroup::dump(const Sink &sink) const
{
    sink(u"[");
    sink(groupName());
    sink(u"]");
}
 
void ErrorGroup::dumpId(const Sink &sink) const
{
    sink(u"[");
    sink(QString(groupId()));
    sink(u"]");
}
 
QLatin1String ErrorGroup::groupId() const
{
    return QLatin1String(m_groupId);
}
 
QString ErrorGroup::groupName() const
{
    return tr(m_groupId);
}
 
void ErrorGroups::dump(const Sink &sink) const
{
    for (int i = 0; i < groups.size(); ++i)
        groups.at(i).dump(sink);
}
 
void ErrorGroups::dumpId(const Sink &sink) const
{
    for (int i = 0; i < groups.size(); ++i)
        groups.at(i).dumpId(sink);
}
 
QCborArray ErrorGroups::toCbor() const
{
    QCborArray res;
    for (int i = 0; i < groups.size(); ++i)
        res.append(QCborValue(groups.at(i).groupId()));
    return res;
}
 
ErrorMessage ErrorGroups::errorMessage(
        const Dumper &msg, ErrorLevel level, const Path &element, const QString &canonicalFilePath,
        SourceLocation location) const
{
    if (level == ErrorLevel::Fatal)
        fatal(msg, element, canonicalFilePath, location);
    return ErrorMessage(dumperToString(msg), *this, level, element, canonicalFilePath, location);
}
 
ErrorMessage ErrorGroups::errorMessage(const DiagnosticMessage &msg, const Path &element, const QString &canonicalFilePath) const
{
    ErrorMessage res(*this, msg, element, canonicalFilePath);
    if (res.location == SourceLocation()
        && (res.location.startLine != 0 || res.location.startColumn != 0)) {
        res.location.offset = -1;
        res.location.length = 1;
    }
    return res;
}
 
void ErrorGroups::fatal(
        const Dumper &msg, const Path &element, QStringView canonicalFilePath,
        SourceLocation location) const
{
    enum { FatalMsgMaxLen = 1023 };
    char buf[FatalMsgMaxLen+1];
    int ibuf = 0;
    auto sink = [&ibuf, &buf](QStringView s) {
        int is = 0;
        while (ibuf < FatalMsgMaxLen && is < s.size()) {
            QChar c = s.at(is);
            if (c == QChar::fromLatin1('\n') || c == QChar::fromLatin1('\r') || (c >= QChar::fromLatin1(' ') && c <= QChar::fromLatin1('~')))
                buf[ibuf++] = c.toLatin1();
            else
                buf[ibuf++] = '~';
            ++is;
        }
    };
    if (!canonicalFilePath.isEmpty()) {
        sink(canonicalFilePath);
        sink(u":");
    }
    if (location.length) {
        sinkInt(sink, location.startLine);
        sink(u":");
        sinkInt(sink, location.startColumn);
        sink(u":");
    }
    dump(sink);
    msg(sink);
    if (element.length()>0) {
        sink(u" for ");
        element.dump(sink);
    }
    buf[ibuf] = 0;
    qFatal("%s", buf);
}
 
ErrorMessage ErrorGroups::debug(const QString &message) const
{
    return ErrorMessage(message, *this, ErrorLevel::Debug);
}
 
ErrorMessage ErrorGroups::debug(const Dumper &message) const
{
    return ErrorMessage(dumperToString(message), *this, ErrorLevel::Debug);
}
 
ErrorMessage ErrorGroups::info(const QString &message) const
{
    return ErrorMessage(message, *this, ErrorLevel::Info);
}
 
ErrorMessage ErrorGroups::info(const Dumper &message) const
{
    return ErrorMessage(dumperToString(message), *this, ErrorLevel::Info);
}
 
ErrorMessage ErrorGroups::warning(const QString &message) const
{
    return ErrorMessage(message, *this, ErrorLevel::Warning);
}
 
ErrorMessage ErrorGroups::warning(const Dumper &message) const
{
    return ErrorMessage(dumperToString(message), *this, ErrorLevel::Warning);
}
 
ErrorMessage ErrorGroups::error(const QString &message) const
{
    return ErrorMessage(message, *this, ErrorLevel::Error);
}
 
ErrorMessage ErrorGroups::error(const Dumper &message) const
{
    return ErrorMessage(dumperToString(message), *this, ErrorLevel::Error);
}
 
int ErrorGroups::cmp(const ErrorGroups &o1, const ErrorGroups &o2)
{
    auto &g1 = o1.groups;
    auto &g2 = o2.groups;
    if (g1.size() < g2.size())
        return -1;
    if (g1.size() < g2.size())
        return 1;
    for (int i = 0; i < g1.size(); ++i) {
        int c = std::strcmp(g1.at(i).groupId().data(), g2.at(i).groupId().data());
        if (c != 0)
            return c;
    }
    return 0;
}
 
ErrorMessage::ErrorMessage(
        const QString &msg, const ErrorGroups &errorGroups, Level level, const Path &element,
        const QString &canonicalFilePath, SourceLocation location, QLatin1String errorId)
    : errorId(errorId)
    , message(msg)
    , errorGroups(errorGroups)
    , level(level)
    , path(element)
    , file(canonicalFilePath)
    , location(location)
{
    if (level == Level::Fatal) // we should not end up here, it should have been handled at a higher level already
        errorGroups.fatal(msg, element, canonicalFilePath, location);
}
 
ErrorMessage::ErrorMessage(
        const ErrorGroups &errorGroups, const DiagnosticMessage &msg, const Path &element,
        const QString &canonicalFilePath, QLatin1String errorId)
    : errorId(errorId)
    , message(msg.message)
    , errorGroups(errorGroups)
    , level(errorLevelFromQtMsgType(msg.type))
    , path(element)
    , file(canonicalFilePath)
    , location(msg.loc)
{
    if (level == Level::Fatal) // we should not end up here, it should have been handled at a higher level already
        errorGroups.fatal(msg.message, element, canonicalFilePath, location);
}
 
 
static QBasicMutex *registryMutex()
{
    static QBasicMutex rMutex{};
    return &rMutex;
}
 
 
static ErrorGroups myErrors()
{
    static ErrorGroups g = {{NewErrorGroup("ErrorMessage")}};
    return g;
}
 
struct StorableMsg {
    StorableMsg():
        msg(QStringLiteral(u"dummy"), myErrors(), ErrorLevel::Error)
    {}
 
    StorableMsg(const ErrorMessage &e):
        msg(e)
    {}
 
    StorableMsg(ErrorMessage &&e):
          msg(std::move(e))
    {}
 
    ErrorMessage msg;
};
 
static QHash<QLatin1String, StorableMsg> &registry()
{
    static QHash<QLatin1String, StorableMsg> r;
    return r;
}
 
QLatin1String ErrorMessage::msg(const char *errorId, ErrorMessage &&err)
{
    return msg(QLatin1String(errorId), std::move(err));
}
 
QLatin1String ErrorMessage::msg(QLatin1String errorId, ErrorMessage &&err)
{
    bool doubleRegister = false;
    ErrorMessage old = myErrors().debug(u"dummy");
    {
        QMutexLocker l(registryMutex());
        auto &r = registry();
        if (r.contains(err.errorId)) {
            old = r[err.errorId].msg;
            doubleRegister = true;
        }
        r[errorId] = StorableMsg{std::move(err.withErrorId(errorId))};
    }
    if (doubleRegister)
        defaultErrorHandler(myErrors().warning(tr("Double registration of error %1: (%2) vs (%3)").arg(errorId, err.withErrorId(errorId).toString(), old.toString())));
    return errorId;
}
 
void ErrorMessage::visitRegisteredMessages(function_ref<bool(const ErrorMessage &)> visitor)
{
    QHash<QLatin1String, StorableMsg> r;
    {
        QMutexLocker l(registryMutex());
        r = registry();
    }
    auto it = r.cbegin();
    auto end = r.cend();
    while (it != end) {
        visitor(it->msg);
        ++it;
    }
}
 
ErrorMessage ErrorMessage::load(QLatin1String errorId)
{
    ErrorMessage res = myErrors().error([errorId](const Sink &s){
            s(u"Unregistered error ");
            s(QString(errorId)); });
    {
        QMutexLocker l(registryMutex());
        res = registry().value(errorId,res).msg;
    }
    return res;
}
 
ErrorMessage ErrorMessage::load(const char *errorId)
{
    return load(QLatin1String(errorId));
}
 
ErrorMessage &ErrorMessage::withErrorId(QLatin1String errorId)
{
    this->errorId = errorId;
    return *this;
}
 
ErrorMessage &ErrorMessage::withPath(const Path &path)
{
    this->path = path;
    return *this;
}
 
ErrorMessage &ErrorMessage::withFile(const QString &f)
{
    file=f;
    return *this;
}
 
ErrorMessage &ErrorMessage::withFile(QStringView f)
{
    file = f.toString();
    return *this;
}
 
ErrorMessage &ErrorMessage::withLocation(SourceLocation loc)
{
    location = loc;
    return *this;
}
 
ErrorMessage &ErrorMessage::withItem(const DomItem &el)
{
    if (path.length() == 0)
        path = el.canonicalPath();
    if (file.isEmpty())
        file = el.canonicalFilePath();
    if (location == SourceLocation()) {
        if (const FileLocations::Tree tree = FileLocations::treeOf(el)) {
            location = FileLocations::region(tree, MainRegion);
        }
    }
    return *this;
}
 
ErrorMessage ErrorMessage::handle(const ErrorHandler &errorHandler)
{
    if (errorHandler)
        errorHandler(*this);
    else
        defaultErrorHandler(*this);
    return *this;
}
 
void ErrorMessage::dump(const Sink &sink) const
{
    if (!file.isEmpty()) {
        sink(file);
        sink(u":");
    }
    if (location.length) {
        sinkInt(sink, location.startLine);
        sink(u":");
        sinkInt(sink, location.startColumn);
        sink(u": ");
    }
    errorGroups.dump(sink);
    sink(u" ");
    dumpErrorLevel(sink, level);
    if (! errorId.isEmpty()) {
        sink(u" ");
        sink(QString(errorId));
    }
    sink(u": ");
    sink(message);
    if (path.length()>0) {
        sink(u" for ");
        if (!file.isEmpty() && path.length() > 3 && path.headKind() == Path::Kind::Root)
            path.mid(3).dump(sink);
        else
            path.dump(sink);
    }
}
 
QString ErrorMessage::toString() const
{
    return dumperToString([this](const Sink &sink){ this->dump(sink); });
}
 
QCborMap ErrorMessage::toCbor() const
{
    return QCborMap({
                        {QStringLiteral(u"errorId"),errorId},
                        {QStringLiteral(u"message"), message},
                        {QStringLiteral(u"errorGroups"), errorGroups.toCbor()},
                        {QStringLiteral(u"level"), int(level)},
                        {QStringLiteral(u"path"), path.toString()},
                        {QStringLiteral(u"file"), file},
                        {QStringLiteral(u"location"), QCborMap({
                             {QStringLiteral(u"offset"),location.offset},
                             {QStringLiteral(u"length"),location.length},
                             {QStringLiteral(u"startLine"),location.startLine},
                             {QStringLiteral(u"startColumn"),location.startColumn}})}
                    });
}
 
void errorToQDebug(const ErrorMessage &error)
{
    dumperToQDebug([&error](const Sink &s){ error.dump(s); }, error.level);
}
 
void silentError(const ErrorMessage &)
{
}
 
void errorHandlerHandler(const ErrorMessage &msg, const ErrorHandler *h = nullptr)
{
    static ErrorHandler handler = &errorToQDebug;
    if (h) {
        handler = *h;
    } else {
        handler(msg);
    }
}
 
void defaultErrorHandler(const ErrorMessage &error)
{
    errorHandlerHandler(error);
}
 
void setDefaultErrorHandler(const ErrorHandler &h)
{
    errorHandlerHandler(ErrorMessage(QString(), ErrorGroups({})), &h);
}
 
ErrorLevel errorLevelFromQtMsgType(QtMsgType msgType)
{
    switch (msgType) {
    case QtFatalMsg:
        return ErrorLevel::Fatal;
    case QtCriticalMsg:
        return ErrorLevel::Error;
    case QtWarningMsg:
        return ErrorLevel::Warning;
    case QtInfoMsg:
        return ErrorLevel::Info;
    case QtDebugMsg:
        return ErrorLevel::Debug;
    default:
        return ErrorLevel::Error;
    }
}
 
} // end namespace Dom
} // end namespace QQmlJS
 
QT_END_NAMESPACE
 
#include "moc_qqmldomerrormessage_p.cpp"