move logic to errorlogger and make generic member

Author: Nettozx

cli/cppcheckexecutor.cpp

@@ -342,11 +342,19 @@ namespace {
 
         static std::string getRuleShortDescription(const ErrorMessage& finding)
         {
+            // Use the generic message if available, otherwise fall back to the original approach
+            if (!finding.genericMessage().empty()) {
+                return finding.genericMessage();
+            }
             return SarifRuleCache::getRuleDescription(finding.id, false);
         }
 
         static std::string getRuleFullDescription(const ErrorMessage& finding)
         {
+            // Use the generic message if available, otherwise fall back to the original approach
+            if (!finding.genericMessage().empty()) {
+                return finding.genericMessage();
+            }
             return SarifRuleCache::getRuleDescription(finding.id, true);
         }
 

lib/errorlogger.cpp

@@ -39,6 +39,7 @@
 #include <string>
 #include <unordered_map>
 #include <utility>
+#include <regex>
 
 #include "xml.h"
 
@@ -190,6 +191,9 @@ ErrorMessage::ErrorMessage(const tinyxml2::XMLElement * const errmsg)
     attr = errmsg->Attribute("verbose");
     mVerboseMessage = attr ? attr : "";
 
+    attr = errmsg->Attribute("generic");
+    mGenericMessage = attr ? attr : "";
+
     attr = errmsg->Attribute("hash");
     hash = attr ? strToInt<std::size_t>(attr) : 0;
 
@@ -216,6 +220,48 @@ ErrorMessage::ErrorMessage(const tinyxml2::XMLElement * const errmsg)
     }
 }
 
+// Convert instance-specific messages to generic ones
+static std::string makeGeneric(const std::string& message)
+{
+    std::string result = message;
+
+    // Replace variable names in single quotes with generic terms
+    result = std::regex_replace(result, std::regex(R"(Variable '[^']*')"), "Variable");
+    result = std::regex_replace(result, std::regex(R"(variable '[^']*')"), "variable");
+    result = std::regex_replace(result, std::regex(R"(Function '[^']*')"), "Function");
+    result = std::regex_replace(result, std::regex(R"(function '[^']*')"), "function");
+    result = std::regex_replace(result, std::regex(R"(Parameter '[^']*')"), "Parameter");
+    result = std::regex_replace(result, std::regex(R"(parameter '[^']*')"), "parameter");
+    result = std::regex_replace(result, std::regex(R"(Member variable '[^']*')"), "Member variable");
+    result = std::regex_replace(result, std::regex(R"(member variable '[^']*')"), "member variable");
+    
+    // Replace class::member patterns
+    result = std::regex_replace(result, std::regex(R"('[^:]*::[^']*')"), "'ClassName::member'");
+    
+    // Replace specific numbers with generic terms
+    result = std::regex_replace(result, std::regex(R"(\d+)"), "N");
+    
+    // Replace array access patterns
+    result = std::regex_replace(result, std::regex(R"(\[[^\]]+\])"), "[index]");
+    
+    // Replace remaining single-quoted identifiers
+    result = std::regex_replace(result, std::regex(R"('[a-zA-Z_][a-zA-Z0-9_]*')"), "'identifier'");
+    
+    // Clean up redundant patterns
+    result = std::regex_replace(result, std::regex(R"(Variable 'identifier')"), "Variable");
+    result = std::regex_replace(result, std::regex(R"(Function 'identifier')"), "Function");
+    result = std::regex_replace(result, std::regex(R"(Parameter 'identifier')"), "Parameter");
+    result = std::regex_replace(result, std::regex(R"(Member variable 'identifier')"), "Member variable");
+    
+    // Clean up multiple spaces
+    result = std::regex_replace(result, std::regex(R"(\s+)"), " ");
+    
+    // Trim whitespace
+    result = std::regex_replace(result, std::regex(R"(^\s+|\s+$)"), "");
+    
+    return result;
+}
+
 void ErrorMessage::setmsg(const std::string &msg)
 {
     // If a message ends to a '\n' and contains only a one '\n'
@@ -233,12 +279,18 @@ void ErrorMessage::setmsg(const std::string &msg)
     if (pos == std::string::npos) {
         mShortMessage = replaceStr(msg, "$symbol", symbolName);
         mVerboseMessage = replaceStr(msg, "$symbol", symbolName);
+        // Set generic message (remove symbol names and make generic)
+        const std::string msgWithoutSymbol = replaceStr(msg, "$symbol", "");
+        mGenericMessage = makeGeneric(msgWithoutSymbol);
     } else if (startsWith(msg,"$symbol:")) {
         mSymbolNames += msg.substr(8, pos-7);
         setmsg(msg.substr(pos + 1));
     } else {
         mShortMessage = replaceStr(msg.substr(0, pos), "$symbol", symbolName);
         mVerboseMessage = replaceStr(msg.substr(pos + 1), "$symbol", symbolName);
+        // Set generic message (remove symbol names and make generic)
+        const std::string msgWithoutSymbol = replaceStr(msg.substr(0, pos), "$symbol", "");
+        mGenericMessage = makeGeneric(msgWithoutSymbol);
     }
 }
 
