Clang/ClangTools: Separate custom diagnostic configs

Add a separate pool of custom diagnostic configs for the
ClangTools plugin. That is, the diagnostic configs in

  Menu: Tools > C++ > Code Model

are not shared anymore with the configs at

  Menu: Tools > Analyzer > ClangTools

On plugin initialization of ClangTools, move tidy/clazy related configs
to ClangTools.

Change-Id: Id06087a58b53e466a3d7bbac669550c5fbe9899d
Reviewed-by: Cristian Adam <cristian.adam@qt.io>
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>

35 files changed, 521 insertions, 441 deletions

diff --git a/src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp b/src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp
index 627299c64e..51acd3a5a6 100644
--- a/src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp
+++ b/src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp
@@ -39,7 +39,6 @@
 
 #include <cpptools/builtincursorinfo.h>
 #include <cpptools/clangdiagnosticconfigsmodel.h>
-#include <cpptools/clangdiagnosticconfigsmodel.h>
 #include <cpptools/compileroptionsbuilder.h>
 #include <cpptools/cppcodemodelsettings.h>
 #include <cpptools/cppmodelmanager.h>
@@ -480,8 +479,8 @@ private:
             ClangProjectSettings &projectSettings = getProjectSettings(m_projectPart.project);
             if (!projectSettings.useGlobalConfig()) {
                 const Core::Id warningConfigId = projectSettings.warningConfigId();
-                const CppTools::ClangDiagnosticConfigsModel configsModel(
-                            CppTools::codeModelSettings()->clangCustomDiagnosticConfigs());
+                const CppTools::ClangDiagnosticConfigsModel configsModel
+                    = CppTools::diagnosticConfigsModel();
                 if (configsModel.hasConfigWithId(warningConfigId)) {
                     addDiagnosticOptionsForConfig(configsModel.configWithId(warningConfigId));
                     return;
@@ -500,42 +499,6 @@ private:
                                        : CppTools::UseBuildSystemWarnings::No;
 
         m_options.append(diagnosticConfig.clangOptions());
-        addClangTidyOptions(diagnosticConfig);
-        addClazyOptions(diagnosticConfig.clazyChecks());
-    }
-
-    void addClangTidyOptions(const CppTools::ClangDiagnosticConfig &diagnosticConfig)
-    {
-        using Mode = CppTools::ClangDiagnosticConfig::TidyMode;
-        Mode tidyMode = diagnosticConfig.clangTidyMode();
-        if (tidyMode == Mode::Disabled)
-            return;
-
-        m_options.append(CppTools::XclangArgs({"-add-plugin", "clang-tidy"}));
-
-        if (tidyMode == Mode::File)
-            return;
-
-        const QString checks = diagnosticConfig.clangTidyChecks();
-        if (!checks.isEmpty())
-            m_options.append(CppTools::XclangArgs({"-plugin-arg-clang-tidy", "-checks=" + checks}));
-    }
-
-    void addClazyOptions(const QString &checks)
-    {
-        if (checks.isEmpty())
-            return;
-
-        m_options.append(CppTools::XclangArgs({"-add-plugin",
-                                               "clazy",
-                                               "-plugin-arg-clazy",
-                                               "enable-all-fixits",
-                                               "-plugin-arg-clazy",
-                                               "no-autowrite-fixits",
-                                               "-plugin-arg-clazy",
-                                               checks,
-                                               "-plugin-arg-clazy",
-                                               "ignore-included-files"}));
     }
 
     void addGlobalDiagnosticOptions()
diff --git a/src/plugins/clangcodemodel/clangprojectsettingswidget.cpp b/src/plugins/clangcodemodel/clangprojectsettingswidget.cpp
index a4bd50e546..a0a980829f 100644
--- a/src/plugins/clangcodemodel/clangprojectsettingswidget.cpp
+++ b/src/plugins/clangcodemodel/clangprojectsettingswidget.cpp
@@ -64,6 +64,17 @@ ClangProjectSettingsWidget::ClangProjectSettingsWidget(ProjectExplorer::Project
     connect(m_ui.clangDiagnosticConfigsSelectionWidget,
             &ClangDiagnosticConfigsSelectionWidget::currentConfigChanged,
             this, &ClangProjectSettingsWidget::onCurrentWarningConfigChanged);
+    connect(m_ui.clangDiagnosticConfigsSelectionWidget,
+            &ClangDiagnosticConfigsSelectionWidget::diagnosticConfigsEdited,
+            this, [this](const ClangDiagnosticConfigs &configs){
+        QSharedPointer<CppCodeModelSettings> cmSettings = CppTools::codeModelSettings();
+        const ClangDiagnosticConfigsModel configsModel = CppTools::diagnosticConfigsModel(configs);
+        if (!configsModel.hasConfigWithId(cmSettings->clangDiagnosticConfigId()))
+            cmSettings->resetClangDiagnosticConfigId();
+        cmSettings->setClangCustomDiagnosticConfigs(configs);
+        cmSettings->toSettings(Core::ICore::settings());
+        refreshDiagnosticConfigsWidgetFromSettings();
+    });
 
     connect(m_ui.delayedTemplateParseCheckBox, &QCheckBox::toggled,
             this, &ClangProjectSettingsWidget::onDelayedTemplateParseClicked);
@@ -146,7 +157,9 @@ void ClangProjectSettingsWidget::syncOtherWidgetsToComboBox()
 
 void ClangProjectSettingsWidget::refreshDiagnosticConfigsWidgetFromSettings()
 {
-    m_ui.clangDiagnosticConfigsSelectionWidget->refresh(configIdForProject(m_projectSettings));
+    m_ui.clangDiagnosticConfigsSelectionWidget->refresh(CppTools::diagnosticConfigsModel(),
+                                                        configIdForProject(m_projectSettings),
+                                                        /*showTidyClazyUi=*/false);
 }
 
 } // namespace Internal
diff --git a/src/plugins/clangcodemodel/clangtextmark.cpp b/src/plugins/clangcodemodel/clangtextmark.cpp
index 905682cd0f..5bb0d06497 100644
--- a/src/plugins/clangcodemodel/clangtextmark.cpp
+++ b/src/plugins/clangcodemodel/clangtextmark.cpp
@@ -139,7 +139,7 @@ ClangDiagnosticConfig diagnosticConfig(ClangProjectSettings &projectSettings,
         currentConfigId = globalSettings.clangDiagnosticConfigId();
 
     // Get config
-    ClangDiagnosticConfigsModel configsModel(globalSettings.clangCustomDiagnosticConfigs());
+    ClangDiagnosticConfigsModel configsModel = CppTools::diagnosticConfigsModel();
     QTC_ASSERT(configsModel.hasConfigWithId(currentConfigId), return {});
     return configsModel.configWithId(currentConfigId);
 }
@@ -174,7 +174,7 @@ void disableDiagnosticInCurrentProjectConfig(const ClangBackEnd::DiagnosticConta
 
     // Get config
     ClangDiagnosticConfig config = diagnosticConfig(projectSettings, *globalSettings);
-    ClangDiagnosticConfigsModel configsModel(globalSettings->clangCustomDiagnosticConfigs());
+    ClangDiagnosticConfigsModel configsModel = CppTools::diagnosticConfigsModel();
 
     // Create copy if needed
     if (config.isReadOnly()) {
diff --git a/src/plugins/clangtools/clangselectablefilesdialog.cpp b/src/plugins/clangtools/clangselectablefilesdialog.cpp
index 6541ca46bc..418615f7da 100644
--- a/src/plugins/clangtools/clangselectablefilesdialog.cpp
+++ b/src/plugins/clangtools/clangselectablefilesdialog.cpp
@@ -32,7 +32,6 @@
 #include "clangtoolsutils.h"
 
 #include <cpptools/compileroptionsbuilder.h>
-#include <cpptools/cppcodemodelsettings.h>
 #include <cpptools/cppmodelmanager.h>
 #include <cpptools/cpptoolsreuse.h>
 #include <cpptools/projectinfo.h>
diff --git a/src/plugins/clangtools/clangtidyclazyrunner.cpp b/src/plugins/clangtools/clangtidyclazyrunner.cpp
index 21238a9f1c..bd909384d0 100644
--- a/src/plugins/clangtools/clangtidyclazyrunner.cpp
+++ b/src/plugins/clangtools/clangtidyclazyrunner.cpp
@@ -30,8 +30,8 @@
 
 #include <coreplugin/icore.h>
 
+#include <cpptools/clangdiagnosticconfigsmodel.h>
 #include <cpptools/compileroptionsbuilder.h>
-#include <cpptools/cppcodemodelsettings.h>
 #include <cpptools/cpptoolsreuse.h>
 
 #include <utils/synchronousprocess.h>
diff --git a/src/plugins/clangtools/clangtool.cpp b/src/plugins/clangtools/clangtool.cpp
index 3e4b3268d7..90c66834ac 100644
--- a/src/plugins/clangtools/clangtool.cpp
+++ b/src/plugins/clangtools/clangtool.cpp
@@ -44,6 +44,7 @@
 #include <coreplugin/icore.h>
 #include <coreplugin/messagebox.h>
 
+#include <cpptools/clangdiagnosticconfigsmodel.h>
 #include <cpptools/cppmodelmanager.h>
 
 #include <debugger/analyzer/analyzermanager.h>
@@ -248,6 +249,13 @@ static RunSettings runSettings()
     return projectSettings->runSettings();
 }
 
+static ClangDiagnosticConfig diagnosticConfig(const Core::Id &diagConfigId)
+{
+    const ClangDiagnosticConfigsModel configs = diagnosticConfigsModel();
+    QTC_ASSERT(configs.hasConfigWithId(diagConfigId), return ClangDiagnosticConfig());
+    return configs.configWithId(diagConfigId);
+}
+
 ClangTool *ClangTool::instance()
 {
     return s_instance;
@@ -440,10 +448,13 @@ void ClangTool::selectPerspective()
 
 void ClangTool::startTool(ClangTool::FileSelection fileSelection)
 {
-    startTool(runSettings(), fileSelection);
+    const RunSettings theRunSettings = runSettings();
+    startTool(fileSelection, theRunSettings, diagnosticConfig(theRunSettings.diagnosticConfigId()));
 }
 
-void ClangTool::startTool(const RunSettings &runSettings, ClangTool::FileSelection fileSelection)
+void ClangTool::startTool(ClangTool::FileSelection fileSelection,
+                          const RunSettings &runSettings,
+                          const CppTools::ClangDiagnosticConfig &diagnosticConfig)
 {
     Project *project = SessionManager::startupProject();
     QTC_ASSERT(project, return);
@@ -459,7 +470,11 @@ void ClangTool::startTool(const RunSettings &runSettings, ClangTool::FileSelecti
         return;
 
     const bool preventBuild = fileSelection == FileSelection::CurrentFile;
-    auto clangTool = new ClangToolRunWorker(runControl, runSettings, fileInfos, preventBuild);
+    auto clangTool = new ClangToolRunWorker(runControl,
+                                            runSettings,
+                                            diagnosticConfig,
+                                            fileInfos,
+                                            preventBuild);
 
     m_stopAction->disconnect();
     connect(m_stopAction, &QAction::triggered, runControl, [runControl] {
diff --git a/src/plugins/clangtools/clangtool.h b/src/plugins/clangtools/clangtool.h
index 8fb6140008..422c24ff95 100644
--- a/src/plugins/clangtools/clangtool.h
+++ b/src/plugins/clangtools/clangtool.h
@@ -38,6 +38,9 @@ QT_BEGIN_NAMESPACE
 class QToolButton;
 QT_END_NAMESPACE
 
+namespace CppTools {
+class ClangDiagnosticConfig;
+}
 namespace Debugger {
 class DetailedErrorView;
 }
@@ -74,7 +77,9 @@ public:
         AskUser,
     };
     void startTool(FileSelection fileSelection);
-    void startTool(const RunSettings &runSettings, FileSelection fileSelection);
+    void startTool(FileSelection fileSelection,
+                   const RunSettings &runSettings,
+                   const CppTools::ClangDiagnosticConfig &diagnosticConfig);
 
     Diagnostics read(OutputFileFormat outputFileFormat,
                      const QString &logFilePath,
diff --git a/src/plugins/clangtools/clangtoolruncontrol.cpp b/src/plugins/clangtools/clangtoolruncontrol.cpp
index 2af11aa7ef..307e2c7e04 100644
--- a/src/plugins/clangtools/clangtoolruncontrol.cpp
+++ b/src/plugins/clangtools/clangtoolruncontrol.cpp
@@ -42,7 +42,6 @@
 
 #include <cpptools/clangdiagnosticconfigsmodel.h>
 #include <cpptools/compileroptionsbuilder.h>
-#include <cpptools/cppcodemodelsettings.h>
 #include <cpptools/cppmodelmanager.h>
 #include <cpptools/cppprojectfile.h>
 #include <cpptools/cpptoolsreuse.h>
@@ -221,21 +220,14 @@ static QDebug operator<<(QDebug debug, const AnalyzeUnits &analyzeUnits)
     return debug;
 }
 
-static ClangDiagnosticConfig diagnosticConfig(const Core::Id &diagConfigId)
-{
-    const ClangDiagnosticConfigsModel configsModel(
-                CppTools::codeModelSettings()->clangCustomDiagnosticConfigs());
-
-    QTC_ASSERT(configsModel.hasConfigWithId(diagConfigId), return ClangDiagnosticConfig());
-    return configsModel.configWithId(diagConfigId);
-}
 
 ClangToolRunWorker::ClangToolRunWorker(RunControl *runControl,
                                        const RunSettings &runSettings,
+                                       const CppTools::ClangDiagnosticConfig &diagnosticConfig,
                                        const FileInfos &fileInfos,
                                        bool preventBuild)
     : RunWorker(runControl)
-    , m_diagnosticConfig(diagnosticConfig(runSettings.diagnosticConfigId()))
+    , m_diagnosticConfig(diagnosticConfig)
     , m_fileInfos(fileInfos)
     , m_temporaryDir("clangtools-XXXXXX")
 {
diff --git a/src/plugins/clangtools/clangtoolruncontrol.h b/src/plugins/clangtools/clangtoolruncontrol.h
index bfada9e502..d1c97c206c 100644
--- a/src/plugins/clangtools/clangtoolruncontrol.h
+++ b/src/plugins/clangtools/clangtoolruncontrol.h
@@ -68,6 +68,7 @@ class ClangToolRunWorker : public ProjectExplorer::RunWorker
 public:
     ClangToolRunWorker(ProjectExplorer::RunControl *runControl,
                        const RunSettings &runSettings,
+                       const CppTools::ClangDiagnosticConfig &diagnosticConfig,
                        const FileInfos &fileInfos,
                        bool preventBuild);
 
diff --git a/src/plugins/clangtools/clangtoolsconstants.h b/src/plugins/clangtools/clangtoolsconstants.h
index f19ffc068a..a3da1d78f5 100644
--- a/src/plugins/clangtools/clangtoolsconstants.h
+++ b/src/plugins/clangtools/clangtoolsconstants.h
@@ -38,5 +38,7 @@ const char CLANGTIDYCLAZY_RUN_MODE[] = "ClangTidyClazy.RunMode";
 const char CLANG_TIDY_EXECUTABLE_NAME[] = "clang-tidy";
 const char CLAZY_STANDALONE_EXECUTABLE_NAME[] = "clazy-standalone";
 
+const char DIAG_CONFIG_TIDY_AND_CLAZY[] = "Builtin.TidyAndClazy";
+
 } // Constants
 } // ClangTools
diff --git a/src/plugins/clangtools/clangtoolsplugin.cpp b/src/plugins/clangtools/clangtoolsplugin.cpp
index 12031dc589..cdcda4d3c6 100644
--- a/src/plugins/clangtools/clangtoolsplugin.cpp
+++ b/src/plugins/clangtools/clangtoolsplugin.cpp
@@ -113,6 +113,10 @@ bool ClangToolsPlugin::initialize(const QStringList &arguments, QString *errorSt
     Q_UNUSED(arguments)
     Q_UNUSED(errorString)
 
+    // Import tidy/clazy diagnostic configs from CppTools now
+    // instead of at opening time of the settings page
+    ClangToolsSettings::instance();
+
     d = new ClangToolsPluginPrivate;
 
     ActionManager::registerAction(d->clangTool.startAction(), Constants::RUN_ON_PROJECT);
diff --git a/src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp b/src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp
index b76f5eefee..2ed19354f2 100644
--- a/src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp
+++ b/src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp
@@ -27,7 +27,6 @@
 
 #include "clangtool.h"
 #include "clangtoolsdiagnostic.h"
-#include "clangtoolssettings.h"
 #include "clangtoolsutils.h"
 
 #include <coreplugin/icore.h>
@@ -122,8 +121,7 @@ void PreconfiguredSessionTests::testPreconfiguredSession()
 
     QVERIFY(switchToProjectAndTarget(project, target));
 
-    ClangTool::instance()->startTool(ClangToolsSettings::instance()->runSettings(),
-                                     ClangTool::FileSelection::AllFiles);
+    ClangTool::instance()->startTool(ClangTool::FileSelection::AllFiles);
     QSignalSpy waitUntilAnalyzerFinished(ClangTool::instance(), SIGNAL(finished(bool)));
     QVERIFY(waitUntilAnalyzerFinished.wait(30000));
     const QList<QVariant> arguments = waitUntilAnalyzerFinished.takeFirst();
diff --git a/src/plugins/clangtools/clangtoolsprojectsettingswidget.cpp b/src/plugins/clangtools/clangtoolsprojectsettingswidget.cpp
index c5b7c53a68..15a86e9d32 100644
--- a/src/plugins/clangtools/clangtoolsprojectsettingswidget.cpp
+++ b/src/plugins/clangtools/clangtoolsprojectsettingswidget.cpp
@@ -29,6 +29,7 @@
 #include "clangtool.h"
 #include "clangtoolsconstants.h"
 #include "clangtoolsprojectsettings.h"
+#include "clangtoolsutils.h"
 
 #include <coreplugin/icore.h>
 
@@ -36,6 +37,8 @@
 
 #include <QAbstractTableModel>
 
+#include <cpptools/clangdiagnosticconfigsmodel.h>
+
 namespace ClangTools {
 namespace Internal {
 
@@ -98,6 +101,25 @@ ProjectSettingsWidget::ProjectSettingsWidget(ProjectExplorer::Project *project,
     connect(m_ui->runSettingsWidget, &RunSettingsWidget::changed, [this]() {
         m_projectSettings->setRunSettings(m_ui->runSettingsWidget->toSettings());
     });
+    connect(m_ui->runSettingsWidget,
+            &RunSettingsWidget::diagnosticConfigsEdited,
+            this,
+            [this](const CppTools::ClangDiagnosticConfigs &configs) {
+                const CppTools::ClangDiagnosticConfigsModel configsModel = diagnosticConfigsModel(
+                    configs);
+                RunSettings runSettings = m_projectSettings->runSettings();
+                if (!configsModel.hasConfigWithId(runSettings.diagnosticConfigId())) {
+                    runSettings.resetDiagnosticConfigId();
+                    m_projectSettings->setRunSettings(runSettings);
+                }
+                ClangToolsSettings::instance()->setDiagnosticConfigs(configs);
+                ClangToolsSettings::instance()->writeSettings();
+                m_ui->runSettingsWidget->fromSettings(runSettings);
+            });
+    connect(ClangToolsSettings::instance(), &ClangToolsSettings::changed,
+            this, [this](){
+        m_ui->runSettingsWidget->fromSettings(m_projectSettings->runSettings());
+    });
 
     // Suppressed diagnostics
     auto * const model = new SuppressedDiagnosticsModel(this);
diff --git a/src/plugins/clangtools/clangtoolsprojectsettingswidget.h b/src/plugins/clangtools/clangtoolsprojectsettingswidget.h
index 680431cc6e..a014dd804e 100644
--- a/src/plugins/clangtools/clangtoolsprojectsettingswidget.h
+++ b/src/plugins/clangtools/clangtoolsprojectsettingswidget.h
@@ -51,8 +51,8 @@ private:
     void updateButtonStateRemoveAll();
     void removeSelected();
 
-    Ui::ProjectSettingsWidget * const m_ui;
-    ClangToolsProjectSettings * const m_projectSettings;
+    Ui::ProjectSettingsWidget *const m_ui;
+    ClangToolsProjectSettings *const m_projectSettings;
 };
 
 } // namespace Internal
diff --git a/src/plugins/clangtools/clangtoolssettings.cpp b/src/plugins/clangtools/clangtoolssettings.cpp
index 07b9592a8e..2e71d3cf62 100644
--- a/src/plugins/clangtools/clangtoolssettings.cpp
+++ b/src/plugins/clangtools/clangtoolssettings.cpp
@@ -28,6 +28,11 @@
 #include "clangtoolsconstants.h"
 
 #include <coreplugin/icore.h>
+#include <cpptools/clangdiagnosticconfig.h>
+#include <cpptools/cppcodemodelsettings.h>
+#include <cpptools/cpptoolsreuse.h>
+
+#include <utils/algorithm.h>
 
 #include <QThread>
 
@@ -39,11 +44,19 @@ static const char buildBeforeAnalysisKey[] = "BuildBeforeAnalysis";
 
 static const char oldDiagnosticConfigIdKey[] = "diagnosticConfigId";
 
+using namespace CppTools;
+
 namespace ClangTools {
 namespace Internal {
 
+static Core::Id defaultDiagnosticId()
+{
+    return ClangTools::Constants::DIAG_CONFIG_TIDY_AND_CLAZY;
+}
+
 RunSettings::RunSettings()
-    : m_parallelJobs(qMax(0, QThread::idealThreadCount() / 2))
+    : m_diagnosticConfigId(defaultDiagnosticId())
+    , m_parallelJobs(qMax(0, QThread::idealThreadCount() / 2))
 {
 }
 
@@ -61,6 +74,11 @@ void RunSettings::toMap(QVariantMap &map, const QString &prefix) const
     map.insert(prefix + buildBeforeAnalysisKey, m_buildBeforeAnalysis);
 }
 
+void RunSettings::resetDiagnosticConfigId()
+{
+    m_diagnosticConfigId = defaultDiagnosticId();
+}
+
 ClangToolsSettings::ClangToolsSettings()
 {
     readSettings();
@@ -89,14 +107,40 @@ static QVariantMap convertToMapFromVersionBefore410(QSettings *s)
     return map;
 }
 
+ClangDiagnosticConfigs importDiagnosticConfigsFromCodeModel()
+{
+    const ClangDiagnosticConfigs configs = codeModelSettings()->clangCustomDiagnosticConfigs();
+
+    ClangDiagnosticConfigs tidyClazyConfigs;
+    ClangDiagnosticConfigs clangOnlyConfigs;
+    std::tie(tidyClazyConfigs, clangOnlyConfigs)
+        = Utils::partition(configs, [](const ClangDiagnosticConfig &config) {
+              return !config.clazyChecks().isEmpty()
+                     || config.clangTidyMode() != ClangDiagnosticConfig::TidyMode::Disabled;
+          });
+
+    if (!tidyClazyConfigs.isEmpty()) {
+        codeModelSettings()->setClangCustomDiagnosticConfigs(clangOnlyConfigs);
+        codeModelSettings()->toSettings(Core::ICore::settings());
+    }
+
+    return tidyClazyConfigs;
+}
+
 void ClangToolsSettings::readSettings()
 {
+    // Transfer tidy/clazy configs from code model
+    bool write = false;
+    ClangDiagnosticConfigs importedConfigs = importDiagnosticConfigsFromCodeModel();
+    m_diagnosticConfigs.append(importedConfigs);
+    if (!importedConfigs.isEmpty())
+        write = true;
+
     QSettings *s = Core::ICore::settings();
     s->beginGroup(Constants::SETTINGS_ID);
     m_clangTidyExecutable = s->value(clangTidyExecutableKey).toString();
     m_clazyStandaloneExecutable = s->value(clazyStandaloneExecutableKey).toString();
-
-    bool write = false;
+    m_diagnosticConfigs.append(diagnosticConfigsFromSettings(s));
 
     QVariantMap map;
     if (!s->value(oldDiagnosticConfigIdKey).isNull()) {
@@ -128,6 +172,7 @@ void ClangToolsSettings::writeSettings()
 
     s->setValue(clangTidyExecutableKey, m_clangTidyExecutable);
     s->setValue(clazyStandaloneExecutableKey, m_clazyStandaloneExecutable);
+    diagnosticConfigsToSettings(s, m_diagnosticConfigs);
 
     QVariantMap map;
     m_runSettings.toMap(map);
@@ -135,6 +180,8 @@ void ClangToolsSettings::writeSettings()
         s->setValue(it.key(), it.value());
 
     s->endGroup();
+
+    emit changed();
 }
 
 } // namespace Internal
diff --git a/src/plugins/clangtools/clangtoolssettings.h b/src/plugins/clangtools/clangtoolssettings.h
index 893dbd23f9..36da00d293 100644
--- a/src/plugins/clangtools/clangtoolssettings.h
+++ b/src/plugins/clangtools/clangtoolssettings.h
@@ -26,7 +26,9 @@
 #pragma once
 
 #include <coreplugin/id.h>
+#include <cpptools/clangdiagnosticconfig.h>
 
+#include <QObject>
 #include <QString>
 
 namespace ClangTools {
@@ -44,6 +46,7 @@ public:
 
     Core::Id diagnosticConfigId() const { return m_diagnosticConfigId; }
     void setDiagnosticConfigId(const Core::Id &id) { m_diagnosticConfigId = id; }
+    void resetDiagnosticConfigId();
 
     bool buildBeforeAnalysis() const { return m_buildBeforeAnalysis; }
     void setBuildBeforeAnalysis(bool yesno) { m_buildBeforeAnalysis = yesno; }
@@ -52,13 +55,15 @@ public:
     void setParallelJobs(int jobs) { m_parallelJobs = jobs; }
 
 private:
-    Core::Id m_diagnosticConfigId = "Builtin.TidyAndClazy"; // TODO
+    Core::Id m_diagnosticConfigId;
     int m_parallelJobs = -1;
     bool m_buildBeforeAnalysis = true;
 };
 
-class ClangToolsSettings
+class ClangToolsSettings : public QObject
 {
+    Q_OBJECT
+
 public:
     static ClangToolsSettings *instance();
     void writeSettings();
@@ -69,9 +74,16 @@ public:
     QString clazyStandaloneExecutable() const { return m_clazyStandaloneExecutable; }
     void setClazyStandaloneExecutable(const QString &path) { m_clazyStandaloneExecutable = path; }
 
+    CppTools::ClangDiagnosticConfigs diagnosticConfigs() const { return m_diagnosticConfigs; }
+    void setDiagnosticConfigs(const CppTools::ClangDiagnosticConfigs &configs)
+    { m_diagnosticConfigs = configs; }
+
     RunSettings runSettings() const { return m_runSettings; }
     void setRunSettings(const RunSettings &settings) { m_runSettings = settings; }
 
+signals:
+    void changed();
+
 private:
     ClangToolsSettings();
     void readSettings();
@@ -80,6 +92,9 @@ private:
     QString m_clangTidyExecutable;
     QString m_clazyStandaloneExecutable;
 
+    // Diagnostic Configs
+    CppTools::ClangDiagnosticConfigs m_diagnosticConfigs;
+
     // Run settings
     RunSettings m_runSettings;
 };
diff --git a/src/plugins/clangtools/clangtoolsunittests.cpp b/src/plugins/clangtools/clangtoolsunittests.cpp
index d0a48f4bc9..609d666ed5 100644
--- a/src/plugins/clangtools/clangtoolsunittests.cpp
+++ b/src/plugins/clangtools/clangtoolsunittests.cpp
@@ -31,10 +31,10 @@
 #include "clangtoolsutils.h"
 
 #include <coreplugin/icore.h>
-#include <cpptools/cppcodemodelsettings.h>
+#include <cpptools/clangdiagnosticconfig.h>
 #include <cpptools/cppmodelmanager.h>
-#include <cpptools/cpptoolstestcase.h>
 #include <cpptools/cpptoolsreuse.h>
+#include <cpptools/cpptoolstestcase.h>
 #include <projectexplorer/kitinformation.h>
 #include <projectexplorer/kitmanager.h>
 #include <projectexplorer/projectexplorer.h>
@@ -62,8 +62,8 @@ void ClangToolsUnitTests::initTestCase()
     const QList<Kit *> allKits = KitManager::kits();
     if (allKits.count() != 1)
         QSKIP("This test requires exactly one kit to be present");
-    const ToolChain * const toolchain = ToolChainKitAspect::toolChain(allKits.first(),
-                                                                           Constants::CXX_LANGUAGE_ID);
+    const ToolChain *const toolchain = ToolChainKitAspect::toolChain(allKits.first(),
+                                                                     Constants::CXX_LANGUAGE_ID);
     if (!toolchain)
         QSKIP("This test requires that there is a kit with a toolchain.");
 
@@ -110,25 +110,11 @@ void ClangToolsUnitTests::testProject()
     Tests::ProjectOpenerAndCloser projectManager;
     const ProjectInfo projectInfo = projectManager.open(projectFilePath, true);
     QVERIFY(projectInfo.isValid());
-    ClangTool *tool = ClangTool::instance();
-
-    // Change configs
-    QSharedPointer<CppCodeModelSettings> cppToolsSettings = codeModelSettings();
-    ClangToolsSettings *clangToolsSettings = ClangToolsSettings::instance();
-    const ClangDiagnosticConfigs originalConfigs = cppToolsSettings->clangCustomDiagnosticConfigs();
 
-    ClangDiagnosticConfigs modifiedConfigs = originalConfigs;
-    modifiedConfigs.push_back(diagnosticConfig);
-
-    ExecuteOnDestruction restoreCustomConfigs([=]() {
-        cppToolsSettings->setClangCustomDiagnosticConfigs(originalConfigs);
-    });
-
-    cppToolsSettings->setClangCustomDiagnosticConfigs(modifiedConfigs);
-    RunSettings runSettings = clangToolsSettings->runSettings();
-    runSettings.setDiagnosticConfigId(diagnosticConfig.id());
-
-    tool->startTool(runSettings, ClangTool::FileSelection::AllFiles);
+    ClangTool *tool = ClangTool::instance();
+    tool->startTool(ClangTool::FileSelection::AllFiles,
+                    ClangToolsSettings::instance()->runSettings(),
+                    diagnosticConfig);
     QSignalSpy waiter(tool, SIGNAL(finished(bool)));
     QVERIFY(waiter.wait(30000));
 
diff --git a/src/plugins/clangtools/clangtoolsutils.cpp b/src/plugins/clangtools/clangtoolsutils.cpp
index acb87f5ec1..4d3c106cc7 100644
--- a/src/plugins/clangtools/clangtoolsutils.cpp
+++ b/src/plugins/clangtools/clangtoolsutils.cpp
@@ -31,7 +31,7 @@
 #include "clangtoolssettings.h"
 
 #include <coreplugin/icore.h>
-
+#include <cpptools/cpptoolsreuse.h>
 #include <projectexplorer/projectexplorerconstants.h>
 
 #include <utils/checkablemessagebox.h>
@@ -39,9 +39,12 @@
 #include <utils/hostosinfo.h>
 #include <utils/synchronousprocess.h>
 
-#include <QCoreApplication>
 #include <QFileInfo>
-#include <QRegularExpression>
+
+#include <cpptools/clangdiagnosticconfigsmodel.h>
+#include <cpptools/clangdiagnosticconfigsmodel.h>
+
+using namespace CppTools;
 
 namespace ClangTools {
 namespace Internal {
@@ -151,7 +154,83 @@ QString clazyStandaloneExecutable()
         shippedClazyStandaloneExecutable(),
         qEnvironmentVariable("QTC_USE_CLAZY_STANDALONE_PATH"),
         Constants::CLAZY_STANDALONE_EXECUTABLE_NAME,
+                               });
+}
+
+constexpr const char *DEFAULT_TIDY_CHECKS = "-*,"
+                                            "bugprone-*,"
+                                            "cppcoreguidelines-*,"
+                                            "misc-*,"
+                                            "modernize-*,"
+                                            "performance-*,"
+                                            "readability-*,"
+                                            "-cppcoreguidelines-owning-memory,"
+                                            "-readability-braces-around-statements,"
+                                            "-readability-implicit-bool-conversion,"
+                                            "-readability-named-parameter";
+
+static void addBuiltinConfigs(ClangDiagnosticConfigsModel &model)
+{
+    // Clang-Tidy
+    ClangDiagnosticConfig config;
+    config.setId("Builtin.Tidy");
+    config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
+                                                      "Clang-Tidy thorough checks"));
+    config.setIsReadOnly(true);
+    config.setClangOptions(QStringList{QStringLiteral("-w")});
+    config.setClangTidyMode(ClangDiagnosticConfig::TidyMode::ChecksPrefixList);
+    config.setClangTidyChecks(QString::fromUtf8(DEFAULT_TIDY_CHECKS));
+    model.appendOrUpdate(config);
+
+    // Clang static analyzer
+    config = ClangDiagnosticConfig();
+    config.setId("Builtin.TidyClangAnalyze");
+    config.setDisplayName(QCoreApplication::translate(
+                              "ClangDiagnosticConfigsModel",
+                              "Clang-Tidy static analyzer checks"));
+    config.setIsReadOnly(true);
+    config.setClangOptions(QStringList{
+        QStringLiteral("-w"),
     });
+    config.setClangTidyMode(ClangDiagnosticConfig::TidyMode::ChecksPrefixList);
+    config.setClangTidyChecks("-*,clang-analyzer-*");
+    model.appendOrUpdate(config);
+
+    // Clazy
+    config = ClangDiagnosticConfig();
+    config.setId("Builtin.Clazy");
+    config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
+                                                      "Clazy level0 checks"));
+    config.setIsReadOnly(true);
+    config.setClangOptions(QStringList{QStringLiteral("-w")});
+    config.setClazyChecks(CppTools::clazyChecksForLevel(0));
+    model.appendOrUpdate(config);
+
+    // Clang-Tidy and Clazy
+    config = ClangDiagnosticConfig();
+    config.setId(Constants::DIAG_CONFIG_TIDY_AND_CLAZY);
+    config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
+                                                      "Clang-Tidy and Clazy preselected checks"));
+    config.setIsReadOnly(true);
+    config.setClangOptions(QStringList{QStringLiteral("-w")});
+    config.setClangTidyMode(ClangDiagnosticConfig::TidyMode::ChecksPrefixList);
+    config.setClangTidyChecks(QString::fromUtf8(DEFAULT_TIDY_CHECKS));
+    config.setClazyChecks(clazyChecksForLevel(0));
+    model.appendOrUpdate(config);
+}
+
+ClangDiagnosticConfigsModel diagnosticConfigsModel(const ClangDiagnosticConfigs &customConfigs)
+{
+    ClangDiagnosticConfigsModel model;
+    addBuiltinConfigs(model);
+    for (const ClangDiagnosticConfig &config : customConfigs)
+        model.appendOrUpdate(config);
+    return model;
+}
+
+ClangDiagnosticConfigsModel diagnosticConfigsModel()
+{
+    return Internal::diagnosticConfigsModel(ClangToolsSettings::instance()->diagnosticConfigs());
 }
 
 } // namespace Internal
