Merge remote-tracking branch 'origin/4.6'

Conflicts:
	share/qtcreator/qml-type-descriptions/qmlproject.qmltypes
	src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp

Change-Id: I35fb652f29a98a798be7c8b4b4c2e581eb175fb6

src/plugins/cpptools/baseeditordocumentprocessor.h

@@ -93,6 +93,8 @@ public:
     virtual QFuture<SymbolInfo> requestFollowSymbol(int line, int column) = 0;
     virtual QFuture<ToolTipInfo> toolTipInfo(const QByteArray &codecName, int line, int column);
 
+    QString filePath() const { return m_filePath; }
+
 public:
     using HeaderErrorDiagnosticWidgetCreator = std::function<QWidget*()>;
 
@@ -117,7 +119,6 @@ protected:
                           BaseEditorDocumentParser::UpdateParams updateParams);
 
     // Convenience
-    QString filePath() const { return m_filePath; }
     unsigned revision() const { return static_cast<unsigned>(m_textDocument->revision()); }
     QTextDocument *textDocument() const { return m_textDocument; }
 

src/plugins/cpptools/clangdiagnosticconfig.cpp

@@ -47,14 +47,14 @@ void ClangDiagnosticConfig::setDisplayName(const QString &displayName)
     m_displayName = displayName;
 }
 
-QStringList ClangDiagnosticConfig::commandLineWarnings() const
+QStringList ClangDiagnosticConfig::clangOptions() const
 {
-    return m_commandLineWarnings;
+    return m_clangOptions;
 }
 
-void ClangDiagnosticConfig::setCommandLineWarnings(const QStringList &warnings)
+void ClangDiagnosticConfig::setClangOptions(const QStringList &options)
 {
-    m_commandLineWarnings = warnings;
+    m_clangOptions = options;
 }
 
 bool ClangDiagnosticConfig::isReadOnly() const
@@ -71,8 +71,35 @@ bool ClangDiagnosticConfig::operator==(const ClangDiagnosticConfig &other) const
 {
     return m_id == other.m_id
         && m_displayName == other.m_displayName
-        && m_commandLineWarnings == other.m_commandLineWarnings
+        && m_clangOptions == other.m_clangOptions
+        && m_clangTidyChecks == other.m_clangTidyChecks
+        && m_clazyChecks == other.m_clazyChecks
         && m_isReadOnly == other.m_isReadOnly;
 }
 
+bool ClangDiagnosticConfig::operator!=(const ClangDiagnosticConfig &other) const
+{
+    return !(*this == other);
+}
+
+QString ClangDiagnosticConfig::clangTidyChecks() const
+{
+    return m_clangTidyChecks;
+}
+
+void ClangDiagnosticConfig::setClangTidyChecks(const QString &checks)
+{
+    m_clangTidyChecks = checks;
+}
+
+QString ClangDiagnosticConfig::clazyChecks() const
+{
+    return m_clazyChecks;
+}
+
+void ClangDiagnosticConfig::setClazyChecks(const QString &checks)
+{
+    m_clazyChecks = checks;
+}
+
 } // namespace CppTools

src/plugins/cpptools/clangdiagnosticconfig.h

@@ -43,18 +43,27 @@ public:
     QString displayName() const;
     void setDisplayName(const QString &displayName);
 
-    QStringList commandLineWarnings() const;
-    void setCommandLineWarnings(const QStringList &commandLineWarnings);
+    QStringList clangOptions() const;
+    void setClangOptions(const QStringList &options);
+
+    QString clangTidyChecks() const;
+    void setClangTidyChecks(const QString &checks);
+
+    QString clazyChecks() const;
+    void setClazyChecks(const QString &checks);
 
     bool isReadOnly() const;
     void setIsReadOnly(bool isReadOnly);
 
     bool operator==(const ClangDiagnosticConfig &other) const;
+    bool operator!=(const ClangDiagnosticConfig &other) const;
 
 private:
     Core::Id m_id;
     QString m_displayName;
-    QStringList m_commandLineWarnings;
+    QStringList m_clangOptions;
+    QString m_clangTidyChecks;
+    QString m_clazyChecks;
     bool m_isReadOnly = false;
 };
 

src/plugins/cpptools/clangdiagnosticconfigsmodel.cpp

@@ -45,7 +45,7 @@ static void addConfigForQuestionableConstructs(ClangDiagnosticConfigsModel &mode
     config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
                                                       "Warnings for questionable constructs"));
     config.setIsReadOnly(true);
-    config.setCommandLineWarnings(QStringList{
+    config.setClangOptions(QStringList{
         QStringLiteral("-Wall"),
         QStringLiteral("-Wextra"),
     } + commonWarnings());
@@ -60,7 +60,7 @@ static void addConfigForPedanticWarnings(ClangDiagnosticConfigsModel &model)
     config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
                                                       "Pedantic Warnings"));
     config.setIsReadOnly(true);
