Taking care of operation overloading functions

Author: Hinterwaeldlers

lib/checkunusedfunctions.cpp

@@ -231,6 +231,53 @@ void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer, const char Fi
 }
 
 
+static bool isOperatorFunction(const std::string & funcName) {
+    /* Operator functions are invalid function names for C, so no need to check
+     * this in here. As result the returned error function might be incorrect.
+     *
+     * List of valid operators can be found at:
+     * http://en.cppreference.com/w/cpp/language/operators
+     *
+     * Conversion functions must be a member function (at least for gcc), so no
+     * need to cover them for unused functions.
+     *
+     * To speed up the comparision, not the whole list of operators is used.
+     * Instead only the character after the operator prefix is checked to be a
+     * none alpa numeric value, but the '_', to cover function names like
+     * "operator_unused". In addition the following valid operators are checked:
+     * - new
+     * - new[]
+     * - delete
+     * - delete[]
+     */
+    const std::string operatorPrefix = "operator";
+    if (funcName.compare(0, operatorPrefix.length(), operatorPrefix) != 0) {
+        return false;
+    }
+
+    const char firstOperatorChar = funcName[operatorPrefix.length()];
+    if (firstOperatorChar == '_') {
+        return false;
+    }
+
+    if (!std::isalnum(firstOperatorChar)) {
+        return true;
+    }
+
+    const std::vector<std::string> additionalOperators = {
+        "new", "new[]", "delete", "delete[]"
+    };
+    const std::string opName = funcName.substr(operatorPrefix.length());
+
+    for (std::vector<std::string>::const_iterator curOp = additionalOperators.begin(); curOp != additionalOperators.end(); ++curOp) {
+        if (*curOp == opName) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 
 
 bool CheckUnusedFunctions::check(ErrorLogger * const errorLogger, const Settings& settings)
@@ -245,11 +292,13 @@ bool CheckUnusedFunctions::check(ErrorLogger * const errorLogger, const Settings
             it->first == "if")
             continue;
         if (!func.usedSameFile) {
-            std::string filename;
-            if (func.filename != "+")
-                filename = func.filename;
-            unusedFunctionError(errorLogger, filename, func.lineNumber, it->first);
-            errors = true;
+            if (!isOperatorFunction(it->first)) {
+                std::string filename;
+                if (func.filename != "+")
+                    filename = func.filename;
+                unusedFunctionError(errorLogger, filename, func.lineNumber, it->first);
+                errors = true;
+            }
         } else if (! func.usedOtherFile) {
             /** @todo add error message "function is only used in <file> it can be static" */
             /*
@@ -382,8 +431,10 @@ void CheckUnusedFunctions::analyseWholeProgram(ErrorLogger * const errorLogger,
             continue;
 
         if (calls.find(functionName) == calls.end()) {
-            const Location &loc = decl->second;
-            unusedFunctionError(errorLogger, loc.fileName, loc.lineNumber, functionName);
+            if (!isOperatorFunction(functionName)) {
+                const Location &loc = decl->second;
+                unusedFunctionError(errorLogger, loc.fileName, loc.lineNumber, functionName);
+            }
         }
     }
 }

test/testunusedfunctions.cpp

@@ -61,6 +61,8 @@ class TestUnusedFunctions : public TestFixture {
         TEST_CASE(lineNumber); // Ticket 3059
 
         TEST_CASE(ignore_declaration); // ignore declaration
+
+        TEST_CASE(operatorOverload);
     }
 
     void check(const char code[], Settings::PlatformType platform = Settings::Native) {
@@ -390,6 +392,69 @@ class TestUnusedFunctions : public TestFixture {
               "void (*list[])(void) = {f}");
         ASSERT_EQUALS("", errout.str());
     }
+
+    void operatorOverload() {
+        check("class A {\n"
+              "private:\n"
+              "    friend std::ostream & operator<<(std::ostream &, const A&);\n"
+              "};\n"
+              "std::ostream & operator<<(std::ostream &os, const A&) {\n"
+              "    os << \"This is class A\";\n"
+              "}");
+        ASSERT_EQUALS("", errout.str());
+
+        check("class A{};\n"
+              "A operator + (const A &, const A &){ return A(); }\n"
+              "A operator - (const A &, const A &){ return A(); }\n"
+              "A operator * (const A &, const A &){ return A(); }\n"
+              "A operator / (const A &, const A &){ return A(); }\n"
+              "A operator % (const A &, const A &){ return A(); }\n"
+              "A operator & (const A &, const A &){ return A(); }\n"
+              "A operator | (const A &, const A &){ return A(); }\n"
+              "A operator ~ (const A &){ return A(); }\n"
+              "A operator ! (const A &){ return A(); }\n"
+              "bool operator < (const A &, const A &){ return true; }\n"
+              "bool operator > (const A &, const A &){ return true; }\n"
+              "A operator += (const A &, const A &){ return A(); }\n"
+              "A operator -= (const A &, const A &){ return A(); }\n"
+              "A operator *= (const A &, const A &){ return A(); }\n"
+              "A operator /= (const A &, const A &){ return A(); }\n"
+              "A operator %= (const A &, const A &){ return A(); }\n"
+              "A operator &= (const A &, const A &){ return A(); }\n"
+              "A operator ^= (const A &, const A &){ return A(); }\n"
+              "A operator |= (const A &, const A &){ return A(); }\n"
+              "A operator << (const A &, const int){ return A(); }\n"
+              "A operator >> (const A &, const int){ return A(); }\n"
+              "A operator <<= (const A &, const int){ return A(); }\n"
+              "A operator >>= (const A &, const int){ return A(); }\n"
+              "bool operator == (const A &, const A &){ return true; }\n"
+              "bool operator != (const A &, const A &){ return true; }\n"
+              "bool operator <= (const A &, const A &){ return true; }\n"
+              "bool operator >= (const A &, const A &){ return true; }\n"
+              "A operator && (const A &, const int){ return A(); }\n"
+              "A operator || (const A &, const int){ return A(); }\n"
+              "A operator ++ (const A &, const int){ return A(); }\n"
+              "A operator ++ (const A &){ return A(); }\n"
+              "A operator -- (const A &, const int){ return A(); }\n"
+              "A operator -- (const A &){ return A(); }\n"
+              "A operator , (const A &, const A &){ return A(); }\n");
+        ASSERT_EQUALS("", errout.str());
+
+
+        check("class A {\n"
+              "public:\n"
+              "    static void * operator new(std::size_t);\n"
+              "    static void * operator new[](std::size_t);\n"
+              "};\n"
+              "void * A::operator new(std::size_t s) {\n"
+              "    return malloc(s);\n"
+              "}\n"
+              "void * A::operator new[](std::size_t s) {\n"
+              "    return malloc(s);\n"
+              "}");
+        ASSERT_EQUALS("", errout.str());
+    }
+
 };
 
 REGISTER_TEST(TestUnusedFunctions)