@@ -289,10 +341,12 @@ std::string ErrorMessage::serialize() const
 
     const std::string saneShortMessage = fixInvalidChars(mShortMessage);
     const std::string saneVerboseMessage = fixInvalidChars(mVerboseMessage);
+    const std::string saneGenericMessage = fixInvalidChars(mGenericMessage);
 
     serializeString(oss, saneShortMessage);
     serializeString(oss, saneVerboseMessage);
     serializeString(oss, mSymbolNames);
+    serializeString(oss, saneGenericMessage);
     oss += std::to_string(callStack.size());
     oss += " ";
 
@@ -320,9 +374,9 @@ void ErrorMessage::deserialize(const std::string &data)
     callStack.clear();
 
     std::istringstream iss(data);
-    std::array<std::string, 10> results;
+    std::array<std::string, 11> results;
     std::size_t elem = 0;
-    while (iss.good() && elem < 10) {
+    while (iss.good() && elem < 11) {
         unsigned int len = 0;
         if (!(iss >> len))
             throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - invalid length");
@@ -348,7 +402,7 @@ void ErrorMessage::deserialize(const std::string &data)
     if (!iss.good())
         throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - premature end of data");
 
-    if (elem != 10)
+    if (elem != 11)
         throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - insufficient elements");
 
     id = std::move(results[0]);
@@ -372,6 +426,7 @@ void ErrorMessage::deserialize(const std::string &data)
     mShortMessage = std::move(results[7]);
     mVerboseMessage = std::move(results[8]);
     mSymbolNames = std::move(results[9]);
+    mGenericMessage = std::move(results[10]);
 
     unsigned int stackSize = 0;
     if (!(iss >> stackSize))
@@ -497,6 +552,8 @@ std::string ErrorMessage::toXML() const
         printer.PushAttribute("classification", classification.c_str());
     printer.PushAttribute("msg", fixInvalidChars(mShortMessage).c_str());
     printer.PushAttribute("verbose", fixInvalidChars(mVerboseMessage).c_str());
+    if (!mGenericMessage.empty())
+        printer.PushAttribute("generic", fixInvalidChars(mGenericMessage).c_str());
     if (cwe.id)
         printer.PushAttribute("cwe", cwe.id);
     if (hash)

lib/errorlogger.h

@@ -200,6 +200,14 @@ class CPPCHECKLIB ErrorMessage {
         return mSymbolNames;
     }
 
+    /** Generic message (instance-specific variables replaced with generic terms) */
+    const std::string &genericMessage() const {
+        return mGenericMessage;
+    }
+
+    /** set generic message */
+    void setGenericMessage(const std::string &msg);
+
     static ErrorMessage fromInternalError(const InternalError &internalError, const TokenList *tokenList, const std::string &filename, const std::string& msg = "");
 
 private:
@@ -213,6 +221,9 @@ class CPPCHECKLIB ErrorMessage {
 
     /** symbol names */
     std::string mSymbolNames;
+
+    /** Generic message */
+    std::string mGenericMessage;
 };
 
 /**