CMake/Utilities/ClangTidyModule/StringConcatenationUseCmstrcatCheck.cxx
Kitware Robot 1772622772 LICENSE: Replace references to Copyright.txt with LICENSE.rst
```
git grep -lz 'Copyright.txt or https://cmake.org/licensing ' |
  while IFS= read -r -d $'\0' f ; do
    sed -i '/Copyright.txt or https:\/\/cmake.org\/licensing / {
              s/Copyright.txt/LICENSE.rst/
            }' "$f" ; done
```
2025-03-03 10:43:35 -05:00

181 lines
5.8 KiB
C++

/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file LICENSE.rst or https://cmake.org/licensing for details. */
#include "StringConcatenationUseCmstrcatCheck.h"
#include <cassert>
#include <clang/ASTMatchers/ASTMatchFinder.h>
#include <clang/Lex/Lexer.h>
namespace clang {
namespace tidy {
namespace cmake {
using namespace ast_matchers;
StringConcatenationUseCmstrcatCheck::StringConcatenationUseCmstrcatCheck(
StringRef Name, ClangTidyContext* Context)
: ClangTidyCheck(Name, Context)
{
}
void StringConcatenationUseCmstrcatCheck::registerMatchers(MatchFinder* Finder)
{
auto IsString = expr(hasType(qualType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(classTemplateSpecializationDecl(
hasName("::std::basic_string"),
hasTemplateArgument(
0, templateArgument(refersToType(asString("char")))))))))));
auto IsChar = expr(hasType(asString("char")));
auto IsCharPtr = expr(hasType(pointerType(pointee(asString("const char")))));
auto IsStringConcat =
cxxOperatorCallExpr(hasOperatorName("+"),
anyOf(allOf(hasLHS(IsString), hasRHS(IsString)),
allOf(hasLHS(IsString), hasRHS(IsChar)),
allOf(hasLHS(IsString), hasRHS(IsCharPtr)),
allOf(hasLHS(IsChar), hasRHS(IsString)),
allOf(hasLHS(IsCharPtr), hasRHS(IsString))));
auto IsStringAppend = cxxOperatorCallExpr(
hasOperatorName("+="), hasLHS(IsString),
anyOf(hasRHS(IsString), hasRHS(IsChar), hasRHS(IsCharPtr)));
auto IsStringConcatWithLHS =
cxxOperatorCallExpr(
IsStringConcat,
optionally(hasLHS(materializeTemporaryExpr(
has(cxxBindTemporaryExpr(has(IsStringConcat.bind("lhs"))))))))
.bind("concat");
auto IsStringAppendWithRHS =
cxxOperatorCallExpr(
IsStringAppend,
optionally(hasRHS(materializeTemporaryExpr(has(implicitCastExpr(
has(cxxBindTemporaryExpr(has(IsStringConcat.bind("rhs"))))))))))
.bind("append");
Finder->addMatcher(IsStringConcatWithLHS, this);
Finder->addMatcher(IsStringAppendWithRHS, this);
}
void StringConcatenationUseCmstrcatCheck::check(
MatchFinder::MatchResult const& Result)
{
CXXOperatorCallExpr const* AppendNode =
Result.Nodes.getNodeAs<CXXOperatorCallExpr>("append");
CXXOperatorCallExpr const* ConcatNode =
Result.Nodes.getNodeAs<CXXOperatorCallExpr>("concat");
if (AppendNode != nullptr) {
if (AppendNode->getBeginLoc().isValid()) {
assert(InProgressExprChains.find(AppendNode) ==
InProgressExprChains.end());
ExprChain TmpExprChain =
std::make_pair(OperatorType::PlusEquals,
std::vector<CXXOperatorCallExpr const*>{ AppendNode });
CXXOperatorCallExpr const* RHSNode =
Result.Nodes.getNodeAs<CXXOperatorCallExpr>("rhs");
if (RHSNode != nullptr) {
if (RHSNode->getBeginLoc().isValid()) {
InProgressExprChains[RHSNode] = std::move(TmpExprChain);
}
} else {
issueCorrection(TmpExprChain, Result);
}
}
}
if (ConcatNode != nullptr) {
if (ConcatNode->getBeginLoc().isValid()) {
ExprChain TmpExprChain;
if (!(InProgressExprChains.find(ConcatNode) ==
InProgressExprChains.end())) {
TmpExprChain = std::move(InProgressExprChains[ConcatNode]);
InProgressExprChains.erase(ConcatNode);
if (TmpExprChain.first == OperatorType::PlusEquals) {
TmpExprChain.second.insert(TmpExprChain.second.begin() + 1,
ConcatNode);
} else {
TmpExprChain.second.insert(TmpExprChain.second.begin(), ConcatNode);
}
} else {
TmpExprChain = std::make_pair(
OperatorType::Plus,
std::vector<CXXOperatorCallExpr const*>{ ConcatNode });
}
CXXOperatorCallExpr const* LHSNode =
Result.Nodes.getNodeAs<CXXOperatorCallExpr>("lhs");
if (LHSNode != nullptr) {
if (LHSNode->getBeginLoc().isValid()) {
InProgressExprChains[LHSNode] = std::move(TmpExprChain);
}
} else {
issueCorrection(TmpExprChain, Result);
}
}
}
}
void StringConcatenationUseCmstrcatCheck::issueCorrection(
ExprChain const& Chain, MatchFinder::MatchResult const& Result)
{
std::vector<FixItHint> FixIts;
CXXOperatorCallExpr const* ExprNode;
std::vector<clang::CXXOperatorCallExpr const*>::const_iterator It =
Chain.second.begin();
if (Chain.first == OperatorType::PlusEquals) {
ExprNode = *It;
StringRef LHS = Lexer::getSourceText(
CharSourceRange::getTokenRange(ExprNode->getArg(0)->getSourceRange()),
Result.Context->getSourceManager(), Result.Context->getLangOpts());
FixIts.push_back(FixItHint::CreateReplacement(
ExprNode->getExprLoc(), "= cmStrCat(" + LHS.str() + ","));
It++;
} else {
ExprNode = *It;
FixIts.push_back(
FixItHint::CreateInsertion(ExprNode->getBeginLoc(), "cmStrCat("));
}
while (It != std::end(Chain.second)) {
ExprNode = *It;
FixIts.push_back(
FixItHint::CreateReplacement(ExprNode->getOperatorLoc(), ","));
It++;
}
It--;
ExprNode = *It;
StringRef LastToken = Lexer::getSourceText(
CharSourceRange::getTokenRange(
ExprNode->getArg(1)->getSourceRange().getEnd()),
Result.Context->getSourceManager(), Result.Context->getLangOpts());
FixIts.push_back(FixItHint::CreateInsertion(
ExprNode->getEndLoc().getLocWithOffset(LastToken.str().size()), ")"));
It = Chain.second.begin();
ExprNode = *It;
if (Chain.first == OperatorType::PlusEquals) {
this->diag(ExprNode->getOperatorLoc(),
"use cmStrCat() instead of string append")
<< FixIts;
} else {
this->diag(ExprNode->getBeginLoc(),
"use cmStrCat() instead of string concatenation")
<< FixIts;
}
}
}
}
}