feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

ClangTools: Query the tools for supported checks

Browse Source 
...instead of hardcoding them for a particular version of
clang-tidy/clazy.

While at it, move also the tidy/clazy widgets to ClangTools as this
simplifies feeding data to them.

Reduce also the built-in configs to a single one using clang-tidy's and
clazy's default checks as they look very reasonable and saves us some
porting effort. Also, our previous built-in configs were just too
numerous.

Change-Id: Ib9297acb7810a940b86a23a8695530506a570394
Reviewed-by: Cristian Adam <cristian.adam@qt.io>
This commit is contained in:
Nikolai Kosjar
2019-10-21 14:59:57 +02:00
parent 9a7f5e08fd
commit 0d7a30cdfe
36 changed files with 1762 additions and 2302 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/plugins/cpptools/CMakeLists.txt
View File

@@ -16,7 +16,6 @@ add_qtc_plugin(CppTools
clangdiagnosticconfigsmodel.cpp clangdiagnosticconfigsmodel.h
clangdiagnosticconfigsselectionwidget.cpp clangdiagnosticconfigsselectionwidget.h
clangdiagnosticconfigswidget.cpp clangdiagnosticconfigswidget.h clangdiagnosticconfigswidget.ui
clazychecks.ui
compileroptionsbuilder.cpp compileroptionsbuilder.h
cppbuiltinmodelmanagersupport.cpp cppbuiltinmodelmanagersupport.h
cppcanonicalsymbol.cpp cppcanonicalsymbol.h
@@ -70,8 +69,6 @@ add_qtc_plugin(CppTools
cppsemanticinfoupdater.cpp cppsemanticinfoupdater.h
cppsourceprocessor.cpp cppsourceprocessor.h
cppsymbolinfo.h
cpptools_clangtidychecks.h
cpptools_clazychecks.h
cpptools_global.h
cpptools_utils.h
cpptoolsbridge.cpp cpptoolsbridge.h
@@ -104,7 +101,6 @@ add_qtc_plugin(CppTools
stringtable.cpp stringtable.h
symbolfinder.cpp symbolfinder.h
symbolsfindfilter.cpp symbolsfindfilter.h
tidychecks.ui
typehierarchybuilder.cpp typehierarchybuilder.h
usages.h
wrappablelineedit.cpp wrappablelineedit.h

30
src/plugins/cpptools/clangdiagnosticconfig.cpp
View File

@@ -79,6 +79,7 @@ bool ClangDiagnosticConfig::operator==(const ClangDiagnosticConfig &other) const
&& m_clangOptions == other.m_clangOptions
&& m_clangTidyMode == other.m_clangTidyMode
&& m_clangTidyChecks == other.m_clangTidyChecks
&& m_clazyMode == other.m_clazyMode
&& m_clazyChecks == other.m_clazyChecks
&& m_isReadOnly == other.m_isReadOnly
&& m_useBuildSystemWarnings == other.m_useBuildSystemWarnings;
@@ -89,6 +90,16 @@ bool ClangDiagnosticConfig::operator!=(const ClangDiagnosticConfig &other) const
return !(*this == other);
}
ClangDiagnosticConfig::ClazyMode ClangDiagnosticConfig::clazyMode() const
{
return m_clazyMode;
}
void ClangDiagnosticConfig::setClazyMode(const ClazyMode &clazyMode)
{
m_clazyMode = clazyMode;
}
bool ClangDiagnosticConfig::useBuildSystemWarnings() const
{
return m_useBuildSystemWarnings;
@@ -135,15 +146,9 @@ static QString convertToNewClazyChecksFormat(const QString &checks)
// Starting with Qt Creator 4.9, checks are a comma-separated string of checks: "x,y,z".
if (checks.isEmpty())
return checks;
if (checks.size() == 6 && checks.startsWith("level")) {
bool ok = false;
const int level = checks.midRef(5).toInt(&ok);
QTC_ASSERT(ok, return QString());
return clazyChecksForLevel(level);
}
return {};
if (checks.size() == 6 && checks.startsWith("level"))
return {};
return checks;
}
@@ -153,6 +158,7 @@ static const char diagnosticConfigDisplayNameKey[] = "displayName";
static const char diagnosticConfigWarningsKey[] = "diagnosticOptions";
static const char diagnosticConfigsTidyChecksKey[] = "clangTidyChecks";
static const char diagnosticConfigsTidyModeKey[] = "clangTidyMode";
static const char diagnosticConfigsClazyModeKey[] = "clazyMode";
static const char diagnosticConfigsClazyChecksKey[] = "clazyChecks";
void diagnosticConfigsToSettings(QSettings *s, const ClangDiagnosticConfigs &configs)
@@ -165,8 +171,8 @@ void diagnosticConfigsToSettings(QSettings *s, const ClangDiagnosticConfigs &con
s->setValue(diagnosticConfigDisplayNameKey, config.displayName());
s->setValue(diagnosticConfigWarningsKey, config.clangOptions());
s->setValue(diagnosticConfigsTidyModeKey, int(config.clangTidyMode()));
s->setValue(diagnosticConfigsTidyChecksKey,
config.clangTidyChecks());
s->setValue(diagnosticConfigsTidyChecksKey, config.clangTidyChecks());
s->setValue(diagnosticConfigsClazyModeKey, int(config.clazyMode()));
s->setValue(diagnosticConfigsClazyChecksKey, config.clazyChecks());
}
s->endArray();
@@ -189,6 +195,8 @@ ClangDiagnosticConfigs diagnosticConfigsFromSettings(QSettings *s)
config.setClangTidyChecks(
s->value(diagnosticConfigsTidyChecksKey).toString());
config.setClazyMode(static_cast<ClangDiagnosticConfig::ClazyMode>(
s->value(diagnosticConfigsClazyModeKey).toInt()));
const QString clazyChecks = s->value(diagnosticConfigsClazyChecksKey).toString();
config.setClazyChecks(convertToNewClazyChecksFormat(clazyChecks));
configs.append(config);

41
src/plugins/cpptools/clangdiagnosticconfig.h
View File

@@ -42,37 +42,47 @@ namespace CppTools {
class CPPTOOLS_EXPORT ClangDiagnosticConfig
{
public:
enum class TidyMode
{
Disabled = 0,
ChecksPrefixList,
File
};
Core::Id id() const;
void setId(const Core::Id &id);
QString displayName() const;
void setDisplayName(const QString &displayName);
bool isReadOnly() const;
void setIsReadOnly(bool isReadOnly);
QStringList clangOptions() const;
void setClangOptions(const QStringList &options);
bool useBuildSystemWarnings() const;
void setUseBuildSystemWarnings(bool useBuildSystemWarnings);
// Clang-Tidy
enum class TidyMode
{
Disabled,
ChecksPrefixList,
File,
Default,
};
TidyMode clangTidyMode() const;
void setClangTidyMode(TidyMode mode);
QString clangTidyChecks() const;
void setClangTidyChecks(const QString &checks);
TidyMode clangTidyMode() const;
void setClangTidyMode(TidyMode mode);
// Clazy
enum class ClazyMode
{
Default,
SpecifiedChecks,
};
ClazyMode clazyMode() const;
void setClazyMode(const ClazyMode &clazyMode);
QString clazyChecks() const;
void setClazyChecks(const QString &checks);
bool isReadOnly() const;
void setIsReadOnly(bool isReadOnly);
bool useBuildSystemWarnings() const;
void setUseBuildSystemWarnings(bool useBuildSystemWarnings);
bool operator==(const ClangDiagnosticConfig &other) const;
bool operator!=(const ClangDiagnosticConfig &other) const;
@@ -83,6 +93,7 @@ private:
TidyMode m_clangTidyMode = TidyMode::Disabled;
QString m_clangTidyChecks;
QString m_clazyChecks;
ClazyMode m_clazyMode = ClazyMode::Default;
bool m_isReadOnly = false;
bool m_useBuildSystemWarnings = false;
};

4
src/plugins/cpptools/clangdiagnosticconfigsmodel.cpp
View File

@@ -105,9 +105,9 @@ QVector<Core::Id> ClangDiagnosticConfigsModel::changedOrRemovedConfigs(
}
ClangDiagnosticConfig ClangDiagnosticConfigsModel::createCustomConfig(
const ClangDiagnosticConfig &config, const QString &displayName)
const ClangDiagnosticConfig &baseConfig, const QString &displayName)
{
ClangDiagnosticConfig copied = config;
ClangDiagnosticConfig copied = baseConfig;
copied.setId(Core::Id::fromString(QUuid::createUuid().toString()));
copied.setDisplayName(displayName);
copied.setIsReadOnly(false);

2
src/plugins/cpptools/clangdiagnosticconfigsmodel.h
View File

@@ -54,7 +54,7 @@ public:
static QVector<Core::Id> changedOrRemovedConfigs(const ClangDiagnosticConfigs &oldConfigs,
const ClangDiagnosticConfigs &newConfigs);
static ClangDiagnosticConfig createCustomConfig(const ClangDiagnosticConfig &config,
static ClangDiagnosticConfig createCustomConfig(const ClangDiagnosticConfig &baseConfig,
const QString &displayName);
static QStringList globalDiagnosticOptions();

12
src/plugins/cpptools/clangdiagnosticconfigsselectionwidget.cpp
View File

@@ -59,11 +59,11 @@ ClangDiagnosticConfigsSelectionWidget::ClangDiagnosticConfigsSelectionWidget(QWi
void ClangDiagnosticConfigsSelectionWidget::refresh(const ClangDiagnosticConfigsModel &model,
const Core::Id &configToSelect,
bool showTidyClazyUi)
const CreateEditWidget &createEditWidget)
{
m_showTidyClazyUi = showTidyClazyUi;
m_diagnosticConfigsModel = model;
m_currentConfigId = configToSelect;
m_createEditWidget = createEditWidget;
const ClangDiagnosticConfig config = m_diagnosticConfigsModel.configWithId(configToSelect);
m_button->setText(config.displayName());
@@ -81,11 +81,11 @@ ClangDiagnosticConfigs ClangDiagnosticConfigsSelectionWidget::customConfigs() co
void ClangDiagnosticConfigsSelectionWidget::onButtonClicked()
{
ClangDiagnosticConfigsWidget *widget
= new ClangDiagnosticConfigsWidget(m_diagnosticConfigsModel.allConfigs(),
m_currentConfigId,
m_showTidyClazyUi);
ClangDiagnosticConfigsWidget *widget = m_createEditWidget(m_diagnosticConfigsModel.allConfigs(),
m_currentConfigId);
widget->sync();
widget->layout()->setContentsMargins(0, 0, 0, 0);
QDialog dialog;
dialog.setWindowTitle(ClangDiagnosticConfigsWidget::tr("Diagnostic Configurations"));
dialog.setLayout(new QVBoxLayout);

12
src/plugins/cpptools/clangdiagnosticconfigsselectionwidget.h
View File

@@ -31,6 +31,8 @@
#include <QWidget>
#include <functional>
QT_BEGIN_NAMESPACE
class QLabel;
class QPushButton;
@@ -38,6 +40,8 @@ QT_END_NAMESPACE
namespace CppTools {
class ClangDiagnosticConfigsWidget;
class CPPTOOLS_EXPORT ClangDiagnosticConfigsSelectionWidget : public QWidget
{
Q_OBJECT
@@ -45,9 +49,13 @@ class CPPTOOLS_EXPORT ClangDiagnosticConfigsSelectionWidget : public QWidget
public:
explicit ClangDiagnosticConfigsSelectionWidget(QWidget *parent = nullptr);
using CreateEditWidget
= std::function<ClangDiagnosticConfigsWidget *(const ClangDiagnosticConfigs &configs,
const Core::Id &configToSelect)>;
void refresh(const ClangDiagnosticConfigsModel &model,
const Core::Id &configToSelect,
bool showTidyClazyUi);
const CreateEditWidget &createEditWidget);
Core::Id currentConfigId() const;
ClangDiagnosticConfigs customConfigs() const;
@@ -64,6 +72,8 @@ private:
QLabel *m_label = nullptr;
QPushButton *m_button = nullptr;
CreateEditWidget m_createEditWidget;
};
} // CppTools namespace

789
src/plugins/cpptools/clangdiagnosticconfigswidget.cpp
View File

@@ -26,549 +26,18 @@
#include "clangdiagnosticconfigswidget.h"
#include "cppcodemodelsettings.h"
#include "cpptools_clangtidychecks.h"
#include "cpptools_clazychecks.h"
#include "cpptoolsconstants.h"
#include "cpptoolsreuse.h"
#include "ui_clangdiagnosticconfigswidget.h"
#include "ui_clangbasechecks.h"
#include "ui_clazychecks.h"
#include "ui_tidychecks.h"
#include <projectexplorer/selectablefilesmodel.h>
#include <utils/algorithm.h>
#include <utils/executeondestruction.h>
#include <utils/qtcassert.h>
#include <utils/treemodel.h>
#include <utils/utilsicons.h>
#include <QDebug>
#include <QDesktopServices>
#include <QDialogButtonBox>
#include <QInputDialog>
#include <QPushButton>
#include <QSortFilterProxyModel>
#include <QStringListModel>
#include <QUuid>
#include <memory>
namespace CppTools {
using namespace Constants;
static constexpr const char CLANG_STATIC_ANALYZER_URL[]
= "https://clang-analyzer.llvm.org/available_checks.html";
static void buildTree(ProjectExplorer::Tree *parent,
ProjectExplorer::Tree *current,
const Constants::TidyNode &node)
{
current->name = QString::fromUtf8(node.name);
current->isDir = node.children.size();
if (parent) {
current->fullPath = parent->fullPath + current->name;
parent->childDirectories.push_back(current);
} else {
current->fullPath = Utils::FilePath::fromString(current->name);
}
current->parent = parent;
for (const Constants::TidyNode &nodeChild : node.children)
buildTree(current, new ProjectExplorer::Tree, nodeChild);
}
static bool needsLink(ProjectExplorer::Tree *node) {
if (node->name == "clang-analyzer-")
return true;
return !node->isDir && !node->fullPath.toString().startsWith("clang-analyzer-");
}
static void selectAll(QAbstractItemView *view)
{
view->setSelectionMode(QAbstractItemView::MultiSelection);
view->selectAll();
view->setSelectionMode(QAbstractItemView::SingleSelection);
}
class BaseChecksTreeModel : public ProjectExplorer::SelectableFilesModel
{
Q_OBJECT
public:
enum Roles { LinkRole = Qt::UserRole + 1 };
enum Columns { NameColumn, LinkColumn };
BaseChecksTreeModel()
: ProjectExplorer::SelectableFilesModel(nullptr)
{}
int columnCount(const QModelIndex &) const override { return 2; }
QVariant data(const QModelIndex &fullIndex, int role = Qt::DisplayRole) const override
{
if (fullIndex.column() == LinkColumn) {
switch (role) {
case Qt::DisplayRole:
return tr("Web Page");
case Qt::FontRole: {
QFont font = QApplication::font();
font.setUnderline(true);
return font;
}
case Qt::ForegroundRole:
return QApplication::palette().link().color();
}
return QVariant();
}
return QVariant();
}
bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override
{
if (role == Qt::CheckStateRole && !m_enabled)
return false;
ProjectExplorer::SelectableFilesModel::setData(index, value, role);
return true;
}
void setEnabled(bool enabled)
{
m_enabled = enabled;
}
// TODO: Remove/replace this method after base class refactoring is done.
void traverse(const QModelIndex &index,
const std::function<bool(const QModelIndex &)> &visit) const
{
if (!index.isValid())
return;
if (!visit(index))
return;
if (!hasChildren(index))
return;
const int rows = rowCount(index);
const int cols = columnCount(index);
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j)
traverse(this->index(i, j, index), visit);
}
}
protected:
bool m_enabled = true;
};
static void openUrl(QAbstractItemModel *model, const QModelIndex &index)
{
const QString link = model->data(index, BaseChecksTreeModel::LinkRole).toString();
if (link.isEmpty())
return;
QDesktopServices::openUrl(QUrl(link));
};
class TidyChecksTreeModel final : public BaseChecksTreeModel
{
Q_OBJECT
public:
TidyChecksTreeModel()
{
buildTree(nullptr, m_root, Constants::CLANG_TIDY_CHECKS_ROOT);
}
QString selectedChecks() const
{
QString checks;
collectChecks(m_root, checks);
return "-*" + checks;
}
void selectChecks(const QString &checks)
{
m_root->checked = Qt::Unchecked;
propagateDown(index(0, 0, QModelIndex()));
QStringList checksList = checks.simplified().remove(" ")
.split(",", QString::SkipEmptyParts);
for (QString &check : checksList) {
Qt::CheckState state;
if (check.startsWith("-")) {
check = check.right(check.length() - 1);
state = Qt::Unchecked;
} else {
state = Qt::Checked;
}
const QModelIndex index = indexForCheck(check);
if (!index.isValid())
continue;
auto *node = static_cast<ProjectExplorer::Tree *>(index.internalPointer());
node->checked = state;
propagateUp(index);
propagateDown(index);
}
}
private:
QVariant data(const QModelIndex &fullIndex, int role = Qt::DisplayRole) const final
{
if (!fullIndex.isValid() || role == Qt::DecorationRole)
return QVariant();
QModelIndex index = this->index(fullIndex.row(), 0, fullIndex.parent());
auto *node = static_cast<ProjectExplorer::Tree *>(index.internalPointer());
if (fullIndex.column() == 1) {
if (!needsLink(node))
return QVariant();
if (role == LinkRole) {
// 'clang-analyzer-' group
if (node->isDir)
return QString::fromUtf8(CLANG_STATIC_ANALYZER_URL);
return QString::fromUtf8(Constants::TIDY_DOCUMENTATION_URL_TEMPLATE)
.arg(node->fullPath.toString());
}
return BaseChecksTreeModel::data(fullIndex, role);
}
if (role == Qt::DisplayRole)
return node->isDir ? (node->name + "*") : node->name;
return ProjectExplorer::SelectableFilesModel::data(index, role);
}
QModelIndex indexForCheck(const QString &check) const {
if (check == "*")
return index(0, 0, QModelIndex());
QModelIndex result;
traverse(index(0, 0, QModelIndex()), [&](const QModelIndex &index){
using ProjectExplorer::Tree;
if (result.isValid())
return false;
auto *node = static_cast<Tree *>(index.internalPointer());
const QString nodeName = node->fullPath.toString();
if ((check.endsWith("*") && nodeName.startsWith(check.left(check.length() - 1)))
|| (!node->isDir && nodeName == check)) {
result = index;
return false;
}
return check.startsWith(nodeName);
});
return result;
}
static void collectChecks(const ProjectExplorer::Tree *root, QString &checks)
{
if (root->checked == Qt::Unchecked)
return;
if (root->checked == Qt::Checked) {
checks += "," + root->fullPath.toString();
if (root->isDir)
checks += "*";
return;
}
for (const ProjectExplorer::Tree *t : root->childDirectories)
collectChecks(t, checks);
}
};
class ClazyChecksTree : public ProjectExplorer::Tree
{
public:
enum Kind { TopLevelNode, LevelNode, CheckNode };
ClazyChecksTree(const QString &name, Kind kind)
{
this->name = name;
this->kind = kind;
this->isDir = kind == TopLevelNode || kind == LevelNode;
}
static ClazyChecksTree *fromIndex(const QModelIndex &index)
{
return static_cast<ClazyChecksTree *>(index.internalPointer());
}
public:
ClazyCheckInfo checkInfo;
Kind kind = TopLevelNode;
};
class ClazyChecksTreeModel final : public BaseChecksTreeModel
{
Q_OBJECT
public:
ClazyChecksTreeModel() { buildTree(); }
QStringList enabledChecks() const
{
QStringList checks;
collectChecks(m_root, checks);
return checks;
}
void enableChecks(const QStringList &checks)
{
// Unselect all
m_root->checked = Qt::Unchecked;
propagateDown(index(0, 0, QModelIndex()));
for (const QString &check : checks) {
const QModelIndex index = indexForCheck(check);
if (!index.isValid())
continue;
ClazyChecksTree::fromIndex(index)->checked = Qt::Checked;
propagateUp(index);
propagateDown(index);
}
}
bool hasEnabledButNotVisibleChecks(
const std::function<bool(const QModelIndex &index)> &isHidden) const
{
bool enabled = false;
traverse(index(0, 0, QModelIndex()), [&](const QModelIndex &index){
if (enabled)
return false;
const auto *node = ClazyChecksTree::fromIndex(index);
if (node->kind == ClazyChecksTree::CheckNode && index.column() == NameColumn) {
const bool isChecked = data(index, Qt::CheckStateRole).toInt() == Qt::Checked;
const bool isVisible = isHidden(index);
if (isChecked && isVisible) {
enabled = true;
return false;
}
}
return true;
});
return enabled;
}
bool enableLowerLevels() const { return m_enableLowerLevels; }
void setEnableLowerLevels(bool enable) { m_enableLowerLevels = enable; }
QSet<QString> topics() const { return m_topics; }
private:
void buildTree()
{
// Top level node
m_root = new ClazyChecksTree("*", ClazyChecksTree::TopLevelNode);
for (const ClazyCheckInfo &check : CLAZY_CHECKS) {
// Level node
ClazyChecksTree *&levelNode = m_levelNodes[check.level];
if (!levelNode) {
levelNode = new ClazyChecksTree(levelDescription(check.level), ClazyChecksTree::LevelNode);
levelNode->parent = m_root;
levelNode->checkInfo.level = check.level; // Pass on the level for sorting
m_root->childDirectories << levelNode;
}
// Check node
auto checkNode = new ClazyChecksTree(check.name, ClazyChecksTree::CheckNode);
checkNode->parent = levelNode;
checkNode->checkInfo = check;
levelNode->childDirectories.append(checkNode);
m_topics.unite(Utils::toSet(check.topics));
}
}
QVariant data(const QModelIndex &fullIndex, int role = Qt::DisplayRole) const final
{
if (!fullIndex.isValid() || role == Qt::DecorationRole)
return QVariant();
const QModelIndex index = this->index(fullIndex.row(), 0, fullIndex.parent());
const auto *node = ClazyChecksTree::fromIndex(index);
if (fullIndex.column() == LinkColumn) {
if (role == LinkRole) {
if (node->checkInfo.name.isEmpty())
return QVariant();
return QString::fromUtf8(Constants::CLAZY_DOCUMENTATION_URL_TEMPLATE).arg(node->name);
}
if (role == Qt::DisplayRole && node->kind != ClazyChecksTree::CheckNode)
return QVariant();
return BaseChecksTreeModel::data(fullIndex, role);
}
if (role == Qt::DisplayRole)
return node->name;
return ProjectExplorer::SelectableFilesModel::data(index, role);
}
static QString levelDescription(int level)
{
switch (level) {
case -1:
return tr("Manual Level: Very few false positives");
case 0:
return tr("Level 0: No false positives");
case 1:
return tr("Level 1: Very few false positives");
case 2:
return tr("Level 2: More false positives");
case 3:
return tr("Level 3: Experimental checks");
default:
QTC_CHECK(false && "No clazy level description");
return tr("Level %1").arg(QString::number(level));
}
}
QModelIndex indexForCheck(const QString &check) const {
if (check == "*")
return index(0, 0, QModelIndex());
QModelIndex result;
traverse(index(0, 0, QModelIndex()), [&](const QModelIndex &index){
if (result.isValid())
return false;
const auto *node = ClazyChecksTree::fromIndex(index);
if (node->kind == ClazyChecksTree::CheckNode && node->checkInfo.name == check) {
result = index;
return false;
}
return true;
});
return result;
}
QModelIndex indexForTree(const ClazyChecksTree *tree) const {
if (!tree)
return {};
QModelIndex result;
traverse(index(0, 0, QModelIndex()), [&](const QModelIndex &index){
if (result.isValid())
return false;
if (index.internalPointer() == tree) {
result = index;
return false;
}
return true;
});
return result;
}
static void collectChecks(const ProjectExplorer::Tree *root, QStringList &checks)
{
if (root->checked == Qt::Unchecked)
return;
if (root->checked == Qt::Checked && !root->isDir) {
checks.append(root->name);
return;
}
for (const ProjectExplorer::Tree *t : root->childDirectories)
collectChecks(t, checks);
}
static QStringList toStringList(const QVariantList &variantList)
{
QStringList list;
for (auto &item : variantList)
list.append(item.toString());
return list;
}
private:
QHash<int, ClazyChecksTree *> m_levelNodes;
QSet<QString> m_topics;
bool m_enableLowerLevels = true;
};
class ClazyChecksSortFilterModel : public QSortFilterProxyModel
{
public:
ClazyChecksSortFilterModel(QObject *parent)
: QSortFilterProxyModel(parent)
{}
void setTopics(const QStringList &value)
{
m_topics = value;
invalidateFilter();
}
bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override
{
const QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
if (!index.isValid())
return false;
const auto *node = ClazyChecksTree::fromIndex(index);
if (node->kind == ClazyChecksTree::CheckNode) {
const QStringList topics = node->checkInfo.topics;
return Utils::anyOf(m_topics, [topics](const QString &topic) {
return topics.contains(topic);
});
}
return true;
}
private:
// Note that sort order of levels is important for "enableLowerLevels" mode, see setData().
bool lessThan(const QModelIndex &l, const QModelIndex &r) const override
{
const int leftLevel = adaptLevel(ClazyChecksTree::fromIndex(l)->checkInfo.level);
const int rightLevel = adaptLevel(ClazyChecksTree::fromIndex(r)->checkInfo.level);
if (leftLevel == rightLevel)
return sourceModel()->data(l).toString() < sourceModel()->data(r).toString();
return leftLevel < rightLevel;
}
static int adaptLevel(int level)
{
if (level == -1) // "Manual Level"
return 1000;
return level;
}
bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override
{
if (!index.isValid())
return false;
if (role == Qt::CheckStateRole
&& static_cast<ClazyChecksTreeModel *>(sourceModel())->enableLowerLevels()
&& QSortFilterProxyModel::setData(index, value, role)) {
const auto *node = ClazyChecksTree::fromIndex(mapToSource(index));
if (node->kind == ClazyChecksTree::LevelNode && node->checkInfo.level >= 0) {
// Rely on the sort order to find the lower level index/node
const auto previousIndex = this->index(index.row() - 1,
index.column(),
index.parent());
if (previousIndex.isValid()
&& ClazyChecksTree::fromIndex(mapToSource(previousIndex))->checkInfo.level
>= 0) {
setData(previousIndex, value, role);
}
}
}
return QSortFilterProxyModel::setData(index, value, role);
}
private:
QStringList m_topics;
};
class ConfigNode : public Utils::TreeItem
{
public:
@@ -660,13 +129,10 @@ private:
ClangDiagnosticConfigsWidget::ClangDiagnosticConfigsWidget(const ClangDiagnosticConfigs &configs,
const Core::Id &configToSelect,
bool showTidyClazyTabs,
QWidget *parent)
: QWidget(parent)
, m_ui(new Ui::ClangDiagnosticConfigsWidget)
, m_configsModel(new ConfigsModel(configs))
, m_clazyTreeModel(new ClazyChecksTreeModel)
, m_tidyTreeModel(new TidyChecksTreeModel)
{
m_ui->setupUi(this);
m_ui->configsView->setHeaderHidden(true);
@@ -679,9 +145,14 @@ ClangDiagnosticConfigsWidget::ClangDiagnosticConfigsWidget(const ClangDiagnostic
connect(m_ui->configsView->selectionModel(),
&QItemSelectionModel::currentChanged,
this,
&ClangDiagnosticConfigsWidget::syncToConfigsView);
&ClangDiagnosticConfigsWidget::sync);
setupTabs(showTidyClazyTabs);
m_clangBaseChecks = std::make_unique<CppTools::Ui::ClangBaseChecks>();
m_clangBaseChecksWidget = new QWidget();
m_clangBaseChecks->setupUi(m_clangBaseChecksWidget);
m_ui->tabWidget->addTab(m_clangBaseChecksWidget, tr("Clang Warnings"));
m_ui->tabWidget->setCurrentIndex(0);
connect(m_ui->copyButton, &QPushButton::clicked,
this, &ClangDiagnosticConfigsWidget::onCopyButtonClicked);
@@ -690,15 +161,6 @@ ClangDiagnosticConfigsWidget::ClangDiagnosticConfigsWidget(const ClangDiagnostic
connect(m_ui->removeButton, &QPushButton::clicked,
this, &ClangDiagnosticConfigsWidget::onRemoveButtonClicked);
connectClangOnlyOptionsChanged();
connect(m_tidyChecks->checksPrefixesTree,
&QTreeView::clicked,
[model = m_tidyTreeModel.get()](const QModelIndex &index) { openUrl(model, index); });
connect(m_clazyChecks->checksView,
&QTreeView::clicked,
[model = m_clazySortFilterProxyModel](const QModelIndex &index) { openUrl(model, index); });
syncToConfigsView();
}
ClangDiagnosticConfigsWidget::~ClangDiagnosticConfigsWidget()
@@ -709,7 +171,6 @@ ClangDiagnosticConfigsWidget::~ClangDiagnosticConfigsWidget()
void ClangDiagnosticConfigsWidget::onCopyButtonClicked()
{
const ClangDiagnosticConfig &config = currentConfig();
bool dialogAccepted = false;
const QString newName = QInputDialog::getText(this,
tr("Copy Diagnostic Configuration"),
@@ -720,9 +181,11 @@ void ClangDiagnosticConfigsWidget::onCopyButtonClicked()
if (dialogAccepted) {
const ClangDiagnosticConfig customConfig
= ClangDiagnosticConfigsModel::createCustomConfig(config, newName);
m_configsModel->appendCustomConfig(customConfig);
m_ui->configsView->setCurrentIndex(m_configsModel->itemForConfigId(customConfig.id())->index());
syncToConfigsView();
m_ui->configsView->setCurrentIndex(
m_configsModel->itemForConfigId(customConfig.id())->index());
sync();
m_clangBaseChecks->diagnosticOptionsTextEdit->setFocus();
}
}
@@ -756,31 +219,7 @@ void ClangDiagnosticConfigsWidget::onRemoveButtonClicked()
if (m_configsModel->customConfigsCount() == 1)
m_ui->configsView->setCurrentIndex(m_configsModel->fallbackConfigIndex());
m_configsModel->removeConfig(configToRemove);
syncToConfigsView();
}
void ClangDiagnosticConfigsWidget::onClangTidyModeChanged(int index)
{
ClangDiagnosticConfig config = currentConfig();
config.setClangTidyMode(static_cast<ClangDiagnosticConfig::TidyMode>(index));
updateConfig(config);
syncClangTidyWidgets(config);
}
void ClangDiagnosticConfigsWidget::onClangTidyTreeChanged()
{
ClangDiagnosticConfig config = currentConfig();
config.setClangTidyChecks(m_tidyTreeModel->selectedChecks());
updateConfig(config);
}
void ClangDiagnosticConfigsWidget::onClazyTreeChanged()
{
syncClazyChecksGroupBox();
ClangDiagnosticConfig config = currentConfig();
config.setClazyChecks(m_clazyTreeModel->enabledChecks().join(","));
updateConfig(config);
sync();
}
static bool isAcceptedWarningOption(const QString &option)
@@ -846,7 +285,7 @@ void ClangDiagnosticConfigsWidget::onClangOnlyOptionsChanged()
updateConfig(updatedConfig);
}
void ClangDiagnosticConfigsWidget::syncToConfigsView()
void ClangDiagnosticConfigsWidget::sync()
{
if (!m_ui->configsView->currentIndex().isValid())
return;
@@ -875,74 +314,7 @@ void ClangDiagnosticConfigsWidget::syncToConfigsView()
m_ui->infoLabel->setStyleSheet(QString());
}
syncClangTidyWidgets(config);
syncClazyWidgets(config);
}
void ClangDiagnosticConfigsWidget::syncClangTidyWidgets(const ClangDiagnosticConfig &config)
{
disconnectClangTidyItemChanged();
ClangDiagnosticConfig::TidyMode tidyMode = config.clangTidyMode();
m_tidyChecks->tidyMode->setCurrentIndex(static_cast<int>(tidyMode));
switch (tidyMode) {
case ClangDiagnosticConfig::TidyMode::Disabled:
case ClangDiagnosticConfig::TidyMode::File:
m_tidyChecks->plainTextEditButton->setVisible(false);
m_tidyChecks->checksListWrapper->setCurrentIndex(1);
break;
case ClangDiagnosticConfig::TidyMode::ChecksPrefixList:
m_tidyChecks->plainTextEditButton->setVisible(true);
m_tidyChecks->checksListWrapper->setCurrentIndex(0);
syncTidyChecksToTree(config);
break;
}
const bool enabled = !config.isReadOnly();
m_tidyChecks->tidyMode->setEnabled(enabled);
m_tidyChecks->plainTextEditButton->setText(enabled ? tr("Edit Checks as String...")
: tr("View Checks as String..."));
m_tidyTreeModel->setEnabled(enabled);
connectClangTidyItemChanged();
}
void ClangDiagnosticConfigsWidget::syncTidyChecksToTree(const ClangDiagnosticConfig &config)
{
m_tidyTreeModel->selectChecks(config.clangTidyChecks());
}
void ClangDiagnosticConfigsWidget::syncClazyWidgets(const ClangDiagnosticConfig &config)
{
disconnectClazyItemChanged();
const QString clazyChecks = config.clazyChecks();
m_clazyTreeModel->enableChecks(clazyChecks.split(',', QString::SkipEmptyParts));
syncClazyChecksGroupBox();
const bool enabled = !config.isReadOnly();
m_clazyChecks->topicsResetButton->setEnabled(enabled);
m_clazyChecks->enableLowerLevelsCheckBox->setEnabled(enabled);
selectAll(m_clazyChecks->topicsView);
m_clazyChecks->topicsView->setEnabled(enabled);
m_clazyTreeModel->setEnabled(enabled);
connectClazyItemChanged();
}
void ClangDiagnosticConfigsWidget::syncClazyChecksGroupBox()
{
const auto isHidden = [this](const QModelIndex &index) {
return !m_clazySortFilterProxyModel->filterAcceptsRow(index.row(), index.parent());
};
const bool hasEnabledButHidden = m_clazyTreeModel->hasEnabledButNotVisibleChecks(isHidden);
const int checksCount = m_clazyTreeModel->enabledChecks().count();
const QString title = hasEnabledButHidden ? tr("Checks (%n enabled, some are filtered out)",
nullptr, checksCount)
: tr("Checks (%n enabled)", nullptr, checksCount);
m_clazyChecks->checksGroupBox->setTitle(title);
syncExtraWidgets(config);
}
void ClangDiagnosticConfigsWidget::updateConfig(const ClangDiagnosticConfig &config)
@@ -979,38 +351,6 @@ void ClangDiagnosticConfigsWidget::updateValidityWidgets(const QString &errorMes
m_ui->infoLabel->setStyleSheet(styleSheet);
}
void ClangDiagnosticConfigsWidget::connectClangTidyItemChanged()
{
connect(m_tidyChecks->tidyMode,
QOverload<int>::of(&QComboBox::currentIndexChanged),
this,
&ClangDiagnosticConfigsWidget::onClangTidyModeChanged);
connect(m_tidyTreeModel.get(), &TidyChecksTreeModel::dataChanged,
this, &ClangDiagnosticConfigsWidget::onClangTidyTreeChanged);
}
void ClangDiagnosticConfigsWidget::disconnectClangTidyItemChanged()
{
disconnect(m_tidyChecks->tidyMode,
QOverload<int>::of(&QComboBox::currentIndexChanged),
this,
&ClangDiagnosticConfigsWidget::onClangTidyModeChanged);
disconnect(m_tidyTreeModel.get(), &TidyChecksTreeModel::dataChanged,
this, &ClangDiagnosticConfigsWidget::onClangTidyTreeChanged);
}
void ClangDiagnosticConfigsWidget::connectClazyItemChanged()
{
connect(m_clazyTreeModel.get(), &ClazyChecksTreeModel::dataChanged,
this, &ClangDiagnosticConfigsWidget::onClazyTreeChanged);
}
void ClangDiagnosticConfigsWidget::disconnectClazyItemChanged()
{
disconnect(m_clazyTreeModel.get(), &ClazyChecksTreeModel::dataChanged,
this, &ClangDiagnosticConfigsWidget::onClazyTreeChanged);
}
void ClangDiagnosticConfigsWidget::connectClangOnlyOptionsChanged()
{
connect(m_clangBaseChecks->useFlagsFromBuildSystemCheckBox,
@@ -1040,106 +380,9 @@ ClangDiagnosticConfigs ClangDiagnosticConfigsWidget::configs() const
return m_configsModel->configs();
}
static void setupTreeView(QTreeView *view, QAbstractItemModel *model, int expandToDepth = 0)
QTabWidget *ClangDiagnosticConfigsWidget::tabWidget() const
{
view->setModel(model);
view->expandToDepth(expandToDepth);
view->header()->setStretchLastSection(false);
view->header()->setSectionResizeMode(0, QHeaderView::Stretch);
view->setHeaderHidden(true);
}
void ClangDiagnosticConfigsWidget::setupTabs(bool showTidyClazyTabs)
{
m_clangBaseChecks = std::make_unique<CppTools::Ui::ClangBaseChecks>();
m_clangBaseChecksWidget = new QWidget();
m_clangBaseChecks->setupUi(m_clangBaseChecksWidget);
m_clazyChecks = std::make_unique<CppTools::Ui::ClazyChecks>();
m_clazyChecksWidget = new QWidget();
m_clazyChecks->setupUi(m_clazyChecksWidget);
m_clazySortFilterProxyModel = new ClazyChecksSortFilterModel(this);
m_clazySortFilterProxyModel->setSourceModel(m_clazyTreeModel.get());
setupTreeView(m_clazyChecks->checksView, m_clazySortFilterProxyModel, 2);
m_clazyChecks->checksView->setSortingEnabled(true);
m_clazyChecks->checksView->sortByColumn(0, Qt::AscendingOrder);
auto topicsModel = new QStringListModel(Utils::toList(m_clazyTreeModel->topics()), this);
topicsModel->sort(0);
m_clazyChecks->topicsView->setModel(topicsModel);
connect(m_clazyChecks->topicsResetButton, &QPushButton::clicked, [this](){
selectAll(m_clazyChecks->topicsView);
});
connect(m_clazyChecks->topicsView->selectionModel(),
&QItemSelectionModel::selectionChanged,
[this, topicsModel](const QItemSelection &, const QItemSelection &) {
const auto indexes = m_clazyChecks->topicsView->selectionModel()->selectedIndexes();
const QStringList topics
= Utils::transform(indexes, [topicsModel](const QModelIndex &index) {
return topicsModel->data(index).toString();
});
m_clazySortFilterProxyModel->setTopics(topics);
this->syncClazyChecksGroupBox();
});
selectAll(m_clazyChecks->topicsView);
connect(m_clazyChecks->enableLowerLevelsCheckBox, &QCheckBox::stateChanged, [this](int) {
const bool enable = m_clazyChecks->enableLowerLevelsCheckBox->isChecked();
m_clazyTreeModel->setEnableLowerLevels(enable);
codeModelSettings()->setEnableLowerClazyLevels(
m_clazyChecks->enableLowerLevelsCheckBox->isChecked());
});
const Qt::CheckState checkEnableLowerClazyLevels
= codeModelSettings()->enableLowerClazyLevels() ? Qt::Checked : Qt::Unchecked;
m_clazyChecks->enableLowerLevelsCheckBox->setCheckState(checkEnableLowerClazyLevels);
m_tidyChecks = std::make_unique<CppTools::Ui::TidyChecks>();
m_tidyChecksWidget = new QWidget();
m_tidyChecks->setupUi(m_tidyChecksWidget);
setupTreeView(m_tidyChecks->checksPrefixesTree, m_tidyTreeModel.get());
connect(m_tidyChecks->plainTextEditButton, &QPushButton::clicked, this, [this]() {
const bool readOnly = currentConfig().isReadOnly();
QDialog dialog;
dialog.setWindowTitle(tr("Checks"));
dialog.setLayout(new QVBoxLayout);
auto *textEdit = new QTextEdit(&dialog);
textEdit->setReadOnly(readOnly);
dialog.layout()->addWidget(textEdit);
auto *buttonsBox = new QDialogButtonBox(QDialogButtonBox::Ok
| (readOnly ? QDialogButtonBox::NoButton
: QDialogButtonBox::Cancel));
dialog.layout()->addWidget(buttonsBox);
QObject::connect(buttonsBox, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
QObject::connect(buttonsBox, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
const QString initialChecks = m_tidyTreeModel->selectedChecks();
textEdit->setPlainText(initialChecks);
QObject::connect(&dialog, &QDialog::accepted, [=, &initialChecks]() {
const QString updatedChecks = textEdit->toPlainText();
if (updatedChecks == initialChecks)
return;
disconnectClangTidyItemChanged();
// Also throws away invalid options.
m_tidyTreeModel->selectChecks(updatedChecks);
onClangTidyTreeChanged();
connectClangTidyItemChanged();
});
dialog.exec();
});
connectClangTidyItemChanged();
connectClazyItemChanged();
m_ui->tabWidget->addTab(m_clangBaseChecksWidget, tr("Clang Warnings"));
if (showTidyClazyTabs) {
m_ui->tabWidget->addTab(m_tidyChecksWidget, tr("Clang-Tidy Checks"));
m_ui->tabWidget->addTab(m_clazyChecksWidget, tr("Clazy Checks"));
}
m_ui->tabWidget->setCurrentIndex(0);
return m_ui->tabWidget;
}
} // CppTools namespace

47
src/plugins/cpptools/clangdiagnosticconfigswidget.h
View File

@@ -35,23 +35,19 @@
#include <memory>
QT_BEGIN_NAMESPACE
class QListWidgetItem;
class QPushButton;
class QTabWidget;
QT_END_NAMESPACE
namespace CppTools {
class ClangDiagnosticConfig;
namespace Ui {
class ClangDiagnosticConfigsWidget;
class ClangBaseChecks;
class ClazyChecks;
class TidyChecks;
}
class ConfigsModel;
class TidyChecksTreeModel;
class ClazyChecksTreeModel;
class ClazyChecksSortFilterModel;
class CPPTOOLS_EXPORT ClangDiagnosticConfigsWidget : public QWidget
{
@@ -60,43 +56,29 @@ class CPPTOOLS_EXPORT ClangDiagnosticConfigsWidget : public QWidget
public:
explicit ClangDiagnosticConfigsWidget(const ClangDiagnosticConfigs &configs,
const Core::Id &configToSelect,
bool showTidyClazyTabs,
QWidget *parent = nullptr);
~ClangDiagnosticConfigsWidget() override;
void sync();
ClangDiagnosticConfigs configs() const;
const ClangDiagnosticConfig currentConfig() const;
private:
void setupTabs(bool showTidyClazyTabs);
protected:
void updateConfig(const CppTools::ClangDiagnosticConfig &config);
virtual void syncExtraWidgets(const ClangDiagnosticConfig &) {}
QTabWidget *tabWidget() const;
private:
void onCopyButtonClicked();
void onRenameButtonClicked();
void onRemoveButtonClicked();
void onClangTidyModeChanged(int index);
void onClangTidyTreeChanged();
void onClazyTreeChanged();
void onClangTidyTreeItemClicked(const QModelIndex &index);
void onClangOnlyOptionsChanged();
void syncToConfigsView();
void syncClangTidyWidgets(const ClangDiagnosticConfig &config);
void syncClazyWidgets(const ClangDiagnosticConfig &config);
void syncClazyChecksGroupBox();
void syncTidyChecksToTree(const ClangDiagnosticConfig &config);
void updateConfig(const CppTools::ClangDiagnosticConfig &config);
void setDiagnosticOptions(const QString &options);
void updateValidityWidgets(const QString &errorMessage);
void connectClangTidyItemChanged();
void disconnectClangTidyItemChanged();
void connectClazyItemChanged();
void disconnectClazyItemChanged();
void connectClangOnlyOptionsChanged();
void disconnectClangOnlyOptionsChanged();
@@ -107,15 +89,6 @@ private:
std::unique_ptr<CppTools::Ui::ClangBaseChecks> m_clangBaseChecks;
QWidget *m_clangBaseChecksWidget = nullptr;
std::unique_ptr<CppTools::Ui::ClazyChecks> m_clazyChecks;
QWidget *m_clazyChecksWidget = nullptr;
std::unique_ptr<ClazyChecksTreeModel> m_clazyTreeModel;
ClazyChecksSortFilterModel *m_clazySortFilterProxyModel = nullptr;
std::unique_ptr<CppTools::Ui::TidyChecks> m_tidyChecks;
QWidget *m_tidyChecksWidget = nullptr;
std::unique_ptr<TidyChecksTreeModel> m_tidyTreeModel;
};
} // CppTools namespace

107
src/plugins/cpptools/clazychecks.ui
View File

@@ -1,107 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>CppTools::ClazyChecks</class>
<widget class="QWidget" name="CppTools::ClazyChecks">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>700</width>
<height>500</height>
</rect>
</property>
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="windowTitle">
<string/>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>See &lt;a href=&quot;https://github.com/KDE/clazy&quot;&gt;Clazy's homepage&lt;/a&gt; for more information.</string>
</property>
<property name="openExternalLinks">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QGroupBox" name="groupBox">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="title">
<string>Topic Filter</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_3">
<item>
<widget class="QPushButton" name="topicsResetButton">
<property name="text">
<string>Reset to All</string>
</property>
</widget>
</item>
<item>
<widget class="QListView" name="topicsView">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="maximumSize">
<size>
<width>150</width>
<height>16777215</height>
</size>
</property>
<property name="editTriggers">
<set>QAbstractItemView::NoEditTriggers</set>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="checksGroupBox">
<property name="title">
<string>Checks</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QCheckBox" name="enableLowerLevelsCheckBox">
<property name="toolTip">
<string>When enabling a level explicitly, also enable lower levels (Clazy semantic).</string>
</property>
<property name="text">
<string>Enable lower levels automatically</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QTreeView" name="checksView"/>
</item>
</layout>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>

10
src/plugins/cpptools/cppcodemodelsettingspage.cpp
View File

@@ -71,9 +71,13 @@ void CppCodeModelSettingsWidget::applyToSettings() const
void CppCodeModelSettingsWidget::setupClangCodeModelWidgets()
{
m_ui->clangDiagnosticConfigsSelectionWidget->refresh(diagnosticConfigsModel(),
m_settings->clangDiagnosticConfigId(),
/*showTidyClazyUi=*/false);
m_ui->clangDiagnosticConfigsSelectionWidget
->refresh(diagnosticConfigsModel(),
m_settings->clangDiagnosticConfigId(),
[](const CppTools::ClangDiagnosticConfigs &configs,
const Core::Id &configToSelect) {
return new CppTools::ClangDiagnosticConfigsWidget(configs, configToSelect);
});
const bool isClangActive = CppModelManager::instance()->isClangCodeModelActive();
m_ui->clangCodeModelIsDisabledHint->setVisible(!isClangActive);

4
src/plugins/cpptools/cpptools.pro
View File

@@ -100,11 +100,9 @@ HEADERS += \
cursorineditor.h \
wrappablelineedit.h \
usages.h \
cpptools_clangtidychecks.h \
cppmodelmanagerinterface.h \
cppbuiltinmodelmanagersupport.h \
headerpathfilter.h \
cpptools_clazychecks.h
SOURCES += \
abstracteditorsupport.cpp \
@@ -198,8 +196,6 @@ FORMS += \
cppcodestylesettingspage.ui \
cppfilesettingspage.ui \
clangbasechecks.ui \
clazychecks.ui \
tidychecks.ui
equals(TEST, 1) {
HEADERS += \

4
src/plugins/cpptools/cpptools.qbs
View File

@@ -53,7 +53,6 @@ Project {
"clangdiagnosticconfigswidget.cpp",
"clangdiagnosticconfigswidget.h",
"clangdiagnosticconfigswidget.ui",
"clazychecks.ui",
"compileroptionsbuilder.cpp",
"compileroptionsbuilder.h",
"cppbuiltinmodelmanagersupport.cpp",
@@ -154,8 +153,6 @@ Project {
"cppsemanticinfoupdater.h",
"cppsourceprocessor.cpp",
"cppsourceprocessor.h",
"cpptools_clangtidychecks.h",
"cpptools_clazychecks.h",
"cpptools_global.h",
"cpptools_utils.h",
"cpptoolsbridge.cpp",
@@ -214,7 +211,6 @@ Project {
"symbolfinder.h",
"symbolsfindfilter.cpp",
"symbolsfindfilter.h",
"tidychecks.ui",
"typehierarchybuilder.cpp",
"typehierarchybuilder.h",
"usages.h",

799
src/plugins/cpptools/cpptools_clangtidychecks.h
View File

@@ -1,799 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2018 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#pragma once
#include <vector>
namespace CppTools {
namespace Constants {
struct TidyNode
{
const std::vector<TidyNode> children;
const char *name = nullptr;
TidyNode(const char *name, std::vector<TidyNode> &&children)
: children(std::move(children))
, name(name)
{}
TidyNode(const char *name) : name(name) {}
};
// CLANG-UPGRADE-CHECK: Run 'scripts/generateClangTidyChecks.py' after Clang upgrade to
// update this header.
static const TidyNode CLANG_TIDY_CHECKS_ROOT
{
"",
{
{
"abseil-",
{
{
"duration-",
{
"comparison",
"division",
{
"factory-",
{
"float",
"scale"
}
},
"subtraction"
}
},
"faster-strsplit-delimiter",
{
"no-",
{
"internal-dependencies",
"namespace"
}
},
"redundant-strcat-calls",
"str-cat-append",
"string-find-startswith",
"upgrade-duration-conversions"
}
},
{
"android-",
{
{
"cloexec-",
{
"accept",
"accept4",
"creat",
"dup",
{
"epoll-",
{
"create",
"create1"
}
},
"fopen",
{
"inotify-",
{
"init",
"init1"
}
},
"memfd-create",
"open",
"socket"
}
},
"comparison-in-temp-failure-retry"
}
},
{
"boost-",
{
"use-to-string"
}
},
{
"bugprone-",
{
"argument-comment",
"assert-side-effect",
"bool-pointer-implicit-conversion",
"copy-constructor-init",
"dangling-handle",
"exception-escape",
"fold-init-type",
"forward-declaration-namespace",
"forwarding-reference-overload",
"inaccurate-erase",
"incorrect-roundings",
"integer-division",
"lambda-function-name",
{
"macro-",
{
"parentheses",
"repeated-side-effects"
}
},
{
"misplaced-",
{
"operator-in-strlen-in-alloc",
"widening-cast"
}
},
"move-forwarding-reference",
"multiple-statement-macro",
"narrowing-conversions",
"parent-virtual-call",
{
"sizeof-",
{
"container",
"expression"
}
},
{
"string-",
{
"constructor",
"integer-assignment",
"literal-with-embedded-nul"
}
},
{
"suspicious-",
{
"enum-usage",
"memset-usage",
"missing-comma",
"semicolon",
"string-compare"
}
},
"swapped-arguments",
"terminating-continue",
"throw-keyword-missing",
"too-small-loop-variable",
"undefined-memory-manipulation",
"undelegated-constructor",
{
"unused-",
{
"raii",
"return-value"
}
},
"use-after-move",
"virtual-near-miss"
}
},
{
"cert-",
{
"dcl03-c",
"dcl16-c",
"dcl21-cpp",
"dcl50-cpp",
"dcl54-cpp",
"dcl58-cpp",
"dcl59-cpp",
"env33-c",
"err09-cpp",
"err34-c",
"err52-cpp",
"err58-cpp",
"err60-cpp",
"err61-cpp",
"fio38-c",
"flp30-c",
"msc30-c",
"msc32-c",
"msc50-cpp",
"msc51-cpp",
"oop11-cpp"
}
},
{
"clang-analyzer-",
{
{
"apiModeling.",
{
"StdCLibraryFunctions",
"TrustNonnull",
"google.GTest"
}
},
{
"core.",
{
"CallAndMessage",
"DivideZero",
"DynamicTypePropagation",
"NonNullParamChecker",
"NonnilStringConstants",
"NullDereference",
"StackAddressEscape",
"UndefinedBinaryOperatorResult",
"VLASize",
{
"builtin.",
{
"BuiltinFunctions",
"NoReturnFunctions"
}
},
{
"uninitialized.",
{
"ArraySubscript",
"Assign",
"Branch",
"CapturedBlockVariable",
"UndefReturn"
}
}
}
},
{
"cplusplus.",
{
"InnerPointer",
"Move",
"NewDelete",
"NewDeleteLeaks",
"SelfAssignment"
}
},
"deadcode.DeadStores",
{
"nullability.",
{
"NullPassedToNonnull",
"NullReturnedFromNonnull",
"NullableDereferenced",
"NullablePassedToNonnull",
"NullableReturnedFromNonnull"
}
},
{
"optin.",
{
"cplusplus.VirtualCall",
"mpi.MPI-Checker",
{
"osx.",
{
{
"cocoa.",
{
{
"localizability.",
{
"EmptyLocalizationContextChecker",
"NonLocalizedStringChecker"
}
}
}
}
}
},
{
"performance.",
{
"GCDAntipattern",
"Padding"
}
},
"portability.UnixAPI"
}
},
{
"osx.",
{
"API",
"NumberObjectConversion",
"OSObjectRetainCount",
"ObjCProperty",
"SecKeychainAPI",
{
"cocoa.",
{
"AtSync",
"AutoreleaseWrite",
"ClassRelease",
"Dealloc",
"IncompatibleMethodTypes",
"Loops",
"MissingSuperCall",
"NSAutoreleasePool",
"NSError",
"NilArg",
"NonNilReturnValue",
"ObjCGenerics",
"RetainCount",
"RunLoopAutoreleaseLeak",
"SelfInit",
"SuperDealloc",
"UnusedIvars",
"VariadicMethodTypes"
}
},
{
"coreFoundation.",
{
"CFError",
"CFNumber",
"CFRetainRelease",
{
"containers.",
{
"OutOfBounds",
"PointerSizedValues"
}
}
}
}
}
},
{
"security.",
{
"FloatLoopCounter",
{
"insecureAPI.",
{
"UncheckedReturn",
"bcmp",
"bcopy",
"bzero",
"getpw",
"gets",
"mkstemp",
"mktemp",
"rand",
"strcpy",
"vfork"
}
}
}
},
{
"unix.",
{
"API",
"Malloc",
"MallocSizeof",
"MismatchedDeallocator",
"Vfork",
{
"cstring.",
{
"BadSizeArg",
"NullArg"
}
}
}
},
{
"valist.",
{
"CopyToSelf",
"Uninitialized",
"Unterminated"
}
}
}
},
{
"cppcoreguidelines-",
{
{
"avoid-",
{
"c-arrays",
"goto",
"magic-numbers"
}
},
"c-copy-assignment-signature",
"interfaces-global-init",
"macro-usage",
"narrowing-conversions",
"no-malloc",
"non-private-member-variables-in-classes",
"owning-memory",
{
"pro-",
{
{
"bounds-",
{
"array-to-pointer-decay",
"constant-array-index",
"pointer-arithmetic"
}
},
{
"type-",
{
"const-cast",
"cstyle-cast",
"member-init",
"reinterpret-cast",
"static-cast-downcast",
"union-access",
"vararg"
}
}
}
},
"slicing",
"special-member-functions"
}
},
{
"fuchsia-",
{
"default-arguments",
"header-anon-namespaces",
"multiple-inheritance",
"overloaded-operator",
"restrict-system-includes",
"statically-constructed-objects",
"trailing-return",
"virtual-inheritance"
}
},
{
"google-",
{
{
"build-",
{
"explicit-make-pair",
"namespaces",
"using-namespace"
}
},
"default-arguments",
"explicit-constructor",
"global-names-in-headers",
{
"objc-",
{
"avoid-throwing-exception",
"function-naming",
"global-variable-declaration"
}
},
{
"readability-",
{
"braces-around-statements",
"casting",
"function-size",
"namespace-comments",
"todo"
}
},
{
"runtime-",
{
"int",
"operator",
"references"
}
}
}
},
{
"hicpp-",
{
{
"avoid-",
{
"c-arrays",
"goto"
}
},
"braces-around-statements",
"deprecated-headers",
"exception-baseclass",
"explicit-conversions",
"function-size",
"invalid-access-moved",
"member-init",
"move-const-arg",
"multiway-paths-covered",
"named-parameter",
"new-delete-operators",
{
"no-",
{
"array-decay",
"assembler",
"malloc"
}
},
"noexcept-move",
"signed-bitwise",
"special-member-functions",
"static-assert",
"undelegated-constructor",
"uppercase-literal-suffix",
{
"use-",
{
"auto",
"emplace",
{
"equals-",
{
"default",
"delete"
}
},
"noexcept",
"nullptr",
"override"
}
},
"vararg"
}
},
{
"llvm-",
{
"header-guard",
"include-order",
"namespace-comment",
"twine-local"
}
},
{
"misc-",
{
"definitions-in-headers",
"misplaced-const",
"new-delete-overloads",
{
"non-",
{
"copyable-objects",
"private-member-variables-in-classes"
}
},
"redundant-expression",
"static-assert",
"throw-by-value-catch-by-reference",
"unconventional-assign-operator",
"uniqueptr-reset-release",
{
"unused-",
{
"alias-decls",
"parameters",
"using-decls"
}
}
}
},
{
"modernize-",
{
{
"avoid-",
{
"bind",
"c-arrays"
}
},
"concat-nested-namespaces",
{
"deprecated-",
{
"headers",
"ios-base-aliases"
}
},
"loop-convert",
{
"make-",
{
"shared",
"unique"
}
},
"pass-by-value",
"raw-string-literal",
"redundant-void-arg",
{
"replace-",
{
"auto-ptr",
"random-shuffle"
}
},
"return-braced-init-list",
"shrink-to-fit",
"unary-static-assert",
{
"use-",
{
"auto",
"bool-literals",
"default-member-init",
"emplace",
{
"equals-",
{
"default",
"delete"
}
},
"nodiscard",
"noexcept",
"nullptr",
"override",
"transparent-functors",
"uncaught-exceptions",
"using"
}
}
}
},
{
"mpi-",
{
"buffer-deref",
"type-mismatch"
}
},
{
"objc-",
{
{
"avoid-",
{
"nserror-init",
"spinlock"
}
},
"forbidden-subclassing",
"property-declaration"
}
},
{
"performance-",
{
"faster-string-find",
"for-range-copy",
"implicit-conversion-in-loop",
{
"inefficient-",
{
"algorithm",
"string-concatenation",
"vector-operation"
}
},
{
"move-",
{
"const-arg",
"constructor-init"
}
},
"noexcept-move-constructor",
"type-promotion-in-math-fn",
{
"unnecessary-",
{
"copy-initialization",
"value-param"
}
}
}
},
{
"portability-",
{
"simd-intrinsics"
}
},
{
"readability-",
{
"avoid-const-params-in-decls",
"braces-around-statements",
"const-return-type",
"container-size-empty",
"delete-null-pointer",
"deleted-default",
"else-after-return",
"function-size",
"identifier-naming",
"implicit-bool-conversion",
"inconsistent-declaration-parameter-name",
"isolate-declaration",
"magic-numbers",
"misleading-indentation",
"misplaced-array-index",
"named-parameter",
"non-const-parameter",
{
"redundant-",
{
"control-flow",
"declaration",
"function-ptr-dereference",
"member-init",
"preprocessor",
"smartptr-get",
{
"string-",
{
"cstr",
"init"
}
}
}
},
{
"simplify-",
{
"boolean-expr",
"subscript-expr"
}
},
{
"static-",
{
"accessed-through-instance",
"definition-in-anonymous-namespace"
}
},
"string-compare",
"uniqueptr-delete-release",
"uppercase-literal-suffix"
}
},
{
"zircon-",
{
"temporary-objects"
}
}
}
};
} // namespace Constants
} // namespace CppTools

130
src/plugins/cpptools/cpptools_clazychecks.h
View File

@@ -1,130 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#pragma once
#include <vector>
namespace CppTools {
namespace Constants {
class ClazyCheckInfo
{
public:
bool isValid() const { return !name.isEmpty() && level >= -1; }
QString name;
int level; // "Manual level"
QStringList topics;
};
using ClazyCheckInfos = std::vector<ClazyCheckInfo>;
// CLANG-UPGRADE-CHECK: Run 'scripts/generateClazyChecks.py' after Clang upgrade to
// update this header.
static const ClazyCheckInfos CLAZY_CHECKS = {
{QString("qt-keywords"), -1, {}},
{QString("ifndef-define-typo"), -1, {"bug"}},
{QString("inefficient-qlist"), -1, {"containers","performance"}},
{QString("isempty-vs-count"), -1, {"readability"}},
{QString("qrequiredresult-candidates"), -1, {"bug"}},
{QString("qstring-varargs"), -1, {"bug"}},
{QString("qt4-qstring-from-array"), -1, {"qt4","qstring"}},
{QString("tr-non-literal"), -1, {"bug"}},
{QString("raw-environment-function"), -1, {"bug"}},
{QString("container-inside-loop"), -1, {"containers","performance"}},
{QString("qhash-with-char-pointer-key"), -1, {"cpp","bug"}},
{QString("connect-by-name"), 0, {"bug","readability"}},
{QString("connect-non-signal"), 0, {"bug"}},
{QString("wrong-qevent-cast"), 0, {"bug"}},
{QString("lambda-in-connect"), 0, {"bug"}},
{QString("lambda-unique-connection"), 0, {"bug"}},
{QString("qdatetime-utc"), 0, {"performance"}},
{QString("qgetenv"), 0, {"performance"}},
{QString("qstring-insensitive-allocation"), 0, {"performance","qstring"}},
{QString("fully-qualified-moc-types"), 0, {"bug","qml"}},
{QString("qvariant-template-instantiation"), 0, {"performance"}},
{QString("unused-non-trivial-variable"), 0, {"readability"}},
{QString("connect-not-normalized"), 0, {"performance"}},
{QString("mutable-container-key"), 0, {"containers","bug"}},
{QString("qenums"), 0, {"deprecation"}},
{QString("qmap-with-pointer-key"), 0, {"containers","performance"}},
{QString("qstring-ref"), 0, {"performance","qstring"}},
{QString("strict-iterators"), 0, {"containers","performance","bug"}},
{QString("writing-to-temporary"), 0, {"bug"}},
{QString("container-anti-pattern"), 0, {"containers","performance"}},
{QString("qcolor-from-literal"), 0, {"performance"}},
{QString("qfileinfo-exists"), 0, {"performance"}},
{QString("qstring-arg"), 0, {"performance","qstring"}},
{QString("empty-qstringliteral"), 0, {"performance"}},
{QString("qt-macros"), 0, {"bug"}},
{QString("temporary-iterator"), 0, {"containers","bug"}},
{QString("wrong-qglobalstatic"), 0, {"performance"}},
{QString("lowercase-qml-type-name"), 0, {"qml","bug"}},
{QString("auto-unexpected-qstringbuilder"), 1, {"bug","qstring"}},
{QString("connect-3arg-lambda"), 1, {"bug"}},
{QString("const-signal-or-slot"), 1, {"readability","bug"}},
{QString("detaching-temporary"), 1, {"containers","performance"}},
{QString("foreach"), 1, {"containers","performance"}},
{QString("incorrect-emit"), 1, {"readability"}},
{QString("inefficient-qlist-soft"), 1, {"containers","performance"}},
{QString("install-event-filter"), 1, {"bug"}},
{QString("non-pod-global-static"), 1, {"performance"}},
{QString("post-event"), 1, {"bug"}},
{QString("qdeleteall"), 1, {"containers","performance"}},
{QString("qlatin1string-non-ascii"), 1, {"bug","qstring"}},
{QString("qproperty-without-notify"), 1, {"bug"}},
{QString("qstring-left"), 1, {"bug","performance","qstring"}},
{QString("range-loop"), 1, {"containers","performance"}},
{QString("returning-data-from-temporary"), 1, {"bug"}},
{QString("rule-of-two-soft"), 1, {"cpp","bug"}},
{QString("child-event-qobject-cast"), 1, {"bug"}},
{QString("virtual-signal"), 1, {"bug","readability"}},
{QString("overridden-signal"), 1, {"bug","readability"}},
{QString("qhash-namespace"), 1, {"bug"}},
{QString("skipped-base-method"), 1, {"bug","cpp"}},
{QString("unneeded-cast"), 3, {"cpp","readability"}},
{QString("ctor-missing-parent-argument"), 2, {"bug"}},
{QString("base-class-event"), 2, {"bug"}},
{QString("copyable-polymorphic"), 2, {"cpp","bug"}},
{QString("function-args-by-ref"), 2, {"cpp","performance"}},
{QString("function-args-by-value"), 2, {"cpp","performance"}},
{QString("global-const-char-pointer"), 2, {"cpp","performance"}},
{QString("implicit-casts"), 2, {"cpp","bug"}},
{QString("missing-qobject-macro"), 2, {"bug"}},
{QString("missing-typeinfo"), 2, {"containers","performance"}},
{QString("old-style-connect"), 2, {"performance"}},
{QString("qstring-allocations"), 2, {"performance","qstring"}},
{QString("returning-void-expression"), 2, {"readability","cpp"}},
{QString("rule-of-three"), 2, {"cpp","bug"}},
{QString("virtual-call-ctor"), 2, {"cpp","bug"}},
{QString("static-pmf"), 2, {"bug"}},
{QString("assert-with-side-effects"), 3, {"bug"}},
{QString("detaching-member"), 3, {"containers","performance"}},
{QString("thread-with-slots"), 3, {"bug"}},
{QString("reserve-candidates"), 3, {"containers"}}
};
} // namespace Constants
} // namespace CppTools

11
src/plugins/cpptools/cpptoolsreuse.cpp
View File

@@ -26,7 +26,6 @@
#include "cpptoolsreuse.h"
#include "cppcodemodelsettings.h"
#include "cpptools_clazychecks.h"
#include "cpptoolsconstants.h"
#include "cpptoolsplugin.h"
@@ -342,16 +341,6 @@ UsePrecompiledHeaders getPchUsage()
return UsePrecompiledHeaders::Yes;
}
QString clazyChecksForLevel(int level)
{
QStringList checks;
for (const Constants::ClazyCheckInfo &check : Constants::CLAZY_CHECKS) {
if (check.level == level)
checks << check.name;
}
return checks.join(',');
}
static void addBuiltinConfigs(ClangDiagnosticConfigsModel &model)
{
ClangDiagnosticConfig config;

2
src/plugins/cpptools/cpptoolsreuse.h
View File

@@ -82,8 +82,6 @@ UsePrecompiledHeaders CPPTOOLS_EXPORT getPchUsage();
int indexerFileSizeLimitInMb();
bool fileSizeExceedsLimit(const QFileInfo &fileInfo, int sizeLimitInMb);
QString CPPTOOLS_EXPORT clazyChecksForLevel(int level);
class ClangDiagnosticConfigsModel;
ClangDiagnosticConfigsModel CPPTOOLS_EXPORT diagnosticConfigsModel();
ClangDiagnosticConfigsModel CPPTOOLS_EXPORT

125
src/plugins/cpptools/tidychecks.ui
View File

@@ -1,125 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>CppTools::TidyChecks</class>
<widget class="QWidget" name="CppTools::TidyChecks">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>682</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string/>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<property name="leftMargin">
<number>9</number>
</property>
<property name="topMargin">
<number>9</number>
</property>
<property name="rightMargin">
<number>9</number>
</property>
<property name="bottomMargin">
<number>9</number>
</property>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QComboBox" name="tidyMode">
<item>
<property name="text">
<string>Disable</string>
</property>
</item>
<item>
<property name="text">
<string>Select Checks</string>
</property>
</item>
<item>
<property name="text">
<string>Use .clang-tidy config file</string>
</property>
</item>
</widget>
</item>
<item>
<widget class="QPushButton" name="plainTextEditButton">
<property name="text">
<string>Edit Checks as String...</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item>
<widget class="QStackedWidget" name="checksListWrapper">
<widget class="QWidget" name="checksPage">
<layout class="QVBoxLayout" name="verticalLayout">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QTreeView" name="checksPrefixesTree">
<property name="minimumSize">
<size>
<width>0</width>
<height>300</height>
</size>
</property>
<attribute name="headerVisible">
<bool>false</bool>
</attribute>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="empltyPage">
<layout class="QVBoxLayout" name="verticalLayout_3">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>