Partial fix for #11897 (Safety: show what checks are enabled/disabled) (#5372)

Example output on stdout:
```
$ ./cppcheck m1.cpp 
Checking m1.cpp ...
Active checkers: 59/177
```

Author: danmar

Makefile

@@ -638,7 +638,7 @@ $(libcppdir)/vfvalue.o: lib/vfvalue.cpp lib/config.h lib/errortypes.h lib/mathli
 cli/cmdlineparser.o: cli/cmdlineparser.cpp cli/cmdlineparser.h cli/cppcheckexecutor.h cli/filelister.h externals/tinyxml2/tinyxml2.h lib/check.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/utils.h
 	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/cmdlineparser.cpp
 
-cli/cppcheckexecutor.o: cli/cppcheckexecutor.cpp cli/cmdlineparser.h cli/cppcheckexecutor.h cli/cppcheckexecutorseh.h cli/cppcheckexecutorsig.h cli/executor.h cli/filelister.h cli/processexecutor.h cli/singleexecutor.h cli/threadexecutor.h lib/analyzerinfo.h lib/check.h lib/checkunusedfunctions.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/pathmatch.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/utils.h
+cli/cppcheckexecutor.o: cli/cppcheckexecutor.cpp cli/cmdlineparser.h cli/cppcheckexecutor.h cli/cppcheckexecutorseh.h cli/cppcheckexecutorsig.h cli/executor.h cli/filelister.h cli/processexecutor.h cli/singleexecutor.h cli/threadexecutor.h lib/analyzerinfo.h lib/check.h lib/checkers.h lib/checkunusedfunctions.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/pathmatch.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/utils.h
 	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/cppcheckexecutor.cpp
 
 cli/cppcheckexecutorseh.o: cli/cppcheckexecutorseh.cpp cli/cppcheckexecutor.h cli/cppcheckexecutorseh.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/utils.h

cli/cmdlineparser.cpp

@@ -253,6 +253,9 @@ bool CmdLineParser::parseFromArgs(int argc, const char* const argv[])
                 mSettings.checkLibrary = true;
             }
 
+            else if (std::strncmp(argv[i], "--checkers-report=", 18) == 0)
+                mSettings.checkersReportFilename = argv[i] + 18;
+
             else if (std::strncmp(argv[i], "--checks-max-time=", 18) == 0) {
                 if (!parseNumberArg(argv[i], 18, mSettings.checksMaxTime, true))
                     return false;
@@ -1115,6 +1118,8 @@ void CmdLineParser::printHelp()
         "                         The default choice is 'normal'.\n"
         "    --check-library      Show information messages when library files have\n"
         "                         incomplete info.\n"
+        "    --checkers-report=<file>\n"
+        "                         Write a report of all the active checkers to the given file.\n"
         "    --clang=<path>       Experimental: Use Clang parser instead of the builtin Cppcheck\n"
         "                         parser. Takes the executable as optional parameter and\n"
         "                         defaults to `clang`. Cppcheck will run the given Clang\n"

cli/cppcheckexecutor.cpp

@@ -19,6 +19,7 @@
 #include "cppcheckexecutor.h"
 
 #include "analyzerinfo.h"
+#include "checkers.h"
 #include "cmdlineparser.h"
 #include "color.h"
 #include "config.h"
@@ -296,6 +297,9 @@ int CppCheckExecutor::check_internal(CppCheck& cppcheck)
         AnalyzerInformation::writeFilesTxt(settings.buildDir, fileNames, settings.userDefines, settings.project.fileSettings);
     }
 
+    if (!settings.checkersReportFilename.empty())
+        std::remove(settings.checkersReportFilename.c_str());
+
     unsigned int returnValue = 0;
     if (settings.useSingleJob()) {
         // Single process
@@ -326,11 +330,186 @@ int CppCheckExecutor::check_internal(CppCheck& cppcheck)
         reportErr(ErrorMessage::getXMLFooter());
     }
 
+    writeCheckersReport(settings);
+
     if (returnValue)
         return settings.exitCode;
     return 0;
 }
 