diff --git a/src/plugins/clangtools/clangtoolsutils.h b/src/plugins/clangtools/clangtoolsutils.h
index a7ae9620de..d0b4829725 100644
--- a/src/plugins/clangtools/clangtoolsutils.h
+++ b/src/plugins/clangtools/clangtoolsutils.h
@@ -26,6 +26,7 @@
 #pragma once
 
 #include <coreplugin/id.h>
+#include <cpptools/clangdiagnosticconfig.h>
 
 #include <QVersionNumber>
 #include <QtGlobal>
@@ -34,6 +35,7 @@ QT_BEGIN_NAMESPACE
 class QString;
 QT_END_NAMESPACE
 
+namespace CppTools { class ClangDiagnosticConfigsModel; }
 namespace Debugger { class DiagnosticLocation; }
 
 namespace ClangTools {
@@ -52,5 +54,9 @@ QString clazyStandaloneExecutable();
 QString shippedClangTidyExecutable();
 QString clangTidyExecutable();
 
+CppTools::ClangDiagnosticConfigsModel diagnosticConfigsModel();
+CppTools::ClangDiagnosticConfigsModel diagnosticConfigsModel(
+    const CppTools::ClangDiagnosticConfigs &customConfigs);
+
 } // namespace Internal
 } // namespace ClangTools
