diff options
Diffstat (limited to 'clang-tools-extra/clang-tidy/misc')
36 files changed, 270 insertions, 172 deletions
diff --git a/clang-tools-extra/clang-tidy/misc/CMakeLists.txt b/clang-tools-extra/clang-tidy/misc/CMakeLists.txt index 2cfee5f..e8705aa 100644 --- a/clang-tools-extra/clang-tidy/misc/CMakeLists.txt +++ b/clang-tools-extra/clang-tidy/misc/CMakeLists.txt @@ -25,14 +25,15 @@ add_clang_library(clangTidyMiscModule STATIC HeaderIncludeCycleCheck.cpp IncludeCleanerCheck.cpp MiscTidyModule.cpp - MisleadingBidirectional.cpp - MisleadingIdentifier.cpp + MisleadingBidirectionalCheck.cpp + MisleadingIdentifierCheck.cpp MisplacedConstCheck.cpp NewDeleteOverloadsCheck.cpp NoRecursionCheck.cpp - NonCopyableObjects.cpp + NonCopyableObjectsCheck.cpp NonPrivateMemberVariablesInClassesCheck.cpp OverrideWithDifferentVisibilityCheck.cpp + PredictableRandCheck.cpp RedundantExpressionCheck.cpp StaticAssertCheck.cpp ThrowByValueCatchByReferenceCheck.cpp diff --git a/clang-tools-extra/clang-tidy/misc/ConfusableIdentifierCheck.cpp b/clang-tools-extra/clang-tidy/misc/ConfusableIdentifierCheck.cpp index b05fd04..418b8ae 100644 --- a/clang-tools-extra/clang-tidy/misc/ConfusableIdentifierCheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/ConfusableIdentifierCheck.cpp @@ -53,10 +53,9 @@ static llvm::SmallString<64U> skeleton(StringRef Name) { const char *Curr = Name.data(); const char *End = Curr + Name.size(); while (Curr < End) { - const char *Prev = Curr; UTF32 CodePoint = 0; - ConversionResult Result = convertUTF8Sequence( + const ConversionResult Result = convertUTF8Sequence( reinterpret_cast<const UTF8 **>(&Curr), reinterpret_cast<const UTF8 *>(End), &CodePoint, strictConversion); if (Result != conversionOK) { @@ -64,7 +63,7 @@ static llvm::SmallString<64U> skeleton(StringRef Name) { break; } - StringRef Key(Prev, Curr - Prev); + const StringRef Key(Prev, Curr - Prev); auto *Where = llvm::lower_bound(ConfusableEntries, CodePoint, [](decltype(ConfusableEntries[0]) X, UTF32 Y) { return X.codepoint < Y; }); @@ -82,7 +81,8 @@ static llvm::SmallString<64U> skeleton(StringRef Name) { errs() << "Unicode conversion issue\n"; break; } - Skeleton.append((char *)BufferStart, (char *)IBuffer); + Skeleton.append(reinterpret_cast<char *>(BufferStart), + reinterpret_cast<char *>(IBuffer)); } } return Skeleton; @@ -183,7 +183,7 @@ void ConfusableIdentifierCheck::addDeclToCheck(const NamedDecl *ND, if (!NDII) return; - StringRef NDName = NDII->getName(); + const StringRef NDName = NDII->getName(); if (NDName.empty()) return; @@ -216,7 +216,7 @@ void ConfusableIdentifierCheck::onEndOfTranslationUnit() { // the same skeleton. for (const IdentifierInfo *II : Idents) { for (auto [OuterND, OuterParent] : NameToDecls[II]) { - for (Entry Inner : DeclsWithinContext[OuterParent]) { + for (const Entry Inner : DeclsWithinContext[OuterParent]) { // Don't complain if the identifiers are the same. if (OuterND->getIdentifier() == Inner.ND->getIdentifier()) continue; diff --git a/clang-tools-extra/clang-tidy/misc/ConfusableIdentifierCheck.h b/clang-tools-extra/clang-tidy/misc/ConfusableIdentifierCheck.h index b341d03..5b98d48 100644 --- a/clang-tools-extra/clang-tidy/misc/ConfusableIdentifierCheck.h +++ b/clang-tools-extra/clang-tidy/misc/ConfusableIdentifierCheck.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_CONFUSABLE_IDENTIFIER_CHECK_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_CONFUSABLE_IDENTIFIER_CHECK_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_CONFUSABLEIDENTIFIERCHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_CONFUSABLEIDENTIFIERCHECK_H #include "../ClangTidyCheck.h" #include "llvm/ADT/DenseMap.h" @@ -41,4 +41,4 @@ private: } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_CONFUSABLE_IDENTIFIER_CHECK_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_CONFUSABLEIDENTIFIERCHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/ConfusableTable/BuildConfusableTable.cpp b/clang-tools-extra/clang-tidy/misc/ConfusableTable/BuildConfusableTable.cpp index 6a07902..f5dcc7f 100644 --- a/clang-tools-extra/clang-tidy/misc/ConfusableTable/BuildConfusableTable.cpp +++ b/clang-tools-extra/clang-tidy/misc/ConfusableTable/BuildConfusableTable.cpp @@ -26,7 +26,7 @@ int main(int argc, char *argv[]) { std::vector<std::pair<llvm::UTF32, SmallVector<llvm::UTF32>>> Entries; SmallVector<StringRef> Values; - for (StringRef Line : Lines) { + for (const StringRef Line : Lines) { if (Line.starts_with("#")) continue; @@ -37,14 +37,14 @@ int main(int argc, char *argv[]) { return 2; } - llvm::StringRef From = Values[0].trim(); + const llvm::StringRef From = Values[0].trim(); llvm::UTF32 CodePoint = 0; From.getAsInteger(16, CodePoint); SmallVector<llvm::UTF32> To; SmallVector<StringRef> ToN; Values[1].split(ToN, ' ', -1, false); - for (StringRef ToI : ToN) { + for (const StringRef ToI : ToN) { llvm::UTF32 ToCodePoint = 0; ToI.trim().getAsInteger(16, ToCodePoint); To.push_back(ToCodePoint); @@ -56,7 +56,7 @@ int main(int argc, char *argv[]) { } llvm::sort(Entries); - unsigned LargestValue = + const unsigned LargestValue = llvm::max_element(Entries, [](const auto &Entry0, const auto &Entry1) { return Entry0.second.size() < Entry1.second.size(); })->second.size(); diff --git a/clang-tools-extra/clang-tidy/misc/CoroutineHostileRAIICheck.cpp b/clang-tools-extra/clang-tidy/misc/CoroutineHostileRAIICheck.cpp index 3b9b8e0..75693a0 100644 --- a/clang-tools-extra/clang-tidy/misc/CoroutineHostileRAIICheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/CoroutineHostileRAIICheck.cpp @@ -56,7 +56,7 @@ AST_MATCHER_P(Stmt, forEachPrevStmt, ast_matchers::internal::Matcher<Stmt>, // Matches the expression awaited by the `co_await`. AST_MATCHER_P(CoawaitExpr, awaitable, ast_matchers::internal::Matcher<Expr>, InnerMatcher) { - if (Expr *E = Node.getOperand()) + if (const Expr *E = Node.getOperand()) return InnerMatcher.matches(*E, Finder, Builder); return false; } @@ -67,13 +67,20 @@ static auto typeWithNameIn(const std::vector<StringRef> &Names) { hasCanonicalType(hasDeclaration(namedDecl(hasAnyName(Names))))); } +static auto functionWithNameIn(const std::vector<StringRef> &Names) { + auto Call = callExpr(callee(functionDecl(hasAnyName(Names)))); + return anyOf(expr(cxxBindTemporaryExpr(has(Call))), expr(Call)); +} + CoroutineHostileRAIICheck::CoroutineHostileRAIICheck(StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), RAIITypesList(utils::options::parseStringList( Options.get("RAIITypesList", "std::lock_guard;std::scoped_lock"))), AllowedAwaitablesList(utils::options::parseStringList( - Options.get("AllowedAwaitablesList", ""))) {} + Options.get("AllowedAwaitablesList", ""))), + AllowedCallees( + utils::options::parseStringList(Options.get("AllowedCallees", ""))) {} void CoroutineHostileRAIICheck::registerMatchers(MatchFinder *Finder) { // A suspension happens with co_await or co_yield. @@ -81,7 +88,8 @@ void CoroutineHostileRAIICheck::registerMatchers(MatchFinder *Finder) { hasAttr(attr::Kind::ScopedLockable))))) .bind("scoped-lockable"); auto OtherRAII = varDecl(typeWithNameIn(RAIITypesList)).bind("raii"); - auto AllowedSuspend = awaitable(typeWithNameIn(AllowedAwaitablesList)); + auto AllowedSuspend = awaitable(anyOf(typeWithNameIn(AllowedAwaitablesList), + functionWithNameIn(AllowedCallees))); Finder->addMatcher( expr(anyOf(coawaitExpr(unless(AllowedSuspend)), coyieldExpr()), forEachPrevStmt( @@ -109,7 +117,9 @@ void CoroutineHostileRAIICheck::storeOptions( ClangTidyOptions::OptionMap &Opts) { Options.store(Opts, "RAIITypesList", utils::options::serializeStringList(RAIITypesList)); - Options.store(Opts, "SafeAwaitableList", + Options.store(Opts, "AllowedAwaitablesList", utils::options::serializeStringList(AllowedAwaitablesList)); + Options.store(Opts, "AllowedCallees", + utils::options::serializeStringList(AllowedCallees)); } } // namespace clang::tidy::misc diff --git a/clang-tools-extra/clang-tidy/misc/CoroutineHostileRAIICheck.h b/clang-tools-extra/clang-tidy/misc/CoroutineHostileRAIICheck.h index e100509..12ad1b1 100644 --- a/clang-tools-extra/clang-tidy/misc/CoroutineHostileRAIICheck.h +++ b/clang-tools-extra/clang-tidy/misc/CoroutineHostileRAIICheck.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_COROUTINESHOSTILERAIICHECK_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_COROUTINESHOSTILERAIICHECK_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_COROUTINEHOSTILERAIICHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_COROUTINEHOSTILERAIICHECK_H #include "../ClangTidyCheck.h" #include "clang/AST/ASTTypeTraits.h" @@ -46,8 +46,11 @@ private: // List of fully qualified awaitable types which are considered safe to // co_await. std::vector<StringRef> AllowedAwaitablesList; + // List of callees whose return values are considered safe to directly + // co_await. + std::vector<StringRef> AllowedCallees; }; } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_COROUTINESHOSTILERAIICHECK_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_COROUTINEHOSTILERAIICHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/DefinitionsInHeadersCheck.cpp b/clang-tools-extra/clang-tidy/misc/DefinitionsInHeadersCheck.cpp index 714af11..c10ee1d 100644 --- a/clang-tools-extra/clang-tidy/misc/DefinitionsInHeadersCheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/DefinitionsInHeadersCheck.cpp @@ -93,7 +93,8 @@ void DefinitionsInHeadersCheck::check(const MatchFinder::MatchResult &Result) { } } - bool IsFullSpec = FD->getTemplateSpecializationKind() != TSK_Undeclared; + const bool IsFullSpec = + FD->getTemplateSpecializationKind() != TSK_Undeclared; diag(FD->getLocation(), "%select{function|full function template specialization}0 %1 defined " "in a header file; function definitions in header files can lead to " diff --git a/clang-tools-extra/clang-tidy/misc/DefinitionsInHeadersCheck.h b/clang-tools-extra/clang-tidy/misc/DefinitionsInHeadersCheck.h index 0c162cc..e52fa20 100644 --- a/clang-tools-extra/clang-tidy/misc/DefinitionsInHeadersCheck.h +++ b/clang-tools-extra/clang-tidy/misc/DefinitionsInHeadersCheck.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_DEFINITIONS_IN_HEADERS_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_DEFINITIONS_IN_HEADERS_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_DEFINITIONSINHEADERSCHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_DEFINITIONSINHEADERSCHECK_H #include "../ClangTidyCheck.h" #include "../utils/FileExtensionsUtils.h" @@ -38,4 +38,4 @@ private: } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_DEFINITIONS_IN_HEADERS_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_DEFINITIONSINHEADERSCHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp b/clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp index 1a5aa4b..558c368 100644 --- a/clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp @@ -200,7 +200,7 @@ void IncludeCleanerCheck::check(const MatchFinder::MatchResult &Result) { Unused.push_back(&I); } - llvm::StringRef Code = SM->getBufferData(SM->getMainFileID()); + const llvm::StringRef Code = SM->getBufferData(SM->getMainFileID()); auto FileStyle = format::getStyle(format::DefaultFormatStyle, getCurrentMainFile(), format::DefaultFallbackStyle, Code, @@ -220,14 +220,14 @@ void IncludeCleanerCheck::check(const MatchFinder::MatchResult &Result) { } if (MissingIncludes) { - tooling::HeaderIncludes HeaderIncludes(getCurrentMainFile(), Code, - FileStyle->IncludeStyle); + const tooling::HeaderIncludes HeaderIncludes(getCurrentMainFile(), Code, + FileStyle->IncludeStyle); // Deduplicate insertions when running in bulk fix mode. llvm::StringSet<> InsertedHeaders{}; for (const auto &Inc : Missing) { - std::string Spelling = include_cleaner::spellHeader( + const std::string Spelling = include_cleaner::spellHeader( {Inc.Missing, PP->getHeaderSearchInfo(), MainFile}); - bool Angled = llvm::StringRef{Spelling}.starts_with("<"); + const bool Angled = llvm::StringRef{Spelling}.starts_with("<"); // We might suggest insertion of an existing include in edge cases, e.g., // include is present in a PP-disabled region, or spelling of the header // turns out to be the same as one of the unresolved includes in the @@ -235,7 +235,7 @@ void IncludeCleanerCheck::check(const MatchFinder::MatchResult &Result) { if (auto Replacement = HeaderIncludes.insert( llvm::StringRef{Spelling}.trim("\"<>"), Angled, tooling::IncludeDirective::Include)) { - DiagnosticBuilder DB = + const DiagnosticBuilder DB = diag(SM->getSpellingLoc(Inc.SymRef.RefLocation), "no header providing \"%0\" is directly included") << Inc.SymRef.Target.name(); diff --git a/clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h b/clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h index 43e1ed8..619d819 100644 --- a/clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h +++ b/clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCLUDECLEANER_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCLUDECLEANER_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCLUDECLEANERCHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCLUDECLEANERCHECK_H #include "../ClangTidyCheck.h" #include "../ClangTidyDiagnosticConsumer.h" @@ -57,4 +57,4 @@ private: } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCLUDECLEANER_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCLUDECLEANERCHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/MiscTidyModule.cpp b/clang-tools-extra/clang-tidy/misc/MiscTidyModule.cpp index 6f4af6c..03f2577 100644 --- a/clang-tools-extra/clang-tidy/misc/MiscTidyModule.cpp +++ b/clang-tools-extra/clang-tidy/misc/MiscTidyModule.cpp @@ -15,14 +15,15 @@ #include "DefinitionsInHeadersCheck.h" #include "HeaderIncludeCycleCheck.h" #include "IncludeCleanerCheck.h" -#include "MisleadingBidirectional.h" -#include "MisleadingIdentifier.h" +#include "MisleadingBidirectionalCheck.h" +#include "MisleadingIdentifierCheck.h" #include "MisplacedConstCheck.h" #include "NewDeleteOverloadsCheck.h" #include "NoRecursionCheck.h" -#include "NonCopyableObjects.h" +#include "NonCopyableObjectsCheck.h" #include "NonPrivateMemberVariablesInClassesCheck.h" #include "OverrideWithDifferentVisibilityCheck.h" +#include "PredictableRandCheck.h" #include "RedundantExpressionCheck.h" #include "StaticAssertCheck.h" #include "ThrowByValueCatchByReferenceCheck.h" @@ -63,6 +64,9 @@ public: "misc-non-copyable-objects"); CheckFactories.registerCheck<NonPrivateMemberVariablesInClassesCheck>( "misc-non-private-member-variables-in-classes"); + CheckFactories.registerCheck<OverrideWithDifferentVisibilityCheck>( + "misc-override-with-different-visibility"); + CheckFactories.registerCheck<PredictableRandCheck>("misc-predictable-rand"); CheckFactories.registerCheck<RedundantExpressionCheck>( "misc-redundant-expression"); CheckFactories.registerCheck<StaticAssertCheck>("misc-static-assert"); @@ -82,8 +86,6 @@ public: "misc-use-anonymous-namespace"); CheckFactories.registerCheck<UseInternalLinkageCheck>( "misc-use-internal-linkage"); - CheckFactories.registerCheck<OverrideWithDifferentVisibilityCheck>( - "misc-override-with-different-visibility"); } }; diff --git a/clang-tools-extra/clang-tidy/misc/MisleadingBidirectional.cpp b/clang-tools-extra/clang-tidy/misc/MisleadingBidirectionalCheck.cpp index f89c539..8a10f70 100644 --- a/clang-tools-extra/clang-tidy/misc/MisleadingBidirectional.cpp +++ b/clang-tools-extra/clang-tidy/misc/MisleadingBidirectionalCheck.cpp @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// -#include "MisleadingBidirectional.h" +#include "MisleadingBidirectionalCheck.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Lex/Preprocessor.h" @@ -40,20 +40,21 @@ static bool containsMisleadingBidi(StringRef Buffer, // // Warn if we end up with an unclosed context. while (CurPtr < Buffer.end()) { - unsigned char C = *CurPtr; + const unsigned char C = *CurPtr; if (isASCII(C)) { ++CurPtr; - bool IsParagrapSep = + const bool IsParagrapSep = (C == 0xA || C == 0xD || (0x1C <= C && C <= 0x1E) || C == 0x85); - bool IsSegmentSep = (C == 0x9 || C == 0xB || C == 0x1F); + const bool IsSegmentSep = (C == 0x9 || C == 0xB || C == 0x1F); if (IsParagrapSep || IsSegmentSep) BidiContexts.clear(); continue; } llvm::UTF32 CodePoint = 0; - llvm::ConversionResult Result = llvm::convertUTF8Sequence( - (const llvm::UTF8 **)&CurPtr, (const llvm::UTF8 *)Buffer.end(), - &CodePoint, llvm::strictConversion); + const llvm::ConversionResult Result = llvm::convertUTF8Sequence( + reinterpret_cast<const llvm::UTF8 **>(&CurPtr), + reinterpret_cast<const llvm::UTF8 *>(Buffer.end()), &CodePoint, + llvm::strictConversion); // If conversion fails, utf-8 is designed so that we can just try next char. if (Result != llvm::conversionOK) { @@ -94,7 +95,7 @@ public: bool HandleComment(Preprocessor &PP, SourceRange Range) override { // FIXME: check that we are in a /* */ comment - StringRef Text = + const StringRef Text = Lexer::getSourceText(CharSourceRange::getCharRange(Range), PP.getSourceManager(), PP.getLangOpts()); @@ -124,7 +125,7 @@ void MisleadingBidirectionalCheck::registerPPCallbacks( void MisleadingBidirectionalCheck::check( const ast_matchers::MatchFinder::MatchResult &Result) { if (const auto *SL = Result.Nodes.getNodeAs<StringLiteral>("strlit")) { - StringRef Literal = SL->getBytes(); + const StringRef Literal = SL->getBytes(); if (containsMisleadingBidi(Literal, false)) diag(SL->getBeginLoc(), "string literal contains misleading " "bidirectional Unicode characters"); diff --git a/clang-tools-extra/clang-tidy/misc/MisleadingBidirectional.h b/clang-tools-extra/clang-tidy/misc/MisleadingBidirectionalCheck.h index ba895b9..7c7577f 100644 --- a/clang-tools-extra/clang-tidy/misc/MisleadingBidirectional.h +++ b/clang-tools-extra/clang-tidy/misc/MisleadingBidirectionalCheck.h @@ -13,6 +13,10 @@ namespace clang::tidy::misc { +/// Warns about unterminated bidirectional unicode sequence. +/// +/// For the user-facing documentation see: +/// https://clang.llvm.org/extra/clang-tidy/checks/misc/misleading-bidirectional.html class MisleadingBidirectionalCheck : public ClangTidyCheck { public: MisleadingBidirectionalCheck(StringRef Name, ClangTidyContext *Context); diff --git a/clang-tools-extra/clang-tidy/misc/MisleadingIdentifier.cpp b/clang-tools-extra/clang-tidy/misc/MisleadingIdentifierCheck.cpp index ce04fb6..9c0de87 100644 --- a/clang-tools-extra/clang-tidy/misc/MisleadingIdentifier.cpp +++ b/clang-tools-extra/clang-tidy/misc/MisleadingIdentifierCheck.cpp @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// -#include "MisleadingIdentifier.h" +#include "MisleadingIdentifierCheck.h" #include "llvm/Support/ConvertUTF.h" @@ -124,8 +124,9 @@ static bool hasRTLCharacters(StringRef Buffer) { const char *EndPtr = Buffer.end(); while (CurPtr < EndPtr) { llvm::UTF32 CodePoint = 0; - llvm::ConversionResult Result = llvm::convertUTF8Sequence( - (const llvm::UTF8 **)&CurPtr, (const llvm::UTF8 *)EndPtr, &CodePoint, + const llvm::ConversionResult Result = llvm::convertUTF8Sequence( + reinterpret_cast<const llvm::UTF8 **>(&CurPtr), + reinterpret_cast<const llvm::UTF8 *>(EndPtr), &CodePoint, llvm::strictConversion); if (Result != llvm::conversionOK) break; @@ -144,9 +145,9 @@ MisleadingIdentifierCheck::~MisleadingIdentifierCheck() = default; void MisleadingIdentifierCheck::check( const ast_matchers::MatchFinder::MatchResult &Result) { if (const auto *ND = Result.Nodes.getNodeAs<NamedDecl>("nameddecl")) { - IdentifierInfo *II = ND->getIdentifier(); + const IdentifierInfo *II = ND->getIdentifier(); if (II) { - StringRef NDName = II->getName(); + const StringRef NDName = II->getName(); if (hasRTLCharacters(NDName)) diag(ND->getBeginLoc(), "identifier has right-to-left codepoints"); } diff --git a/clang-tools-extra/clang-tidy/misc/MisleadingIdentifier.h b/clang-tools-extra/clang-tidy/misc/MisleadingIdentifierCheck.h index 06b83d56..9f8eb40 100644 --- a/clang-tools-extra/clang-tidy/misc/MisleadingIdentifier.h +++ b/clang-tools-extra/clang-tidy/misc/MisleadingIdentifierCheck.h @@ -13,6 +13,12 @@ namespace clang::tidy::misc { +/// Finds identifiers that contain Unicode characters with right-to-left +/// direction, which can be confusing as they may change the understanding of a +/// whole statement line. +/// +/// For the user-facing documentation see: +/// https://clang.llvm.org/extra/clang-tidy/checks/misc/misleading-identifier.html class MisleadingIdentifierCheck : public ClangTidyCheck { public: MisleadingIdentifierCheck(StringRef Name, ClangTidyContext *Context); diff --git a/clang-tools-extra/clang-tidy/misc/MisplacedConstCheck.cpp b/clang-tools-extra/clang-tidy/misc/MisplacedConstCheck.cpp index afa59f3..c8c0cfd 100644 --- a/clang-tools-extra/clang-tidy/misc/MisplacedConstCheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/MisplacedConstCheck.cpp @@ -40,7 +40,7 @@ static QualType guessAlternateQualification(ASTContext &Context, QualType QT) { Qualifiers Quals = QT.getLocalQualifiers(); Quals.removeConst(); - QualType NewQT = Context.getPointerType( + const QualType NewQT = Context.getPointerType( QualType(QT->getPointeeType().getTypePtr(), Qualifiers::Const)); return NewQT.withCVRQualifiers(Quals.getCVRQualifiers()); } @@ -48,7 +48,7 @@ static QualType guessAlternateQualification(ASTContext &Context, QualType QT) { void MisplacedConstCheck::check(const MatchFinder::MatchResult &Result) { const auto *Var = Result.Nodes.getNodeAs<ValueDecl>("decl"); ASTContext &Ctx = *Result.Context; - QualType CanQT = Var->getType().getCanonicalType(); + const QualType CanQT = Var->getType().getCanonicalType(); SourceLocation AliasLoc; const char *AliasType = nullptr; diff --git a/clang-tools-extra/clang-tidy/misc/MisplacedConstCheck.h b/clang-tools-extra/clang-tidy/misc/MisplacedConstCheck.h index 2b8a05d..5f5a4cfd 100644 --- a/clang-tools-extra/clang-tidy/misc/MisplacedConstCheck.h +++ b/clang-tools-extra/clang-tidy/misc/MisplacedConstCheck.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MISPLACED_CONST_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MISPLACED_CONST_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MISPLACEDCONSTCHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MISPLACEDCONSTCHECK_H #include "../ClangTidyCheck.h" @@ -28,4 +28,4 @@ public: } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MISPLACED_CONST_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MISPLACEDCONSTCHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/NewDeleteOverloadsCheck.cpp b/clang-tools-extra/clang-tidy/misc/NewDeleteOverloadsCheck.cpp index 9801c9e..0471ba8 100644 --- a/clang-tools-extra/clang-tidy/misc/NewDeleteOverloadsCheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/NewDeleteOverloadsCheck.cpp @@ -51,7 +51,7 @@ AST_MATCHER(FunctionDecl, isPlacementOverload) { return true; const auto *FPT = Node.getType()->castAs<FunctionProtoType>(); - ASTContext &Ctx = Node.getASTContext(); + const ASTContext &Ctx = Node.getASTContext(); if (Ctx.getLangOpts().SizedDeallocation && ASTContext::hasSameType(FPT->getParamType(1), Ctx.getSizeType())) return false; @@ -114,17 +114,15 @@ hasCorrespondingOverloadInBaseClass(const CXXMethodDecl *MD, RD = MD->getParent(); } - for (const auto &BS : RD->bases()) { + return llvm::any_of(RD->bases(), [&](const CXXBaseSpecifier &BS) { // We can't say much about a dependent base class, but to avoid false // positives assume it can have a corresponding overload. if (BS.getType()->isDependentType()) return true; - if (const auto *BaseRD = BS.getType()->getAsCXXRecordDecl()) - if (hasCorrespondingOverloadInBaseClass(MD, BaseRD)) - return true; - } - - return false; + if (const CXXRecordDecl *BaseRD = BS.getType()->getAsCXXRecordDecl()) + return hasCorrespondingOverloadInBaseClass(MD, BaseRD); + return false; + }); } void NewDeleteOverloadsCheck::registerMatchers(MatchFinder *Finder) { diff --git a/clang-tools-extra/clang-tidy/misc/NewDeleteOverloadsCheck.h b/clang-tools-extra/clang-tidy/misc/NewDeleteOverloadsCheck.h index 93c39fc..9c7aff0 100644 --- a/clang-tools-extra/clang-tidy/misc/NewDeleteOverloadsCheck.h +++ b/clang-tools-extra/clang-tidy/misc/NewDeleteOverloadsCheck.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NEWDELETEOVERLOADS_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NEWDELETEOVERLOADS_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NEWDELETEOVERLOADSCHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NEWDELETEOVERLOADSCHECK_H #include "../ClangTidyCheck.h" #include "llvm/ADT/SmallVector.h" @@ -33,4 +33,4 @@ public: } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NEWDELETEOVERLOADS_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NEWDELETEOVERLOADSCHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/NoRecursionCheck.cpp b/clang-tools-extra/clang-tidy/misc/NoRecursionCheck.cpp index 035598d..8bcbb61 100644 --- a/clang-tools-extra/clang-tidy/misc/NoRecursionCheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/NoRecursionCheck.cpp @@ -122,7 +122,7 @@ private: } // Set time! // Note that this must be after `populateSet()` might have been called. - bool SetInsertionSucceeded = Set.insert(V).second; + const bool SetInsertionSucceeded = Set.insert(V).second; (void)SetInsertionSucceeded; assert(SetInsertionSucceeded && "We did check that no such value existed"); return true; @@ -132,7 +132,7 @@ public: /// Insert a new element into the SmartSmallSetVector. /// \returns true if the element was inserted into the SmartSmallSetVector. bool insert(const T &X) { - bool Result = setInsert(X); + const bool Result = setInsert(X); if (Result) Vector.push_back(X); return Result; @@ -200,8 +200,8 @@ void NoRecursionCheck::handleSCC(ArrayRef<CallGraphNode *> SCC) { assert(!SCC.empty() && "Empty SCC does not make sense."); // First of all, call out every strongly connected function. - for (CallGraphNode *N : SCC) { - FunctionDecl *D = N->getDefinition(); + for (const CallGraphNode *N : SCC) { + const FunctionDecl *D = N->getDefinition(); diag(D->getLocation(), "function %0 is within a recursive call chain") << D; } @@ -224,7 +224,8 @@ void NoRecursionCheck::handleSCC(ArrayRef<CallGraphNode *> SCC) { assert(CyclicCallStack.size() >= 2 && "Cycle requires at least 2 frames"); // Which function we decided to be the entry point that lead to the recursion? - FunctionDecl *CycleEntryFn = CyclicCallStack.front().Callee->getDefinition(); + const FunctionDecl *CycleEntryFn = + CyclicCallStack.front().Callee->getDefinition(); // And now, for ease of understanding, let's print the call sequence that // forms the cycle in question. diag(CycleEntryFn->getLocation(), @@ -233,8 +234,8 @@ void NoRecursionCheck::handleSCC(ArrayRef<CallGraphNode *> SCC) { << CycleEntryFn; for (int CurFrame = 1, NumFrames = CyclicCallStack.size(); CurFrame != NumFrames; ++CurFrame) { - CallGraphNode::CallRecord PrevNode = CyclicCallStack[CurFrame - 1]; - CallGraphNode::CallRecord CurrNode = CyclicCallStack[CurFrame]; + const CallGraphNode::CallRecord PrevNode = CyclicCallStack[CurFrame - 1]; + const CallGraphNode::CallRecord CurrNode = CyclicCallStack[CurFrame]; Decl *PrevDecl = PrevNode.Callee->getDecl(); Decl *CurrDecl = CurrNode.Callee->getDecl(); diff --git a/clang-tools-extra/clang-tidy/misc/NonCopyableObjects.cpp b/clang-tools-extra/clang-tidy/misc/NonCopyableObjectsCheck.cpp index b33e266..bfeb5fa 100644 --- a/clang-tools-extra/clang-tidy/misc/NonCopyableObjects.cpp +++ b/clang-tools-extra/clang-tidy/misc/NonCopyableObjectsCheck.cpp @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// -#include "NonCopyableObjects.h" +#include "NonCopyableObjectsCheck.h" #include "clang/AST/ASTContext.h" #include "clang/ASTMatchers/ASTMatchFinder.h" diff --git a/clang-tools-extra/clang-tidy/misc/NonCopyableObjects.h b/clang-tools-extra/clang-tidy/misc/NonCopyableObjectsCheck.h index 2fcbf41..608e078 100644 --- a/clang-tools-extra/clang-tidy/misc/NonCopyableObjects.h +++ b/clang-tools-extra/clang-tidy/misc/NonCopyableObjectsCheck.h @@ -6,15 +6,18 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NONCOPYABLEOBJECTS_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NONCOPYABLEOBJECTS_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NONCOPYABLEOBJECTSCHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NONCOPYABLEOBJECTSCHECK_H #include "../ClangTidyCheck.h" namespace clang::tidy::misc { -/// The check flags dereferences and non-pointer declarations of objects that +/// Flags dereferences and non-pointer declarations of objects that /// are not meant to be passed by value, such as C FILE objects. +/// +/// For the user-facing documentation see: +/// https://clang.llvm.org/extra/clang-tidy/checks/misc/non-copyable-objects.html class NonCopyableObjectsCheck : public ClangTidyCheck { public: NonCopyableObjectsCheck(StringRef Name, ClangTidyContext *Context) @@ -25,4 +28,4 @@ public: } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NONCOPYABLEOBJECTS_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NONCOPYABLEOBJECTSCHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/PredictableRandCheck.cpp b/clang-tools-extra/clang-tidy/misc/PredictableRandCheck.cpp new file mode 100644 index 0000000..eed80e0 --- /dev/null +++ b/clang-tools-extra/clang-tidy/misc/PredictableRandCheck.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// 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 "PredictableRandCheck.h" +#include "clang/AST/ASTContext.h" +#include "clang/ASTMatchers/ASTMatchFinder.h" + +using namespace clang::ast_matchers; + +namespace clang::tidy::misc { + +void PredictableRandCheck::registerMatchers(MatchFinder *Finder) { + Finder->addMatcher(callExpr(callee(functionDecl(namedDecl(hasName("::rand")), + parameterCountIs(0)))) + .bind("randomGenerator"), + this); +} + +void PredictableRandCheck::check(const MatchFinder::MatchResult &Result) { + std::string Msg; + if (getLangOpts().CPlusPlus) + Msg = "; use C++11 random library instead"; + + const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("randomGenerator"); + diag(MatchedDecl->getBeginLoc(), "rand() has limited randomness" + Msg); +} + +} // namespace clang::tidy::misc diff --git a/clang-tools-extra/clang-tidy/misc/PredictableRandCheck.h b/clang-tools-extra/clang-tidy/misc/PredictableRandCheck.h new file mode 100644 index 0000000..2237e7e --- /dev/null +++ b/clang-tools-extra/clang-tidy/misc/PredictableRandCheck.h @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_PREDICTABLERANDCHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_PREDICTABLERANDCHECK_H + +#include "../ClangTidyCheck.h" + +namespace clang::tidy::misc { + +/// Pseudorandom number generators are not genuinely random. The result of the +/// std::rand() function makes no guarantees as to the quality of the random +/// sequence produced. +/// This check warns for the usage of std::rand() function. +/// +/// For the user-facing documentation see: +/// https://clang.llvm.org/extra/clang-tidy/checks/misc/predictable-rand.html +class PredictableRandCheck : public ClangTidyCheck { +public: + PredictableRandCheck(StringRef Name, ClangTidyContext *Context) + : ClangTidyCheck(Name, Context) {} + void registerMatchers(ast_matchers::MatchFinder *Finder) override; + void check(const ast_matchers::MatchFinder::MatchResult &Result) override; +}; + +} // namespace clang::tidy::misc + +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_PREDICTABLERANDCHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.cpp b/clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.cpp index 6baa12a..2b63dab 100644 --- a/clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.cpp @@ -77,8 +77,8 @@ static bool areEquivalentExpr(const Expr *Left, const Expr *Right) { return cast<CharacterLiteral>(Left)->getValue() == cast<CharacterLiteral>(Right)->getValue(); case Stmt::IntegerLiteralClass: { - llvm::APInt LeftLit = cast<IntegerLiteral>(Left)->getValue(); - llvm::APInt RightLit = cast<IntegerLiteral>(Right)->getValue(); + const llvm::APInt LeftLit = cast<IntegerLiteral>(Left)->getValue(); + const llvm::APInt RightLit = cast<IntegerLiteral>(Right)->getValue(); return LeftLit.getBitWidth() == RightLit.getBitWidth() && LeftLit == RightLit; } @@ -256,7 +256,7 @@ static bool rangeSubsumesRange(BinaryOperatorKind OpcodeLHS, const APSInt &ValueLHS, BinaryOperatorKind OpcodeRHS, const APSInt &ValueRHS) { - int Comparison = APSInt::compareValues(ValueLHS, ValueRHS); + const int Comparison = APSInt::compareValues(ValueLHS, ValueRHS); switch (OpcodeLHS) { case BO_EQ: return OpcodeRHS == BO_EQ && Comparison == 0; @@ -352,11 +352,11 @@ static bool hasSameOperatorParent(const Expr *TheExpr, ASTContext &Context) { // IgnoreParenImpCasts logic in reverse: skip surrounding uninteresting nodes const DynTypedNodeList Parents = Context.getParents(*TheExpr); - for (DynTypedNode DynParent : Parents) { + for (const DynTypedNode DynParent : Parents) { if (const auto *Parent = DynParent.get<Expr>()) { - bool Skip = isa<ParenExpr>(Parent) || isa<ImplicitCastExpr>(Parent) || - isa<FullExpr>(Parent) || - isa<MaterializeTemporaryExpr>(Parent); + const bool Skip = + isa<ParenExpr>(Parent) || isa<ImplicitCastExpr>(Parent) || + isa<FullExpr>(Parent) || isa<MaterializeTemporaryExpr>(Parent); if (Skip && hasSameOperatorParent<TExpr>(Parent, OpKind, Context)) return true; if (checkOpKind<TExpr>(Parent, OpKind)) @@ -392,7 +392,7 @@ markDuplicateOperands(const TExpr *TheExpr, return false; if (collectOperands<TExpr>(Operands.second, AllOperands, OpKind)) return false; - size_t NumOperands = AllOperands.size(); + const size_t NumOperands = AllOperands.size(); llvm::SmallBitVector Duplicates(NumOperands); for (size_t I = 0; I < NumOperands; I++) { if (Duplicates[I]) @@ -463,7 +463,7 @@ AST_MATCHER_P(Expr, expandedByMacro, ArrayRef<llvm::StringLiteral>, Names) { const LangOptions &LO = Finder->getASTContext().getLangOpts(); SourceLocation Loc = Node.getExprLoc(); while (Loc.isMacroID()) { - StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM, LO); + const StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM, LO); if (llvm::is_contained(Names, MacroName)) return true; Loc = SM.getImmediateMacroCallerLoc(Loc); @@ -476,7 +476,7 @@ AST_MATCHER_P(Expr, expandedByMacro, ArrayRef<llvm::StringLiteral>, Names) { // Returns a matcher for integer constant expressions. static ast_matchers::internal::Matcher<Expr> matchIntegerConstantExpr(StringRef Id) { - std::string CstId = (Id + "-const").str(); + const std::string CstId = (Id + "-const").str(); return expr(isIntegerConstantExpr()).bind(CstId); } @@ -486,7 +486,7 @@ matchIntegerConstantExpr(StringRef Id) { static bool retrieveIntegerConstantExpr(const MatchFinder::MatchResult &Result, StringRef Id, APSInt &Value, const Expr *&ConstExpr) { - std::string CstId = (Id + "-const").str(); + const std::string CstId = (Id + "-const").str(); ConstExpr = Result.Nodes.getNodeAs<Expr>(CstId); if (!ConstExpr) return false; @@ -508,7 +508,7 @@ static bool retrieveIntegerConstantExpr(const MatchFinder::MatchResult &Result, // Returns a matcher for symbolic expressions (matches every expression except // ingeter constant expressions). static ast_matchers::internal::Matcher<Expr> matchSymbolicExpr(StringRef Id) { - std::string SymId = (Id + "-sym").str(); + const std::string SymId = (Id + "-sym").str(); return ignoringParenImpCasts( expr(unless(isIntegerConstantExpr())).bind(SymId)); } @@ -517,7 +517,7 @@ static ast_matchers::internal::Matcher<Expr> matchSymbolicExpr(StringRef Id) { // stores it into 'SymExpr'. static bool retrieveSymbolicExpr(const MatchFinder::MatchResult &Result, StringRef Id, const Expr *&SymExpr) { - std::string SymId = (Id + "-sym").str(); + const std::string SymId = (Id + "-sym").str(); if (const auto *Node = Result.Nodes.getNodeAs<Expr>(SymId)) { SymExpr = Node; return true; @@ -557,11 +557,11 @@ retrieveBinOpIntegerConstantExpr(const MatchFinder::MatchResult &Result, // Matches relational expressions: 'Expr <op> k' (i.e. x < 2, x != 3, 12 <= x). static ast_matchers::internal::Matcher<Expr> matchRelationalIntegerConstantExpr(StringRef Id) { - std::string CastId = (Id + "-cast").str(); - std::string SwapId = (Id + "-swap").str(); - std::string NegateId = (Id + "-negate").str(); - std::string OverloadId = (Id + "-overload").str(); - std::string ConstId = (Id + "-const").str(); + const std::string CastId = (Id + "-cast").str(); + const std::string SwapId = (Id + "-swap").str(); + const std::string NegateId = (Id + "-negate").str(); + const std::string OverloadId = (Id + "-overload").str(); + const std::string ConstId = (Id + "-const").str(); const auto RelationalExpr = ignoringParenImpCasts(binaryOperator( isComparisonOperator(), expr().bind(Id), @@ -625,7 +625,7 @@ canOverloadedOperatorArgsBeModified(const CXXOperatorCallExpr *OperatorCall, if (!OperatorDecl) return true; - unsigned ParamCount = OperatorDecl->getNumParams(); + const unsigned ParamCount = OperatorDecl->getNumParams(); // Overloaded operators declared inside a class have only one param. // These functions must be declared const in order to not be able to modify @@ -647,10 +647,10 @@ static bool retrieveRelationalIntegerConstantExpr( const MatchFinder::MatchResult &Result, StringRef Id, const Expr *&OperandExpr, BinaryOperatorKind &Opcode, const Expr *&Symbol, APSInt &Value, const Expr *&ConstExpr) { - std::string CastId = (Id + "-cast").str(); - std::string SwapId = (Id + "-swap").str(); - std::string NegateId = (Id + "-negate").str(); - std::string OverloadId = (Id + "-overload").str(); + const std::string CastId = (Id + "-cast").str(); + const std::string SwapId = (Id + "-swap").str(); + const std::string NegateId = (Id + "-negate").str(); + const std::string OverloadId = (Id + "-overload").str(); if (const auto *Bin = Result.Nodes.getNodeAs<BinaryOperator>(Id)) { // Operand received with explicit comparator. @@ -829,11 +829,11 @@ static bool areExprsFromDifferentMacros(const Expr *LhsExpr, const SourceManager &SM = AstCtx->getSourceManager(); const LangOptions &LO = AstCtx->getLangOpts(); - std::pair<FileID, unsigned> LsrLocInfo = + const std::pair<FileID, unsigned> LsrLocInfo = SM.getDecomposedLoc(SM.getExpansionLoc(Lsr.getBegin())); - std::pair<FileID, unsigned> RsrLocInfo = + const std::pair<FileID, unsigned> RsrLocInfo = SM.getDecomposedLoc(SM.getExpansionLoc(Rsr.getBegin())); - llvm::MemoryBufferRef MB = SM.getBufferOrFake(LsrLocInfo.first); + const llvm::MemoryBufferRef MB = SM.getBufferOrFake(LsrLocInfo.first); const char *LTokenPos = MB.getBufferStart() + LsrLocInfo.second; const char *RTokenPos = MB.getBufferStart() + RsrLocInfo.second; @@ -890,7 +890,6 @@ static bool areStringsSameIgnoreSpaces(const llvm::StringRef Left, static bool areExprsSameMacroOrLiteral(const BinaryOperator *BinOp, const ASTContext *Context) { - if (!BinOp) return false; @@ -1097,7 +1096,7 @@ void RedundantExpressionCheck::checkArithmeticExpr( if (const auto *ComparisonOperator = Result.Nodes.getNodeAs<BinaryOperator>( "binop-const-compare-to-sym")) { - BinaryOperatorKind Opcode = ComparisonOperator->getOpcode(); + const BinaryOperatorKind Opcode = ComparisonOperator->getOpcode(); if (!retrieveBinOpIntegerConstantExpr(Result, "lhs", LhsOpcode, LhsSymbol, LhsValue) || !retrieveSymbolicExpr(Result, "rhs", RhsSymbol) || @@ -1118,7 +1117,7 @@ void RedundantExpressionCheck::checkArithmeticExpr( } else if (const auto *ComparisonOperator = Result.Nodes.getNodeAs<BinaryOperator>( "binop-const-compare-to-binop-const")) { - BinaryOperatorKind Opcode = ComparisonOperator->getOpcode(); + const BinaryOperatorKind Opcode = ComparisonOperator->getOpcode(); if (!retrieveBinOpIntegerConstantExpr(Result, "lhs", LhsOpcode, LhsSymbol, LhsValue) || @@ -1147,16 +1146,18 @@ void RedundantExpressionCheck::checkArithmeticExpr( } } -static bool exprEvaluatesToZero(BinaryOperatorKind Opcode, APSInt Value) { +static bool exprEvaluatesToZero(BinaryOperatorKind Opcode, + const APSInt &Value) { return (Opcode == BO_And || Opcode == BO_AndAssign) && Value == 0; } static bool exprEvaluatesToBitwiseNegatedZero(BinaryOperatorKind Opcode, - APSInt Value) { + const APSInt &Value) { return (Opcode == BO_Or || Opcode == BO_OrAssign) && ~Value == 0; } -static bool exprEvaluatesToSymbolic(BinaryOperatorKind Opcode, APSInt Value) { +static bool exprEvaluatesToSymbolic(BinaryOperatorKind Opcode, + const APSInt &Value) { return ((Opcode == BO_Or || Opcode == BO_OrAssign) && Value == 0) || ((Opcode == BO_And || Opcode == BO_AndAssign) && ~Value == 0); } @@ -1165,7 +1166,7 @@ void RedundantExpressionCheck::checkBitwiseExpr( const MatchFinder::MatchResult &Result) { if (const auto *ComparisonOperator = Result.Nodes.getNodeAs<BinaryOperator>( "binop-const-compare-to-const")) { - BinaryOperatorKind Opcode = ComparisonOperator->getOpcode(); + const BinaryOperatorKind Opcode = ComparisonOperator->getOpcode(); APSInt LhsValue, RhsValue; const Expr *LhsSymbol = nullptr; @@ -1175,9 +1176,9 @@ void RedundantExpressionCheck::checkBitwiseExpr( !retrieveIntegerConstantExpr(Result, "rhs", RhsValue)) return; - uint64_t LhsConstant = LhsValue.getZExtValue(); - uint64_t RhsConstant = RhsValue.getZExtValue(); - SourceLocation Loc = ComparisonOperator->getOperatorLoc(); + const uint64_t LhsConstant = LhsValue.getZExtValue(); + const uint64_t RhsConstant = RhsValue.getZExtValue(); + const SourceLocation Loc = ComparisonOperator->getOperatorLoc(); // Check expression: x & k1 == k2 (i.e. x & 0xFF == 0xF00) if (LhsOpcode == BO_And && (LhsConstant & RhsConstant) != RhsConstant) { @@ -1208,24 +1209,24 @@ void RedundantExpressionCheck::checkBitwiseExpr( if ((Value != 0 && ~Value != 0) || Sym->getExprLoc().isMacroID()) return; - SourceLocation Loc = IneffectiveOperator->getOperatorLoc(); + const SourceLocation Loc = IneffectiveOperator->getOperatorLoc(); - BinaryOperatorKind Opcode = IneffectiveOperator->getOpcode(); + const BinaryOperatorKind Opcode = IneffectiveOperator->getOpcode(); if (exprEvaluatesToZero(Opcode, Value)) { diag(Loc, "expression always evaluates to 0"); } else if (exprEvaluatesToBitwiseNegatedZero(Opcode, Value)) { - SourceRange ConstExprRange(ConstExpr->getBeginLoc(), - ConstExpr->getEndLoc()); - StringRef ConstExprText = Lexer::getSourceText( + const SourceRange ConstExprRange(ConstExpr->getBeginLoc(), + ConstExpr->getEndLoc()); + const StringRef ConstExprText = Lexer::getSourceText( CharSourceRange::getTokenRange(ConstExprRange), *Result.SourceManager, Result.Context->getLangOpts()); diag(Loc, "expression always evaluates to '%0'") << ConstExprText; } else if (exprEvaluatesToSymbolic(Opcode, Value)) { - SourceRange SymExprRange(Sym->getBeginLoc(), Sym->getEndLoc()); + const SourceRange SymExprRange(Sym->getBeginLoc(), Sym->getEndLoc()); - StringRef ExprText = Lexer::getSourceText( + const StringRef ExprText = Lexer::getSourceText( CharSourceRange::getTokenRange(SymExprRange), *Result.SourceManager, Result.Context->getLangOpts()); @@ -1240,7 +1241,7 @@ void RedundantExpressionCheck::checkRelationalExpr( "comparisons-of-symbol-and-const")) { // Matched expressions are: (x <op> k1) <REL> (x <op> k2). // E.g.: (X < 2) && (X > 4) - BinaryOperatorKind Opcode = ComparisonOperator->getOpcode(); + const BinaryOperatorKind Opcode = ComparisonOperator->getOpcode(); const Expr *LhsExpr = nullptr, *RhsExpr = nullptr; const Expr *LhsSymbol = nullptr, *RhsSymbol = nullptr; @@ -1392,7 +1393,7 @@ void RedundantExpressionCheck::check(const MatchFinder::MatchResult &Result) { if (Call && canOverloadedOperatorArgsBeModified(Call, true)) return; - StringRef Message = + const StringRef Message = Call ? "overloaded operator has equivalent nested operands" : "operator has equivalent nested operands"; @@ -1405,12 +1406,12 @@ void RedundantExpressionCheck::check(const MatchFinder::MatchResult &Result) { if (const auto *NegateOperator = Result.Nodes.getNodeAs<UnaryOperator>("logical-bitwise-confusion")) { - SourceLocation OperatorLoc = NegateOperator->getOperatorLoc(); + const SourceLocation OperatorLoc = NegateOperator->getOperatorLoc(); auto Diag = diag(OperatorLoc, "ineffective logical negation operator used; did you mean '~'?"); - SourceLocation LogicalNotLocation = OperatorLoc.getLocWithOffset(1); + const SourceLocation LogicalNotLocation = OperatorLoc.getLocWithOffset(1); if (!LogicalNotLocation.isMacroID()) Diag << FixItHint::CreateReplacement( diff --git a/clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.h b/clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.h index 57289c39..f127007 100644 --- a/clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.h +++ b/clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_REDUNDANT_EXPRESSION_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_REDUNDANT_EXPRESSION_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_REDUNDANTEXPRESSIONCHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_REDUNDANTEXPRESSIONCHECK_H #include "../ClangTidyCheck.h" @@ -33,4 +33,4 @@ private: } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_REDUNDANT_EXPRESSION_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_REDUNDANTEXPRESSIONCHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/StaticAssertCheck.cpp b/clang-tools-extra/clang-tidy/misc/StaticAssertCheck.cpp index 5ac5300..ff866e9 100644 --- a/clang-tools-extra/clang-tidy/misc/StaticAssertCheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/StaticAssertCheck.cpp @@ -84,12 +84,12 @@ void StaticAssertCheck::check(const MatchFinder::MatchResult &Result) { const auto *AssertExprRoot = Result.Nodes.getNodeAs<BinaryOperator>("assertExprRoot"); const auto *CastExpr = Result.Nodes.getNodeAs<CStyleCastExpr>("castExpr"); - SourceLocation AssertExpansionLoc = CondStmt->getBeginLoc(); + const SourceLocation AssertExpansionLoc = CondStmt->getBeginLoc(); if (!AssertExpansionLoc.isValid() || !AssertExpansionLoc.isMacroID()) return; - StringRef MacroName = + const StringRef MacroName = Lexer::getImmediateMacroName(AssertExpansionLoc, SM, Opts); if (MacroName != "assert" || Condition->isValueDependent() || @@ -99,19 +99,20 @@ void StaticAssertCheck::check(const MatchFinder::MatchResult &Result) { // False literal is not the result of macro expansion. if (IsAlwaysFalse && (!CastExpr || CastExpr->getType()->isPointerType())) { - SourceLocation FalseLiteralLoc = + const SourceLocation FalseLiteralLoc = SM.getImmediateSpellingLoc(IsAlwaysFalse->getExprLoc()); if (!FalseLiteralLoc.isMacroID()) return; - StringRef FalseMacroName = + const StringRef FalseMacroName = Lexer::getImmediateMacroName(FalseLiteralLoc, SM, Opts); if (FalseMacroName.compare_insensitive("false") == 0 || FalseMacroName.compare_insensitive("null") == 0) return; } - SourceLocation AssertLoc = SM.getImmediateMacroCallerLoc(AssertExpansionLoc); + const SourceLocation AssertLoc = + SM.getImmediateMacroCallerLoc(AssertExpansionLoc); SmallVector<FixItHint, 4> FixItHints; SourceLocation LastParenLoc; diff --git a/clang-tools-extra/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.h b/clang-tools-extra/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.h index 15c17e7..56e4c12 100644 --- a/clang-tools-extra/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.h +++ b/clang-tools-extra/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROW_BY_VALUE_CATCH_BY_REFERENCE_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROW_BY_VALUE_CATCH_BY_REFERENCE_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROWBYVALUECATCHBYREFERENCECHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROWBYVALUECATCHBYREFERENCECHECK_H #include "../ClangTidyCheck.h" @@ -49,4 +49,4 @@ private: } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROW_BY_VALUE_CATCH_BY_REFERENCE_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROWBYVALUECATCHBYREFERENCECHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp b/clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp index 8a85e79..a14a559 100644 --- a/clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp @@ -18,7 +18,7 @@ namespace { AST_MATCHER_P(CXXMethodDecl, firstParameter, ast_matchers::internal::Matcher<ParmVarDecl>, InnerMatcher) { - unsigned N = Node.isExplicitObjectMemberFunction() ? 1 : 0; + const unsigned N = Node.isExplicitObjectMemberFunction() ? 1 : 0; return (N < Node.parameters().size() && InnerMatcher.matches(*Node.parameters()[N], Finder, Builder)); } diff --git a/clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.h b/clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.h index be9e7b9..941fe72 100644 --- a/clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.h +++ b/clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ASSIGNOPERATORSIGNATURECHECK_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ASSIGNOPERATORSIGNATURECHECK_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNCONVENTIONALASSIGNOPERATORCHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNCONVENTIONALASSIGNOPERATORCHECK_H #include "../ClangTidyCheck.h" @@ -37,4 +37,4 @@ public: } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ASSIGNOPERATORSIGNATURECHECK_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNCONVENTIONALASSIGNOPERATORCHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/UnusedAliasDeclsCheck.h b/clang-tools-extra/clang-tidy/misc/UnusedAliasDeclsCheck.h index ffe82ca..b9d85c1 100644 --- a/clang-tools-extra/clang-tidy/misc/UnusedAliasDeclsCheck.h +++ b/clang-tools-extra/clang-tidy/misc/UnusedAliasDeclsCheck.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSEDALIASDECLSCHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSEDALIASDECLSCHECK_H #include "../ClangTidyCheck.h" #include "llvm/ADT/DenseMap.h" @@ -32,4 +32,4 @@ private: } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSEDALIASDECLSCHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/UnusedParametersCheck.cpp b/clang-tools-extra/clang-tidy/misc/UnusedParametersCheck.cpp index f2189f5..9c38bb1 100644 --- a/clang-tools-extra/clang-tidy/misc/UnusedParametersCheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/UnusedParametersCheck.cpp @@ -30,13 +30,10 @@ static bool isOverrideMethod(const FunctionDecl *Function) { static bool hasAttrAfterParam(const SourceManager *SourceManager, const ParmVarDecl *Param) { - for (const auto *Attr : Param->attrs()) { - if (SourceManager->isBeforeInTranslationUnit(Param->getLocation(), - Attr->getLocation())) { - return true; - } - } - return false; + return llvm::any_of(Param->attrs(), [&](const Attr *Attr) { + return SourceManager->isBeforeInTranslationUnit(Param->getLocation(), + Attr->getLocation()); + }); } void UnusedParametersCheck::registerMatchers(MatchFinder *Finder) { @@ -160,12 +157,11 @@ void UnusedParametersCheck::warnOnUnusedParameter( !Result.SourceManager->isInMainFile(Function->getLocation()) || !Indexer->getOtherRefs(Function).empty() || isOverrideMethod(Function) || isLambdaCallOperator(Function)) { - // It is illegal to omit parameter name here in C code, so early-out. if (!Result.Context->getLangOpts().CPlusPlus) return; - SourceRange RemovalRange(Param->getLocation()); + const SourceRange RemovalRange(Param->getLocation()); // Note: We always add a space before the '/*' to not accidentally create // a '*/*' for pointer types, which doesn't start a comment. clang-format // will clean this up afterwards. diff --git a/clang-tools-extra/clang-tidy/misc/UnusedParametersCheck.h b/clang-tools-extra/clang-tidy/misc/UnusedParametersCheck.h index 877fc4d..fe2cc6e 100644 --- a/clang-tools-extra/clang-tidy/misc/UnusedParametersCheck.h +++ b/clang-tools-extra/clang-tidy/misc/UnusedParametersCheck.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSEDPARAMETERSCHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSEDPARAMETERSCHECK_H #include "../ClangTidyCheck.h" @@ -36,4 +36,4 @@ private: } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSEDPARAMETERSCHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/UnusedUsingDeclsCheck.h b/clang-tools-extra/clang-tidy/misc/UnusedUsingDeclsCheck.h index 96d8d9d..986bf37 100644 --- a/clang-tools-extra/clang-tidy/misc/UnusedUsingDeclsCheck.h +++ b/clang-tools-extra/clang-tidy/misc/UnusedUsingDeclsCheck.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_USING_DECLS_H -#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_USING_DECLS_H +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSEDUSINGDECLSCHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSEDUSINGDECLSCHECK_H #include "../ClangTidyCheck.h" #include "../utils/FileExtensionsUtils.h" @@ -56,4 +56,4 @@ private: } // namespace clang::tidy::misc -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_USING_DECLS_H +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSEDUSINGDECLSCHECK_H diff --git a/clang-tools-extra/clang-tidy/misc/UseAnonymousNamespaceCheck.cpp b/clang-tools-extra/clang-tidy/misc/UseAnonymousNamespaceCheck.cpp index aa0cc1e..ed36d48 100644 --- a/clang-tools-extra/clang-tidy/misc/UseAnonymousNamespaceCheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/UseAnonymousNamespaceCheck.cpp @@ -52,7 +52,8 @@ void UseAnonymousNamespaceCheck::registerMatchers(MatchFinder *Finder) { void UseAnonymousNamespaceCheck::check(const MatchFinder::MatchResult &Result) { if (const auto *MatchedDecl = Result.Nodes.getNodeAs<NamedDecl>("x")) { - StringRef Type = llvm::isa<VarDecl>(MatchedDecl) ? "variable" : "function"; + const StringRef Type = + llvm::isa<VarDecl>(MatchedDecl) ? "variable" : "function"; diag(MatchedDecl->getLocation(), "%0 %1 declared 'static', move to anonymous namespace instead") << Type << MatchedDecl; diff --git a/clang-tools-extra/clang-tidy/misc/UseInternalLinkageCheck.cpp b/clang-tools-extra/clang-tidy/misc/UseInternalLinkageCheck.cpp index 415852d..bad51c60 100644 --- a/clang-tools-extra/clang-tidy/misc/UseInternalLinkageCheck.cpp +++ b/clang-tools-extra/clang-tidy/misc/UseInternalLinkageCheck.cpp @@ -43,12 +43,6 @@ struct OptionEnumMapping<misc::UseInternalLinkageCheck::FixModeKind> { namespace clang::tidy::misc { -namespace { - -AST_MATCHER(Decl, isFirstDecl) { return Node.isFirstDecl(); } - -AST_MATCHER(FunctionDecl, hasBody) { return Node.hasBody(); } - static bool isInMainFile(SourceLocation L, SourceManager &SM, const FileExtensionsSet &HeaderFileExtensions) { for (;;) { @@ -65,6 +59,12 @@ static bool isInMainFile(SourceLocation L, SourceManager &SM, } } +namespace { + +AST_MATCHER(Decl, isFirstDecl) { return Node.isFirstDecl(); } + +AST_MATCHER(FunctionDecl, hasBody) { return Node.hasBody(); } + AST_MATCHER_P(Decl, isAllRedeclsInMainFile, FileExtensionsSet, HeaderFileExtensions) { return llvm::all_of(Node.redecls(), [&](const Decl *D) { @@ -142,7 +142,8 @@ static constexpr StringRef Message = void UseInternalLinkageCheck::check(const MatchFinder::MatchResult &Result) { if (const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>("fn")) { - DiagnosticBuilder DB = diag(FD->getLocation(), Message) << "function" << FD; + const DiagnosticBuilder DB = diag(FD->getLocation(), Message) + << "function" << FD; const SourceLocation FixLoc = FD->getInnerLocStart(); if (FixLoc.isInvalid() || FixLoc.isMacroID()) return; @@ -157,7 +158,8 @@ void UseInternalLinkageCheck::check(const MatchFinder::MatchResult &Result) { if (getLangOpts().CPlusPlus && VD->getType().isConstQualified()) return; - DiagnosticBuilder DB = diag(VD->getLocation(), Message) << "variable" << VD; + const DiagnosticBuilder DB = diag(VD->getLocation(), Message) + << "variable" << VD; const SourceLocation FixLoc = VD->getInnerLocStart(); if (FixLoc.isInvalid() || FixLoc.isMacroID()) return; |