ClangDiagnosticConfig: Introduce ClangToolType enum

And reuse it where applicable.

Change-Id: If75f849ac936ef2c67b35c6a78d5bb055fc172d2
Reviewed-by: David Schulz <david.schulz@qt.io>

src/plugins/clangcodemodel/clangtextmark.cpp

@@ -75,15 +75,15 @@ void disableDiagnosticInConfig(ClangDiagnosticConfig &config, const ClangDiagnos
         config.setClangOptions(config.clangOptions() + QStringList(diagnostic.disableOption));
         break;
     case DiagnosticType::Tidy:
-        config.setClangTidyChecks(config.clangTidyChecks() + QString(",-")
+        config.setChecks(ClangToolType::Tidy, config.checks(ClangToolType::Tidy) + QString(",-")
                                   + DiagnosticTextInfo(diagnostic.text).option());
         break;
     case DiagnosticType::Clazy: {
         const DiagnosticTextInfo textInfo(diagnostic.text);
         const QString checkName = DiagnosticTextInfo::clazyCheckName(textInfo.option());
-        QStringList newChecks = config.clazyChecks().split(',');
+        QStringList newChecks = config.checks(ClangToolType::Clazy).split(',');
         newChecks.removeOne(checkName);
-        config.setClazyChecks(newChecks.join(','));
+        config.setChecks(ClangToolType::Clazy, newChecks.join(','));
         break;
     }
     }

src/plugins/clangtools/clangtidyclazyrunner.cpp

@@ -42,9 +42,9 @@ static QStringList tidyChecksArguments(const ClangDiagnosticConfig diagnosticCon
 
 static QStringList clazyChecksArguments(const ClangDiagnosticConfig diagnosticConfig)
 {
-    const QString clazyChecks = diagnosticConfig.clazyChecks();
+    const QString clazyChecks = diagnosticConfig.checks(ClangToolType::Clazy);
     if (!clazyChecks.isEmpty())
-        return {"-checks=" + diagnosticConfig.clazyChecks()};
+        return {"-checks=" + diagnosticConfig.checks(ClangToolType::Clazy)};
     return {};
 }
 

src/plugins/clangtools/clangtool.cpp

@@ -860,12 +860,12 @@ static CheckResult canAnalyze()
 {
     const ClangDiagnosticConfig config = diagnosticConfig(runSettings().diagnosticConfigId());
 
-    if (config.isClangTidyEnabled() && !clangTidyExecutable().isExecutableFile()) {
+    if (config.isEnabled(ClangToolType::Tidy) && !clangTidyExecutable().isExecutableFile()) {
         return {CheckResult::InvalidTidyExecutable,
                 ClangTool::tr("Set a valid Clang-Tidy executable.")};
     }
 
-    if (config.isClazyEnabled() && !clazyStandaloneExecutable().isExecutableFile()) {
+    if (config.isEnabled(ClangToolType::Clazy) && !clazyStandaloneExecutable().isExecutableFile()) {
         return {CheckResult::InvalidClazyExecutable,
                 ClangTool::tr("Set a valid Clazy-Standalone executable.")};
     }

src/plugins/clangtools/clangtoolssettings.cpp

@@ -109,8 +109,9 @@ ClangDiagnosticConfigs importDiagnosticConfigsFromCodeModel()
     ClangDiagnosticConfigs clangOnlyConfigs;
     std::tie(tidyClazyConfigs, clangOnlyConfigs)
         = Utils::partition(configs, [](const ClangDiagnosticConfig &config) {
-              return !config.clazyChecks().isEmpty()
+              return !config.checks(ClangToolType::Clazy).isEmpty()
-                  || (!config.clangTidyChecks().isEmpty() && config.clangTidyChecks() != "-*");
+                     || (!config.checks(ClangToolType::Tidy).isEmpty()
+                         && config.checks(ClangToolType::Tidy) != "-*");
           });
     return tidyClazyConfigs;
 }

src/plugins/clangtools/clangtoolsunittests.cpp

@@ -68,8 +68,7 @@ void ClangToolsUnitTests::cleanupTestCase()
     delete m_tmpDir;
 }
 
-static ClangDiagnosticConfig configFor(const QString &tidyChecks,
+static ClangDiagnosticConfig configFor(const QString &tidyChecks, const QString &clazyChecks)
-                                                 const QString &clazyChecks)
 {
     ClangDiagnosticConfig config;
     config.setId("Test.MyTestConfig");
@@ -78,8 +77,8 @@ static ClangDiagnosticConfig configFor(const QString &tidyChecks,
     config.setClangOptions(QStringList{QStringLiteral("-Wno-everything")});
     config.setClangTidyMode(ClangDiagnosticConfig::TidyMode::UseCustomChecks);
     const QString theTidyChecks = tidyChecks.isEmpty() ? tidyChecks : "-*," + tidyChecks;
-    config.setClangTidyChecks(theTidyChecks);
+    config.setChecks(ClangToolType::Tidy, theTidyChecks);
-    config.setClazyChecks(clazyChecks);
+    config.setChecks(ClangToolType::Clazy, clazyChecks);
     return config;
 }
 

src/plugins/clangtools/diagnosticconfigswidget.cpp

@@ -1158,9 +1158,9 @@ void DiagnosticConfigsWidget::syncClazyWidgets(const ClangDiagnosticConfig &conf
 
     disconnectClazyItemChanged();
     const QStringList checkNames = config.clazyMode()
-                                           == ClangDiagnosticConfig::ClazyMode::UseDefaultChecks
+                      == ClangDiagnosticConfig::ClazyMode::UseDefaultChecks
-                                       ? m_clazyInfo.defaultChecks
+                      ? m_clazyInfo.defaultChecks
-                                       : config.clazyChecks().split(',', Qt::SkipEmptyParts);
+                      : config.checks(ClangToolType::Clazy).split(',', Qt::SkipEmptyParts);
     m_clazyTreeModel->enableChecks(checkNames);
 
     syncClazyChecksGroupBox();
@@ -1180,7 +1180,7 @@ void DiagnosticConfigsWidget::syncTidyChecksToTree(const ClangDiagnosticConfig &
     const QString checks = config.clangTidyMode()
                                    == ClangDiagnosticConfig::TidyMode::UseDefaultChecks
                                ? m_tidyInfo.defaultChecks.join(',')
-                               : config.clangTidyChecks();
+                               : config.checks(ClangToolType::Tidy);
     m_tidyTreeModel->selectChecks(checks);
 }
 
@@ -1235,7 +1235,7 @@ void DiagnosticConfigsWidget::onClangTidyTreeChanged()
     ClangDiagnosticConfig config = currentConfig();
     if (config.clangTidyMode() == ClangDiagnosticConfig::TidyMode::UseDefaultChecks)
         config.setClangTidyMode(ClangDiagnosticConfig::TidyMode::UseCustomChecks);
-    config.setClangTidyChecks(m_tidyTreeModel->selectedChecks());
+    config.setChecks(ClangToolType::Tidy, m_tidyTreeModel->selectedChecks());
     updateConfig(config);
 }
 
@@ -1246,7 +1246,7 @@ void DiagnosticConfigsWidget::onClazyTreeChanged()
     ClangDiagnosticConfig config = currentConfig();
     if (config.clazyMode() == ClangDiagnosticConfig::ClazyMode::UseDefaultChecks)
         config.setClazyMode(ClangDiagnosticConfig::ClazyMode::UseCustomChecks);
-    config.setClazyChecks(m_clazyTreeModel->enabledChecks().join(","));
+    config.setChecks(ClangToolType::Clazy, m_clazyTreeModel->enabledChecks().join(","));
     updateConfig(config);
 }
 
@@ -1329,16 +1329,18 @@ void disableChecks(const QList<Diagnostic> &diagnostics)
                 config.setClazyMode(ClangDiagnosticConfig::ClazyMode::UseCustomChecks);
                 const ClazyStandaloneInfo clazyInfo
                         = ClazyStandaloneInfo::getInfo(clazyStandaloneExecutable());
-                config.setClazyChecks(clazyInfo.defaultChecks.join(','));
+                config.setChecks(ClangToolType::Clazy, clazyInfo.defaultChecks.join(','));
             }
-            config.setClazyChecks(removeClazyCheck(config.clazyChecks(), diag.name));
+            config.setChecks(ClangToolType::Clazy,
+                             removeClazyCheck(config.checks(ClangToolType::Clazy), diag.name));
         } else if (config.clangTidyMode() != ClangDiagnosticConfig::TidyMode::UseConfigFile) {
             if (config.clangTidyMode() == ClangDiagnosticConfig::TidyMode::UseDefaultChecks) {
                 config.setClangTidyMode(ClangDiagnosticConfig::TidyMode::UseCustomChecks);
                 const ClangTidyInfo tidyInfo(clangTidyExecutable());
-                config.setClangTidyChecks(tidyInfo.defaultChecks.join(','));
+                config.setChecks(ClangToolType::Tidy, tidyInfo.defaultChecks.join(','));
             }
-            config.setClangTidyChecks(removeClangTidyCheck(config.clangTidyChecks(), diag.name));
+            config.setChecks(ClangToolType::Tidy,
+                             removeClangTidyCheck(config.checks(ClangToolType::Tidy), diag.name));
         }
     }
 