diff --git a/src/plugins/clangtools/runsettingswidget.cpp b/src/plugins/clangtools/runsettingswidget.cpp
index 1a26d2e7d0..381d29ea19 100644
--- a/src/plugins/clangtools/runsettingswidget.cpp
+++ b/src/plugins/clangtools/runsettingswidget.cpp
@@ -40,14 +40,6 @@ RunSettingsWidget::RunSettingsWidget(QWidget *parent)
     , m_ui(new Ui::RunSettingsWidget)
 {
     m_ui->setupUi(this);
-
-    connect(m_ui->diagnosticWidget,
-            &CppTools::ClangDiagnosticConfigsSelectionWidget::currentConfigChanged,
-            [this](const Core::Id &) { emit changed(); });
-    // m_ui->buildBeforeAnalysis is handled in fromSettings()
-    connect(m_ui->parallelJobsSpinBox,
-            QOverload<int>::of(&QSpinBox::valueChanged),
-            [this](int) { emit changed(); });
 }
 
 RunSettingsWidget::~RunSettingsWidget()
@@ -57,7 +49,17 @@ RunSettingsWidget::~RunSettingsWidget()
 
 void RunSettingsWidget::fromSettings(const RunSettings &s)
 {
-    m_ui->diagnosticWidget->refresh(s.diagnosticConfigId());
+    disconnect(m_ui->diagnosticWidget, 0, 0, 0);
+    m_ui->diagnosticWidget->refresh(diagnosticConfigsModel(),
+                                    s.diagnosticConfigId(),
+                                    /*showTidyClazyUi=*/true);
+    connect(m_ui->diagnosticWidget,
+            &CppTools::ClangDiagnosticConfigsSelectionWidget::diagnosticConfigsEdited,
+            this,
+            &RunSettingsWidget::diagnosticConfigsEdited);
+    connect(m_ui->diagnosticWidget,
+            &CppTools::ClangDiagnosticConfigsSelectionWidget::currentConfigChanged,
+            [this](const Core::Id &) { emit changed(); });
 
     disconnect(m_ui->buildBeforeAnalysis, 0, 0, 0);
     m_ui->buildBeforeAnalysis->setToolTip(hintAboutBuildBeforeAnalysis());
@@ -68,9 +70,13 @@ void RunSettingsWidget::fromSettings(const RunSettings &s)
         emit changed();
     });
 
