File indexing completed on 2024-05-12 05:41:02

 /*
     SPDX-FileCopyrightText: 2015 Klarälvdalens Datakonsult AB a KDAB Group company info@kdab.com
     SPDX-FileContributor: Sérgio Martins <sergio.martins@kdab.com>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "qt4-qstring-from-array.h"
 #include "ClazyContext.h"
 #include "FixItUtils.h"
 #include "HierarchyUtils.h"
 #include "StringUtils.h"
 #include "Utils.h"
 #include "clazy_stl.h"
 
 #include <clang/AST/Decl.h>
 #include <clang/AST/DeclCXX.h>
 #include <clang/AST/Expr.h>
 #include <clang/AST/ExprCXX.h>
 #include <clang/AST/Stmt.h>
 #include <clang/AST/Type.h>
 #include <clang/Basic/Diagnostic.h>
 #include <clang/Basic/LLVM.h>
 #include <clang/Basic/SourceLocation.h>
 #include <clang/Lex/Lexer.h>
 #include <llvm/ADT/ArrayRef.h>
 #include <llvm/ADT/StringRef.h>
 #include <llvm/Support/Casting.h>
 
 using namespace clang;
 
 Qt4QStringFromArray::Qt4QStringFromArray(const std::string &name, ClazyContext *context)
     : CheckBase(name, context, Option_CanIgnoreIncludes)
 {
 }
 
 static bool isInterestingParam(ParmVarDecl *param, bool &is_char_array, bool &is_byte_array)
 {
     is_char_array = false;
     is_byte_array = false;
     const std::string typeStr = param->getType().getAsString();
     if (typeStr == "const class QByteArray &") {
         is_byte_array = true;
     } else if (typeStr == "const char *") { // We only want bytearray and const char*
         is_char_array = true;
     }
 
     return is_char_array || is_byte_array;
 }
 
 static bool isInterestingCtorCall(CXXConstructorDecl *ctor, bool &is_char_array, bool &is_byte_array)
 {
     is_char_array = false;
     is_byte_array = false;
     if (!ctor || !clazy::isOfClass(ctor, "QString")) {
         return false;
     }
 
     for (auto *param : Utils::functionParameters(ctor)) {
         if (isInterestingParam(param, is_char_array, is_byte_array)) {
             break;
         }
 
         return false;
     }
 
     return is_char_array || is_byte_array;
 }
 
 static bool isInterestingMethod(const std::string &methodName)
 {
     static const std::vector<std::string> methods =
         {"append", "prepend", "operator=", "operator==", "operator!=", "operator<", "operator<=", "operator>", "operator>=", "operator+="};
     return clazy::contains(methods, methodName);
 }
 
 static bool isInterestingMethodCall(CXXMethodDecl *method, std::string &methodName, bool &is_char_array, bool &is_byte_array)
 {
     is_char_array = false;
     is_byte_array = false;
     if (!method) {
         return false;
     }
 
     if (clazy::name(method->getParent()) != "QString" || method->getNumParams() != 1) {
         return false;
     }
 
     methodName = method->getNameAsString();
     if (!isInterestingMethod(methodName)) {
         return false;
     }
 
     if (!isInterestingParam(method->getParamDecl(0), is_char_array, is_byte_array)) {
         return false;
     }
 
     return true;
 }
 
 static bool isInterestingOperatorCall(CXXOperatorCallExpr *op, std::string &operatorName, bool &is_char_array, bool &is_byte_array)
 {
     is_char_array = false;
     is_byte_array = false;
     FunctionDecl *func = op->getDirectCallee();
     if (!func) {
         return false;
     }
 
     return isInterestingMethodCall(dyn_cast<CXXMethodDecl>(func), operatorName, is_char_array, is_byte_array);
 }
 
 void Qt4QStringFromArray::VisitStmt(clang::Stmt *stm)
 {
     auto *ctorExpr = dyn_cast<CXXConstructExpr>(stm);
     auto *operatorCall = dyn_cast<CXXOperatorCallExpr>(stm);
     auto *memberCall = dyn_cast<CXXMemberCallExpr>(stm);
     if (!ctorExpr && !operatorCall && !memberCall) {
         return;
     }
 
     std::vector<FixItHint> fixits;
     bool is_char_array = false;
     bool is_byte_array = false;
     std::string methodName;
     std::string message;
 
     if (ctorExpr) {
         CXXConstructorDecl *ctorDecl = ctorExpr->getConstructor();
 
         if (!isInterestingCtorCall(ctorDecl, is_char_array, is_byte_array)) {
             return;
         }
 
         fixits = fixCtorCall(ctorExpr);
         if (is_char_array) {
             message = "QString(const char *) ctor being called";
         } else {
             message = "QString(QByteArray) ctor being called";
         }
     } else if (operatorCall) {
         if (!isInterestingOperatorCall(operatorCall, /*by-ref*/ methodName, is_char_array, is_byte_array)) {
             return;
         }
 
         fixits = fixOperatorCall(operatorCall);
     } else if (memberCall) {
         if (!isInterestingMethodCall(memberCall->getMethodDecl(), /*by-ref*/ methodName, is_char_array, is_byte_array)) {
             return;
         }
 
         fixits = fixMethodCallCall(memberCall);
     } else {
         return;
     }
 
     if (operatorCall || memberCall) {
         if (is_char_array) {
             message = "QString::" + methodName + "(const char *) being called";
         } else {
             message = "QString::" + methodName + "(QByteArray) being called";
         }
     }
 
     emitWarning(stm->getBeginLoc(), message, fixits);
 }
 
 std::vector<FixItHint> Qt4QStringFromArray::fixCtorCall(CXXConstructExpr *ctorExpr)
 {
     Stmt *parent = clazy::parent(m_context->parentMap, ctorExpr); // CXXBindTemporaryExpr
     Stmt *grandParent = clazy::parent(m_context->parentMap, parent); // CXXFunctionalCastExpr
 
     if (parent && grandParent && isa<CXXBindTemporaryExpr>(parent) && isa<CXXFunctionalCastExpr>(grandParent)) {
         return fixitReplaceWithFromLatin1(ctorExpr);
     }
     return fixitInsertFromLatin1(ctorExpr);
 }
 
 std::vector<FixItHint> Qt4QStringFromArray::fixOperatorCall(CXXOperatorCallExpr *op)
 {
     std::vector<FixItHint> fixits;
     if (op->getNumArgs() == 2) {
         Expr *e = op->getArg(1);
         SourceLocation start = e->getBeginLoc();
         SourceLocation end = Lexer::getLocForEndOfToken(clazy::biggestSourceLocationInStmt(sm(), e), 0, sm(), lo());
 
         SourceRange range = {start, end};
         if (range.isInvalid()) {
             emitWarning(op->getBeginLoc(), "internal error");
             return {};
         }
 
         clazy::insertParentMethodCall("QString::fromLatin1", {start, end}, /*by-ref*/ fixits);
 
     } else {
         emitWarning(op->getBeginLoc(), "internal error");
     }
 
     return fixits;
 }
 
 std::vector<FixItHint> Qt4QStringFromArray::fixMethodCallCall(clang::CXXMemberCallExpr *memberExpr)
 {
     std::vector<FixItHint> fixits;
 
     if (memberExpr->getNumArgs() == 1) {
         Expr *e = *(memberExpr->arg_begin());
         SourceLocation start = e->getBeginLoc();
         SourceLocation end = Lexer::getLocForEndOfToken(clazy::biggestSourceLocationInStmt(sm(), e), 0, sm(), lo());
 
         SourceRange range = {start, end};
         if (range.isInvalid()) {
             emitWarning(memberExpr->getBeginLoc(), "internal error");
             return {};
         }
 
         clazy::insertParentMethodCall("QString::fromLatin1", {start, end}, /*by-ref*/ fixits);
     } else {
         emitWarning(memberExpr->getBeginLoc(), "internal error");
     }
 
     return fixits;
 }
 
 std::vector<FixItHint> Qt4QStringFromArray::fixitReplaceWithFromLatin1(CXXConstructExpr *ctorExpr)
 {
     const std::string replacement = "QString::fromLatin1";
     const std::string replacee = "QString";
     std::vector<FixItHint> fixits;
 
     SourceLocation rangeStart = ctorExpr->getBeginLoc();
     SourceLocation rangeEnd = Lexer::getLocForEndOfToken(rangeStart, -1, sm(), lo());
 
     if (rangeEnd.isInvalid()) {
         // Fallback. Have seen a case in the wild where the above would fail, it's very rare
         rangeEnd = rangeStart.getLocWithOffset(replacee.size() - 2);
         if (rangeEnd.isInvalid()) {
             clazy::printLocation(sm(), rangeStart);
             clazy::printLocation(sm(), rangeEnd);
             clazy::printLocation(sm(), Lexer::getLocForEndOfToken(rangeStart, 0, sm(), lo()));
             queueManualFixitWarning(ctorExpr->getBeginLoc());
             return {};
         }
     }
 
     fixits.push_back(FixItHint::CreateReplacement(SourceRange(rangeStart, rangeEnd), replacement));
     return fixits;
 }
 
 std::vector<FixItHint> Qt4QStringFromArray::fixitInsertFromLatin1(CXXConstructExpr *ctorExpr)
 {
     std::vector<FixItHint> fixits;
     SourceRange range;
 
     Expr *arg = *(ctorExpr->arg_begin());
     range.setBegin(arg->getBeginLoc());
     range.setEnd(Lexer::getLocForEndOfToken(clazy::biggestSourceLocationInStmt(sm(), ctorExpr), 0, sm(), lo()));
     if (range.isInvalid()) {
         emitWarning(ctorExpr->getBeginLoc(), "Internal error");
         return {};
     }
 
     clazy::insertParentMethodCall("QString::fromLatin1", range, fixits);
 
     return fixits;
 }