src/plugins/clangtools/documentclangtoolrunner.cpp

@@ -198,12 +198,12 @@ void DocumentClangToolRunner::run()
                         runSettings.diagnosticConfigId());
 
                     Environment env = projectBuildEnvironment(project);
-                    if (config.isClangTidyEnabled()) {
+                    if (config.isEnabled(ClangToolType::Tidy)) {
                         m_runnerCreators << [this, env, config] {
                             return createRunner<ClangTidyRunner>(config, env);
                         };
                     }
-                    if (config.isClazyEnabled()) {
+                    if (config.isEnabled(ClangToolType::Clazy)) {
                         m_runnerCreators << [this, env, config] {
                             return createRunner<ClazyStandaloneRunner>(config, env);
                         };

src/plugins/cppeditor/clangdiagnosticconfig.cpp

@@ -99,14 +99,9 @@ void ClangDiagnosticConfig::setClangTidyMode(TidyMode mode)
     m_clangTidyMode = mode;
 }
 
-QString ClangDiagnosticConfig::clangTidyChecks() const
-{
-    return m_clangTidyChecks;
-}
-
 QString ClangDiagnosticConfig::clangTidyChecksAsJson() const
 {
-    QString jsonString = "{Checks: '" + clangTidyChecks()
+    QString jsonString = "{Checks: '" + checks(ClangToolType::Tidy)
             + ",-clang-diagnostic-*', CheckOptions: [";
 
     // The check is either listed verbatim or covered by the "<prefix>-*" pattern.
@@ -141,16 +136,6 @@ QString ClangDiagnosticConfig::clangTidyChecksAsJson() const
     return jsonString += "]}";
 }
 
-void ClangDiagnosticConfig::setClangTidyChecks(const QString &checks)
-{
-    m_clangTidyChecks = checks;
-}
-
-bool ClangDiagnosticConfig::isClangTidyEnabled() const
-{
-    return m_clangTidyMode != TidyMode::UseCustomChecks || clangTidyChecks() != "-*";
-}
-
 void ClangDiagnosticConfig::setTidyCheckOptions(const QString &check,
                                                 const TidyCheckOptions &options)
 {
@@ -187,18 +172,23 @@ QVariant ClangDiagnosticConfig::tidyChecksOptionsForSettings() const
     return topLevelMap;
 }
 
-QString ClangDiagnosticConfig::clazyChecks() const
+QString ClangDiagnosticConfig::checks(ClangToolType tool) const
 {
-    return m_clazyChecks;
+    return tool == ClangToolType::Tidy ? m_clangTidyChecks : m_clazyChecks;
 }
 
-void ClangDiagnosticConfig::setClazyChecks(const QString &checks)
+void ClangDiagnosticConfig::setChecks(ClangToolType tool, const QString &checks)
 {
-    m_clazyChecks = checks;
+    if (tool == ClangToolType::Tidy)
+        m_clangTidyChecks = checks;
+    else
+        m_clazyChecks = checks;
 }
 
-bool ClangDiagnosticConfig::isClazyEnabled() const
+bool ClangDiagnosticConfig::isEnabled(ClangToolType tool) const
 {
+    if (tool == ClangToolType::Tidy)
+        return m_clangTidyMode != TidyMode::UseCustomChecks || checks(ClangToolType::Tidy) != "-*";
     return m_clazyMode != ClazyMode::UseCustomChecks || !m_clazyChecks.isEmpty();
 }
 
@@ -236,10 +226,10 @@ void diagnosticConfigsToSettings(QSettings *s, const ClangDiagnosticConfigs &con
         s->setValue(diagnosticConfigWarningsKey, config.clangOptions());
         s->setValue(useBuildSystemFlagsKey, config.useBuildSystemWarnings());
         s->setValue(diagnosticConfigsTidyModeKey, int(config.clangTidyMode()));
-        s->setValue(diagnosticConfigsTidyChecksKey, config.clangTidyChecks());
+        s->setValue(diagnosticConfigsTidyChecksKey, config.checks(ClangToolType::Tidy));
         s->setValue(diagnosticConfigsTidyChecksOptionsKey, config.tidyChecksOptionsForSettings());
         s->setValue(diagnosticConfigsClazyModeKey, int(config.clazyMode()));
-        s->setValue(diagnosticConfigsClazyChecksKey, config.clazyChecks());
+        s->setValue(diagnosticConfigsClazyChecksKey, config.checks(ClangToolType::Clazy));
     }
     s->endArray();
 }
@@ -260,10 +250,10 @@ ClangDiagnosticConfigs diagnosticConfigsFromSettings(QSettings *s)
         const int tidyModeValue = s->value(diagnosticConfigsTidyModeKey).toInt();
         if (tidyModeValue == 0) { // Convert from settings of <= Qt Creator 4.10
             config.setClangTidyMode(ClangDiagnosticConfig::TidyMode::UseCustomChecks);
-            config.setClangTidyChecks("-*");
+            config.setChecks(ClangToolType::Tidy, "-*");
         } else {
             config.setClangTidyMode(static_cast<ClangDiagnosticConfig::TidyMode>(tidyModeValue));
-            config.setClangTidyChecks(s->value(diagnosticConfigsTidyChecksKey).toString());
+            config.setChecks(ClangToolType::Tidy, s->value(diagnosticConfigsTidyChecksKey).toString());
             config.setTidyChecksOptionsFromSettings(
                         s->value(diagnosticConfigsTidyChecksOptionsKey));
         }
@@ -271,7 +261,7 @@ ClangDiagnosticConfigs diagnosticConfigsFromSettings(QSettings *s)
         config.setClazyMode(static_cast<ClangDiagnosticConfig::ClazyMode>(
             s->value(diagnosticConfigsClazyModeKey).toInt()));
         const QString clazyChecks = s->value(diagnosticConfigsClazyChecksKey).toString();
-        config.setClazyChecks(convertToNewClazyChecksFormat(clazyChecks));
+        config.setChecks(ClangToolType::Clazy, convertToNewClazyChecksFormat(clazyChecks));
         configs.append(config);
     }
     s->endArray();