+static bool isCppcheckPremium(const Settings& settings) {
+    return (settings.cppcheckCfgProductName.compare(0, 16, "Cppcheck Premium") == 0);
+}
+
+static std::string getMisraRuleSeverity(const std::string& rule) {
+    if (checkers::misraRuleSeverity.count(rule) > 0)
+        return checkers::misraRuleSeverity.at(rule);
+    return "style";
+}
+
+static bool isMisraRuleInconclusive(const std::string& rule) {
+    return rule == "8.3";
+}
+
+static bool isMisraRuleActive(const std::string& rule, int amendment, const std::string& severity, const Settings& settings) {
+    if (!isCppcheckPremium(settings) && amendment >= 3)
+        return false;
+    const bool inconclusive = isMisraRuleInconclusive(rule);
+    if (inconclusive && !settings.certainty.isEnabled(Certainty::inconclusive))
+        return false;
+    if (severity == "warning")
+        return settings.severity.isEnabled(Severity::warning);
+    if (severity == "style")
+        return settings.severity.isEnabled(Severity::style);
+    return true; // error severity
+}
+
+void CppCheckExecutor::writeCheckersReport(const Settings& settings) const
+{
+    if (!settings.quiet) {
+        int activeCheckers = 0;
+        int totalCheckers = 0;
+        for (const auto& checkReq: checkers::allCheckers) {
+            if (mActiveCheckers.count(checkReq.first) > 0)
+                ++activeCheckers;
+            ++totalCheckers;
+        }
+        if (isCppcheckPremium(settings)) {
+            for (const auto& checkReq: checkers::premiumCheckers) {
+                if (mActiveCheckers.count(checkReq.first) > 0)
+                    ++activeCheckers;
+                ++totalCheckers;
+            }
+        }
+        if (mSettings->premiumArgs.find("misra-c-") != std::string::npos || mSettings->addons.count("misra")) {
+            for (const checkers::MisraInfo& info: checkers::misraC2012Rules) {
+                const std::string rule = std::to_string(info.a) + "." + std::to_string(info.b);
+                const std::string severity = getMisraRuleSeverity(rule);
+                const bool active = isMisraRuleActive(rule, info.amendment, severity, settings);
+                if (active)
+                    ++activeCheckers;
+                ++totalCheckers;
+            }
+        }
+
+        const std::string extra = settings.verbose ? " (use --checkers-report=<filename> to see details)" : "";
+        if (mCriticalErrors.empty())
+            std::cout << "Active checkers: " << activeCheckers << "/" << totalCheckers << extra << std::endl;
+        else
+            std::cout << "Active checkers: There was critical errors" << extra << std::endl;
+    }
+
+    if (settings.checkersReportFilename.empty())
+        return;
+
+    std::ofstream fout(settings.checkersReportFilename);
+    if (!fout.is_open())
+        return;
+
+    fout << "Critical errors" << std::endl;
+    fout << "---------------" << std::endl;
+    if (!mCriticalErrors.empty()) {
+        fout << "There was critical errors (" << mCriticalErrors << ")" << std::endl;
+        fout << "All checking is skipped for a file with such error" << std::endl;
+    } else {
+        fout << "No critical errors, all files were checked." << std::endl;
+        fout << "Important: Analysis is still not guaranteed to be 'complete' it is possible there are false negatives." << std::endl;
+    }
+
+    fout << std::endl << std::endl;
+    fout << "Open source checkers" << std::endl;
+    fout << "--------------------" << std::endl;
+
+    int maxCheckerSize = 0;
+    for (const auto& checkReq: checkers::allCheckers) {
+        const std::string& checker = checkReq.first;
+        if (checker.size() > maxCheckerSize)
+            maxCheckerSize = checker.size();
+    }
+    for (const auto& checkReq: checkers::allCheckers) {
+        const std::string& checker = checkReq.first;
+        const bool active = mActiveCheckers.count(checkReq.first) > 0;
+        const std::string& req = checkReq.second;
+        fout << (active ? "Yes  " : "No   ") << checker;
+        if (!active && !req.empty())
+            fout << std::string(maxCheckerSize + 4 - checker.size(), ' ') << "require:" + req;
+        fout << std::endl;
+    }
+
+    const bool cppcheckPremium = isCppcheckPremium(settings);
+
+    if (cppcheckPremium) {
+        fout << std::endl << std::endl;
+        fout << "Premium checkers" << std::endl;
+        fout << "----------------" << std::endl;
+
+        maxCheckerSize = 0;
+        for (const auto& checkReq: checkers::premiumCheckers) {
+            const std::string& checker = checkReq.first;
+            if (checker.size() > maxCheckerSize)
+                maxCheckerSize = checker.size();
+        }
+        for (const auto& checkReq: checkers::premiumCheckers) {
+            const std::string& checker = checkReq.first;
+            std::string req = checkReq.second;
+            bool active = cppcheckPremium;
+            if (req == "warning")
+                active &= mSettings->severity.isEnabled(Severity::warning);
+            else if (req == "style")
+                active &= mSettings->severity.isEnabled(Severity::style);
+            fout << (active ? "Yes  " : "No   ") << checker;
+            if (!req.empty())
+                req = "premium," + req;
+            else
+                req = "premium";
+            if (!active)
+                fout << std::string(maxCheckerSize + 4 - checker.size(), ' ') << "require:" + req;
+            fout << std::endl;
+        }
+    }
+
+    int misra = 0;
+    if (mSettings->premiumArgs.find("misra-c-2012") != std::string::npos)
+        misra = 2012;
+    else if (mSettings->premiumArgs.find("misra-c-2023") != std::string::npos)
+        misra = 2023;
+    else if (mSettings->addons.count("misra"))
+        misra = 2012;
+
+    if (misra == 0) {
+        fout << std::endl << std::endl;
+        fout << "Misra C" << std::endl;
+        fout << "-------" << std::endl;
+        fout << "Misra is not enabled" << std::endl;
+    } else {
+        fout << std::endl << std::endl;
+        fout << "Misra C " << misra << std::endl;
+        fout << "------------" << std::endl;
+        for (const checkers::MisraInfo& info: checkers::misraC2012Rules) {
+            const std::string rule = std::to_string(info.a) + "." + std::to_string(info.b);
+            const std::string severity = getMisraRuleSeverity(rule);
+            const bool active = isMisraRuleActive(rule, info.amendment, severity, settings);
+            const bool inconclusive = isMisraRuleInconclusive(rule);
+            fout << (active ? "Yes  " : "No   ") << rule;
+            std::string extra;
+            if (misra == 2012 && info.amendment >= 1)
+                extra = " amendment:" + std::to_string(info.amendment);
+            std::string reqs;
+            if (info.amendment >= 3)
+                reqs += ",premium";
+            if (severity != "error")
+                reqs += "," + severity;
+            if (inconclusive)
+                reqs += ",inconclusive";
+            if (!active && !reqs.empty())
+                extra += " require:" + reqs.substr(1);
+            if (!extra.empty())
+                fout << std::string(7 - rule.size(), ' ') << extra;
+            fout << '\n';
+        }
+    }
+}
+
 bool CppCheckExecutor::loadLibraries(Settings& settings)
 {
     if (!tryLoadLibrary(settings.library, settings.exename, "std.cfg")) {
@@ -428,10 +607,22 @@ void CppCheckExecutor::reportErr(const ErrorMessage &msg)
 {
     assert(mSettings != nullptr);
 
+    if (msg.severity == Severity::none && msg.id == "logChecker") {
+        const std::string& checker = msg.shortMessage();
+        mActiveCheckers.emplace(checker);
+        return;
+    }
+
     // Alert only about unique errors
     if (!mShownErrors.insert(msg.toString(mSettings->verbose)).second)
         return;
 
+    if (ErrorLogger::isCriticalErrorId(msg.id) && mCriticalErrors.find(msg.id) == std::string::npos) {
+        if (!mCriticalErrors.empty())
+            mCriticalErrors += ", ";
+        mCriticalErrors += msg.id;
+    }
+
     if (mSettings->xml)
         reportErr(msg.toXML());
     else

cli/cppcheckexecutor.h

@@ -153,6 +153,11 @@ class CppCheckExecutor : public ErrorLogger {
      */
     bool loadLibraries(Settings& settings);
 
+    /**
+     * @brief Write the checkers report
+     */
+    void writeCheckersReport(const Settings& settings) const;
+
     /**
      * Pointer to current settings; set while check() is running for reportError().
      */
@@ -182,6 +187,16 @@ class CppCheckExecutor : public ErrorLogger {
      * Error output
      */
     std::ofstream* mErrorOutput{};
+
+    /**
+     * Checkers that has been executed
+     */
+    std::set<std::string> mActiveCheckers;
+
+    /**
+     * True if there are critical errors
+     */
+    std::string mCriticalErrors;
 };
 
 #endif // CPPCHECKEXECUTOR_H

gui/resultsview.cpp

@@ -527,18 +527,7 @@ void ResultsView::stopAnalysis()
 
 void ResultsView::handleCriticalError(const ErrorItem &item)
 {
-    const QSet<QString> criticalErrors{
-        "cppcheckError",
-        "cppcheckLimit",
-        "internalAstError",
-        "instantiationError",
-        "internalError",
-        "preprocessorErrorDirective",
-        "syntaxError",
-        "unknownMacro"
-    };
-
-    if (criticalErrors.contains(item.errorId)) {
+    if (ErrorLogger::isCriticalErrorId(item.errorId.toStdString())) {
         QString msg = tr("There was a critical error with id '%1'").arg(item.errorId);
         if (!item.file0.isEmpty())
             msg += ", " + tr("when checking %1").arg(item.file0);

lib/check.cpp

@@ -125,3 +125,9 @@ ErrorPath Check::getErrorPath(const Token* errtok, const ValueFlow::Value* value
     }
     return errorPath;
 }
+
+void Check::logChecker(const char id[])
+{
+    reportError(nullptr, Severity::none, "logChecker", id);
+}
+

lib/check.h

@@ -155,6 +155,9 @@ class CPPCHECKLIB Check {
 
     void reportError(const ErrorPath &errorPath, Severity::SeverityType severity, const char id[], const std::string &msg, const CWE &cwe, Certainty certainty);
 
+    /** log checker */
+    void logChecker(const char id[]);
+
     ErrorPath getErrorPath(const Token* errtok, const ValueFlow::Value* value, std::string bug) const;
 
     /**

lib/check64bit.cpp

@@ -46,6 +46,8 @@ void Check64BitPortability::pointerassignment()
     if (!mSettings->severity.isEnabled(Severity::portability))
         return;
 
+    logChecker("Check64BitPortability::pointerassignment"); // portability
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     // Check return values

lib/checkassert.cpp

@@ -44,6 +44,8 @@ void CheckAssert::assertWithSideEffects()
     if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckAssert::assertWithSideEffects"); // warning
+
     for (const Token* tok = mTokenizer->list.front(); tok; tok = tok->next()) {
         if (!Token::simpleMatch(tok, "assert ("))
             continue;

lib/checkautovariables.cpp

@@ -213,6 +213,8 @@ void CheckAutoVariables::assignFunctionArg()
     if (!printStyle && !printWarning)
         return;
 
+    logChecker("CheckAutoVariables::assignFunctionArg"); // style,warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart; tok && tok != scope->bodyEnd; tok = tok->next()) {
@@ -261,6 +263,8 @@ static bool hasOverloadedAssignment(const Token* tok, bool c, bool& inconclusive
 
 void CheckAutoVariables::autoVariables()
 {
+    logChecker("CheckAutoVariables::autoVariables");
+
     const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
@@ -674,6 +678,7 @@ void CheckAutoVariables::checkVarLifetimeScope(const Token * start, const Token
 
 void CheckAutoVariables::checkVarLifetime()
 {
+    logChecker("CheckAutoVariables::checkVarLifetime");
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         if (!scope->function)