// Catches cases like: int i = s.mid(1, 1).toInt()
bool StringRefCandidates::processCase1(CXXMemberCallExpr *memberCall)
{
if (!memberCall)
return false;
// In the AST secondMethod() is parent of firstMethod() call, and will be visited first (because at runtime firstMethod() is resolved first().
// So check for interesting second method first
CXXMethodDecl *method = memberCall->getMethodDecl();
if (!isInterestingSecondMethod(method))
return false;
vector<CallExpr *> callExprs = Utils::callListForChain(memberCall);
if (callExprs.size() < 2)
return false;
// The list now contains {secondMethod(), firstMethod() }
CXXMemberCallExpr *firstMemberCall = dyn_cast<CXXMemberCallExpr>(callExprs.at(1));
if (!firstMemberCall || !isInterestingFirstMethod(firstMemberCall->getMethodDecl()))
return false;
const string firstMethodName = firstMemberCall->getMethodDecl()->getNameAsString();
std::vector<FixItHint> fixits;
if (isFixitEnabled(FixitUseQStringRef)) {
fixits = fixit(firstMemberCall);
}
emitWarning(firstMemberCall->getLocEnd(), "Use " + firstMethodName + "Ref() instead", fixits);
return true;
}
void QDeleteAll::VisitStmt(clang::Stmt *stmt)
{
// Find a call to QMap/QSet/QHash::values
CXXMemberCallExpr *valuesCall = dyn_cast<CXXMemberCallExpr>(stmt);
if (valuesCall &&
valuesCall->getDirectCallee() &&
valuesCall->getDirectCallee()->getNameAsString() == "values")
{
const std::string valuesClassName = valuesCall->getMethodDecl()->getParent()->getNameAsString();
if (valuesClassName == "QMap" || valuesClassName == "QSet" || valuesClassName == "QHash") { // QMultiHash and QMultiMap automatically supported
// Once found see if the first parent call is qDeleteAll
int i = 1;
Stmt *p = Utils::parent(m_parentMap, stmt, i);
while (p) {
CallExpr *pc = dyn_cast<CallExpr>(p);
if (pc) {
if (pc->getDirectCallee() && pc->getDirectCallee()->getNameAsString() == "qDeleteAll") {
emitWarning(p->getLocStart(), "Calling qDeleteAll with " + valuesClassName + "::values, call qDeleteAll on the container itself");
}
break;
}
++i;
p = Utils::parent(m_parentMap, stmt, i);
}
}
}
}
void QGetEnv::VisitStmt(clang::Stmt *stmt)
{
// Lets check only in function calls. Otherwise there are too many false positives, it's common
// to implicit cast to bool when checking pointers for validity, like if (ptr)
CXXMemberCallExpr *memberCall = dyn_cast<CXXMemberCallExpr>(stmt);
if (!memberCall)
return;
CXXMethodDecl *method = memberCall->getMethodDecl();
if (!method)
return;
CXXRecordDecl *record = method->getParent();
if (!record || record->getNameAsString() != "QByteArray") {
return;
}
std::vector<CallExpr *> calls = Utils::callListForChain(memberCall);
if (calls.size() != 2)
return;
CallExpr *qgetEnvCall = calls.back();
FunctionDecl *func = qgetEnvCall->getDirectCallee();
if (!func || func->getNameAsString() != "qgetenv")
return;
string methodname = method->getNameAsString();
string errorMsg;
std::string replacement;
if (methodname == "isEmpty") {
errorMsg = "qgetenv().isEmpty() allocates.";
replacement = "qEnvironmentVariableIsEmpty";
} else if (methodname == "isNull") {
errorMsg = "qgetenv().isNull() allocates.";
replacement = "qEnvironmentVariableIsSet";
} else if (methodname == "toInt") {
errorMsg = "qgetenv().toInt() is slow.";
replacement = "qEnvironmentVariableIntValue";
}
if (!errorMsg.empty()) {
std::vector<FixItHint> fixits;
if (isFixitEnabled(FixitAll)) {
const bool success = FixItUtils::transformTwoCallsIntoOne(m_ci, qgetEnvCall, memberCall, replacement, fixits);
if (!success) {
queueManualFixitWarning(memberCall->getLocStart(), FixitAll);
}
}
errorMsg += " Use " + replacement + "() instead";
emitWarning(memberCall->getLocStart(), errorMsg.c_str(), fixits);
}
}
// Catches cases like: s.append(s2.mid(1, 1));
bool StringRefCandidates::processCase2(CallExpr *call)
{
CXXMemberCallExpr *memberCall = dyn_cast<CXXMemberCallExpr>(call);
CXXOperatorCallExpr *operatorCall = dyn_cast<CXXOperatorCallExpr>(call);
CXXMethodDecl *method = nullptr;
if (memberCall) {
method = memberCall->getMethodDecl();
} else if (operatorCall && operatorCall->getCalleeDecl()) {
Decl *decl = operatorCall->getCalleeDecl();
method = dyn_cast<CXXMethodDecl>(decl);
}
if (!isMethodReceivingQStringRef(method))
return false;
Expr *firstArgument = call->getNumArgs() > 0 ? call->getArg(0) : nullptr;
MaterializeTemporaryExpr *temp = firstArgument ? dyn_cast<MaterializeTemporaryExpr>(firstArgument) : nullptr;
if (!temp) {
Expr *secondArgument = call->getNumArgs() > 1 ? call->getArg(1) : nullptr;
temp = secondArgument ? dyn_cast<MaterializeTemporaryExpr>(secondArgument) : nullptr;
if (!temp) // For the CXXOperatorCallExpr it's in the second argument
return false;
}
CallExpr *innerCall = HierarchyUtils::getFirstChildOfType2<CallExpr>(temp);
CXXMemberCallExpr *innerMemberCall = innerCall ? dyn_cast<CXXMemberCallExpr>(innerCall) : nullptr;
if (!innerMemberCall)
return false;
CXXMethodDecl *innerMethod = innerMemberCall->getMethodDecl();
if (!isInterestingFirstMethod(innerMethod))
return false;
std::vector<FixItHint> fixits;
if (isFixitEnabled(FixitUseQStringRef)) {
fixits = fixit(innerMemberCall);
}
emitWarning(call->getLocStart(), "Use " + innerMethod->getNameAsString() + "Ref() instead", fixits);
return true;
}
void Qt4_QStringFromArray::VisitStmt(clang::Stmt *stm)
{
CXXConstructExpr *ctorExpr = dyn_cast<CXXConstructExpr>(stm);
CXXOperatorCallExpr *operatorCall = dyn_cast<CXXOperatorCallExpr>(stm);
CXXMemberCallExpr *memberCall = dyn_cast<CXXMemberCallExpr>(stm);
if (!ctorExpr && !operatorCall && !memberCall)
return;
vector<FixItHint> fixits;
bool is_char_array = false;
bool is_byte_array = false;
string methodName;
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->getLocStart(), message, fixits);
}
void IsEmptyVSCount::VisitStmt(clang::Stmt *stmt)
{
ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(stmt);
if (!cast || cast->getCastKind() != clang::CK_IntegralToBoolean)
return;
CXXMemberCallExpr *memberCall = dyn_cast<CXXMemberCallExpr>(*(cast->child_begin()));
CXXMethodDecl *method = memberCall ? memberCall->getMethodDecl() : nullptr;
if (!StringUtils::functionIsOneOf(method, {"size", "count", "length"}))
return;
if (!StringUtils::classIsOneOf(method->getParent(), QtUtils::qtContainers()))
return;
emitWarning(stmt->getLocStart(), "use isEmpty() instead");
}
