Fixed #12370 (Premium misra/cert/autosar: enable all corresponding ch…

…eckers in open source cppcheck) (#5901)

cli/cmdlineparser.cpp

@@ -913,6 +913,12 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
                 mSettings.premiumArgs += "--" + p;
                 if (p == "misra-c-2012" || p == "misra-c-2023")
                     mSettings.addons.emplace("misra");
+                if (startsWith(p, "autosar") || startsWith(p, "cert") || startsWith(p, "misra")) {
+                    // All checkers related to the coding standard should be enabled. The coding standards
+                    // do not all undefined behavior or portability issues.
+                    mSettings.addEnabled("warning");
+                    mSettings.addEnabled("portability");
+                }
             }
 
             // --project

createrelease

@@ -5,6 +5,10 @@
 # Create release candidate
 # ========================
 #
+# check every isPremiumEnabled call:
+# - every id should be in --errorlist
+# - premiumaddon: check coverage.py
+#
 # Windows installer:
 # - ensure latest build was successful
 # - ensure cfg files etc are included (win_installer/cppcheck.wxs)

lib/checkautovariables.cpp

@@ -210,7 +210,7 @@ void CheckAutoVariables::assignFunctionArg()
 {
     const bool printStyle = mSettings->severity.isEnabled(Severity::style);
     const bool printWarning = mSettings->severity.isEnabled(Severity::warning);
-    if (!printStyle && !printWarning)
+    if (!printStyle && !printWarning && !mSettings->isPremiumEnabled("uselessAssignmentPtrArg"))
         return;
 
     logChecker("CheckAutoVariables::assignFunctionArg"); // style,warning

lib/checkbool.cpp

@@ -50,7 +50,7 @@ static bool isBool(const Variable* var)
 //---------------------------------------------------------------------------
 void CheckBool::checkIncrementBoolean()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("incrementboolean"))
         return;
 
     logChecker("CheckBool::checkIncrementBoolean"); // style

lib/checkclass.cpp

@@ -127,7 +127,7 @@ void CheckClass::constructors()
 {
     const bool printStyle = mSettings->severity.isEnabled(Severity::style);
     const bool printWarnings = mSettings->severity.isEnabled(Severity::warning);
-    if (!printStyle && !printWarnings)
+    if (!printStyle && !printWarnings && !mSettings->isPremiumEnabled("uninitMemberVar"))
         return;
 
     logChecker("CheckClass::checkConstructors"); // style,warning
@@ -336,7 +336,7 @@ void CheckClass::constructors()
 
 void CheckClass::checkExplicitConstructors()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("noExplicitConstructor"))
         return;
 
     logChecker("CheckClass::checkExplicitConstructors"); // style
@@ -1275,7 +1275,7 @@ static bool checkFunctionUsage(const Function *privfunc, const Scope* scope)
 
 void CheckClass::privateFunctions()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("unusedPrivateFunction"))
         return;
 
     logChecker("CheckClass::privateFunctions"); // style
@@ -1564,7 +1564,7 @@ void CheckClass::memsetErrorFloat(const Token *tok, const std::string &type)
 
 void CheckClass::operatorEqRetRefThis()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("operatorEqRetRefThis"))
         return;
 
     logChecker("CheckClass::operatorEqRetRefThis"); // style
@@ -2090,7 +2090,9 @@ void CheckClass::checkConst()
     if (!mSettings->certainty.isEnabled(Certainty::inconclusive))
         return;
 
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) &&
+        !mSettings->isPremiumEnabled("functionConst") &&
+        !mSettings->isPremiumEnabled("functionStatic"))
         return;
 
     logChecker("CheckClass::checkConst"); // style,inconclusive
@@ -2639,7 +2641,7 @@ namespace { // avoid one-definition-rule violation
 
 void CheckClass::initializerListOrder()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("initializerList"))
         return;
 
     // This check is not inconclusive.  However it only determines if the initialization
@@ -3137,7 +3139,7 @@ void CheckClass::copyCtorAndEqOperatorError(const Token *tok, const std::string
 
 void CheckClass::checkOverride()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("missingOverride"))
         return;
     if (mSettings->standards.cpp < Standards::CPP11)
         return;
@@ -3237,7 +3239,7 @@ static bool compareTokenRanges(const Token* start1, const Token* end1, const Tok
 
 void CheckClass::checkUselessOverride()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("uselessOverride"))
         return;
 
     logChecker("CheckClass::checkUselessOverride"); // style

lib/checkcondition.cpp

@@ -87,7 +87,7 @@ bool CheckCondition::isAliased(const std::set<int> &vars) const
 
 void CheckCondition::assignIf()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("assignIf"))
         return;
 
     logChecker("CheckCondition::assignIf"); // style
@@ -306,7 +306,7 @@ static bool isOperandExpanded(const Token *tok)
 
 void CheckCondition::checkBadBitmaskCheck()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("badBitmaskCheck"))
         return;
 
     logChecker("CheckCondition::checkBadBitmaskCheck"); // style
@@ -354,7 +354,7 @@ void CheckCondition::badBitmaskCheckError(const Token *tok, bool isNoOp)
 
 void CheckCondition::comparison()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("comparisonError"))
         return;
 
     logChecker("CheckCondition::comparison"); // style
@@ -472,7 +472,7 @@ bool CheckCondition::isOverlappingCond(const Token * const cond1, const Token *
 
 void CheckCondition::duplicateCondition()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("duplicateCondition"))
         return;
 
     logChecker("CheckCondition::duplicateCondition"); // style
