Optimize more codepaths to use operator enum instead of string compar…

…isons

This is a small optimization, but checking the operator costs 1/10 of the time of a string comparison.
Especially for the often used Utils and level0 check, this is sensible
to have.

src/Utils.cpp

@@ -578,7 +578,7 @@ bool Utils::isAssignOperator(CXXOperatorCallExpr *op, StringRef className, Strin
         }
     }
 
-    if (functionDecl->getNameAsString() != "operator=") {
+    if (functionDecl->getOverloadedOperator() != clang::OO_Equal) {
         return false;
     }
 

src/checks/level0/qstring-comparison-to-implicit-char.cpp

@@ -33,7 +33,7 @@ void QStringComparisonToImplicitChar::VisitStmt(clang::Stmt *stmt)
     }
 
     auto *functionDecl = dyn_cast<FunctionDecl>(callExpr->getCalleeDecl());
-    if (!functionDecl || functionDecl->getQualifiedNameAsString() != "operator==") {
+    if (!functionDecl || functionDecl->getOverloadedOperator() != clang::OO_EqualEqual) {
         return;
     }
 

src/checks/level2/function-args-by-ref.cpp

@@ -61,9 +61,8 @@ bool FunctionArgsByRef::shouldIgnoreClass(CXXRecordDecl *record)
 bool FunctionArgsByRef::shouldIgnoreOperator(FunctionDecl *function)
 {
     // Too many warnings in operator<<
-    static const std::vector<StringRef> ignoreList = {"operator<<"};
-
-    return clazy::contains(ignoreList, clazy::name(function));
+    OverloadedOperatorKind op = function->getOverloadedOperator();
+    return op == clang::OO_LessLess;
 }
 
 bool FunctionArgsByRef::shouldIgnoreFunction(clang::FunctionDecl *function)

src/checks/level2/old-style-connect.cpp

@@ -189,22 +189,10 @@ bool OldStyleConnect::isQPointer(Expr *expr) const
     std::vector<CXXMemberCallExpr *> memberCalls;
     clazy::getChilds<CXXMemberCallExpr>(expr, memberCalls);
 
-    for (auto *callExpr : memberCalls) {
-        if (!callExpr->getDirectCallee()) {
-            continue;
-        }
-        auto *method = dyn_cast<CXXMethodDecl>(callExpr->getDirectCallee());
-        if (!method) {
-            continue;
-        }
-
-        // Any better way to detect it's an operator ?
-        if (clazy::startsWith(method->getNameAsString(), "operator ")) {
-            return true;
-        }
-    }
-
-    return false;
+    return std::any_of(memberCalls.begin(), memberCalls.end(), [](CXXMemberCallExpr *callExpr) {
+        auto *callee = callExpr->getDirectCallee();
+        return callee && dyn_cast<CXXConversionDecl>(callee);
+    });
 }
 
 bool OldStyleConnect::isPrivateSlot(const std::string &name) const

src/checks/manuallevel/detaching-member.cpp

@@ -22,6 +22,7 @@
 #include <clang/AST/Stmt.h>
 #include <clang/AST/Type.h>
 #include <clang/Basic/LLVM.h>
+#include <clang/Basic/OperatorKinds.h>
 #include <llvm/ADT/StringRef.h>
 #include <llvm/Support/Casting.h>
 
@@ -57,7 +58,7 @@ void DetachingMember::VisitStmt(clang::Stmt *stm)
     if (operatorExpr) {
         FunctionDecl *func = operatorExpr->getDirectCallee();
         method = func ? dyn_cast<CXXMethodDecl>(func) : nullptr;
-        if (!method || clazy::name(method) != "operator[]") {
+        if (!method || method->getOverloadedOperator() != clang::OO_Subscript) {
             return;
         }