qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qtdeclarative/src/qmlcompiler/qqmljslogger.cpp

325 lines
14 KiB
C++
Raw Normal View History

Use SPDX license identifiers Replace the current license disclaimer in files by a SPDX-License-Identifier. Files that have to be modified by hand are modified. License files are organized under LICENSES directory. Pick-to: 6.4 Task-number: QTBUG-67283 Change-Id: I63563bbeb6f60f89d2c99660400dca7fab78a294 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2022-05-13 13:12:05 +00:00
// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
QQmlJSLogger: disable warning from GCC 11 & 12 I think it's coming from the push_back in QQmlJSLogger::log(), but GCC appears to require the warning be suppressed at the template, not the instantiation point. GCC 11: qarraydataops.h:581:11: error: ‘*(QArrayDataPointer<FixSuggestion::Fix>*)((char*)&tmp + offsetof(Message, Message::fixSuggestion.std::optional<FixSuggestion>::<unnamed>.std::_Optional_base<FixSuggestion, false, false>::<unnamed>)).QArrayDataPointer<FixSuggestion::Fix>::ptr’ is used uninitialized [-Werror=uninitialized] GCC 12: qarraydataops.h:581:11: error: ?*(QArrayDataPointer<FixSuggestion::Fix>*)((char*)&tmp + offsetof(Message, Message::fixSuggestion.std::optional<FixSuggestion>::<unnamed>.std::_Optional_base<FixSuggestion, false, false>::<unnamed>)).QArrayDataPointer<FixSuggestion::Fix>::d? may be used uninitialized [-Werror=maybe-uninitialized] Pick-to: 6.2 6.3 6.4 Change-Id: I0e5f6bec596a4a78bd3bfffd16c995116afc2718 Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2022-01-12 17:10:41 +00:00
#include <qglobal.h>
// GCC 11 thinks diagMsg.fixSuggestion.fixes.d.ptr is somehow uninitialized in
// QList::emplaceBack(), probably called from QQmlJsLogger::log()
// Ditto for GCC 12, but it emits a different warning
QT_WARNING_PUSH
QT_WARNING_DISABLE_GCC("-Wuninitialized")
QT_WARNING_DISABLE_GCC("-Wmaybe-uninitialized")
#include <qlist.h>
QT_WARNING_POP
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
#include "qqmljslogger_p.h"
qmlcompiler: Allow for logging other files and add auto-fix infrastructure This change makes sure the logger can write messages and show excerpts from files other than the current one. This is necessary in order to give users hints about problems that arise due to other components. It also adds a field to FixSuggestion::Fix which specifies whether a suggested fix can be applied automatically or is only a hint. Change-Id: I94a929d3fc3fc966591cffb99e67309d264c38e7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-24 09:28:52 +00:00
#include <QtCore/qfile.h>
#include <QtCore/qfileinfo.h>
qmlcompiler: Use QT_BEGIN_NAMESPACE / QT_END_NAMESPACE everywhere Some code was not properly wrapped in a namespace. Change-Id: If70fd9782391309c511b66ae01eae43cb36292ac Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-22 12:41:14 +00:00
QT_BEGIN_NAMESPACE
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
using namespace Qt::StringLiterals;
QQmlJSLogger: Switch to an ID based system This change makes qmljslogger use an ID based system for categorizing logging entries instead of using an enum. This allows plugins to register their own logging categories after the fact. It's also necessary for us to later show the warning ID when printing warnings and for creating documentation for each ID entry. Currently not every ID maps cleanly to only one type of warning, this has to be cleaned up in a follow-up change. Task-number: QTBUG-103453 Change-Id: I4cac6be7ca165b938e0ea032d077823bf17baf75 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-05-30 12:52:03 +00:00
const LoggerWarningId qmlRequired { "required" };
const LoggerWarningId qmlAlias { "alias" };
const LoggerWarningId qmlImport { "import" };
const LoggerWarningId qmlRecursionDepthErrors { "recursion-depth-errors" };
const LoggerWarningId qmlWith { "with" };
const LoggerWarningId qmlInheritanceCycle { "inheritance-cycle" };
const LoggerWarningId qmlDeprecated { "deprecated" };
const LoggerWarningId qmlSignal { "signal" };
const LoggerWarningId qmlType { "type" };
const LoggerWarningId qmlProperty { "property" };
const LoggerWarningId qmlDeferredPropertyId { "deferred-property-id" };
const LoggerWarningId qmlUnqualified { "unqualified" };
const LoggerWarningId qmlUnusedImports { "unused-imports" };
const LoggerWarningId qmlMultilineStrings { "multiline-strings" };
const LoggerWarningId qmlSyntax { "syntax" };
const LoggerWarningId qmlSyntaxIdQuotation { "syntax.id-quotation" };
const LoggerWarningId qmlSyntaxDuplicateIds { "syntax.duplicate-ids" };
const LoggerWarningId qmlCompiler { "compiler" };
const LoggerWarningId qmlControlsSanity { "controls-sanity" };
const LoggerWarningId qmlAttachedPropertyReuse { "attached-property-reuse" };
const LoggerWarningId qmlPlugin { "plugin" };
const QList<QQmlJSLogger::Category> &QQmlJSLogger::defaultCategories()
{
static const QList<QQmlJSLogger::Category> cats = {
QQmlJSLogger::Category { qmlRequired.name().toString(), QStringLiteral("RequiredProperty"),
QStringLiteral("Warn about required properties"), QtWarningMsg },
QQmlJSLogger::Category { qmlAlias.name().toString(), QStringLiteral("PropertyAlias"),
QStringLiteral("Warn about alias errors"), QtWarningMsg },
QQmlJSLogger::Category {
qmlImport.name().toString(), QStringLiteral("ImportFailure"),
QStringLiteral("Warn about failing imports and deprecated qmltypes"),
QtWarningMsg },
QQmlJSLogger::Category {
qmlRecursionDepthErrors.name().toString(), QStringLiteral("ImportFailure"),
QStringLiteral("Warn about failing imports and deprecated qmltypes"), QtWarningMsg,
false, true },
QQmlJSLogger::Category {
qmlWith.name().toString(), QStringLiteral("WithStatement"),
QStringLiteral("Warn about with statements as they can cause false "
"positives when checking for unqualified access"),
QtWarningMsg },
QQmlJSLogger::Category { qmlInheritanceCycle.name().toString(),
QStringLiteral("InheritanceCycle"),
QStringLiteral("Warn about inheritance cycles"), QtWarningMsg },
QQmlJSLogger::Category { qmlDeprecated.name().toString(), QStringLiteral("Deprecated"),
QStringLiteral("Warn about deprecated properties and types"),
QtWarningMsg },
QQmlJSLogger::Category { qmlSignal.name().toString(), QStringLiteral("BadSignalHandler"),
QStringLiteral("Warn about bad signal handler parameters"),
QtWarningMsg },
QQmlJSLogger::Category {
qmlType.name().toString(), QStringLiteral("TypeError"),
QStringLiteral("Warn about unresolvable types and type mismatches"), QtWarningMsg },
QQmlJSLogger::Category { qmlProperty.name().toString(), QStringLiteral("UnknownProperty"),
QStringLiteral("Warn about unknown properties"), QtWarningMsg },
QQmlJSLogger::Category {
qmlDeferredPropertyId.name().toString(), QStringLiteral("DeferredPropertyId"),
QStringLiteral(
"Warn about making deferred properties immediate by giving them an id."),
QtWarningMsg },
QQmlJSLogger::Category {
qmlUnqualified.name().toString(), QStringLiteral("UnqualifiedAccess"),
QStringLiteral("Warn about unqualified identifiers and how to fix them"),
QtWarningMsg },
QQmlJSLogger::Category { qmlUnusedImports.name().toString(),
QStringLiteral("UnusedImports"),
QStringLiteral("Warn about unused imports"), QtInfoMsg },
QQmlJSLogger::Category { qmlMultilineStrings.name().toString(),
QStringLiteral("MultilineStrings"),
QStringLiteral("Warn about multiline strings"), QtInfoMsg },
QQmlJSLogger::Category { qmlSyntax.name().toString(), QString(),
QStringLiteral("Syntax errors"), QtWarningMsg, false, true },
QQmlJSLogger::Category { qmlSyntaxIdQuotation.name().toString(), QString(),
QStringLiteral("ID quotation"), QtWarningMsg, false, true },
QQmlJSLogger::Category { qmlSyntaxDuplicateIds.name().toString(), QString(),
QStringLiteral("ID duplication"), QtCriticalMsg, false, true },
QQmlJSLogger::Category { qmlCompiler.name().toString(), QStringLiteral("CompilerWarnings"),
QStringLiteral("Warn about compiler issues"), QtWarningMsg, true },
QQmlJSLogger::Category {
qmlControlsSanity.name().toString(), QStringLiteral("ControlsSanity"),
QStringLiteral("Performance checks used for QuickControl's implementation"),
QtCriticalMsg, true },
QQmlJSLogger::Category {
qmlAttachedPropertyReuse.name().toString(), QStringLiteral("AttachedPropertyReuse"),
QStringLiteral("Warn if attached types from parent components aren't reused"),
QtCriticalMsg, true },
QQmlJSLogger::Category { qmlPlugin.name().toString(), QStringLiteral("LintPluginWarnings"),
QStringLiteral("Warn if a qmllint plugin finds an issue"),
qmllint: Hide plugin category The plugin category is only used for our debugging passes anymore, just hide it from the user from now. Maybe it could be removed later on. Change-Id: Ifa7e55ee950277d0b9e75cfe590b9052767a256a Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-06-30 09:53:51 +00:00
QtWarningMsg, true }
qmllint: Warn about multiline strings Task-number: QTBUG-92448 Change-Id: Ic6305f05cb8a0af5c36ac03d8b541ac78cea0612 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-04-19 14:54:45 +00:00
};
qmllint: add options for setting logging levels Add the ability to individually disable and set the severity of all warnings produced by qmllint. Change-Id: I46081f8b37fb90f8d0f4a5f2f08223d7b7285041 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-03-30 10:58:26 +00:00
QQmlJSLogger: Switch to an ID based system This change makes qmljslogger use an ID based system for categorizing logging entries instead of using an enum. This allows plugins to register their own logging categories after the fact. It's also necessary for us to later show the warning ID when printing warnings and for creating documentation for each ID entry. Currently not every ID maps cleanly to only one type of warning, this has to be cleaned up in a follow-up change. Task-number: QTBUG-103453 Change-Id: I4cac6be7ca165b938e0ea032d077823bf17baf75 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-05-30 12:52:03 +00:00
return cats;
qmllint: add options for setting logging levels Add the ability to individually disable and set the severity of all warnings produced by qmllint. Change-Id: I46081f8b37fb90f8d0f4a5f2f08223d7b7285041 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-03-30 10:58:26 +00:00
}
QQmlJSLogger: Switch to an ID based system This change makes qmljslogger use an ID based system for categorizing logging entries instead of using an enum. This allows plugins to register their own logging categories after the fact. It's also necessary for us to later show the warning ID when printing warnings and for creating documentation for each ID entry. Currently not every ID maps cleanly to only one type of warning, this has to be cleaned up in a follow-up change. Task-number: QTBUG-103453 Change-Id: I4cac6be7ca165b938e0ea032d077823bf17baf75 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-05-30 12:52:03 +00:00
const QList<QQmlJSLogger::Category> QQmlJSLogger::categories() const
{
return m_categories.values();
}
void QQmlJSLogger::registerCategory(const QQmlJSLogger::Category &category)
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
{
QQmlJSLogger: Switch to an ID based system This change makes qmljslogger use an ID based system for categorizing logging entries instead of using an enum. This allows plugins to register their own logging categories after the fact. It's also necessary for us to later show the warning ID when printing warnings and for creating documentation for each ID entry. Currently not every ID maps cleanly to only one type of warning, this has to be cleaned up in a follow-up change. Task-number: QTBUG-103453 Change-Id: I4cac6be7ca165b938e0ea032d077823bf17baf75 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-05-30 12:52:03 +00:00
if (m_categories.contains(category.name)) {
qWarning() << "Trying to re-register existing logger category" << category.name;
return;
qmllint: add options for setting logging levels Add the ability to individually disable and set the severity of all warnings produced by qmllint. Change-Id: I46081f8b37fb90f8d0f4a5f2f08223d7b7285041 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-03-30 10:58:26 +00:00
}
QQmlJSLogger: Switch to an ID based system This change makes qmljslogger use an ID based system for categorizing logging entries instead of using an enum. This allows plugins to register their own logging categories after the fact. It's also necessary for us to later show the warning ID when printing warnings and for creating documentation for each ID entry. Currently not every ID maps cleanly to only one type of warning, this has to be cleaned up in a follow-up change. Task-number: QTBUG-103453 Change-Id: I4cac6be7ca165b938e0ea032d077823bf17baf75 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-05-30 12:52:03 +00:00
m_categoryLevels[category.name] = category.level;
m_categoryIgnored[category.name] = category.ignored;
m_categories.insert(category.name, category);
}
QQmlJSLogger::QQmlJSLogger()
{
static const QList<QQmlJSLogger::Category> cats = defaultCategories();
for (const QQmlJSLogger::Category &category : cats)
registerCategory(category);
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
// setup color output
m_output.insertMapping(QtCriticalMsg, QColorOutput::RedForeground);
Redesign QQmlJSLogger internals High-level goal: be able to reuse existing infrastructure "as is" to configure semantic analysis categories in tools (qmllint, qmltc, qmlsc, etc.) To achieve that, simplify the logging to always "log" something, without explicitly specifying the severity. The severity is now baked into the category (and we can extend those to cover different cases) One slight deviation is the cache generation which likes to do its own thing at present. Provide a "forced logging" option where we can specify which severify we want. The hope is that this gets removed at some point Particular list of (noteworthy) changes: * No more "thresholding" by the level (this is rarely needed and is actually questionable). Instead, we can ignore a particular category explicitly * Category levels are repurposed as category severities (at least from the high-level picture that always should've been this way) * log{Warning,Info,Critical} removed. We use category severity instead * "category error" makes zero sense so removed: if our severity is: - QtWarningMsg (qmllint), it is already an "error" - QtCriticalMsg (compilers), it is already an "error" * Align m_output and m_{infos,warnings,errors} stored information * Accept the fact that we don't support QtDebugMsg and QtFatalMsg * Additional categories added to cover for places where the same category would be both an error and not an error Task-number: QTBUG-100052 Change-Id: I3cd5d17d58be204f48428877bed053f756ac40a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-02-03 12:45:18 +00:00
m_output.insertMapping(QtWarningMsg, QColorOutput::PurpleForeground); // Yellow?
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
m_output.insertMapping(QtInfoMsg, QColorOutput::BlueForeground);
Redesign QQmlJSLogger internals High-level goal: be able to reuse existing infrastructure "as is" to configure semantic analysis categories in tools (qmllint, qmltc, qmlsc, etc.) To achieve that, simplify the logging to always "log" something, without explicitly specifying the severity. The severity is now baked into the category (and we can extend those to cover different cases) One slight deviation is the cache generation which likes to do its own thing at present. Provide a "forced logging" option where we can specify which severify we want. The hope is that this gets removed at some point Particular list of (noteworthy) changes: * No more "thresholding" by the level (this is rarely needed and is actually questionable). Instead, we can ignore a particular category explicitly * Category levels are repurposed as category severities (at least from the high-level picture that always should've been this way) * log{Warning,Info,Critical} removed. We use category severity instead * "category error" makes zero sense so removed: if our severity is: - QtWarningMsg (qmllint), it is already an "error" - QtCriticalMsg (compilers), it is already an "error" * Align m_output and m_{infos,warnings,errors} stored information * Accept the fact that we don't support QtDebugMsg and QtFatalMsg * Additional categories added to cover for places where the same category would be both an error and not an error Task-number: QTBUG-100052 Change-Id: I3cd5d17d58be204f48428877bed053f756ac40a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-02-03 12:45:18 +00:00
m_output.insertMapping(QtDebugMsg, QColorOutput::GreenForeground); // None?
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
}
qmllint: Implement severity levels qmllint now supports logging levels of different severities. Still lacking a good way to toggle the verbosity more granularly though (i.e. disabling only info messages while still receiving the rest). Change-Id: I71abddcdf1adf60315a87d776af8085acf7aeffe Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 15:30:42 +00:00
static bool isMsgTypeLess(QtMsgType a, QtMsgType b)
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
{
qmllint: Implement severity levels qmllint now supports logging levels of different severities. Still lacking a good way to toggle the verbosity more granularly though (i.e. disabling only info messages while still receiving the rest). Change-Id: I71abddcdf1adf60315a87d776af8085acf7aeffe Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 15:30:42 +00:00
static QHash<QtMsgType, int> level = { { QtDebugMsg, 0 },
{ QtInfoMsg, 1 },
{ QtWarningMsg, 2 },
{ QtCriticalMsg, 3 },
{ QtFatalMsg, 4 } };
return level[a] < level[b];
}
QQmlJSLogger: Switch to an ID based system This change makes qmljslogger use an ID based system for categorizing logging entries instead of using an enum. This allows plugins to register their own logging categories after the fact. It's also necessary for us to later show the warning ID when printing warnings and for creating documentation for each ID entry. Currently not every ID maps cleanly to only one type of warning, this has to be cleaned up in a follow-up change. Task-number: QTBUG-103453 Change-Id: I4cac6be7ca165b938e0ea032d077823bf17baf75 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-05-30 12:52:03 +00:00
void QQmlJSLogger::log(const QString &message, LoggerWarningId id,
qmllint: Implement severity levels qmllint now supports logging levels of different severities. Still lacking a good way to toggle the verbosity more granularly though (i.e. disabling only info messages while still receiving the rest). Change-Id: I71abddcdf1adf60315a87d776af8085acf7aeffe Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 15:30:42 +00:00
const QQmlJS::SourceLocation &srcLocation, QtMsgType type, bool showContext,
qmlcompiler: Allow for logging other files and add auto-fix infrastructure This change makes sure the logger can write messages and show excerpts from files other than the current one. This is necessary in order to give users hints about problems that arise due to other components. It also adds a field to FixSuggestion::Fix which specifies whether a suggested fix can be applied automatically or is only a hint. Change-Id: I94a929d3fc3fc966591cffb99e67309d264c38e7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-24 09:28:52 +00:00
bool showFileName, const std::optional<FixSuggestion> &suggestion,
const QString overrideFileName)
qmllint: Implement severity levels qmllint now supports logging levels of different severities. Still lacking a good way to toggle the verbosity more granularly though (i.e. disabling only info messages while still receiving the rest). Change-Id: I71abddcdf1adf60315a87d776af8085acf7aeffe Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 15:30:42 +00:00
{
QQmlJSLogger: Switch to an ID based system This change makes qmljslogger use an ID based system for categorizing logging entries instead of using an enum. This allows plugins to register their own logging categories after the fact. It's also necessary for us to later show the warning ID when printing warnings and for creating documentation for each ID entry. Currently not every ID maps cleanly to only one type of warning, this has to be cleaned up in a follow-up change. Task-number: QTBUG-103453 Change-Id: I4cac6be7ca165b938e0ea032d077823bf17baf75 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-05-30 12:52:03 +00:00
Q_ASSERT(m_categoryLevels.contains(id.name().toString()));
if (isCategoryIgnored(id))
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
return;
Redesign QQmlJSLogger internals High-level goal: be able to reuse existing infrastructure "as is" to configure semantic analysis categories in tools (qmllint, qmltc, qmlsc, etc.) To achieve that, simplify the logging to always "log" something, without explicitly specifying the severity. The severity is now baked into the category (and we can extend those to cover different cases) One slight deviation is the cache generation which likes to do its own thing at present. Provide a "forced logging" option where we can specify which severify we want. The hope is that this gets removed at some point Particular list of (noteworthy) changes: * No more "thresholding" by the level (this is rarely needed and is actually questionable). Instead, we can ignore a particular category explicitly * Category levels are repurposed as category severities (at least from the high-level picture that always should've been this way) * log{Warning,Info,Critical} removed. We use category severity instead * "category error" makes zero sense so removed: if our severity is: - QtWarningMsg (qmllint), it is already an "error" - QtCriticalMsg (compilers), it is already an "error" * Align m_output and m_{infos,warnings,errors} stored information * Accept the fact that we don't support QtDebugMsg and QtFatalMsg * Additional categories added to cover for places where the same category would be both an error and not an error Task-number: QTBUG-100052 Change-Id: I3cd5d17d58be204f48428877bed053f756ac40a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-02-03 12:45:18 +00:00
// Note: assume \a type is the type we should prefer for logging
QQmlJSLogger: Switch to an ID based system This change makes qmljslogger use an ID based system for categorizing logging entries instead of using an enum. This allows plugins to register their own logging categories after the fact. It's also necessary for us to later show the warning ID when printing warnings and for creating documentation for each ID entry. Currently not every ID maps cleanly to only one type of warning, this has to be cleaned up in a follow-up change. Task-number: QTBUG-103453 Change-Id: I4cac6be7ca165b938e0ea032d077823bf17baf75 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-05-30 12:52:03 +00:00
if (srcLocation.isValid()
&& m_ignoredWarnings[srcLocation.startLine].contains(id.name().toString()))
qmllint: Add ability to ignore individual warnings Allows users to ignore individual warnings by adding a "// qmllint disable" comment in the line that triggers the warning. This feature is especially useful for use in pre-commit / CI tests as it allows to add exceptions for individual warnings that cannot be fixed immediately. [ChangeLog][qmllint][New Feature] You can now ignore individual warnings by adding "// qmllint disable" in the line causing it. You may also specify one or more warning type to ignore ("// qmllint disable warningtype1 warningtype2...") which is preferable. This can also be done for entire blocks of code by using "// qmllint disable" in an empty line and ending it with "// qmllint enable" Change-Id: Iea6c29132d6b51ecfb5e5d8a19a43446a7286c24 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-05-27 12:32:43 +00:00
return;
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
QString prefix;
qmlcompiler: Allow for logging other files and add auto-fix infrastructure This change makes sure the logger can write messages and show excerpts from files other than the current one. This is necessary in order to give users hints about problems that arise due to other components. It also adds a field to FixSuggestion::Fix which specifies whether a suggested fix can be applied automatically or is only a hint. Change-Id: I94a929d3fc3fc966591cffb99e67309d264c38e7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-24 09:28:52 +00:00
if ((!overrideFileName.isEmpty() || !m_fileName.isEmpty()) && showFileName)
prefix =
(!overrideFileName.isEmpty() ? overrideFileName : m_fileName) + QStringLiteral(":");
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
if (srcLocation.isValid())
prefix += QStringLiteral("%1:%2:").arg(srcLocation.startLine).arg(srcLocation.startColumn);
if (!prefix.isEmpty())
prefix.append(QLatin1Char(' '));
Redesign QQmlJSLogger internals High-level goal: be able to reuse existing infrastructure "as is" to configure semantic analysis categories in tools (qmllint, qmltc, qmlsc, etc.) To achieve that, simplify the logging to always "log" something, without explicitly specifying the severity. The severity is now baked into the category (and we can extend those to cover different cases) One slight deviation is the cache generation which likes to do its own thing at present. Provide a "forced logging" option where we can specify which severify we want. The hope is that this gets removed at some point Particular list of (noteworthy) changes: * No more "thresholding" by the level (this is rarely needed and is actually questionable). Instead, we can ignore a particular category explicitly * Category levels are repurposed as category severities (at least from the high-level picture that always should've been this way) * log{Warning,Info,Critical} removed. We use category severity instead * "category error" makes zero sense so removed: if our severity is: - QtWarningMsg (qmllint), it is already an "error" - QtCriticalMsg (compilers), it is already an "error" * Align m_output and m_{infos,warnings,errors} stored information * Accept the fact that we don't support QtDebugMsg and QtFatalMsg * Additional categories added to cover for places where the same category would be both an error and not an error Task-number: QTBUG-100052 Change-Id: I3cd5d17d58be204f48428877bed053f756ac40a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-02-03 12:45:18 +00:00
// Note: we do the clamping to [Info, Critical] range since our logger only
// supports 3 categories
type = std::clamp(type, QtInfoMsg, QtCriticalMsg, isMsgTypeLess);
qmllint: Implement severity levels qmllint now supports logging levels of different severities. Still lacking a good way to toggle the verbosity more granularly though (i.e. disabling only info messages while still receiving the rest). Change-Id: I71abddcdf1adf60315a87d776af8085acf7aeffe Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 15:30:42 +00:00
Redesign QQmlJSLogger internals High-level goal: be able to reuse existing infrastructure "as is" to configure semantic analysis categories in tools (qmllint, qmltc, qmlsc, etc.) To achieve that, simplify the logging to always "log" something, without explicitly specifying the severity. The severity is now baked into the category (and we can extend those to cover different cases) One slight deviation is the cache generation which likes to do its own thing at present. Provide a "forced logging" option where we can specify which severify we want. The hope is that this gets removed at some point Particular list of (noteworthy) changes: * No more "thresholding" by the level (this is rarely needed and is actually questionable). Instead, we can ignore a particular category explicitly * Category levels are repurposed as category severities (at least from the high-level picture that always should've been this way) * log{Warning,Info,Critical} removed. We use category severity instead * "category error" makes zero sense so removed: if our severity is: - QtWarningMsg (qmllint), it is already an "error" - QtCriticalMsg (compilers), it is already an "error" * Align m_output and m_{infos,warnings,errors} stored information * Accept the fact that we don't support QtDebugMsg and QtFatalMsg * Additional categories added to cover for places where the same category would be both an error and not an error Task-number: QTBUG-100052 Change-Id: I3cd5d17d58be204f48428877bed053f756ac40a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-02-03 12:45:18 +00:00
// Note: since we clamped our \a type, the output message is not printed
// exactly like it was requested, bear with us
m_output.writePrefixedMessage(prefix + message, type);
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
qmllint: Use fix suggestions in a more structured way Fix suggestions are now attached to the warnings they are caused by and are also accessible via JSON. This allows us to use the qmllint library for more of tst_qmllint, greatly improving performance. Change-Id: Idd0398028bff1272a75dc1193d2c15a25d335dbf Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-12-07 17:48:08 +00:00
Message diagMsg;
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
diagMsg.message = message;
diagMsg.loc = srcLocation;
Redesign QQmlJSLogger internals High-level goal: be able to reuse existing infrastructure "as is" to configure semantic analysis categories in tools (qmllint, qmltc, qmlsc, etc.) To achieve that, simplify the logging to always "log" something, without explicitly specifying the severity. The severity is now baked into the category (and we can extend those to cover different cases) One slight deviation is the cache generation which likes to do its own thing at present. Provide a "forced logging" option where we can specify which severify we want. The hope is that this gets removed at some point Particular list of (noteworthy) changes: * No more "thresholding" by the level (this is rarely needed and is actually questionable). Instead, we can ignore a particular category explicitly * Category levels are repurposed as category severities (at least from the high-level picture that always should've been this way) * log{Warning,Info,Critical} removed. We use category severity instead * "category error" makes zero sense so removed: if our severity is: - QtWarningMsg (qmllint), it is already an "error" - QtCriticalMsg (compilers), it is already an "error" * Align m_output and m_{infos,warnings,errors} stored information * Accept the fact that we don't support QtDebugMsg and QtFatalMsg * Additional categories added to cover for places where the same category would be both an error and not an error Task-number: QTBUG-100052 Change-Id: I3cd5d17d58be204f48428877bed053f756ac40a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-02-03 12:45:18 +00:00
diagMsg.type = type;
qmllint: Use fix suggestions in a more structured way Fix suggestions are now attached to the warnings they are caused by and are also accessible via JSON. This allows us to use the qmllint library for more of tst_qmllint, greatly improving performance. Change-Id: Idd0398028bff1272a75dc1193d2c15a25d335dbf Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-12-07 17:48:08 +00:00
diagMsg.fixSuggestion = suggestion;
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
Redesign QQmlJSLogger internals High-level goal: be able to reuse existing infrastructure "as is" to configure semantic analysis categories in tools (qmllint, qmltc, qmlsc, etc.) To achieve that, simplify the logging to always "log" something, without explicitly specifying the severity. The severity is now baked into the category (and we can extend those to cover different cases) One slight deviation is the cache generation which likes to do its own thing at present. Provide a "forced logging" option where we can specify which severify we want. The hope is that this gets removed at some point Particular list of (noteworthy) changes: * No more "thresholding" by the level (this is rarely needed and is actually questionable). Instead, we can ignore a particular category explicitly * Category levels are repurposed as category severities (at least from the high-level picture that always should've been this way) * log{Warning,Info,Critical} removed. We use category severity instead * "category error" makes zero sense so removed: if our severity is: - QtWarningMsg (qmllint), it is already an "error" - QtCriticalMsg (compilers), it is already an "error" * Align m_output and m_{infos,warnings,errors} stored information * Accept the fact that we don't support QtDebugMsg and QtFatalMsg * Additional categories added to cover for places where the same category would be both an error and not an error Task-number: QTBUG-100052 Change-Id: I3cd5d17d58be204f48428877bed053f756ac40a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-02-03 12:45:18 +00:00
switch (type) {
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
case QtWarningMsg: m_warnings.push_back(diagMsg); break;
case QtCriticalMsg: m_errors.push_back(diagMsg); break;
case QtInfoMsg: m_infos.push_back(diagMsg); break;
default: break;
}
if (srcLocation.isValid() && !m_code.isEmpty() && showContext)
qmlcompiler: Allow for logging other files and add auto-fix infrastructure This change makes sure the logger can write messages and show excerpts from files other than the current one. This is necessary in order to give users hints about problems that arise due to other components. It also adds a field to FixSuggestion::Fix which specifies whether a suggested fix can be applied automatically or is only a hint. Change-Id: I94a929d3fc3fc966591cffb99e67309d264c38e7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-24 09:28:52 +00:00
printContext(overrideFileName, srcLocation);
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
qmllint: Use fix suggestions in a more structured way Fix suggestions are now attached to the warnings they are caused by and are also accessible via JSON. This allows us to use the qmllint library for more of tst_qmllint, greatly improving performance. Change-Id: Idd0398028bff1272a75dc1193d2c15a25d335dbf Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-12-07 17:48:08 +00:00
if (suggestion.has_value())
printFix(suggestion.value());
qmllint: Formalize fix suggestions They are now handled by the logger instead of being done by external classes using the ColorOutput directly. This will allow for modernizing the logger and for automatically applying those suggested fixes. Fixes: QTBUG-94170 Change-Id: I90b960d22cb91203b8e8a5c69b0fdaf6fca2fc0c Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 11:55:11 +00:00
}
qmllint: Implement severity levels qmllint now supports logging levels of different severities. Still lacking a good way to toggle the verbosity more granularly though (i.e. disabling only info messages while still receiving the rest). Change-Id: I71abddcdf1adf60315a87d776af8085acf7aeffe Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 15:30:42 +00:00
void QQmlJSLogger::processMessages(const QList<QQmlJS::DiagnosticMessage> &messages,
QQmlJSLogger: Switch to an ID based system This change makes qmljslogger use an ID based system for categorizing logging entries instead of using an enum. This allows plugins to register their own logging categories after the fact. It's also necessary for us to later show the warning ID when printing warnings and for creating documentation for each ID entry. Currently not every ID maps cleanly to only one type of warning, this has to be cleaned up in a follow-up change. Task-number: QTBUG-103453 Change-Id: I4cac6be7ca165b938e0ea032d077823bf17baf75 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-05-30 12:52:03 +00:00
LoggerWarningId id)
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
{
QQmlJSLogger: Switch to an ID based system This change makes qmljslogger use an ID based system for categorizing logging entries instead of using an enum. This allows plugins to register their own logging categories after the fact. It's also necessary for us to later show the warning ID when printing warnings and for creating documentation for each ID entry. Currently not every ID maps cleanly to only one type of warning, this has to be cleaned up in a follow-up change. Task-number: QTBUG-103453 Change-Id: I4cac6be7ca165b938e0ea032d077823bf17baf75 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-05-30 12:52:03 +00:00
if (messages.isEmpty() || isCategoryIgnored(id))
qmllint: Improve import warnings Import warnings will now always be clearly associated with the line and import that caused them. They're also visually separated now and don't redundantly show the importing files name in every warning. Some type of imports such as file or URI based imports never had their warnings processed which is also fixed by this change. Change-Id: I63d720fcf198ff5302c2566a91cde4c716697f7e Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Andrei Golubev <andrei.golubev@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-30 08:16:03 +00:00
return;
m_output.write(QStringLiteral("---\n"));
Redesign QQmlJSLogger internals High-level goal: be able to reuse existing infrastructure "as is" to configure semantic analysis categories in tools (qmllint, qmltc, qmlsc, etc.) To achieve that, simplify the logging to always "log" something, without explicitly specifying the severity. The severity is now baked into the category (and we can extend those to cover different cases) One slight deviation is the cache generation which likes to do its own thing at present. Provide a "forced logging" option where we can specify which severify we want. The hope is that this gets removed at some point Particular list of (noteworthy) changes: * No more "thresholding" by the level (this is rarely needed and is actually questionable). Instead, we can ignore a particular category explicitly * Category levels are repurposed as category severities (at least from the high-level picture that always should've been this way) * log{Warning,Info,Critical} removed. We use category severity instead * "category error" makes zero sense so removed: if our severity is: - QtWarningMsg (qmllint), it is already an "error" - QtCriticalMsg (compilers), it is already an "error" * Align m_output and m_{infos,warnings,errors} stored information * Accept the fact that we don't support QtDebugMsg and QtFatalMsg * Additional categories added to cover for places where the same category would be both an error and not an error Task-number: QTBUG-100052 Change-Id: I3cd5d17d58be204f48428877bed053f756ac40a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-02-03 12:45:18 +00:00
// TODO: we should instead respect message's category here (potentially, it
// should hold a category instead of type)
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
for (const QQmlJS::DiagnosticMessage &message : messages)
QQmlJSLogger: Switch to an ID based system This change makes qmljslogger use an ID based system for categorizing logging entries instead of using an enum. This allows plugins to register their own logging categories after the fact. It's also necessary for us to later show the warning ID when printing warnings and for creating documentation for each ID entry. Currently not every ID maps cleanly to only one type of warning, this has to be cleaned up in a follow-up change. Task-number: QTBUG-103453 Change-Id: I4cac6be7ca165b938e0ea032d077823bf17baf75 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-05-30 12:52:03 +00:00
log(message.message, id, QQmlJS::SourceLocation(), false, false);
qmllint: Improve import warnings Import warnings will now always be clearly associated with the line and import that caused them. They're also visually separated now and don't redundantly show the importing files name in every warning. Some type of imports such as file or URI based imports never had their warnings processed which is also fixed by this change. Change-Id: I63d720fcf198ff5302c2566a91cde4c716697f7e Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Andrei Golubev <andrei.golubev@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-30 08:16:03 +00:00
m_output.write(QStringLiteral("---\n\n"));
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
}
qmlcompiler: Allow for logging other files and add auto-fix infrastructure This change makes sure the logger can write messages and show excerpts from files other than the current one. This is necessary in order to give users hints about problems that arise due to other components. It also adds a field to FixSuggestion::Fix which specifies whether a suggested fix can be applied automatically or is only a hint. Change-Id: I94a929d3fc3fc966591cffb99e67309d264c38e7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-24 09:28:52 +00:00
void QQmlJSLogger::printContext(const QString &overrideFileName,
const QQmlJS::SourceLocation &location)
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
{
qmlcompiler: Allow for logging other files and add auto-fix infrastructure This change makes sure the logger can write messages and show excerpts from files other than the current one. This is necessary in order to give users hints about problems that arise due to other components. It also adds a field to FixSuggestion::Fix which specifies whether a suggested fix can be applied automatically or is only a hint. Change-Id: I94a929d3fc3fc966591cffb99e67309d264c38e7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-24 09:28:52 +00:00
QString code = m_code;
if (!overrideFileName.isEmpty() && overrideFileName != QFileInfo(m_fileName).absolutePath()) {
QFile file(overrideFileName);
const bool success = file.open(QFile::ReadOnly);
Q_ASSERT(success);
code = QString::fromUtf8(file.readAll());
}
IssueLocationWithContext issueLocationWithContext { code, location };
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
if (const QStringView beforeText = issueLocationWithContext.beforeText(); !beforeText.isEmpty())
m_output.write(beforeText);
qmllint: Warn about multiline strings Task-number: QTBUG-92448 Change-Id: Ic6305f05cb8a0af5c36ac03d8b541ac78cea0612 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-04-19 14:54:45 +00:00
bool locationMultiline = issueLocationWithContext.issueText().contains(QLatin1Char('\n'));
qmllint: Integrate type inference warnings This change helps bring in type inference and compiler warnings previously only generated by qmlcachegen+. These warnings are disabled by default and have to be enabled manually via the --compiler option. Also makes the logger handle zero length SourceLocations properly by just highlighting the entire line instead of hitting an assert. Change-Id: Iebad6e9236214d9367f97487e7b5787592edab7d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-05 10:48:49 +00:00
if (!issueLocationWithContext.issueText().isEmpty())
m_output.write(issueLocationWithContext.issueText().toString(), QtCriticalMsg);
qmlcompiler: enable standalone building: - convert to string to in a couple of places to work without QStringView + operator - import local files with "*" (not via <private/*>) Change-Id: I1d7cdcbd39e609f36693733e98d4f74a7260ce88 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-08-13 07:44:42 +00:00
m_output.write(issueLocationWithContext.afterText().toString() + QLatin1Char('\n'));
qmllint: Warn about multiline strings Task-number: QTBUG-92448 Change-Id: Ic6305f05cb8a0af5c36ac03d8b541ac78cea0612 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-04-19 14:54:45 +00:00
// Do not draw location indicator for multiline locations
if (locationMultiline)
return;
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
int tabCount = issueLocationWithContext.beforeText().count(QLatin1Char('\t'));
qmllint: Integrate type inference warnings This change helps bring in type inference and compiler warnings previously only generated by qmlcachegen+. These warnings are disabled by default and have to be enabled manually via the --compiler option. Also makes the logger handle zero length SourceLocations properly by just highlighting the entire line instead of hitting an assert. Change-Id: Iebad6e9236214d9367f97487e7b5787592edab7d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-05 10:48:49 +00:00
int locationLength = location.length == 0 ? 1 : location.length;
m_output.write(QString::fromLatin1(" ").repeated(issueLocationWithContext.beforeText().length()
- tabCount)
+ QString::fromLatin1("\t").repeated(tabCount)
+ QString::fromLatin1("^").repeated(locationLength) + QLatin1Char('\n'));
qmlcompiler/qmllint: Use unified logger Improves the logging situation greatly by allowing all logging messages to be assigned different severities, highlighting the code that caused them and by now ensuring a qmllint warning will always result in a non-zero exit code. A later patch will expose more of these options to the user. Change-Id: Id9b036fe3ba80dd18e9f8cb1b05efa891713d5a8 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-03-25 14:34:42 +00:00
}
qmllint: Formalize fix suggestions They are now handled by the logger instead of being done by external classes using the ColorOutput directly. This will allow for modernizing the logger and for automatically applying those suggested fixes. Fixes: QTBUG-94170 Change-Id: I90b960d22cb91203b8e8a5c69b0fdaf6fca2fc0c Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 11:55:11 +00:00
void QQmlJSLogger::printFix(const FixSuggestion &fix)
{
qmlcompiler: Allow for logging other files and add auto-fix infrastructure This change makes sure the logger can write messages and show excerpts from files other than the current one. This is necessary in order to give users hints about problems that arise due to other components. It also adds a field to FixSuggestion::Fix which specifies whether a suggested fix can be applied automatically or is only a hint. Change-Id: I94a929d3fc3fc966591cffb99e67309d264c38e7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-24 09:28:52 +00:00
const QString currentFileAbsPath = QFileInfo(m_fileName).absolutePath();
QString code = m_code;
QString currentFile;
qmllint: Formalize fix suggestions They are now handled by the logger instead of being done by external classes using the ColorOutput directly. This will allow for modernizing the logger and for automatically applying those suggested fixes. Fixes: QTBUG-94170 Change-Id: I90b960d22cb91203b8e8a5c69b0fdaf6fca2fc0c Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 11:55:11 +00:00
for (const auto &fixItem : fix.fixes) {
qmllint: Force fix suggestions to use QtInfoMsg It makes no sense to use a higher message level for a fix suggestion. A fix suggestion should be prefixed by the warning or error that triggers it. That warning or error should have the actual level. Change-Id: I4b5a2ec150afd469ea53697546541a7890c525ec Reviewed-by: Andrei Golubev <andrei.golubev@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 09:39:28 +00:00
m_output.writePrefixedMessage(fixItem.message, QtInfoMsg);
qmllint: Formalize fix suggestions They are now handled by the logger instead of being done by external classes using the ColorOutput directly. This will allow for modernizing the logger and for automatically applying those suggested fixes. Fixes: QTBUG-94170 Change-Id: I90b960d22cb91203b8e8a5c69b0fdaf6fca2fc0c Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 11:55:11 +00:00
if (!fixItem.cutLocation.isValid())
continue;
qmlcompiler: Allow for logging other files and add auto-fix infrastructure This change makes sure the logger can write messages and show excerpts from files other than the current one. This is necessary in order to give users hints about problems that arise due to other components. It also adds a field to FixSuggestion::Fix which specifies whether a suggested fix can be applied automatically or is only a hint. Change-Id: I94a929d3fc3fc966591cffb99e67309d264c38e7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-24 09:28:52 +00:00
if (fixItem.fileName == currentFile) {
// Nothing to do in this case, we've already read the code
} else if (fixItem.fileName.isEmpty() || fixItem.fileName == currentFileAbsPath) {
code = m_code;
} else {
QFile file(fixItem.fileName);
const bool success = file.open(QFile::ReadOnly);
Q_ASSERT(success);
code = QString::fromUtf8(file.readAll());
currentFile = fixItem.fileName;
}
IssueLocationWithContext issueLocationWithContext { code, fixItem.cutLocation };
qmllint: Formalize fix suggestions They are now handled by the logger instead of being done by external classes using the ColorOutput directly. This will allow for modernizing the logger and for automatically applying those suggested fixes. Fixes: QTBUG-94170 Change-Id: I90b960d22cb91203b8e8a5c69b0fdaf6fca2fc0c Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 11:55:11 +00:00
if (const QStringView beforeText = issueLocationWithContext.beforeText();
!beforeText.isEmpty()) {
m_output.write(beforeText);
}
qmlcompiler: Allow for logging other files and add auto-fix infrastructure This change makes sure the logger can write messages and show excerpts from files other than the current one. This is necessary in order to give users hints about problems that arise due to other components. It also adds a field to FixSuggestion::Fix which specifies whether a suggested fix can be applied automatically or is only a hint. Change-Id: I94a929d3fc3fc966591cffb99e67309d264c38e7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-24 09:28:52 +00:00
// The replacement string can be empty if we're only pointing something out to the user
QStringView replacementString = fixItem.replacementString.isEmpty()
? issueLocationWithContext.issueText()
: fixItem.replacementString;
// But if there's nothing to change it has to be a hint
if (fixItem.replacementString.isEmpty())
Q_ASSERT(fixItem.isHint);
m_output.write(replacementString, QtDebugMsg);
qmlcompiler: enable standalone building: - convert to string to in a couple of places to work without QStringView + operator - import local files with "*" (not via <private/*>) Change-Id: I1d7cdcbd39e609f36693733e98d4f74a7260ce88 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-08-13 07:44:42 +00:00
m_output.write(issueLocationWithContext.afterText().toString() + u'\n');
qmllint: Formalize fix suggestions They are now handled by the logger instead of being done by external classes using the ColorOutput directly. This will allow for modernizing the logger and for automatically applying those suggested fixes. Fixes: QTBUG-94170 Change-Id: I90b960d22cb91203b8e8a5c69b0fdaf6fca2fc0c Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 11:55:11 +00:00
int tabCount = issueLocationWithContext.beforeText().count(u'\t');
qmlcompiler: Suggest fix for multiline strings We can now suggest a template string to use instead that is properly escaped. Once auto-fixing becomes available we can automatically replace deprecated multiline strings with the new suggestion. Task-number: QTBUG-92448 Change-Id: I4e77820b66ae960cde558a62689c5da328b8df5b Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-02-25 11:15:06 +00:00
// Do not draw location indicator for multiline replacement strings
qmlcompiler: Allow for logging other files and add auto-fix infrastructure This change makes sure the logger can write messages and show excerpts from files other than the current one. This is necessary in order to give users hints about problems that arise due to other components. It also adds a field to FixSuggestion::Fix which specifies whether a suggested fix can be applied automatically or is only a hint. Change-Id: I94a929d3fc3fc966591cffb99e67309d264c38e7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-24 09:28:52 +00:00
if (replacementString.contains(u'\n'))
qmlcompiler: Suggest fix for multiline strings We can now suggest a template string to use instead that is properly escaped. Once auto-fixing becomes available we can automatically replace deprecated multiline strings with the new suggestion. Task-number: QTBUG-92448 Change-Id: I4e77820b66ae960cde558a62689c5da328b8df5b Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-02-25 11:15:06 +00:00
continue;
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
m_output.write(u" "_s.repeated(
qmllint: Formalize fix suggestions They are now handled by the logger instead of being done by external classes using the ColorOutput directly. This will allow for modernizing the logger and for automatically applying those suggested fixes. Fixes: QTBUG-94170 Change-Id: I90b960d22cb91203b8e8a5c69b0fdaf6fca2fc0c Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 11:55:11 +00:00
issueLocationWithContext.beforeText().length() - tabCount)
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
+ u"\t"_s.repeated(tabCount)
+ u"^"_s.repeated(fixItem.replacementString.length()) + u'\n');
qmllint: Formalize fix suggestions They are now handled by the logger instead of being done by external classes using the ColorOutput directly. This will allow for modernizing the logger and for automatically applying those suggested fixes. Fixes: QTBUG-94170 Change-Id: I90b960d22cb91203b8e8a5c69b0fdaf6fca2fc0c Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-01 11:55:11 +00:00
}
}
qmlcompiler: Use QT_BEGIN_NAMESPACE / QT_END_NAMESPACE everywhere Some code was not properly wrapped in a namespace. Change-Id: If70fd9782391309c511b66ae01eae43cb36292ac Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-22 12:41:14 +00:00
QT_END_NAMESPACE