-    config.setCommandLineWarnings(QStringList{QStringLiteral("-Wpedantic")} + commonWarnings());
+    config.setClangOptions(QStringList{QStringLiteral("-Wpedantic")} + commonWarnings());
 
     model.appendOrUpdate(config);
 }
@@ -72,7 +72,7 @@ static void addConfigForAlmostEveryWarning(ClangDiagnosticConfigsModel &model)
     config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
                                                       "Warnings for almost everything"));
     config.setIsReadOnly(true);
-    config.setCommandLineWarnings(QStringList{
+    config.setClangOptions(QStringList{
         QStringLiteral("-Weverything"),
         QStringLiteral("-Wno-c++98-compat"),
         QStringLiteral("-Wno-c++98-compat-pedantic"),
@@ -158,6 +158,23 @@ ClangDiagnosticConfigsModel::displayNameWithBuiltinIndication(const ClangDiagnos
             : config.displayName();
 }
 
+QVector<Core::Id> ClangDiagnosticConfigsModel::changedOrRemovedConfigs(
+    const ClangDiagnosticConfigs &oldConfigs, const ClangDiagnosticConfigs &newConfigs)
+{
+    ClangDiagnosticConfigsModel newConfigsModel(newConfigs);
+    QVector<Core::Id> changedConfigs;
+
+    for (const ClangDiagnosticConfig &old: oldConfigs) {
+        const int i = newConfigsModel.indexOfConfig(old.id());
+        if (i == -1)
+            changedConfigs.append(old.id()); // Removed
+        else if (newConfigsModel.configs()[i] != old)
+            changedConfigs.append(old.id()); // Changed
+    }
+
+    return changedConfigs;
+}
+
 int ClangDiagnosticConfigsModel::indexOfConfig(const Core::Id &id) const
 {
     return Utils::indexOf(m_diagnosticConfigs, [&](const ClangDiagnosticConfig &config) {

src/plugins/cpptools/clangdiagnosticconfigsmodel.h

@@ -29,6 +29,8 @@
 
 #include "clangdiagnosticconfig.h"
 
+#include <QVector>
+
 namespace CppTools {
 
 class CPPTOOLS_EXPORT ClangDiagnosticConfigsModel
@@ -47,11 +49,11 @@ public:
     ClangDiagnosticConfigs configs() const;
     bool hasConfigWithId(const Core::Id &id) const;
     const ClangDiagnosticConfig &configWithId(const Core::Id &id) const;
+    int indexOfConfig(const Core::Id &id) const;
 
     static QString displayNameWithBuiltinIndication(const ClangDiagnosticConfig &config);
-
-private:
-    int indexOfConfig(const Core::Id &id) const;
+    static QVector<Core::Id> changedOrRemovedConfigs(const ClangDiagnosticConfigs &oldConfigs,
+                                                     const ClangDiagnosticConfigs &newConfigs);
 
 private:
     ClangDiagnosticConfigs m_diagnosticConfigs;

src/plugins/cpptools/clangdiagnosticconfigswidget.cpp

@@ -25,6 +25,8 @@
 
 #include "clangdiagnosticconfigswidget.h"
 #include "ui_clangdiagnosticconfigswidget.h"
+#include "ui_clazychecks.h"
+#include "ui_tidychecks.h"
 
 #include <utils/algorithm.h>
 #include <utils/qtcassert.h>
@@ -45,6 +47,7 @@ ClangDiagnosticConfigsWidget::ClangDiagnosticConfigsWidget(
     , m_diagnosticConfigsModel(diagnosticConfigsModel)
 {
     m_ui->setupUi(this);
+    setupPluginsWidgets();
 
     connectConfigChooserCurrentIndex();
     connect(m_ui->copyButton, &QPushButton::clicked,
@@ -108,6 +111,18 @@ void ClangDiagnosticConfigsWidget::onRemoveButtonClicked()
     syncConfigChooserToModel();
 }
 
+void ClangDiagnosticConfigsWidget::onClangTidyItemChanged(QListWidgetItem *item)
+{
+    const QString prefix = item->text();
+    ClangDiagnosticConfig config = currentConfig();
+    QString checks = config.clangTidyChecks();
+    item->checkState() == Qt::Checked
+            ? checks.append(',' + prefix)
+            : checks.remove(',' + prefix);
+    config.setClangTidyChecks(checks);
+    updateConfig(config);
+}
+
 static bool isAcceptedWarningOption(const QString &option)
 {
     return option == "-w"
@@ -162,10 +177,8 @@ void ClangDiagnosticConfigsWidget::onDiagnosticOptionsEdited()
 
     // Commit valid changes
     ClangDiagnosticConfig updatedConfig = currentConfig();
-    updatedConfig.setCommandLineWarnings(normalizedOptions);
-
-    m_diagnosticConfigsModel.appendOrUpdate(updatedConfig);
-    emit customConfigsChanged(customConfigs());
+    updatedConfig.setClangOptions(normalizedOptions);
+    updateConfig(updatedConfig);
 }
 
 void ClangDiagnosticConfigsWidget::syncWidgetsToModel(const Core::Id &configToSelect)
@@ -213,12 +226,74 @@ void ClangDiagnosticConfigsWidget::syncOtherWidgetsToComboBox()
     // Update main button row
     m_ui->removeButton->setEnabled(!config.isReadOnly());
 
-    // Update child widgets
+    // Update Text Edit
     const QString options = m_notAcceptedOptions.contains(config.id())
             ? m_notAcceptedOptions.value(config.id())
-            : config.commandLineWarnings().join(QLatin1Char(' '));
+            : config.clangOptions().join(QLatin1Char(' '));
     setDiagnosticOptions(options);
     m_ui->diagnosticOptionsTextEdit->setReadOnly(config.isReadOnly());
+
+    syncClangTidyWidgets(config);
+    syncClazyWidgets(config);
+}
+
+void ClangDiagnosticConfigsWidget::syncClangTidyWidgets(const ClangDiagnosticConfig &config)
+{
+    disconnectClangTidyItemChanged();
+
+    const QString tidyChecks = config.clangTidyChecks();
+    for (int row = 0; row < m_tidyChecks->checksList->count(); ++row) {
+        QListWidgetItem *item = m_tidyChecks->checksList->item(row);
+
+        Qt::ItemFlags flags = item->flags();
+        flags |= Qt::ItemIsUserCheckable;
+        if (config.isReadOnly())
+            flags &= ~Qt::ItemIsEnabled;
+        else
+            flags |= Qt::ItemIsEnabled;
+        item->setFlags(flags);
+
+        if (tidyChecks.indexOf(item->text()) != -1)
+            item->setCheckState(Qt::Checked);
+        else
+            item->setCheckState(Qt::Unchecked);
+    }
+
+    connectClangTidyItemChanged();
+}
+
+void ClangDiagnosticConfigsWidget::syncClazyWidgets(const ClangDiagnosticConfig &config)
+{
+    const QString clazyChecks = config.clazyChecks();
+    if (clazyChecks.isEmpty())
+        m_clazyChecks->clazyLevel->setCurrentIndex(0);
+    else
+        m_clazyChecks->clazyLevel->setCurrentText(clazyChecks);
+    m_clazyChecksWidget->setEnabled(!config.isReadOnly());
+}
+
+void ClangDiagnosticConfigsWidget::setClazyLevelDescription(int index)
+{
+    // Levels descriptions are taken from https://github.com/KDE/clazy
+    static const QString levelDescriptions[] {
+        QString(),
+        tr("Very stable checks, 99.99% safe, no false-positives."),
+        tr("Similar to level 0, but sometimes (rarely) there might be\n"
+           "some false-positives."),
+        tr("Sometimes has false-positives (20-30%)."),
+        tr("Not always correct, possibly very noisy, might require\n"
+           "a knowledgeable developer to review, might have a very big\n"
+           "rate of false-positives, might have bugs.")
+    };
+
+    QTC_ASSERT(m_clazyChecks, return);
+    m_clazyChecks->levelDescription->setText(levelDescriptions[static_cast<unsigned>(index)]);
+}
+
+void ClangDiagnosticConfigsWidget::updateConfig(const ClangDiagnosticConfig &config)
+{
+    m_diagnosticConfigsModel.appendOrUpdate(config);
+    emit customConfigsChanged(customConfigs());
 }
 
 bool ClangDiagnosticConfigsWidget::isConfigChooserEmpty() const
@@ -264,6 +339,18 @@ void ClangDiagnosticConfigsWidget::updateValidityWidgets(const QString &errorMes
     m_ui->validationResultLabel->setStyleSheet(styleSheet);
 }
 
+void ClangDiagnosticConfigsWidget::connectClangTidyItemChanged()
+{
+    connect(m_tidyChecks->checksList, &QListWidget::itemChanged,
+            this, &ClangDiagnosticConfigsWidget::onClangTidyItemChanged);
+}
+
+void ClangDiagnosticConfigsWidget::disconnectClangTidyItemChanged()
+{
+    disconnect(m_tidyChecks->checksList, &QListWidget::itemChanged,
+               this, &ClangDiagnosticConfigsWidget::onClangTidyItemChanged);
+}
+
 void ClangDiagnosticConfigsWidget::connectConfigChooserCurrentIndex()
 {
     connect(m_ui->configChooserComboBox,
@@ -314,4 +401,31 @@ void ClangDiagnosticConfigsWidget::refresh(
     syncWidgetsToModel(configToSelect);
 }
 
+void ClangDiagnosticConfigsWidget::setupPluginsWidgets()
+{
+    m_clazyChecks.reset(new CppTools::Ui::ClazyChecks);
+    m_clazyChecksWidget = new QWidget();
+    m_clazyChecks->setupUi(m_clazyChecksWidget);
+    connect(m_clazyChecks->clazyLevel,
+            static_cast<void (QComboBox::*)(int index)>(&QComboBox::currentIndexChanged),
+            [this](int index) {
+        setClazyLevelDescription(index);
+        ClangDiagnosticConfig config = currentConfig();
+        if (index == 0)
+            config.setClazyChecks(QString());
+        else
+            config.setClazyChecks(m_clazyChecks->clazyLevel->itemText(index));
+        updateConfig(config);
+    });
+
+    m_tidyChecks.reset(new CppTools::Ui::TidyChecks);
+    m_tidyChecksWidget = new QWidget();
+    m_tidyChecks->setupUi(m_tidyChecksWidget);
+    connectClangTidyItemChanged();
+
+    m_ui->pluginChecksTabs->addTab(m_tidyChecksWidget, tr("Clang-Tidy"));
+    m_ui->pluginChecksTabs->addTab(m_clazyChecksWidget, tr("Clazy"));
+    m_ui->pluginChecksTabs->setCurrentIndex(0);
+}
+
 } // CppTools namespace

src/plugins/cpptools/clangdiagnosticconfigswidget.h

@@ -33,9 +33,17 @@
 #include <QHash>
 #include <QWidget>
 
+#include <memory>
+
+QT_FORWARD_DECLARE_CLASS(QListWidgetItem)
+
 namespace CppTools {
 
-namespace Ui { class ClangDiagnosticConfigsWidget; }
+namespace Ui {
+class ClangDiagnosticConfigsWidget;
+class ClazyChecks;
+class TidyChecks;
+}
 
 class CPPTOOLS_EXPORT ClangDiagnosticConfigsWidget : public QWidget
 {
@@ -59,15 +67,23 @@ signals:
     void customConfigsChanged(const CppTools::ClangDiagnosticConfigs &customConfigs);
 
 private:
+    void setupPluginsWidgets();
+
     void onCurrentConfigChanged(int);
     void onCopyButtonClicked();
     void onRemoveButtonClicked();
+    void onClangTidyItemChanged(QListWidgetItem *item);
 
     void onDiagnosticOptionsEdited();
 
     void syncWidgetsToModel(const Core::Id &configToSelect = Core::Id());
     void syncConfigChooserToModel(const Core::Id &configToSelect = Core::Id());
     void syncOtherWidgetsToComboBox();
+    void syncClangTidyWidgets(const ClangDiagnosticConfig &config);
+    void syncClazyWidgets(const ClangDiagnosticConfig &config);
+
+    void setClazyLevelDescription(int index);
+    void updateConfig(const CppTools::ClangDiagnosticConfig &config);
 
     bool isConfigChooserEmpty() const;
     const ClangDiagnosticConfig &currentConfig() const;
@@ -75,6 +91,9 @@ private:
     void setDiagnosticOptions(const QString &options);
     void updateValidityWidgets(const QString &errorMessage);
 
+    void connectClangTidyItemChanged();
+    void disconnectClangTidyItemChanged();
+
     void connectConfigChooserCurrentIndex();
     void disconnectConfigChooserCurrentIndex();
     void connectDiagnosticOptionsChanged();
@@ -84,6 +103,12 @@ private:
     Ui::ClangDiagnosticConfigsWidget *m_ui;
     ClangDiagnosticConfigsModel m_diagnosticConfigsModel;
     QHash<Core::Id, QString> m_notAcceptedOptions;
+
+    std::unique_ptr<CppTools::Ui::ClazyChecks> m_clazyChecks;
+    QWidget *m_clazyChecksWidget = nullptr;
+
+    std::unique_ptr<CppTools::Ui::TidyChecks> m_tidyChecks;
+    QWidget *m_tidyChecksWidget = nullptr;
 };
 
 } // CppTools namespace

src/plugins/cpptools/clangdiagnosticconfigswidget.ui

@@ -93,6 +93,9 @@
      </property>
     </widget>
    </item>
+   <item>
+    <widget class="QTabWidget" name="pluginChecksTabs"/>
+   </item>
   </layout>
  </widget>
  <customwidgets>

src/plugins/cpptools/compileroptionsbuilder.cpp

@@ -27,8 +27,10 @@
 
 #include <coreplugin/icore.h>
 
+#include <projectexplorer/project.h>
 #include <projectexplorer/projectexplorerconstants.h>
 
+#include <utils/fileutils.h>
 #include <utils/qtcassert.h>
 #include <utils/qtcfallthrough.h>
 
@@ -37,6 +39,8 @@
 
 namespace CppTools {
 
+static constexpr char SYSTEM_INCLUDE_PREFIX[] = "-isystem";
+
 CompilerOptionsBuilder::CompilerOptionsBuilder(const ProjectPart &projectPart,
                                                const QString &clangVersion,
                                                const QString &clangResourceDirectory)
@@ -119,10 +123,23 @@ void CompilerOptionsBuilder::enableExceptions()
     add(QLatin1String("-fexceptions"));
 }
 
+static Utils::FileName absoluteDirectory(const QString &filePath)
+{
+    return Utils::FileName::fromString(QFileInfo(filePath + '/').absolutePath());
+}
+
+static Utils::FileName projectTopLevelDirectory(const ProjectPart &projectPart)
+{
+    if (!projectPart.project)
+        return Utils::FileName();
+    return projectPart.project->projectDirectory();
+}
+
 void CompilerOptionsBuilder::addHeaderPathOptions()
 {
     typedef ProjectPartHeaderPath HeaderPath;
     const QString defaultPrefix = includeDirOption();
+    const Utils::FileName projectDirectory = projectTopLevelDirectory(m_projectPart);
 
     QStringList result;
 
@@ -134,6 +151,7 @@ void CompilerOptionsBuilder::addHeaderPathOptions()
             continue;
 
         QString prefix;
+        Utils::FileName path;
         switch (headerPath.type) {
         case HeaderPath::FrameworkPath:
             prefix = QLatin1String("-F");
@@ -141,7 +159,11 @@ void CompilerOptionsBuilder::addHeaderPathOptions()
         default: // This shouldn't happen, but let's be nice..:
             // intentional fall-through:
         case HeaderPath::IncludePath:
-            prefix = defaultPrefix;
+            path = absoluteDirectory(headerPath.path);
+            if (path == projectDirectory || path.isChildOf(projectDirectory))
+                prefix = defaultPrefix;
+            else
+                prefix = SYSTEM_INCLUDE_PREFIX;
             break;
         }
 
@@ -409,7 +431,7 @@ void CompilerOptionsBuilder::addDefineFunctionMacrosMsvc()
 
 QString CompilerOptionsBuilder::includeDirOption() const
 {
-    return QLatin1String("-isystem");
+    return QLatin1String("-I");
 }
 
 QByteArray CompilerOptionsBuilder::macroOption(const ProjectExplorer::Macro &macro) const
@@ -506,7 +528,7 @@ void CompilerOptionsBuilder::addPredefinedHeaderPathsOptions()
 void CompilerOptionsBuilder::addClangIncludeFolder()
 {
     QTC_CHECK(!m_clangVersion.isEmpty());
-    add(includeDirOption());
+    add(SYSTEM_INCLUDE_PREFIX);
     add(clangIncludeDirectory());
 }
 

src/plugins/cpptools/cppcodemodelsettings.cpp

@@ -55,6 +55,12 @@ static QString clangDiagnosticConfigsArrayDisplayNameKey()
 static QString clangDiagnosticConfigsArrayWarningsKey()
 { return QLatin1String("diagnosticOptions"); }
 
+static QString clangDiagnosticConfigsArrayClangTidyChecksKey()
+{ return QLatin1String("clangTidyChecks"); }
+
+static QString clangDiagnosticConfigsArrayClazyChecksKey()
+{ return QLatin1String("clazyChecks"); }
+
 static QString pchUsageKey()
 { return QLatin1String(Constants::CPPTOOLS_MODEL_MANAGER_PCH_USAGE); }
 
@@ -67,15 +73,12 @@ static QString skipIndexingBigFilesKey()
 static QString indexerFileSizeLimitKey()
 { return QLatin1String(Constants::CPPTOOLS_INDEXER_FILE_SIZE_LIMIT); }
 
-static QString tidyChecksKey()
-{ return QLatin1String(Constants::CPPTOOLS_TIDY_CHECKS); }
-
-static QString clazyChecksKey()
-{ return QLatin1String(Constants::CPPTOOLS_CLAZY_CHECKS); }
-
-void CppCodeModelSettings::fromSettings(QSettings *s)
+static ClangDiagnosticConfigs customDiagnosticConfigsFromSettings(QSettings *s)
 {
-    s->beginGroup(QLatin1String(Constants::CPPTOOLS_SETTINGSGROUP));
+    QTC_ASSERT(s->group() == QLatin1String(Constants::CPPTOOLS_SETTINGSGROUP),
+               return ClangDiagnosticConfigs());
+
+    ClangDiagnosticConfigs configs;
 
     const int size = s->beginReadArray(clangDiagnosticConfigsArrayKey());
     for (int i = 0; i < size; ++i) {
@@ -84,15 +87,30 @@ void CppCodeModelSettings::fromSettings(QSettings *s)
         ClangDiagnosticConfig config;
         config.setId(Core::Id::fromSetting(s->value(clangDiagnosticConfigsArrayIdKey())));
         config.setDisplayName(s->value(clangDiagnosticConfigsArrayDisplayNameKey()).toString());
-        config.setCommandLineWarnings(s->value(clangDiagnosticConfigsArrayWarningsKey()).toStringList());
-        m_clangCustomDiagnosticConfigs.append(config);
+        config.setClangOptions(s->value(clangDiagnosticConfigsArrayWarningsKey()).toStringList());
+        config.setClangTidyChecks(s->value(clangDiagnosticConfigsArrayClangTidyChecksKey()).toString());
+        config.setClazyChecks(s->value(clangDiagnosticConfigsArrayClazyChecksKey()).toString());
+        configs.append(config);
     }
     s->endArray();
 
-    const Core::Id diagnosticConfigId = Core::Id::fromSetting(
-                                            s->value(clangDiagnosticConfigKey(),
-                                                     initialClangDiagnosticConfigId().toSetting()));
-    setClangDiagnosticConfigId(diagnosticConfigId);
+    return configs;
+}
+
+static Core::Id clangDiagnosticConfigIdFromSettings(QSettings *s)
+{
+    QTC_ASSERT(s->group() == QLatin1String(Constants::CPPTOOLS_SETTINGSGROUP), return Core::Id());
+
+    return Core::Id::fromSetting(
+        s->value(clangDiagnosticConfigKey(), initialClangDiagnosticConfigId().toSetting()));
+}
+
+void CppCodeModelSettings::fromSettings(QSettings *s)
+{
+    s->beginGroup(QLatin1String(Constants::CPPTOOLS_SETTINGSGROUP));
+
+    setClangCustomDiagnosticConfigs(customDiagnosticConfigsFromSettings(s));
+    setClangDiagnosticConfigId(clangDiagnosticConfigIdFromSettings(s));
 
     const QVariant pchUsageVariant = s->value(pchUsageKey(), initialPchUsage());
     setPCHUsage(static_cast<PCHUsage>(pchUsageVariant.toInt()));
@@ -107,11 +125,6 @@ void CppCodeModelSettings::fromSettings(QSettings *s)
     const QVariant indexerFileSizeLimit = s->value(indexerFileSizeLimitKey(), 5);
     setIndexerFileSizeLimitInMb(indexerFileSizeLimit.toInt());
 
-    const QVariant tidyChecks = s->value(tidyChecksKey(), QString());
-    setTidyChecks(tidyChecks.toString());
-    const QVariant clazyChecks = s->value(clazyChecksKey(), QString());
-    setClazyChecks(clazyChecks.toString());
-
     s->endGroup();
 
     emit changed();
@@ -120,6 +133,8 @@ void CppCodeModelSettings::fromSettings(QSettings *s)
 void CppCodeModelSettings::toSettings(QSettings *s)
 {
     s->beginGroup(QLatin1String(Constants::CPPTOOLS_SETTINGSGROUP));
+    const ClangDiagnosticConfigs previousConfigs = customDiagnosticConfigsFromSettings(s);
+    const Core::Id previousConfigId = clangDiagnosticConfigIdFromSettings(s);
 
     s->beginWriteArray(clangDiagnosticConfigsArrayKey());
     for (int i = 0, size = m_clangCustomDiagnosticConfigs.size(); i < size; ++i) {
@@ -128,7 +143,9 @@ void CppCodeModelSettings::toSettings(QSettings *s)
         s->setArrayIndex(i);
         s->setValue(clangDiagnosticConfigsArrayIdKey(), config.id().toSetting());
         s->setValue(clangDiagnosticConfigsArrayDisplayNameKey(), config.displayName());
-        s->setValue(clangDiagnosticConfigsArrayWarningsKey(), config.commandLineWarnings());
+        s->setValue(clangDiagnosticConfigsArrayWarningsKey(), config.clangOptions());
+        s->setValue(clangDiagnosticConfigsArrayClangTidyChecksKey(), config.clangTidyChecks());
+        s->setValue(clangDiagnosticConfigsArrayClazyChecksKey(), config.clazyChecks());
     }
     s->endArray();
 
@@ -138,11 +155,18 @@ void CppCodeModelSettings::toSettings(QSettings *s)
     s->setValue(interpretAmbiguousHeadersAsCHeadersKey(), interpretAmbigiousHeadersAsCHeaders());
     s->setValue(skipIndexingBigFilesKey(), skipIndexingBigFiles());
     s->setValue(indexerFileSizeLimitKey(), indexerFileSizeLimitInMb());
-    s->setValue(tidyChecksKey(), tidyChecks());
-    s->setValue(clazyChecksKey(), clazyChecks());
 
     s->endGroup();
 
+    QVector<Core::Id> invalidated
+        = ClangDiagnosticConfigsModel::changedOrRemovedConfigs(previousConfigs,
+                                                               m_clangCustomDiagnosticConfigs);
+
+    if (previousConfigId != clangDiagnosticConfigId() && !invalidated.contains(previousConfigId))
+        invalidated.append(previousConfigId);
+
+    if (!invalidated.isEmpty())
+        emit clangDiagnosticConfigsInvalidated(invalidated);
     emit changed();
 }
 
@@ -212,23 +236,3 @@ void CppCodeModelSettings::setIndexerFileSizeLimitInMb(int sizeInMB)
 {
     m_indexerFileSizeLimitInMB = sizeInMB;
 }
-
-QString CppCodeModelSettings::tidyChecks() const
-{
-    return m_tidyChecks;
-}
-
-void CppCodeModelSettings::setTidyChecks(QString checks)
-{
-    m_tidyChecks = checks;
-}
-
-QString CppCodeModelSettings::clazyChecks() const
-{
-    return m_clazyChecks;
-}
-
-void CppCodeModelSettings::setClazyChecks(QString checks)
-{
-    m_clazyChecks = checks;
-}

src/plugins/cpptools/cppcodemodelsettings.h

@@ -72,13 +72,8 @@ public:
     int indexerFileSizeLimitInMb() const;
     void setIndexerFileSizeLimitInMb(int sizeInMB);
 
-    QString tidyChecks() const;
-    void setTidyChecks(QString checks);
-
-    QString clazyChecks() const;
-    void setClazyChecks(QString checks);
-
 signals:
+    void clangDiagnosticConfigsInvalidated(const QVector<Core::Id> &configId);
     void changed();
 
 private:
@@ -88,9 +83,6 @@ private:
     int m_indexerFileSizeLimitInMB = 5;
     ClangDiagnosticConfigs m_clangCustomDiagnosticConfigs;
     Core::Id m_clangDiagnosticConfigId;
-
-    QString m_tidyChecks;
-    QString m_clazyChecks;
 };
 
 } // namespace CppTools

src/plugins/cpptools/cppcodemodelsettingspage.cpp

@@ -29,8 +29,6 @@
 #include "cppmodelmanager.h"
 #include "cpptoolsconstants.h"
 #include "ui_cppcodemodelsettingspage.h"
-#include "ui_clazychecks.h"
-#include "ui_tidychecks.h"
 
 #include <coreplugin/icore.h>
 #include <utils/algorithm.h>
@@ -86,79 +84,6 @@ void CppCodeModelSettingsWidget::setupClangCodeModelWidgets()
                                             diagnosticConfigsModel,
                                             m_settings->clangDiagnosticConfigId());
     m_ui->clangSettingsGroupBox->layout()->addWidget(m_clangDiagnosticConfigsWidget);
-
-    m_ui->clangPlugins->setEnabled(isClangActive);
-    setupPluginsWidgets();
-}
-
-void CppCodeModelSettingsWidget::setupPluginsWidgets()
-{
-    m_clazyChecks.reset(new CppTools::Ui::ClazyChecks);
-    m_clazyChecksWidget = new QWidget();
-    m_clazyChecks->setupUi(m_clazyChecksWidget);
-
-    m_tidyChecks.reset(new CppTools::Ui::TidyChecks);
-    m_tidyChecksWidget = new QWidget();
-    m_tidyChecks->setupUi(m_tidyChecksWidget);
-
-    m_ui->pluginChecks->addTab(m_tidyChecksWidget, tr("ClangTidy"));
-    m_ui->pluginChecks->addTab(m_clazyChecksWidget, tr("Clazy"));
-    m_ui->pluginChecks->setCurrentIndex(0);
-
-    setupTidyChecks();
-    setupClazyChecks();
-}
-
-void CppCodeModelSettingsWidget::setupTidyChecks()
-{
-    m_currentTidyChecks = m_settings->tidyChecks();
-    for (int row = 0; row < m_tidyChecks->checksList->count(); ++row) {
-        QListWidgetItem *item = m_tidyChecks->checksList->item(row);
-        item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
-        if (m_currentTidyChecks.indexOf(item->text()) != -1)
-            item->setCheckState(Qt::Checked);
-        else
-            item->setCheckState(Qt::Unchecked);
-    }
-    connect(m_tidyChecks->checksList, &QListWidget::itemChanged, [this](QListWidgetItem *item) {
-        const QString prefix = item->text();
-        item->checkState() == Qt::Checked
-                ? m_currentTidyChecks.append(',' + prefix)
-                : m_currentTidyChecks.remove(',' + prefix);
-    });
-}
-
-void CppCodeModelSettingsWidget::setupClazyChecks()
-{
-    // Levels descriptions are taken from https://github.com/KDE/clazy
-    static const std::array<QString, 5> levelDescriptions {{
-        QString(),
-        tr("Very stable checks, 99.99% safe, no false-positives."),
-        tr("Similar to level0, but sometimes (rarely) there might be\n"
-           "some false-positives."),
-        tr("Sometimes has false-positives (20-30%)."),
-        tr("Not always correct, possibly very noisy, might require\n"
-           "a knowledgeable developer to review, might have a very big\n"
-           "rate of false-positives, might have bugs.")
-    }};
-
-    m_currentClazyChecks = m_settings->clazyChecks();
-    if (!m_currentClazyChecks.isEmpty()) {
-        m_clazyChecks->clazyLevel->setCurrentText(m_currentClazyChecks);
-        const unsigned index = static_cast<unsigned>(m_clazyChecks->clazyLevel->currentIndex());
-        m_clazyChecks->levelDescription->setText(levelDescriptions[index]);
-    }
-
-    connect(m_clazyChecks->clazyLevel,
-            static_cast<void (QComboBox::*)(int index)>(&QComboBox::currentIndexChanged),
-            [this](int index) {
-        m_clazyChecks->levelDescription->setText(levelDescriptions[static_cast<unsigned>(index)]);
-        if (index == 0) {
-            m_currentClazyChecks.clear();
-            return;
-        }
-        m_currentClazyChecks = m_clazyChecks->clazyLevel->itemText(index);
-    });
 }
 
 void CppCodeModelSettingsWidget::setupGeneralWidgets()
@@ -192,16 +117,6 @@ bool CppCodeModelSettingsWidget::applyClangCodeModelWidgetsToSettings() const
         settingsChanged = true;
     }
 
-    if (m_settings->tidyChecks() != m_currentTidyChecks) {
-        m_settings->setTidyChecks(m_currentTidyChecks);
-        settingsChanged = true;
-    }
-
-    if (m_settings->clazyChecks() != m_currentClazyChecks) {
-        m_settings->setClazyChecks(m_currentClazyChecks);
-        settingsChanged = true;
-    }
-
     return settingsChanged;
 }
 

src/plugins/cpptools/cppcodemodelsettingspage.h

@@ -32,8 +32,6 @@
 #include <QPointer>
 #include <QWidget>
 
-#include <memory>
-
 QT_FORWARD_DECLARE_CLASS(QComboBox)
 QT_FORWARD_DECLARE_CLASS(QSettings)
 
@@ -41,11 +39,6 @@ namespace CppTools {
 
 class ClangDiagnosticConfigsWidget;
 
-namespace Ui {
-class ClazyChecks;
-class TidyChecks;
-} // namespace Ui
-
 namespace Internal {
 
 namespace Ui { class CppCodeModelSettingsPage; }
@@ -64,9 +57,6 @@ public:
 private:
     void setupGeneralWidgets();
     void setupClangCodeModelWidgets();
-    void setupPluginsWidgets();
-    void setupTidyChecks();
-    void setupClazyChecks();
 
     bool applyGeneralWidgetsToSettings() const;
     bool applyClangCodeModelWidgetsToSettings() const;
@@ -75,14 +65,6 @@ private:
     Ui::CppCodeModelSettingsPage *m_ui = nullptr;
     QPointer<ClangDiagnosticConfigsWidget> m_clangDiagnosticConfigsWidget;
     QSharedPointer<CppCodeModelSettings> m_settings;
-
-    std::unique_ptr<CppTools::Ui::ClazyChecks> m_clazyChecks;
-    QWidget *m_clazyChecksWidget = nullptr;
-    QString m_currentClazyChecks;
-
-    std::unique_ptr<CppTools::Ui::TidyChecks> m_tidyChecks;
-    QWidget *m_tidyChecksWidget = nullptr;
-    QString m_currentTidyChecks;
 };
 
 class CppCodeModelSettingsPage: public Core::IOptionsPage

src/plugins/cpptools/cppcodemodelsettingspage.ui

@@ -114,18 +114,6 @@
      <layout class="QVBoxLayout" name="verticalLayout_3"/>
     </widget>
    </item>
-   <item>
-    <widget class="QGroupBox" name="clangPlugins">
-     <property name="title">
-      <string>Clang Plugins</string>
-     </property>
-     <layout class="QHBoxLayout" name="horizontalLayout_2">
-      <item>
-       <widget class="QTabWidget" name="pluginChecks"/>
-      </item>
-     </layout>
-    </widget>
-   </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">

src/plugins/cpptools/cpptoolsconstants.h

@@ -56,8 +56,6 @@ const char CPPTOOLS_INTERPRET_AMBIGIUOUS_HEADERS_AS_C_HEADERS[]
     = "InterpretAmbiguousHeadersAsCHeaders";
 const char CPPTOOLS_SKIP_INDEXING_BIG_FILES[] = "SkipIndexingBigFiles";
 const char CPPTOOLS_INDEXER_FILE_SIZE_LIMIT[] = "IndexerFileSizeLimit";
-const char CPPTOOLS_TIDY_CHECKS[] = "TidyChecks";
-const char CPPTOOLS_CLAZY_CHECKS[] = "ClazyChecks";
 
 const char CPP_CLANG_BUILTIN_CONFIG_ID_EVERYTHING_WITH_EXCEPTIONS[]
     = "Builtin.EverythingWithExceptions";