@@ -523,7 +523,7 @@ void CheckCondition::duplicateConditionError(const Token *tok1, const Token *tok
 
 void CheckCondition::multiCondition()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("multiCondition"))
         return;
 
     logChecker("CheckCondition::multiCondition"); // style
@@ -1123,7 +1123,7 @@ void CheckCondition::checkIncorrectLogicOperator()
 {
     const bool printStyle = mSettings->severity.isEnabled(Severity::style);
     const bool printWarning = mSettings->severity.isEnabled(Severity::warning);
-    if (!printWarning && !printStyle)
+    if (!printWarning && !printStyle && !mSettings->isPremiumEnabled("incorrectLogicOperator"))
         return;
     const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
 
@@ -1415,7 +1415,7 @@ static int countPar(const Token *tok1, const Token *tok2)
 //---------------------------------------------------------------------------
 void CheckCondition::clarifyCondition()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("clarifyCondition"))
         return;
 
     const bool isC = mTokenizer->isC();
@@ -1481,7 +1481,9 @@ void CheckCondition::clarifyConditionError(const Token *tok, bool assign, bool b
 
 void CheckCondition::alwaysTrueFalse()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) &&
+        !mSettings->isPremiumEnabled("alwaysTrue") &&
+        !mSettings->isPremiumEnabled("alwaysFalse"))
         return;
 
     logChecker("CheckCondition::alwaysTrueFalse"); // style
@@ -1783,7 +1785,7 @@ void CheckCondition::pointerAdditionResultNotNullError(const Token *tok, const T
 
 void CheckCondition::checkDuplicateConditionalAssign()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("duplicateConditionalAssign"))
         return;
 
     logChecker("CheckCondition::checkDuplicateConditionalAssign"); // style
@@ -1862,7 +1864,7 @@ void CheckCondition::duplicateConditionalAssignError(const Token *condTok, const
 
 void CheckCondition::checkAssignmentInCondition()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("assignmentInCondition"))
         return;
 
     logChecker("CheckCondition::checkAssignmentInCondition"); // style
@@ -1909,7 +1911,7 @@ void CheckCondition::assignmentInCondition(const Token *eq)
 
 void CheckCondition::checkCompareValueOutOfTypeRange()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("compareValueOutOfTypeRange"))
         return;
 
     if (mSettings->platform.type == Platform::Type::Native ||

lib/checkexceptionsafety.cpp

@@ -169,7 +169,7 @@ void CheckExceptionSafety::deallocThrowError(const Token * const tok, const std:
 //---------------------------------------------------------------------------
 void CheckExceptionSafety::checkRethrowCopy()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("rethrowcopy"))
         return;
 
     logChecker("CheckExceptionSafety::checkRethrowCopy"); // style
@@ -213,7 +213,7 @@ void CheckExceptionSafety::rethrowCopyError(const Token * const tok, const std::
 //---------------------------------------------------------------------------
 void CheckExceptionSafety::checkCatchExceptionByValue()
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("catchexceptionbyvalue"))
         return;
 
     logChecker("CheckExceptionSafety::checkCatchExceptionByValue"); // style
@@ -329,7 +329,8 @@ void CheckExceptionSafety::noexceptThrowError(const Token * const tok)
 //--------------------------------------------------------------------------
 void CheckExceptionSafety::unhandledExceptionSpecification()
 {
-    if (!mSettings->severity.isEnabled(Severity::style) || !mSettings->certainty.isEnabled(Certainty::inconclusive))
+    if ((!mSettings->severity.isEnabled(Severity::style) || !mSettings->certainty.isEnabled(Certainty::inconclusive)) &&
+        !mSettings->isPremiumEnabled("unhandledexceptionspecification"))
         return;
 
     logChecker("CheckExceptionSafety::unhandledExceptionSpecification"); // style,inconclusive

lib/checkfunctions.cpp

@@ -242,7 +242,9 @@ void CheckFunctions::invalidFunctionArgStrError(const Token *tok, const std::str
 //---------------------------------------------------------------------------
 void CheckFunctions::checkIgnoredReturnValue()
 {
-    if (!mSettings->severity.isEnabled(Severity::warning) && !mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::warning) &&
+        !mSettings->severity.isEnabled(Severity::style) &&
+        !mSettings->isPremiumEnabled("ignoredReturnValue"))
         return;
 
     logChecker("CheckFunctions::checkIgnoredReturnValue"); // style,warning
@@ -424,7 +426,7 @@ void CheckFunctions::checkMathFunctions()
     const bool styleC99 = mSettings->severity.isEnabled(Severity::style) && mSettings->standards.c != Standards::C89 && mSettings->standards.cpp != Standards::CPP03;
     const bool printWarnings = mSettings->severity.isEnabled(Severity::warning);
 
-    if (!styleC99 && !printWarnings)
+    if (!styleC99 && !printWarnings && !mSettings->isPremiumEnabled("wrongmathcall"))
         return;
 
     logChecker("CheckFunctions::checkMathFunctions"); // style,warning,c99,c++11

lib/checkmemoryleak.cpp

@@ -635,7 +635,7 @@ void CheckMemoryLeakInClass::variable(const Scope *scope, const Token *tokVarnam
 
 void CheckMemoryLeakInClass::unsafeClassError(const Token *tok, const std::string &classname, const std::string &varname)
 {
-    if (!mSettings->severity.isEnabled(Severity::style))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("unsafeClassCanLeak"))
         return;
 
     reportError(tok, Severity::style, "unsafeClassCanLeak",