+    disconnect(m_ui->parallelJobsSpinBox, 0, 0, 0);
     m_ui->parallelJobsSpinBox->setValue(s.parallelJobs());
     m_ui->parallelJobsSpinBox->setMinimum(1);
     m_ui->parallelJobsSpinBox->setMaximum(QThread::idealThreadCount());
+    connect(m_ui->parallelJobsSpinBox,
+            QOverload<int>::of(&QSpinBox::valueChanged),
+            [this](int) { emit changed(); });
 }
 
 RunSettings RunSettingsWidget::toSettings() const
diff --git a/src/plugins/clangtools/runsettingswidget.h b/src/plugins/clangtools/runsettingswidget.h
index c49bc88f75..615348c38a 100644
--- a/src/plugins/clangtools/runsettingswidget.h
+++ b/src/plugins/clangtools/runsettingswidget.h
@@ -25,6 +25,8 @@
 
 #pragma once
 
+#include <cpptools/clangdiagnosticconfig.h>
+
 #include <QWidget>
 
 namespace ClangTools {
@@ -48,6 +50,7 @@ public:
     RunSettings toSettings() const;
 
 signals:
+    void diagnosticConfigsEdited(const CppTools::ClangDiagnosticConfigs &configs);
     void changed();
 
 private:
diff --git a/src/plugins/clangtools/settingswidget.cpp b/src/plugins/clangtools/settingswidget.cpp
index 110135a779..ba619b9f45 100644
--- a/src/plugins/clangtools/settingswidget.cpp
+++ b/src/plugins/clangtools/settingswidget.cpp
@@ -30,6 +30,10 @@
 #include "clangtoolsconstants.h"
 #include "clangtoolsutils.h"
 
+#include <cpptools/clangdiagnosticconfigsmodel.h>
+
+#include <utils/optional.h>
+
 namespace ClangTools {
 namespace Internal {
 
@@ -101,6 +105,21 @@ SettingsWidget::SettingsWidget(ClangToolsSettings *settings, QWidget *parent)
     //
 
     m_ui->runSettingsWidget->fromSettings(m_settings->runSettings());
+    connect(m_ui->runSettingsWidget,
+            &RunSettingsWidget::diagnosticConfigsEdited,
+            this,
+            [this](const CppTools::ClangDiagnosticConfigs &configs) {
+                const CppTools::ClangDiagnosticConfigsModel configsModel = diagnosticConfigsModel(
+                    configs);
+                RunSettings runSettings = m_settings->runSettings();
+                if (!configsModel.hasConfigWithId(m_settings->runSettings().diagnosticConfigId())) {
+                    runSettings.resetDiagnosticConfigId();
+                    m_settings->setRunSettings(runSettings);
+                }
+                m_settings->setDiagnosticConfigs(configs);
+                m_settings->writeSettings();
+                m_ui->runSettingsWidget->fromSettings(runSettings);
+            });
 }
 
 void SettingsWidget::apply()
diff --git a/src/plugins/cpptools/clangdiagnosticconfig.cpp b/src/plugins/cpptools/clangdiagnosticconfig.cpp
index b254250e42..d8c6353e2c 100644
--- a/src/plugins/cpptools/clangdiagnosticconfig.cpp
+++ b/src/plugins/cpptools/clangdiagnosticconfig.cpp
@@ -24,6 +24,11 @@
 ****************************************************************************/
 
 #include "clangdiagnosticconfig.h"
+#include "cpptoolsreuse.h"
+
+#include <utils/qtcassert.h>
+
+#include <QSettings>
 
 namespace CppTools {
 
@@ -124,4 +129,73 @@ void ClangDiagnosticConfig::setClazyChecks(const QString &checks)
     m_clazyChecks = checks;
 }
 
+static QString convertToNewClazyChecksFormat(const QString &checks)
+{
+    // Before Qt Creator 4.9 valid values for checks were: "", "levelN".
+    // 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 checks;
+}
+
+static const char diagnosticConfigsArrayKey[] = "ClangDiagnosticConfigs";
+static const char diagnosticConfigIdKey[] = "id";
+static const char diagnosticConfigDisplayNameKey[] = "displayName";
+static const char diagnosticConfigWarningsKey[] = "diagnosticOptions";
+static const char diagnosticConfigsTidyChecksKey[] = "clangTidyChecks";
+static const char diagnosticConfigsTidyModeKey[] = "clangTidyMode";
+static const char diagnosticConfigsClazyChecksKey[] = "clazyChecks";
+
+void diagnosticConfigsToSettings(QSettings *s, const ClangDiagnosticConfigs &configs)
+{
+    s->beginWriteArray(diagnosticConfigsArrayKey);
+    for (int i = 0, size = configs.size(); i < size; ++i) {
+        const ClangDiagnosticConfig &config = configs.at(i);
+        s->setArrayIndex(i);
+        s->setValue(diagnosticConfigIdKey, config.id().toSetting());
+        s->setValue(diagnosticConfigDisplayNameKey, config.displayName());
+        s->setValue(diagnosticConfigWarningsKey, config.clangOptions());
+        s->setValue(diagnosticConfigsTidyModeKey, int(config.clangTidyMode()));
+        s->setValue(diagnosticConfigsTidyChecksKey,
+                    config.clangTidyChecks());
+        s->setValue(diagnosticConfigsClazyChecksKey, config.clazyChecks());
+    }
+    s->endArray();
+}
+
+ClangDiagnosticConfigs diagnosticConfigsFromSettings(QSettings *s)
+{
+    ClangDiagnosticConfigs configs;
+
+    const int size = s->beginReadArray(diagnosticConfigsArrayKey);
+    for (int i = 0; i < size; ++i) {
+        s->setArrayIndex(i);
+
+        ClangDiagnosticConfig config;
+        config.setId(Core::Id::fromSetting(s->value(diagnosticConfigIdKey)));
+        config.setDisplayName(s->value(diagnosticConfigDisplayNameKey).toString());
+        config.setClangOptions(s->value(diagnosticConfigWarningsKey).toStringList());
+        config.setClangTidyMode(static_cast<ClangDiagnosticConfig::TidyMode>(
+            s->value(diagnosticConfigsTidyModeKey).toInt()));
+        config.setClangTidyChecks(
+            s->value(diagnosticConfigsTidyChecksKey).toString());
+
+        const QString clazyChecks = s->value(diagnosticConfigsClazyChecksKey).toString();
+        config.setClazyChecks(convertToNewClazyChecksFormat(clazyChecks));
+        configs.append(config);
+    }
+    s->endArray();
+
+    return configs;
+}
+
 } // namespace CppTools
diff --git a/src/plugins/cpptools/clangdiagnosticconfig.h b/src/plugins/cpptools/clangdiagnosticconfig.h
index bb3af15e0e..0dc55e18e9 100644
--- a/src/plugins/cpptools/clangdiagnosticconfig.h
+++ b/src/plugins/cpptools/clangdiagnosticconfig.h
@@ -32,8 +32,13 @@
 #include <QStringList>
 #include <QVector>
 
+QT_BEGIN_NAMESPACE
+class QSettings;
+QT_END_NAMESPACE
+
 namespace CppTools {
 
+// TODO: Split this class as needed for ClangCodeModel and ClangTools
 class CPPTOOLS_EXPORT ClangDiagnosticConfig
 {
 public:
@@ -84,4 +89,8 @@ private:
 
 using ClangDiagnosticConfigs = QVector<ClangDiagnosticConfig>;
 
+ClangDiagnosticConfigs CPPTOOLS_EXPORT diagnosticConfigsFromSettings(QSettings *s);
+void CPPTOOLS_EXPORT diagnosticConfigsToSettings(QSettings *s,
+                                                 const ClangDiagnosticConfigs &configs);
+
 } // namespace CppTools
diff --git a/src/plugins/cpptools/clangdiagnosticconfigsmodel.cpp b/src/plugins/cpptools/clangdiagnosticconfigsmodel.cpp
index 236bcfde20..9a47c3d2f9 100644
--- a/src/plugins/cpptools/clangdiagnosticconfigsmodel.cpp
+++ b/src/plugins/cpptools/clangdiagnosticconfigsmodel.cpp
@@ -35,161 +35,9 @@
 
 namespace CppTools {
 
-static void addConfigForQuestionableConstructs(ClangDiagnosticConfigsModel &model)
+ClangDiagnosticConfigsModel::ClangDiagnosticConfigsModel(const ClangDiagnosticConfigs &configs)
 {
-    ClangDiagnosticConfig config;
-    config.setId("Builtin.Questionable");
-    config.setDisplayName(QCoreApplication::translate(
-                              "ClangDiagnosticConfigsModel",
-                              "Clang-only checks for questionable constructs"));
-    config.setIsReadOnly(true);
-    config.setClangOptions(QStringList{
-        QStringLiteral("-Wall"),
-        QStringLiteral("-Wextra"),
-    });
-
-    model.appendOrUpdate(config);
-}
-
-static void addConfigForPedanticWarnings(ClangDiagnosticConfigsModel &model)
-{
-    ClangDiagnosticConfig config;
-    config.setId("Builtin.Pedantic");
-    config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
-                                                      "Clang-only pedantic checks"));
-    config.setIsReadOnly(true);
-    config.setClangOptions(QStringList{QStringLiteral("-Wpedantic")});
-
-    model.appendOrUpdate(config);
-}
-
-constexpr const char *DEFAULT_TIDY_CHECKS = "-*,"
-                                            "bugprone-*,"
-                                            "cppcoreguidelines-*,"
-                                            "misc-*,"
-                                            "modernize-*,"
-                                            "performance-*,"
-                                            "readability-*,"
-                                            "-cppcoreguidelines-owning-memory,"
-                                            "-readability-braces-around-statements,"
-                                            "-readability-implicit-bool-conversion,"
-                                            "-readability-named-parameter";
-
-static void addConfigForAlmostEveryWarning(ClangDiagnosticConfigsModel &model)
-{
-    ClangDiagnosticConfig config;
-    config.setId(Constants::CPP_CLANG_BUILTIN_CONFIG_ID_EVERYTHING_WITH_EXCEPTIONS);
-    config.setDisplayName(QCoreApplication::translate(
-                              "ClangDiagnosticConfigsModel",
-                              "Clang-only checks for almost everything"));
-    config.setIsReadOnly(true);
-    config.setClangOptions(QStringList{
-        QStringLiteral("-Weverything"),
-        QStringLiteral("-Wno-c++98-compat"),
-        QStringLiteral("-Wno-c++98-compat-pedantic"),
-        QStringLiteral("-Wno-unused-macros"),
-        QStringLiteral("-Wno-newline-eof"),
-        QStringLiteral("-Wno-exit-time-destructors"),
-        QStringLiteral("-Wno-global-constructors"),
-        QStringLiteral("-Wno-gnu-zero-variadic-macro-arguments"),
-        QStringLiteral("-Wno-documentation"),
-        QStringLiteral("-Wno-shadow"),
-        QStringLiteral("-Wno-switch-enum"),
-        QStringLiteral("-Wno-missing-prototypes"), // Not optimal for C projects.
-        QStringLiteral("-Wno-used-but-marked-unused"), // e.g. QTest::qWait
-    });
-
-    model.appendOrUpdate(config);
-}
-
-static void addConfigForTidy(ClangDiagnosticConfigsModel &model)
-{
-    ClangDiagnosticConfig config;
-    config.setId("Builtin.Tidy");
-    config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
-                                                      "Clang-Tidy thorough checks"));
-    config.setIsReadOnly(true);
-    config.setClangOptions(QStringList{QStringLiteral("-w")});
-    config.setClangTidyMode(ClangDiagnosticConfig::TidyMode::ChecksPrefixList);
-    config.setClangTidyChecks(QString::fromUtf8(DEFAULT_TIDY_CHECKS));
-
-    model.appendOrUpdate(config);
-}
-
-static void addConfigForClangAnalyze(ClangDiagnosticConfigsModel &model)
-{
-    ClangDiagnosticConfig config;
-    config.setId("Builtin.TidyClangAnalyze");
-    config.setDisplayName(QCoreApplication::translate(
-                              "ClangDiagnosticConfigsModel",
-                              "Clang-Tidy static analyzer checks"));
-    config.setIsReadOnly(true);
-    config.setClangOptions(QStringList{
-        QStringLiteral("-w"),
-    });
-    config.setClangTidyMode(ClangDiagnosticConfig::TidyMode::ChecksPrefixList);
-    config.setClangTidyChecks("-*,clang-analyzer-*");
-
-    model.appendOrUpdate(config);
-}
-
-static void addConfigForClazy(ClangDiagnosticConfigsModel &model)
-{
-    ClangDiagnosticConfig config;
-    config.setId("Builtin.Clazy");
-    config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
-                                                      "Clazy level0 checks"));
-    config.setIsReadOnly(true);
-    config.setClangOptions(QStringList{QStringLiteral("-w")});
-    config.setClazyChecks(clazyChecksForLevel(0));
-
-    model.appendOrUpdate(config);
-}
-
-static void addConfigForTidyAndClazy(ClangDiagnosticConfigsModel &model)
-{
-    ClangDiagnosticConfig config;
-    config.setId("Builtin.TidyAndClazy");
-    config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
-                                                      "Clang-Tidy and Clazy preselected checks"));
-    config.setIsReadOnly(true);
-    config.setClangOptions(QStringList{QStringLiteral("-w")});
-    config.setClangTidyMode(ClangDiagnosticConfig::TidyMode::ChecksPrefixList);
-
-    config.setClangTidyChecks(QString::fromUtf8(DEFAULT_TIDY_CHECKS));
-    config.setClazyChecks(clazyChecksForLevel(0));
-
-    model.appendOrUpdate(config);
-}
-
-static void addConfigForBuildSystem(ClangDiagnosticConfigsModel &model)
-{
-    ClangDiagnosticConfig config;
-    config.setId("Builtin.BuildSystem");
-    config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
-                                                      "Build-system warnings"));
-    config.setIsReadOnly(true);
-    config.setUseBuildSystemWarnings(true);
-
-    model.appendOrUpdate(config);
-}
-
-static void addBuiltinConfigs(ClangDiagnosticConfigsModel &model)
-{
-    addConfigForPedanticWarnings(model);
-    addConfigForQuestionableConstructs(model);
-    addConfigForAlmostEveryWarning(model);
-    addConfigForTidy(model);
-    addConfigForClangAnalyze(model);
-    addConfigForClazy(model);
-    addConfigForTidyAndClazy(model);
-    addConfigForBuildSystem(model);
-}
-
-ClangDiagnosticConfigsModel::ClangDiagnosticConfigsModel(const ClangDiagnosticConfigs &customConfigs)
-{
-    addBuiltinConfigs(*this);
-    m_diagnosticConfigs.append(customConfigs);
+    m_diagnosticConfigs.append(configs);
 }
 
 int ClangDiagnosticConfigsModel::size() const
