================ @@ -0,0 +1,280 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "MissingEndComparisonCheck.h" +#include "../utils/OptionsUtils.h" +#include "clang/AST/ASTContext.h" +#include "clang/ASTMatchers/ASTMatchFinder.h" +#include "clang/Lex/Lexer.h" +#include "clang/Tooling/FixIt.h" + +using namespace clang::ast_matchers; + +namespace clang::tidy::bugprone { + +namespace { + +constexpr llvm::StringRef IteratorAlgorithms[] = { + "::std::find", "::std::find_if", + "::std::find_if_not", "::std::search", + "::std::search_n", "::std::find_end", + "::std::find_first_of", "::std::lower_bound", + "::std::upper_bound", "::std::partition_point", + "::std::min_element", "::std::max_element", + "::std::adjacent_find", "::std::is_sorted_until"}; + +constexpr llvm::StringRef RangeAlgorithms[] = { + "::std::ranges::find", "::std::ranges::find_if", + "::std::ranges::find_if_not", "::std::ranges::lower_bound", + "::std::ranges::upper_bound", "::std::ranges::min_element", + "::std::ranges::max_element", "::std::ranges::find_first_of", + "::std::ranges::adjacent_find", "::std::ranges::is_sorted_until"}; +} // namespace + +MissingEndComparisonCheck::MissingEndComparisonCheck(StringRef Name, + ClangTidyContext *Context) + : ClangTidyCheck(Name, Context), + ExtraAlgorithms( + utils::options::parseStringList(Options.get("ExtraAlgorithms", ""))) { +} + +void MissingEndComparisonCheck::storeOptions( + ClangTidyOptions::OptionMap &Opts) { + Options.store(Opts, "ExtraAlgorithms", + utils::options::serializeStringList(ExtraAlgorithms)); +} + +static bool isConditionVar(const DeclStmt *S, ASTContext &Ctx) { + const auto &Parents = Ctx.getParents(*S); + if (Parents.empty()) + return false; + + const auto *ParentStmt = Parents[0].get<Stmt>(); + if (!ParentStmt) + return false; + + if (const auto *If = dyn_cast<IfStmt>(ParentStmt)) + return If->getConditionVariableDeclStmt() == S; + if (const auto *While = dyn_cast<WhileStmt>(ParentStmt)) + return While->getConditionVariableDeclStmt() == S; + if (const auto *For = dyn_cast<ForStmt>(ParentStmt)) + return For->getConditionVariableDeclStmt() == S; + + return false; +} + +static std::optional<std::string> +getRangesEndText(const MatchFinder::MatchResult &Result, const CallExpr *Call) { + const FunctionDecl *Callee = Call->getDirectCallee(); + assert(Callee && Callee->getNumParams() > 0 && + "Matcher should ensure Callee has parameters"); + + // Range overloads take a reference (R&&), Iterator overloads pass by value. + const bool IsIterPair = + !Callee->getParamDecl(0)->getType()->isReferenceType(); + + if (IsIterPair) { + if (Call->getNumArgs() < 3) + return std::nullopt; + // find(CPO, Iter, Sent, Val...) -> Sent is Arg 2. + const Expr *EndArg = Call->getArg(2); + return tooling::fixit::getText(*EndArg, *Result.Context).str(); + } + + if (Call->getNumArgs() < 2) + return std::nullopt; + // find(CPO, Range, Val, Proj) -> Range is Arg 1. + const Expr *RangeArg = Call->getArg(1); + // Avoid potential side-effects + const Expr *InnerRange = RangeArg->IgnoreParenImpCasts(); + if (isa<DeclRefExpr>(InnerRange) || isa<MemberExpr>(InnerRange)) { + const StringRef RangeText = + tooling::fixit::getText(*RangeArg, *Result.Context); + if (!RangeText.empty()) + return ("std::ranges::end(" + RangeText + ")").str(); + } + return ""; +} + +static std::optional<std::string> +getStandardEndText(const MatchFinder::MatchResult &Result, + const CallExpr *Call) { + if (Call->getNumArgs() < 2) + return std::nullopt; + + // Heuristic: if the first argument is a record type and the types of the + // first two arguments are distinct, we assume it's a range algorithm. + if (Call->getNumArgs() == 2) { + const Expr *Arg0 = Call->getArg(0); + const Expr *Arg1 = Call->getArg(1); + const QualType T0 = Arg0->getType().getCanonicalType(); + const QualType T1 = Arg1->getType().getCanonicalType(); + + if (T0.getNonReferenceType() != T1.getNonReferenceType() && + T0.getNonReferenceType()->isRecordType()) { + const StringRef ContainerText = + tooling::fixit::getText(*Arg0, *Result.Context); + if (!ContainerText.empty()) + return ("std::end(" + ContainerText + ")").str(); + } + } + + unsigned EndIdx = 1; + const Expr *FirstArg = Call->getArg(0); ---------------- zeyi2 wrote:
This part handles C++17 Execution Policies. Parallel versions of algorithms have an additional first argument, so we need to handle this differently. I identify these by checking if the first argument's type name ends with `_policy`. IIUC this is the naming convention in the standard library. https://github.com/llvm/llvm-project/pull/182543 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