src/plugins/cppeditor/clangdiagnosticconfig.h

@@ -18,6 +18,8 @@ QT_END_NAMESPACE
 
 namespace CppEditor {
 
+enum class ClangToolType { Tidy, Clazy };
+
 // TODO: Split this class as needed for ClangCodeModel and ClangTools
 class CPPEDITOR_EXPORT ClangDiagnosticConfig
 {
@@ -48,11 +50,7 @@ public:
     TidyMode clangTidyMode() const;
     void setClangTidyMode(TidyMode mode);
 
-    QString clangTidyChecks() const;
     QString clangTidyChecksAsJson() const;
-    void setClangTidyChecks(const QString &checks);
-
-    bool isClangTidyEnabled() const;
 
     using TidyCheckOptions = QMap<QString, QString>;
     void setTidyCheckOptions(const QString &check, const TidyCheckOptions &options);
@@ -69,10 +67,10 @@ public:
     ClazyMode clazyMode() const;
     void setClazyMode(const ClazyMode &clazyMode);
 
-    QString clazyChecks() const;
+    QString checks(ClangToolType tool) const;
-    void setClazyChecks(const QString &checks);
+    void setChecks(ClangToolType tool, const QString &checks);
 
-    bool isClazyEnabled() const;
+    bool isEnabled(ClangToolType tool) const;
 
     bool operator==(const ClangDiagnosticConfig &other) const;
     bool operator!=(const ClangDiagnosticConfig &other) const;