diff --git a/src/plugins/cpptools/clangdiagnosticconfigsmodel.h b/src/plugins/cpptools/clangdiagnosticconfigsmodel.h
index ada373bcdb..dab70f0bd7 100644
--- a/src/plugins/cpptools/clangdiagnosticconfigsmodel.h
+++ b/src/plugins/cpptools/clangdiagnosticconfigsmodel.h
@@ -37,7 +37,7 @@ class CPPTOOLS_EXPORT ClangDiagnosticConfigsModel
 {
 public:
     ClangDiagnosticConfigsModel() = default;
-    explicit ClangDiagnosticConfigsModel(const ClangDiagnosticConfigs &customConfigs);
+    explicit ClangDiagnosticConfigsModel(const ClangDiagnosticConfigs &configs);
 
     int size() const;
     const ClangDiagnosticConfig &at(int index) const;
diff --git a/src/plugins/cpptools/clangdiagnosticconfigsselectionwidget.cpp b/src/plugins/cpptools/clangdiagnosticconfigsselectionwidget.cpp
index 217ca95cb2..29491c9126 100644
--- a/src/plugins/cpptools/clangdiagnosticconfigsselectionwidget.cpp
+++ b/src/plugins/cpptools/clangdiagnosticconfigsselectionwidget.cpp
@@ -49,14 +49,23 @@ ClangDiagnosticConfigsSelectionWidget::ClangDiagnosticConfigsSelectionWidget(QWi
     setLayout(layout);
     layout->addWidget(m_label);
     layout->addWidget(m_selectionComboBox, 1);
-    auto *manageButton = new QPushButton(tr("Manage..."), this);
-    layout->addWidget(manageButton);
+    m_manageButton = new QPushButton(tr("Manage..."), this);
+    layout->addWidget(m_manageButton);
     layout->addStretch();
+}
 
-    connectToClangDiagnosticConfigsDialog(manageButton);
+void ClangDiagnosticConfigsSelectionWidget::refresh(const ClangDiagnosticConfigsModel &model,
+                                                    const Core::Id &configToSelect,
+                                                    bool showTidyClazyUi)
+{
+    m_showTidyClazyUi = showTidyClazyUi;
+    m_diagnosticConfigsModel = model;
 
-    refresh(codeModelSettings()->clangDiagnosticConfigId());
+    disconnect(m_manageButton, 0, 0, 0);
+    connectToClangDiagnosticConfigsDialog();
 
+    disconnectFromCurrentIndexChanged();
+    refresh(configToSelect);
     connectToCurrentIndexChanged();
 }
 
@@ -83,8 +92,6 @@ void ClangDiagnosticConfigsSelectionWidget::refresh(Core::Id id)
 
     int configToSelectIndex = -1;
     m_selectionComboBox->clear();
-    m_diagnosticConfigsModel = ClangDiagnosticConfigsModel(
-                codeModelSettings()->clangCustomDiagnosticConfigs());
     const int size = m_diagnosticConfigsModel.size();
     for (int i = 0; i < size; ++i) {
         const ClangDiagnosticConfig &config = m_diagnosticConfigsModel.at(i);
@@ -104,10 +111,13 @@ void ClangDiagnosticConfigsSelectionWidget::refresh(Core::Id id)
     connectToCurrentIndexChanged();
 }
 
-void ClangDiagnosticConfigsSelectionWidget::connectToClangDiagnosticConfigsDialog(QPushButton *button)
+void ClangDiagnosticConfigsSelectionWidget::connectToClangDiagnosticConfigsDialog()
 {
-    connect(button, &QPushButton::clicked, [this]() {
-        ClangDiagnosticConfigsWidget *widget = new ClangDiagnosticConfigsWidget(currentConfigId());
+    connect(m_manageButton, &QPushButton::clicked, [this]() {
+        ClangDiagnosticConfigsWidget *widget
+            = new ClangDiagnosticConfigsWidget(m_diagnosticConfigsModel,
+                                               currentConfigId(),
+                                               m_showTidyClazyUi);
         widget->layout()->setContentsMargins(0, 0, 0, 0);
         QDialog dialog;
         dialog.setWindowTitle(ClangDiagnosticConfigsWidget::tr("Diagnostic Configurations"));
@@ -119,19 +129,10 @@ void ClangDiagnosticConfigsSelectionWidget::connectToClangDiagnosticConfigsDialo
         connect(buttonsBox, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
 
         const bool previousEnableLowerClazyLevels = codeModelSettings()->enableLowerClazyLevels();
-        connect(&dialog, &QDialog::accepted, [widget, previousEnableLowerClazyLevels]() {
-            QSharedPointer<CppCodeModelSettings> settings = codeModelSettings();
-            const ClangDiagnosticConfigs oldDiagnosticConfigs
-                    = settings->clangCustomDiagnosticConfigs();
-            const ClangDiagnosticConfigs currentDiagnosticConfigs = widget->customConfigs();
-            if (oldDiagnosticConfigs != currentDiagnosticConfigs
-                 || previousEnableLowerClazyLevels != codeModelSettings()->enableLowerClazyLevels()) {
-                const ClangDiagnosticConfigsModel configsModel(currentDiagnosticConfigs);
-                if (!configsModel.hasConfigWithId(settings->clangDiagnosticConfigId()))
-                    settings->resetClangDiagnosticConfigId();
-                settings->setClangCustomDiagnosticConfigs(currentDiagnosticConfigs);
-                settings->toSettings(Core::ICore::settings());
-            }
+        connect(&dialog, &QDialog::accepted, [this, widget, previousEnableLowerClazyLevels]() {
+            if (previousEnableLowerClazyLevels != codeModelSettings()->enableLowerClazyLevels())
+                codeModelSettings()->toSettings(Core::ICore::settings());
+            emit diagnosticConfigsEdited(widget->customConfigs());
         });
         dialog.exec();
     });
diff --git a/src/plugins/cpptools/clangdiagnosticconfigsselectionwidget.h b/src/plugins/cpptools/clangdiagnosticconfigsselectionwidget.h
index da82789c75..d3e5badd27 100644
--- a/src/plugins/cpptools/clangdiagnosticconfigsselectionwidget.h
+++ b/src/plugins/cpptools/clangdiagnosticconfigsselectionwidget.h
@@ -46,22 +46,29 @@ class CPPTOOLS_EXPORT ClangDiagnosticConfigsSelectionWidget : public QWidget
 public:
     explicit ClangDiagnosticConfigsSelectionWidget(QWidget *parent = nullptr);
 
-    Core::Id currentConfigId() const;
+    void refresh(const ClangDiagnosticConfigsModel &model,
+                 const Core::Id &configToSelect,
+                 bool showTidyClazyUi);
 
-    void refresh(Core::Id id);
+    Core::Id currentConfigId() const;
 
 signals:
+    void diagnosticConfigsEdited(const ClangDiagnosticConfigs &configs);
     void currentConfigChanged(const Core::Id &currentConfigId);
 
 private:
-    void connectToClangDiagnosticConfigsDialog(QPushButton *button);
+    void connectToClangDiagnosticConfigsDialog();
     void connectToCurrentIndexChanged();
     void disconnectFromCurrentIndexChanged();
 
+    void refresh(Core::Id id);
+
     QMetaObject::Connection m_currentIndexChangedConnection;
+    bool m_showTidyClazyUi = true;
     ClangDiagnosticConfigsModel m_diagnosticConfigsModel;
 
     QLabel *m_label = nullptr;
+    QPushButton *m_manageButton = nullptr;
     QComboBox *m_selectionComboBox = nullptr;
 };
 
diff --git a/src/plugins/cpptools/clangdiagnosticconfigswidget.cpp b/src/plugins/cpptools/clangdiagnosticconfigswidget.cpp
index 58589a5308..5736c28641 100644
--- a/src/plugins/cpptools/clangdiagnosticconfigswidget.cpp
+++ b/src/plugins/cpptools/clangdiagnosticconfigswidget.cpp
@@ -568,19 +568,19 @@ private:
     QStringList m_topics;
 };
 
-ClangDiagnosticConfigsWidget::ClangDiagnosticConfigsWidget(const Core::Id &configToSelect,
-                                                           QWidget *parent)
+ClangDiagnosticConfigsWidget::ClangDiagnosticConfigsWidget(
+    const ClangDiagnosticConfigsModel &configsModel,
+    const Core::Id &configToSelect,
+    bool showTidyClazyTabs,
+    QWidget *parent)
     : QWidget(parent)
     , m_ui(new Ui::ClangDiagnosticConfigsWidget)
-    , m_diagnosticConfigsModel(codeModelSettings()->clangCustomDiagnosticConfigs())
+    , m_diagnosticConfigsModel(configsModel)
     , m_clazyTreeModel(new ClazyChecksTreeModel())
     , m_tidyTreeModel(new TidyChecksTreeModel())
 {
     m_ui->setupUi(this);
-    setupTabs();
-
-    m_selectedConfigIndex = m_diagnosticConfigsModel.indexOfConfig(
-                codeModelSettings()->clangDiagnosticConfigId());
+    setupTabs(showTidyClazyTabs);
 
     connectConfigChooserCurrentIndex();
     connect(m_ui->copyButton, &QPushButton::clicked,
@@ -989,7 +989,7 @@ static void setupTreeView(QTreeView *view, QAbstractItemModel *model, int expand
     view->setHeaderHidden(true);
 }
 
-void ClangDiagnosticConfigsWidget::setupTabs()
+void ClangDiagnosticConfigsWidget::setupTabs(bool showTidyClazyTabs)
 {
     m_clangBaseChecks = std::make_unique<CppTools::Ui::ClangBaseChecks>();
     m_clangBaseChecksWidget = new QWidget();
@@ -1075,8 +1075,10 @@ void ClangDiagnosticConfigsWidget::setupTabs()
     connectClazyItemChanged();
 
     m_ui->tabWidget->addTab(m_clangBaseChecksWidget, tr("Clang"));
-    m_ui->tabWidget->addTab(m_tidyChecksWidget, tr("Clang-Tidy"));
-    m_ui->tabWidget->addTab(m_clazyChecksWidget, tr("Clazy"));
+    if (showTidyClazyTabs) {
+        m_ui->tabWidget->addTab(m_tidyChecksWidget, tr("Clang-Tidy"));
+        m_ui->tabWidget->addTab(m_clazyChecksWidget, tr("Clazy"));
+    }
     m_ui->tabWidget->setCurrentIndex(0);
 }
 
diff --git a/src/plugins/cpptools/clangdiagnosticconfigswidget.h b/src/plugins/cpptools/clangdiagnosticconfigswidget.h
index 39d733cea5..412170ba59 100644
--- a/src/plugins/cpptools/clangdiagnosticconfigswidget.h
+++ b/src/plugins/cpptools/clangdiagnosticconfigswidget.h
@@ -58,7 +58,10 @@ class CPPTOOLS_EXPORT ClangDiagnosticConfigsWidget : public QWidget
     Q_OBJECT
 
 public:
-    explicit ClangDiagnosticConfigsWidget(const Core::Id &configToSelect, QWidget *parent = nullptr);
+    explicit ClangDiagnosticConfigsWidget(const ClangDiagnosticConfigsModel &configsModel,
+                                          const Core::Id &configToSelect,
+                                          bool showTidyClazyTabs,
+                                          QWidget *parent = nullptr);
     ~ClangDiagnosticConfigsWidget() override;
 
     ClangDiagnosticConfigs customConfigs() const;
@@ -67,7 +70,7 @@ signals:
     void customConfigsChanged(const CppTools::ClangDiagnosticConfigs &customConfigs);
 
 private:
-    void setupTabs();
+    void setupTabs(bool showTidyClazyTabs);
 
     void onCurrentConfigChanged(int index);
     void onCopyButtonClicked();
diff --git a/src/plugins/cpptools/cppcodemodelsettings.cpp b/src/plugins/cpptools/cppcodemodelsettings.cpp
index 2f8d0b3d42..244480c81b 100644
--- a/src/plugins/cpptools/cppcodemodelsettings.cpp
+++ b/src/plugins/cpptools/cppcodemodelsettings.cpp
@@ -44,27 +44,6 @@ static CppCodeModelSettings::PCHUsage initialPchUsage()
 static QString clangDiagnosticConfigKey()
 { return QStringLiteral("ClangDiagnosticConfig"); }
 
-static QString clangDiagnosticConfigsArrayKey()
-{ return QStringLiteral("ClangDiagnosticConfigs"); }
-
-static QString clangDiagnosticConfigsArrayIdKey()
-{ return QLatin1String("id"); }
-
-static QString clangDiagnosticConfigsArrayDisplayNameKey()
-{ return QLatin1String("displayName"); }
-
-static QString clangDiagnosticConfigsArrayWarningsKey()
-{ return QLatin1String("diagnosticOptions"); }
-
-static QString clangDiagnosticConfigsArrayClangTidyChecksKey()
-{ return QLatin1String("clangTidyChecks"); }
-
-static QString clangDiagnosticConfigsArrayClangTidyModeKey()
-{ return QLatin1String("clangTidyMode"); }
-
-static QString clangDiagnosticConfigsArrayClazyChecksKey()
-{ return QLatin1String("clazyChecks"); }
-
 static QString enableLowerClazyLevelsKey()
 { return QLatin1String("enableLowerClazyLevels"); }
 
@@ -80,53 +59,6 @@ static QString skipIndexingBigFilesKey()
 static QString indexerFileSizeLimitKey()
 { return QLatin1String(Constants::CPPTOOLS_INDEXER_FILE_SIZE_LIMIT); }
 
-static QString convertToNewClazyChecksFormat(const QString &checks)
-{
-    // Before Qt Creator 4.9 valid values for checks were: "", "levelN".
-    // 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 checks;
-}
-
-static ClangDiagnosticConfigs customDiagnosticConfigsFromSettings(QSettings *s)
-{
-    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) {
-        s->setArrayIndex(i);
-
-        ClangDiagnosticConfig config;
-        config.setId(Core::Id::fromSetting(s->value(clangDiagnosticConfigsArrayIdKey())));
-        config.setDisplayName(s->value(clangDiagnosticConfigsArrayDisplayNameKey()).toString());
-        config.setClangOptions(s->value(clangDiagnosticConfigsArrayWarningsKey()).toStringList());
-        config.setClangTidyMode(static_cast<ClangDiagnosticConfig::TidyMode>(
-                                    s->value(clangDiagnosticConfigsArrayClangTidyModeKey()).toInt()));
-        config.setClangTidyChecks(
-                    s->value(clangDiagnosticConfigsArrayClangTidyChecksKey()).toString());
-
-        const QString clazyChecks = s->value(clangDiagnosticConfigsArrayClazyChecksKey()).toString();
-        config.setClazyChecks(convertToNewClazyChecksFormat(clazyChecks));
-        configs.append(config);
-    }
-    s->endArray();
-
-    return configs;
-}
-
 static Core::Id clangDiagnosticConfigIdFromSettings(QSettings *s)
 {
     QTC_ASSERT(s->group() == QLatin1String(Constants::CPPTOOLS_SETTINGSGROUP), return Core::Id());
@@ -139,11 +71,12 @@ void CppCodeModelSettings::fromSettings(QSettings *s)
 {
     s->beginGroup(QLatin1String(Constants::CPPTOOLS_SETTINGSGROUP));
 
-    setClangCustomDiagnosticConfigs(customDiagnosticConfigsFromSettings(s));
+    setClangCustomDiagnosticConfigs(diagnosticConfigsFromSettings(s));
     setClangDiagnosticConfigId(clangDiagnosticConfigIdFromSettings(s));
 
     { // Before Qt Creator 4.8, inconsistent settings might have been written.
-        const ClangDiagnosticConfigsModel model(m_clangCustomDiagnosticConfigs);
+        const ClangDiagnosticConfigsModel model = diagnosticConfigsModel(
+            m_clangCustomDiagnosticConfigs);
         if (!model.hasConfigWithId(m_clangDiagnosticConfigId))
             setClangDiagnosticConfigId(initialClangDiagnosticConfigId());
     }
@@ -171,24 +104,10 @@ void CppCodeModelSettings::fromSettings(QSettings *s)
 void CppCodeModelSettings::toSettings(QSettings *s)
 {
     s->beginGroup(QLatin1String(Constants::CPPTOOLS_SETTINGSGROUP));
-    const ClangDiagnosticConfigs previousConfigs = customDiagnosticConfigsFromSettings(s);
+    const ClangDiagnosticConfigs previousConfigs = diagnosticConfigsFromSettings(s);
     const Core::Id previousConfigId = clangDiagnosticConfigIdFromSettings(s);
 
-    s->beginWriteArray(clangDiagnosticConfigsArrayKey());
-    for (int i = 0, size = m_clangCustomDiagnosticConfigs.size(); i < size; ++i) {
-        const ClangDiagnosticConfig &config = m_clangCustomDiagnosticConfigs.at(i);
-
-        s->setArrayIndex(i);
-        s->setValue(clangDiagnosticConfigsArrayIdKey(), config.id().toSetting());
-        s->setValue(clangDiagnosticConfigsArrayDisplayNameKey(), config.displayName());
-        s->setValue(clangDiagnosticConfigsArrayWarningsKey(), config.clangOptions());
-        s->setValue(clangDiagnosticConfigsArrayClangTidyModeKey(),
-                    static_cast<int>(config.clangTidyMode()));
-        s->setValue(clangDiagnosticConfigsArrayClangTidyChecksKey(),
-                    config.clangTidyChecks());
-        s->setValue(clangDiagnosticConfigsArrayClazyChecksKey(), config.clazyChecks());
-    }
-    s->endArray();
+    diagnosticConfigsToSettings(s, m_clangCustomDiagnosticConfigs);
 
     s->setValue(clangDiagnosticConfigKey(), clangDiagnosticConfigId().toSetting());
     s->setValue(enableLowerClazyLevelsKey(), enableLowerClazyLevels());
@@ -229,7 +148,8 @@ void CppCodeModelSettings::resetClangDiagnosticConfigId()
 
 const ClangDiagnosticConfig CppCodeModelSettings::clangDiagnosticConfig() const
 {
-    const ClangDiagnosticConfigsModel configsModel(m_clangCustomDiagnosticConfigs);
+    const ClangDiagnosticConfigsModel configsModel = diagnosticConfigsModel(
+        m_clangCustomDiagnosticConfigs);
 
     return configsModel.configWithId(clangDiagnosticConfigId());
 }
diff --git a/src/plugins/cpptools/cppcodemodelsettingspage.cpp b/src/plugins/cpptools/cppcodemodelsettingspage.cpp
index 0cd52a5228..c700899f00 100644
--- a/src/plugins/cpptools/cppcodemodelsettingspage.cpp
+++ b/src/plugins/cpptools/cppcodemodelsettingspage.cpp
@@ -24,17 +24,15 @@
 ****************************************************************************/
 
 #include "cppcodemodelsettingspage.h"
+#include "ui_cppcodemodelsettingspage.h"
 
 #include "clangdiagnosticconfigswidget.h"
 #include "cppmodelmanager.h"
 #include "cpptoolsconstants.h"
 #include "cpptoolsreuse.h"
-#include "ui_cppcodemodelsettingspage.h"
 
-#include <clangtools/clangtoolsconstants.h> // for opening the respective options page
 #include <coreplugin/icore.h>
 #include <utils/algorithm.h>
-#include <utils/utilsicons.h>
 
 #include <QTextStream>
 
@@ -45,12 +43,6 @@ CppCodeModelSettingsWidget::CppCodeModelSettingsWidget()
     : m_ui(new Ui::CppCodeModelSettingsPage)
 {
     m_ui->setupUi(this);
-    m_ui->expensiveChecksHintIcon->setPixmap(Utils::Icons::WARNING.pixmap());
-    m_ui->expensiveChecksHintIcon->setVisible(false);
-    m_ui->expensiveChecksHintText->setVisible(false);
-    connect(m_ui->expensiveChecksHintText, &QLabel::linkActivated, [](const QString &){
-        Core::ICore::showOptionsDialog(ClangTools::Constants::SETTINGS_PAGE_ID);
-    });
 }
 
 CppCodeModelSettingsWidget::~CppCodeModelSettingsWidget()
@@ -77,24 +69,30 @@ void CppCodeModelSettingsWidget::applyToSettings() const
         m_settings->toSettings(Core::ICore::settings());
 }
 
-static bool hasConfigExpensiveChecks(const Core::Id &configId)
+void CppCodeModelSettingsWidget::setupClangCodeModelWidgets()
 {
-    if (!configId.isValid())
-        return false;
+    m_ui->clangDiagnosticConfigsSelectionWidget->refresh(diagnosticConfigsModel(),
+                                                         m_settings->clangDiagnosticConfigId(),
+                                                         /*showTidyClazyUi=*/false);
 
-    const ClangDiagnosticConfig config
-        = ClangDiagnosticConfigsModel(
-              codeModelSettings()->clangCustomDiagnosticConfigs())
-              .configWithId(configId);
+    connect(m_ui->clangDiagnosticConfigsSelectionWidget,
+            &ClangDiagnosticConfigsSelectionWidget::diagnosticConfigsEdited,
+            this,
+            [this](const ClangDiagnosticConfigs &configs) {
+            const ClangDiagnosticConfigsModel configsModel = diagnosticConfigsModel(configs);
+            if (!configsModel.hasConfigWithId(m_settings->clangDiagnosticConfigId()))
+                m_settings->resetClangDiagnosticConfigId();
+            m_settings->setClangCustomDiagnosticConfigs(configs);
+            applyClangCodeModelWidgetsToSettings();
+            m_settings->toSettings(Core::ICore::settings());
 
-    return !config.clazyChecks().isEmpty()
-        || config.clangTidyMode() != ClangDiagnosticConfig::TidyMode::Disabled;
-}
+            m_ui->clangDiagnosticConfigsSelectionWidget
+                ->refresh(configsModel,
+                          m_settings->clangDiagnosticConfigId(),
+                          /*showTidyClazyUi=*/false);
+    });
 
-void CppCodeModelSettingsWidget::setupClangCodeModelWidgets()
-{
     const bool isClangActive = CppModelManager::instance()->isClangCodeModelActive();
-
     m_ui->clangCodeModelIsDisabledHint->setVisible(!isClangActive);
     m_ui->clangCodeModelIsEnabledHint->setVisible(isClangActive);
     for (int i = 0; i < m_ui->clangDiagnosticConfigsSelectionWidget->layout()->count(); ++i) {
@@ -102,25 +100,6 @@ void CppCodeModelSettingsWidget::setupClangCodeModelWidgets()
         if (widget)
             widget->setEnabled(isClangActive);
     }
-
-    connect(m_settings.data(), &CppCodeModelSettings::changed,
-            this, [this]() {
-        m_ui->clangDiagnosticConfigsSelectionWidget->refresh(
-                    m_ui->clangDiagnosticConfigsSelectionWidget->currentConfigId());
-        if (applyClangCodeModelWidgetsToSettings())
-            m_settings->toSettings(Core::ICore::settings());
-    });
-
-    const auto checkForExpensiveChecks = [this](const Core::Id &configId) {
-        const bool visible = hasConfigExpensiveChecks(configId);
-        m_ui->expensiveChecksHintIcon->setVisible(visible);
-        m_ui->expensiveChecksHintText->setVisible(visible);
-    };
-
-    checkForExpensiveChecks(m_ui->clangDiagnosticConfigsSelectionWidget->currentConfigId());
-    connect(m_ui->clangDiagnosticConfigsSelectionWidget,
-            &ClangDiagnosticConfigsSelectionWidget::currentConfigChanged,
-            checkForExpensiveChecks);
 }
 
 void CppCodeModelSettingsWidget::setupGeneralWidgets()
diff --git a/src/plugins/cpptools/cppcodemodelsettingspage.ui b/src/plugins/cpptools/cppcodemodelsettingspage.ui
index 64baa51c72..996ddc9e75 100644
--- a/src/plugins/cpptools/cppcodemodelsettingspage.ui
+++ b/src/plugins/cpptools/cppcodemodelsettingspage.ui
@@ -109,23 +109,6 @@
       <item>
        <layout class="QHBoxLayout" name="horizontalLayout_2">
         <item>
-         <widget class="QLabel" name="expensiveChecksHintIcon">
-          <property name="text">
-           <string/>
-          </property>
-          <property name="alignment">
-           <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QLabel" name="expensiveChecksHintText">
-          <property name="text">
-           <string>The selected configuration has potentially expensive Clang-Tidy or Clazy checks enabled.&lt;br/&gt;Consider to run these in a separate &lt;a href=&quot;target&quot;&gt;Clang-Tidy and Clazy analyzer&lt;/a&gt; run.</string>
-          </property>
-         </widget>
-        </item>
-        <item>
          <spacer name="horizontalSpacer_2">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
diff --git a/src/plugins/cpptools/cpptoolsreuse.cpp b/src/plugins/cpptools/cpptoolsreuse.cpp
index 0d186f8421..bf37098f88 100644
--- a/src/plugins/cpptools/cpptoolsreuse.cpp
+++ b/src/plugins/cpptools/cpptoolsreuse.cpp
@@ -26,8 +26,9 @@
 #include "cpptoolsreuse.h"
 
 #include "cppcodemodelsettings.h"
-#include "cpptoolsplugin.h"
 #include "cpptools_clazychecks.h"
+#include "cpptoolsconstants.h"
+#include "cpptoolsplugin.h"
 
 #include <coreplugin/documentmanager.h>
 #include <coreplugin/editormanager/editormanager.h>
@@ -351,4 +352,76 @@ QString clazyChecksForLevel(int level)
     return checks.join(',');
 }
 
+static void addBuiltinConfigs(ClangDiagnosticConfigsModel &model)
+{
+    // Pedantic
+    ClangDiagnosticConfig config;
+    config.setId("Builtin.Pedantic");
+    config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
+                                                      "Pedantic checks"));
+    config.setIsReadOnly(true);
+    config.setClangOptions(QStringList{QStringLiteral("-Wpedantic")});
+    model.appendOrUpdate(config);
+
+    // Questionable constructs
+    config = ClangDiagnosticConfig();
+    config.setId("Builtin.Questionable");
+    config.setDisplayName(QCoreApplication::translate(
+                              "ClangDiagnosticConfigsModel",
+                              "Checks for questionable constructs"));
+    config.setIsReadOnly(true);
+    config.setClangOptions(QStringList{
+        QStringLiteral("-Wall"),
+        QStringLiteral("-Wextra"),
+    });
+    model.appendOrUpdate(config);
+
+    // Everything with exceptions
+    config = ClangDiagnosticConfig();
+    config.setId(Constants::CPP_CLANG_BUILTIN_CONFIG_ID_EVERYTHING_WITH_EXCEPTIONS);
+    config.setDisplayName(QCoreApplication::translate(
+                              "ClangDiagnosticConfigsModel",
+                              "Checks for almost everything"));
+    config.setIsReadOnly(true);
+    config.setClangOptions(QStringList{
+        QStringLiteral("-Weverything"),
+        QStringLiteral("-Wno-c++98-compat"),
+        QStringLiteral("-Wno-c++98-compat-pedantic"),
+        QStringLiteral("-Wno-unused-macros"),
+        QStringLiteral("-Wno-newline-eof"),
+        QStringLiteral("-Wno-exit-time-destructors"),
+        QStringLiteral("-Wno-global-constructors"),
+        QStringLiteral("-Wno-gnu-zero-variadic-macro-arguments"),
+        QStringLiteral("-Wno-documentation"),
+        QStringLiteral("-Wno-shadow"),
+        QStringLiteral("-Wno-switch-enum"),
+        QStringLiteral("-Wno-missing-prototypes"), // Not optimal for C projects.
+        QStringLiteral("-Wno-used-but-marked-unused"), // e.g. QTest::qWait
+    });
+    model.appendOrUpdate(config);
+
+    // Build system
+    config = ClangDiagnosticConfig();
+    config.setId("Builtin.BuildSystem");
+    config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
+                                                      "Build-system warnings"));
+    config.setIsReadOnly(true);
+    config.setUseBuildSystemWarnings(true);
+    model.appendOrUpdate(config);
+}
+
+ClangDiagnosticConfigsModel diagnosticConfigsModel(const ClangDiagnosticConfigs &customConfigs)
+{
+    ClangDiagnosticConfigsModel model;
+    addBuiltinConfigs(model);
+    for (const ClangDiagnosticConfig &config : customConfigs)
+        model.appendOrUpdate(config);
+    return model;
+}
+
+ClangDiagnosticConfigsModel diagnosticConfigsModel()
+{
+    return diagnosticConfigsModel(CppTools::codeModelSettings()->clangCustomDiagnosticConfigs());
+}
+
 } // CppTools
diff --git a/src/plugins/cpptools/cpptoolsreuse.h b/src/plugins/cpptools/cpptoolsreuse.h
index 92e1365d15..7807b35099 100644
--- a/src/plugins/cpptools/cpptoolsreuse.h
+++ b/src/plugins/cpptools/cpptoolsreuse.h
@@ -29,6 +29,7 @@
 
 #include <texteditor/texteditor.h>
 
+#include <cpptools/clangdiagnosticconfig.h>
 #include <cpptools/compileroptionsbuilder.h>
 
 #include <cplusplus/CppDocument.h>
@@ -81,6 +82,11 @@ UsePrecompiledHeaders CPPTOOLS_EXPORT getPchUsage();
 int indexerFileSizeLimitInMb();
 bool fileSizeExceedsLimit(const QFileInfo &fileInfo, int sizeLimitInMb);
 
-QString clazyChecksForLevel(int level);
+QString CPPTOOLS_EXPORT clazyChecksForLevel(int level);
+
+class ClangDiagnosticConfigsModel;
+ClangDiagnosticConfigsModel CPPTOOLS_EXPORT diagnosticConfigsModel();
+ClangDiagnosticConfigsModel CPPTOOLS_EXPORT
+diagnosticConfigsModel(const CppTools::ClangDiagnosticConfigs &customConfigs);
 
 } // CppTools