This is an archive of the discontinued LLVM Phabricator instance.

Differential D50354

Port getLocStart -> getBeginLoc
ClosedPublic

Authored by steveire on Aug 6 2018, 12:47 PM.

Details

Reviewers
javed.absar
rsmith
Commits
rG43465bf3fd6c: Port getLocStart -> getBeginLoc
rCTE339400: Port getLocStart -> getBeginLoc
rL339400: Port getLocStart -> getBeginLoc

Diff Detail

Event Timeline

steveire created this revision.Aug 6 2018, 12:47 PM
Herald added a reviewer: javed.absar. · View Herald TranscriptAug 6 2018, 12:47 PM
Herald added subscribers: cfe-commits, jfb, arphaman and 5 others. · View Herald Transcript
Harbormaster completed remote builds in B21143: Diff 159366.Aug 6 2018, 12:47 PM
steveire added a reviewer: rsmith.Aug 6 2018, 12:51 PM
steveire added a comment.Aug 9 2018, 3:42 PM

Accepted as part of a whole-branch review here: http://clang-developers.42468.n3.nabble.com/getLocStart-versus-getStartLoc-td4061010.html

This revision was not accepted when it landed; it landed in state Needs Review.Aug 9 2018, 3:43 PM
Closed by commit rL339400: Port getLocStart -> getBeginLoc (authored by steveire). · Explain Why
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptAug 9 2018, 3:43 PM

Revision Contents

PathSize
change-namespace/
12 lines
clang-doc/
4 lines
clang-move/
10 lines
clang-tidy/
abseil/
6 lines
android/
6 lines
6 lines
boost/
6 lines
bugprone/
4 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
8 lines
2 lines
28 lines
2 lines
2 lines
4 lines
6 lines
2 lines
4 lines
12 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
4 lines
2 lines
cert/
2 lines
cppcoreguidelines/
4 lines
4 lines
4 lines
24 lines
8 lines
12 lines
fuchsia/
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
google/
8 lines
6 lines
8 lines
2 lines
2 lines
2 lines
2 lines
hicpp/
4 lines
8 lines
6 lines
llvm/
2 lines
misc/
2 lines
4 lines
4 lines
8 lines
4 lines
2 lines
4 lines
2 lines
modernize/
4 lines
4 lines
4 lines
6 lines
10 lines
10 lines
4 lines
2 lines
2 lines
2 lines
2 lines
10 lines
2 lines
6 lines
2 lines
objc/
2 lines
2 lines
performance/
4 lines
2 lines
2 lines
4 lines
6 lines
2 lines
2 lines
10 lines
readability/
6 lines
4 lines
4 lines
4 lines
4 lines
6 lines
2 lines
16 lines
2 lines
6 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
22 lines
2 lines
4 lines
6 lines
6 lines
utils/
4 lines
2 lines
2 lines
clangd/
2 lines
4 lines
2 lines
tool-template/
4 lines
unittests/
clang-tidy/
2 lines
6 lines
6 lines
4 lines

Diff 159366

change-namespace/ChangeNamespace.cpp

Show All 40 LinesSourceLocation startLocationForType(TypeLoc TLoc) {
// `struct` but including the namespace qualifier, `a::`. // `struct` but including the namespace qualifier, `a::`.
if (TLoc.getTypeLocClass() == TypeLoc::Elaborated) { if (TLoc.getTypeLocClass() == TypeLoc::Elaborated) {
NestedNameSpecifierLoc NestedNameSpecifier = NestedNameSpecifierLoc NestedNameSpecifier =
TLoc.castAs<ElaboratedTypeLoc>().getQualifierLoc(); TLoc.castAs<ElaboratedTypeLoc>().getQualifierLoc();
if (NestedNameSpecifier.getNestedNameSpecifier()) if (NestedNameSpecifier.getNestedNameSpecifier())
return NestedNameSpecifier.getBeginLoc(); return NestedNameSpecifier.getBeginLoc();
TLoc = TLoc.getNextTypeLoc(); TLoc = TLoc.getNextTypeLoc();
} }
return TLoc.getLocStart(); return TLoc.getBeginLoc();
} }
SourceLocation endLocationForType(TypeLoc TLoc) { SourceLocation endLocationForType(TypeLoc TLoc) {
// Dig past any namespace or keyword qualifications. // Dig past any namespace or keyword qualifications.
while (TLoc.getTypeLocClass() == TypeLoc::Elaborated || while (TLoc.getTypeLocClass() == TypeLoc::Elaborated ||
TLoc.getTypeLocClass() == TypeLoc::Qualified) TLoc.getTypeLocClass() == TypeLoc::Qualified)
TLoc = TLoc.getNextTypeLoc(); TLoc = TLoc.getNextTypeLoc();
▲ Show 20 Lines • Show All 212 Lines • ▼ Show 20 Lines while (D) {
D = D->getParent(); D = D->getParent();
} }
return false; return false;
} }
// Returns true if \p D is visible at \p Loc with DeclContext \p DeclCtx. // Returns true if \p D is visible at \p Loc with DeclContext \p DeclCtx.
bool isDeclVisibleAtLocation(const SourceManager &SM, const Decl *D, bool isDeclVisibleAtLocation(const SourceManager &SM, const Decl *D,
const DeclContext *DeclCtx, SourceLocation Loc) { const DeclContext *DeclCtx, SourceLocation Loc) {
SourceLocation DeclLoc = SM.getSpellingLoc(D->getLocStart()); SourceLocation DeclLoc = SM.getSpellingLoc(D->getBeginLoc());
Loc = SM.getSpellingLoc(Loc); Loc = SM.getSpellingLoc(Loc);
return SM.isBeforeInTranslationUnit(DeclLoc, Loc) && return SM.isBeforeInTranslationUnit(DeclLoc, Loc) &&
(SM.getFileID(DeclLoc) == SM.getFileID(Loc) && (SM.getFileID(DeclLoc) == SM.getFileID(Loc) &&
isNestedDeclContext(DeclCtx, D->getDeclContext())); isNestedDeclContext(DeclCtx, D->getDeclContext()));
} }
// Given a qualified symbol name, returns true if the symbol will be // Given a qualified symbol name, returns true if the symbol will be
// incorrectly qualified without leading "::". // incorrectly qualified without leading "::".
▲ Show 20 Lines • Show All 342 Lines • ▼ Show 20 Lines replaceQualifiedSymbolInDeclContext(
CalleeRange.getEnd(), llvm::cast<NamedDecl>(Func)); CalleeRange.getEnd(), llvm::cast<NamedDecl>(Func));
} }
} }
static SourceLocation getLocAfterNamespaceLBrace(const NamespaceDecl *NsDecl, static SourceLocation getLocAfterNamespaceLBrace(const NamespaceDecl *NsDecl,
const SourceManager &SM, const SourceManager &SM,
const LangOptions &LangOpts) { const LangOptions &LangOpts) {
std::unique_ptr<Lexer> Lex = std::unique_ptr<Lexer> Lex =
getLexerStartingFromLoc(NsDecl->getLocStart(), SM, LangOpts); getLexerStartingFromLoc(NsDecl->getBeginLoc(), SM, LangOpts);
assert(Lex.get() && assert(Lex.get() &&
"Failed to create lexer from the beginning of namespace."); "Failed to create lexer from the beginning of namespace.");
if (!Lex.get()) if (!Lex.get())
return SourceLocation(); return SourceLocation();
Token Tok; Token Tok;
while (!Lex->LexFromRawLexer(Tok) && Tok.isNot(tok::TokenKind::l_brace)) { while (!Lex->LexFromRawLexer(Tok) && Tok.isNot(tok::TokenKind::l_brace)) {
} }
return Tok.isNot(tok::TokenKind::l_brace) return Tok.isNot(tok::TokenKind::l_brace)
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
// class FWD; // class FWD;
// } // a // } // a
// namespace x { // namespace x {
// class A { a::FWD *fwd; } // class A { a::FWD *fwd; }
// } // x // } // x
void ChangeNamespaceTool::moveClassForwardDeclaration( void ChangeNamespaceTool::moveClassForwardDeclaration(
const ast_matchers::MatchFinder::MatchResult &Result, const ast_matchers::MatchFinder::MatchResult &Result,
const NamedDecl *FwdDecl) { const NamedDecl *FwdDecl) {
SourceLocation Start = FwdDecl->getLocStart(); SourceLocation Start = FwdDecl->getBeginLoc();
SourceLocation End = FwdDecl->getLocEnd(); SourceLocation End = FwdDecl->getLocEnd();
const SourceManager &SM = *Result.SourceManager; const SourceManager &SM = *Result.SourceManager;
SourceLocation AfterSemi = Lexer::findLocationAfterToken( SourceLocation AfterSemi = Lexer::findLocationAfterToken(
End, tok::semi, SM, Result.Context->getLangOpts(), End, tok::semi, SM, Result.Context->getLangOpts(),
/*SkipTrailingWhitespaceAndNewLine=*/true); /*SkipTrailingWhitespaceAndNewLine=*/true);
if (AfterSemi.isValid()) if (AfterSemi.isValid())
End = AfterSemi.getLocWithOffset(-1); End = AfterSemi.getLocWithOffset(-1);
// Delete the forward declaration from the code to be moved. // Delete the forward declaration from the code to be moved.
▲ Show 20 Lines • Show All 153 Lines • ▼ Show 20 Linesvoid ChangeNamespaceTool::fixTypeLoc(
// The declaration which this TypeLoc refers to. // The declaration which this TypeLoc refers to.
const auto *FromDecl = Result.Nodes.getNodeAs<NamedDecl>("from_decl"); const auto *FromDecl = Result.Nodes.getNodeAs<NamedDecl>("from_decl");
// `hasDeclaration` gives underlying declaration, but if the type is // `hasDeclaration` gives underlying declaration, but if the type is
// a typedef type, we need to use the typedef type instead. // a typedef type, we need to use the typedef type instead.
auto IsInMovedNs = [&](const NamedDecl *D) { auto IsInMovedNs = [&](const NamedDecl *D) {
if (!llvm::StringRef(D->getQualifiedNameAsString()) if (!llvm::StringRef(D->getQualifiedNameAsString())
.startswith(OldNamespace + "::")) .startswith(OldNamespace + "::"))
return false; return false;
auto ExpansionLoc = Result.SourceManager->getExpansionLoc(D->getLocStart()); auto ExpansionLoc = Result.SourceManager->getExpansionLoc(D->getBeginLoc());
if (ExpansionLoc.isInvalid()) if (ExpansionLoc.isInvalid())
return false; return false;
llvm::StringRef Filename = Result.SourceManager->getFilename(ExpansionLoc); llvm::StringRef Filename = Result.SourceManager->getFilename(ExpansionLoc);
return FilePatternRE.match(Filename); return FilePatternRE.match(Filename);
}; };
// Make `FromDecl` the immediate declaration that `Type` refers to, i.e. if // Make `FromDecl` the immediate declaration that `Type` refers to, i.e. if
// `Type` is an alias type, we make `FromDecl` the type alias declaration. // `Type` is an alias type, we make `FromDecl` the type alias declaration.
// Also, don't fix the \p Type if it refers to a type alias decl in the moved // Also, don't fix the \p Type if it refers to a type alias decl in the moved
Show All 14 Linesvoid ChangeNamespaceTool::fixTypeLoc(
assert(DeclCtx && "Empty decl context."); assert(DeclCtx && "Empty decl context.");
replaceQualifiedSymbolInDeclContext(Result, DeclCtx->getDeclContext(), Start, replaceQualifiedSymbolInDeclContext(Result, DeclCtx->getDeclContext(), Start,
End, FromDecl); End, FromDecl);
} }
void ChangeNamespaceTool::fixUsingShadowDecl( void ChangeNamespaceTool::fixUsingShadowDecl(
const ast_matchers::MatchFinder::MatchResult &Result, const ast_matchers::MatchFinder::MatchResult &Result,
const UsingDecl *UsingDeclaration) { const UsingDecl *UsingDeclaration) {
SourceLocation Start = UsingDeclaration->getLocStart(); SourceLocation Start = UsingDeclaration->getBeginLoc();
SourceLocation End = UsingDeclaration->getLocEnd(); SourceLocation End = UsingDeclaration->getLocEnd();
if (Start.isInvalid() || End.isInvalid()) if (Start.isInvalid() || End.isInvalid())
return; return;
assert(UsingDeclaration->shadow_size() > 0); assert(UsingDeclaration->shadow_size() > 0);
// FIXME: it might not be always accurate to use the first using-decl. // FIXME: it might not be always accurate to use the first using-decl.
const NamedDecl *TargetDecl = const NamedDecl *TargetDecl =
UsingDeclaration->shadow_begin()->getTargetDecl(); UsingDeclaration->shadow_begin()->getTargetDecl();
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

clang-doc/Mapper.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines if (Comment) {
Comment->setAttached(); Comment->setAttached();
return Comment->parse(Context, nullptr, D); return Comment->parse(Context, nullptr, D);
} }
return nullptr; return nullptr;
} }
int MapASTVisitor::getLine(const NamedDecl *D, int MapASTVisitor::getLine(const NamedDecl *D,
const ASTContext &Context) const { const ASTContext &Context) const {
return Context.getSourceManager().getPresumedLoc(D->getLocStart()).getLine(); return Context.getSourceManager().getPresumedLoc(D->getBeginLoc()).getLine();
} }
llvm::StringRef MapASTVisitor::getFile(const NamedDecl *D, llvm::StringRef MapASTVisitor::getFile(const NamedDecl *D,
const ASTContext &Context) const { const ASTContext &Context) const {
return Context.getSourceManager() return Context.getSourceManager()
.getPresumedLoc(D->getLocStart()) .getPresumedLoc(D->getBeginLoc())
.getFilename(); .getFilename();
} }
} // namespace doc } // namespace doc
} // namespace clang } // namespace clang

clang-move/ClangMove.cpp

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Linesstd::string MakeAbsolutePath(const SourceManager &SM, StringRef Path) {
return CleanPath(AbsolutePath); return CleanPath(AbsolutePath);
} }
// Matches AST nodes that are expanded within the given AbsoluteFilePath. // Matches AST nodes that are expanded within the given AbsoluteFilePath.
AST_POLYMORPHIC_MATCHER_P(isExpansionInFile, AST_POLYMORPHIC_MATCHER_P(isExpansionInFile,
AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc), AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc),
std::string, AbsoluteFilePath) { std::string, AbsoluteFilePath) {
auto &SourceManager = Finder->getASTContext().getSourceManager(); auto &SourceManager = Finder->getASTContext().getSourceManager();
auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getLocStart()); auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getBeginLoc());
if (ExpansionLoc.isInvalid()) if (ExpansionLoc.isInvalid())
return false; return false;
auto FileEntry = auto FileEntry =
SourceManager.getFileEntryForID(SourceManager.getFileID(ExpansionLoc)); SourceManager.getFileEntryForID(SourceManager.getFileID(ExpansionLoc));
if (!FileEntry) if (!FileEntry)
return false; return false;
return MakeAbsolutePath(SourceManager, FileEntry->getName()) == return MakeAbsolutePath(SourceManager, FileEntry->getName()) ==
AbsoluteFilePath; AbsoluteFilePath;
▲ Show 20 Lines • Show All 189 Lines • ▼ Show 20 Lines return SM.getLocForEndOfFile(LocInfo.first) == EndLoc
: EndLoc.getLocWithOffset(1); : EndLoc.getLocWithOffset(1);
} }
// Get full range of a Decl including the comments associated with it. // Get full range of a Decl including the comments associated with it.
clang::CharSourceRange clang::CharSourceRange
getFullRange(const clang::Decl *D, getFullRange(const clang::Decl *D,
const clang::LangOptions &options = clang::LangOptions()) { const clang::LangOptions &options = clang::LangOptions()) {
const auto &SM = D->getASTContext().getSourceManager(); const auto &SM = D->getASTContext().getSourceManager();
clang::SourceRange Full(SM.getExpansionLoc(D->getLocStart()), clang::SourceRange Full(SM.getExpansionLoc(D->getBeginLoc()),
getLocForEndOfDecl(D)); getLocForEndOfDecl(D));
// Expand to comments that are associated with the Decl. // Expand to comments that are associated with the Decl.
if (const auto *Comment = D->getASTContext().getRawCommentForDeclNoCache(D)) { if (const auto *Comment = D->getASTContext().getRawCommentForDeclNoCache(D)) {
if (SM.isBeforeInTranslationUnit(Full.getEnd(), Comment->getLocEnd())) if (SM.isBeforeInTranslationUnit(Full.getEnd(), Comment->getLocEnd()))
Full.setEnd(Comment->getLocEnd()); Full.setEnd(Comment->getLocEnd());
// FIXME: Don't delete a preceding comment, if there are no other entities // FIXME: Don't delete a preceding comment, if there are no other entities
// it could refer to. // it could refer to.
if (SM.isBeforeInTranslationUnit(Comment->getLocStart(), Full.getBegin())) if (SM.isBeforeInTranslationUnit(Comment->getBeginLoc(), Full.getBegin()))
Full.setBegin(Comment->getLocStart()); Full.setBegin(Comment->getBeginLoc());
} }
return clang::CharSourceRange::getCharRange(Full); return clang::CharSourceRange::getCharRange(Full);
} }
std::string getDeclarationSourceText(const clang::Decl *D) { std::string getDeclarationSourceText(const clang::Decl *D) {
const auto &SM = D->getASTContext().getSourceManager(); const auto &SM = D->getASTContext().getSourceManager();
llvm::StringRef SourceText = llvm::StringRef SourceText =
clang::Lexer::getSourceText(getFullRange(D), SM, clang::LangOptions()); clang::Lexer::getSourceText(getFullRange(D), SM, clang::LangOptions());
return SourceText.str(); return SourceText.str();
} }
bool isInHeaderFile(const clang::Decl *D, bool isInHeaderFile(const clang::Decl *D,
llvm::StringRef OriginalRunningDirectory, llvm::StringRef OriginalRunningDirectory,
llvm::StringRef OldHeader) { llvm::StringRef OldHeader) {
const auto &SM = D->getASTContext().getSourceManager(); const auto &SM = D->getASTContext().getSourceManager();
if (OldHeader.empty()) if (OldHeader.empty())
return false; return false;
auto ExpansionLoc = SM.getExpansionLoc(D->getLocStart()); auto ExpansionLoc = SM.getExpansionLoc(D->getBeginLoc());
if (ExpansionLoc.isInvalid()) if (ExpansionLoc.isInvalid())
return false; return false;
if (const auto *FE = SM.getFileEntryForID(SM.getFileID(ExpansionLoc))) { if (const auto *FE = SM.getFileEntryForID(SM.getFileID(ExpansionLoc))) {
return MakeAbsolutePath(SM, FE->getName()) == return MakeAbsolutePath(SM, FE->getName()) ==
MakeAbsolutePath(OriginalRunningDirectory, OldHeader); MakeAbsolutePath(OriginalRunningDirectory, OldHeader);
} }
▲ Show 20 Lines • Show All 592 Lines • Show Last 20 Lines

clang-tidy/abseil/StringFindStartswithCheck.cpp

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Linesvoid StringFindStartswithCheck::check(const MatchFinder::MatchResult &Result) {
const auto *ComparisonExpr = Result.Nodes.getNodeAs<BinaryOperator>("expr"); const auto *ComparisonExpr = Result.Nodes.getNodeAs<BinaryOperator>("expr");
assert(ComparisonExpr != nullptr); assert(ComparisonExpr != nullptr);
const auto *Needle = Result.Nodes.getNodeAs<Expr>("needle"); const auto *Needle = Result.Nodes.getNodeAs<Expr>("needle");
assert(Needle != nullptr); assert(Needle != nullptr);
const Expr *Haystack = Result.Nodes.getNodeAs<CXXMemberCallExpr>("findexpr") const Expr *Haystack = Result.Nodes.getNodeAs<CXXMemberCallExpr>("findexpr")
->getImplicitObjectArgument(); ->getImplicitObjectArgument();
assert(Haystack != nullptr); assert(Haystack != nullptr);
if (ComparisonExpr->getLocStart().isMacroID()) if (ComparisonExpr->getBeginLoc().isMacroID())
return; return;
// Get the source code blocks (as characters) for both the string object // Get the source code blocks (as characters) for both the string object
// and the search expression // and the search expression
const StringRef NeedleExprCode = Lexer::getSourceText( const StringRef NeedleExprCode = Lexer::getSourceText(
CharSourceRange::getTokenRange(Needle->getSourceRange()), Source, CharSourceRange::getTokenRange(Needle->getSourceRange()), Source,
Context.getLangOpts()); Context.getLangOpts());
const StringRef HaystackExprCode = Lexer::getSourceText( const StringRef HaystackExprCode = Lexer::getSourceText(
CharSourceRange::getTokenRange(Haystack->getSourceRange()), Source, CharSourceRange::getTokenRange(Haystack->getSourceRange()), Source,
Context.getLangOpts()); Context.getLangOpts());
// Create the StartsWith string, negating if comparison was "!=". // Create the StartsWith string, negating if comparison was "!=".
bool Neg = ComparisonExpr->getOpcodeStr() == "!="; bool Neg = ComparisonExpr->getOpcodeStr() == "!=";
StringRef StartswithStr; StringRef StartswithStr;
if (Neg) { if (Neg) {
StartswithStr = "!absl::StartsWith"; StartswithStr = "!absl::StartsWith";
} else { } else {
StartswithStr = "absl::StartsWith"; StartswithStr = "absl::StartsWith";
} }
// Create the warning message and a FixIt hint replacing the original expr. // Create the warning message and a FixIt hint replacing the original expr.
auto Diagnostic = auto Diagnostic =
diag(ComparisonExpr->getLocStart(), diag(ComparisonExpr->getBeginLoc(),
(StringRef("use ") + StartswithStr + " instead of find() " + (StringRef("use ") + StartswithStr + " instead of find() " +
ComparisonExpr->getOpcodeStr() + " 0") ComparisonExpr->getOpcodeStr() + " 0")
.str()); .str());
Diagnostic << FixItHint::CreateReplacement( Diagnostic << FixItHint::CreateReplacement(
ComparisonExpr->getSourceRange(), ComparisonExpr->getSourceRange(),
(StartswithStr + "(" + HaystackExprCode + ", " + NeedleExprCode + ")") (StartswithStr + "(" + HaystackExprCode + ", " + NeedleExprCode + ")")
.str()); .str());
// Create a preprocessor #include FixIt hint (CreateIncludeInsertion checks // Create a preprocessor #include FixIt hint (CreateIncludeInsertion checks
// whether this already exists). // whether this already exists).
auto IncludeHint = IncludeInserter->CreateIncludeInsertion( auto IncludeHint = IncludeInserter->CreateIncludeInsertion(
Source.getFileID(ComparisonExpr->getLocStart()), AbseilStringsMatchHeader, Source.getFileID(ComparisonExpr->getBeginLoc()), AbseilStringsMatchHeader,
false); false);
if (IncludeHint) { if (IncludeHint) {
Diagnostic << *IncludeHint; Diagnostic << *IncludeHint;
} }
} }
void StringFindStartswithCheck::registerPPCallbacks( void StringFindStartswithCheck::registerPPCallbacks(
CompilerInstance &Compiler) { CompilerInstance &Compiler) {
Show All 18 Lines

clang-tidy/android/CloexecCheck.cpp

Show All 19 Lines
namespace android { namespace android {
namespace { namespace {
// Helper function to form the correct string mode for Type3. // Helper function to form the correct string mode for Type3.
// Build the replace text. If it's string constant, add <Mode> directly in the // Build the replace text. If it's string constant, add <Mode> directly in the
// end of the string. Else, add <Mode>. // end of the string. Else, add <Mode>.
std::string buildFixMsgForStringFlag(const Expr *Arg, const SourceManager &SM, std::string buildFixMsgForStringFlag(const Expr *Arg, const SourceManager &SM,
const LangOptions &LangOpts, char Mode) { const LangOptions &LangOpts, char Mode) {
if (Arg->getLocStart().isMacroID()) if (Arg->getBeginLoc().isMacroID())
return (Lexer::getSourceText( return (Lexer::getSourceText(
CharSourceRange::getTokenRange(Arg->getSourceRange()), SM, CharSourceRange::getTokenRange(Arg->getSourceRange()), SM,
LangOpts) + LangOpts) +
" \"" + Twine(Mode) + "\"") " \"" + Twine(Mode) + "\"")
.str(); .str();
StringRef SR = cast<StringLiteral>(Arg->IgnoreParenCasts())->getString(); StringRef SR = cast<StringLiteral>(Arg->IgnoreParenCasts())->getString();
return ("\"" + SR + Twine(Mode) + "\"").str(); return ("\"" + SR + Twine(Mode) + "\"").str();
Show All 33 Linesvoid CloexecCheck::insertMacroFlag(const MatchFinder::MatchResult &Result,
diag(EndLoc, "%0 should use %1 where possible") diag(EndLoc, "%0 should use %1 where possible")
<< FD << MacroFlag << FD << MacroFlag
<< FixItHint::CreateInsertion(EndLoc, (Twine(" | ") + MacroFlag).str()); << FixItHint::CreateInsertion(EndLoc, (Twine(" | ") + MacroFlag).str());
} }
void CloexecCheck::replaceFunc(const MatchFinder::MatchResult &Result, void CloexecCheck::replaceFunc(const MatchFinder::MatchResult &Result,
StringRef WarningMsg, StringRef FixMsg) { StringRef WarningMsg, StringRef FixMsg) {
const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr); const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
diag(MatchedCall->getLocStart(), WarningMsg) diag(MatchedCall->getBeginLoc(), WarningMsg)
<< FixItHint::CreateReplacement(MatchedCall->getSourceRange(), FixMsg); << FixItHint::CreateReplacement(MatchedCall->getSourceRange(), FixMsg);
} }
void CloexecCheck::insertStringFlag( void CloexecCheck::insertStringFlag(
const ast_matchers::MatchFinder::MatchResult &Result, const char Mode, const ast_matchers::MatchFinder::MatchResult &Result, const char Mode,
const int ArgPos) { const int ArgPos) {
const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr); const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>(FuncDeclBindingStr); const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>(FuncDeclBindingStr);
const auto *ModeArg = MatchedCall->getArg(ArgPos); const auto *ModeArg = MatchedCall->getArg(ArgPos);
// Check if the <Mode> may be in the mode string. // Check if the <Mode> may be in the mode string.
const auto *ModeStr = dyn_cast<StringLiteral>(ModeArg->IgnoreParenCasts()); const auto *ModeStr = dyn_cast<StringLiteral>(ModeArg->IgnoreParenCasts());
if (!ModeStr || (ModeStr->getString().find(Mode) != StringRef::npos)) if (!ModeStr || (ModeStr->getString().find(Mode) != StringRef::npos))
return; return;
const std::string &ReplacementText = buildFixMsgForStringFlag( const std::string &ReplacementText = buildFixMsgForStringFlag(
ModeArg, *Result.SourceManager, Result.Context->getLangOpts(), Mode); ModeArg, *Result.SourceManager, Result.Context->getLangOpts(), Mode);
diag(ModeArg->getLocStart(), "use %0 mode '%1' to set O_CLOEXEC") diag(ModeArg->getBeginLoc(), "use %0 mode '%1' to set O_CLOEXEC")
<< FD << std::string(1, Mode) << FD << std::string(1, Mode)
<< FixItHint::CreateReplacement(ModeArg->getSourceRange(), << FixItHint::CreateReplacement(ModeArg->getSourceRange(),
ReplacementText); ReplacementText);
} }
StringRef CloexecCheck::getSpellingArg(const MatchFinder::MatchResult &Result, StringRef CloexecCheck::getSpellingArg(const MatchFinder::MatchResult &Result,
int N) const { int N) const {
const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr); const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
Show All 9 Lines

clang-tidy/android/ComparisonInTempFailureRetryCheck.cpp

Show All 15 Lines
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
namespace { namespace {
AST_MATCHER(BinaryOperator, isRHSATempFailureRetryArg) { AST_MATCHER(BinaryOperator, isRHSATempFailureRetryArg) {
if (!Node.getLocStart().isMacroID()) if (!Node.getBeginLoc().isMacroID())
return false; return false;
const SourceManager &SM = Finder->getASTContext().getSourceManager(); const SourceManager &SM = Finder->getASTContext().getSourceManager();
if (!SM.isMacroArgExpansion(Node.getRHS()->IgnoreParenCasts()->getLocStart())) if (!SM.isMacroArgExpansion(Node.getRHS()->IgnoreParenCasts()->getBeginLoc()))
return false; return false;
const LangOptions &Opts = Finder->getASTContext().getLangOpts(); const LangOptions &Opts = Finder->getASTContext().getLangOpts();
SourceLocation LocStart = Node.getLocStart(); SourceLocation LocStart = Node.getBeginLoc();
while (LocStart.isMacroID()) { while (LocStart.isMacroID()) {
SourceLocation Invocation = SM.getImmediateMacroCallerLoc(LocStart); SourceLocation Invocation = SM.getImmediateMacroCallerLoc(LocStart);
Token Tok; Token Tok;
if (!Lexer::getRawToken(SM.getSpellingLoc(Invocation), Tok, SM, Opts, if (!Lexer::getRawToken(SM.getSpellingLoc(Invocation), Tok, SM, Opts,
/*IgnoreWhiteSpace=*/true)) { /*IgnoreWhiteSpace=*/true)) {
if (Tok.getKind() == tok::raw_identifier && if (Tok.getKind() == tok::raw_identifier &&
Tok.getRawIdentifier() == "TEMP_FAILURE_RETRY") Tok.getRawIdentifier() == "TEMP_FAILURE_RETRY")
return true; return true;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

clang-tidy/boost/UseToStringCheck.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines if (CharType->isSpecificBuiltinType(BuiltinType::Char_S) ||
CharType->isSpecificBuiltinType(BuiltinType::Char_U)) CharType->isSpecificBuiltinType(BuiltinType::Char_U))
StringType = "string"; StringType = "string";
else if (CharType->isSpecificBuiltinType(BuiltinType::WChar_S) || else if (CharType->isSpecificBuiltinType(BuiltinType::WChar_S) ||
CharType->isSpecificBuiltinType(BuiltinType::WChar_U)) CharType->isSpecificBuiltinType(BuiltinType::WChar_U))
StringType = "wstring"; StringType = "wstring";
else else
return; return;
auto Loc = Call->getLocStart(); auto Loc = Call->getBeginLoc();
auto Diag = auto Diag =
diag(Loc, "use std::to_%0 instead of boost::lexical_cast<std::%0>") diag(Loc, "use std::to_%0 instead of boost::lexical_cast<std::%0>")
<< StringType; << StringType;
if (Loc.isMacroID()) if (Loc.isMacroID())
return; return;
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
CharSourceRange::getCharRange(Call->getLocStart(), CharSourceRange::getCharRange(Call->getBeginLoc(),
Call->getArg(0)->getLocStart()), Call->getArg(0)->getBeginLoc()),
(llvm::Twine("std::to_") + StringType + "(").str()); (llvm::Twine("std::to_") + StringType + "(").str());
} }
} // namespace boost } // namespace boost
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/ArgumentCommentCheck.cpp

Show First 20 Lines • Show All 236 Lines • ▼ Show 20 Lines if (auto Template = Callee->getTemplateInstantiationPattern()) {
// pack. // pack.
if (Template->getNumParams() <= I || if (Template->getNumParams() <= I ||
Template->getParamDecl(I)->isParameterPack()) { Template->getParamDecl(I)->isParameterPack()) {
continue; continue;
} }
} }
CharSourceRange BeforeArgument = CharSourceRange BeforeArgument =
makeFileCharRange(ArgBeginLoc, Args[I]->getLocStart()); makeFileCharRange(ArgBeginLoc, Args[I]->getBeginLoc());
ArgBeginLoc = Args[I]->getLocEnd(); ArgBeginLoc = Args[I]->getLocEnd();
std::vector<std::pair<SourceLocation, StringRef>> Comments; std::vector<std::pair<SourceLocation, StringRef>> Comments;
if (BeforeArgument.isValid()) { if (BeforeArgument.isValid()) {
Comments = getCommentsInRange(Ctx, BeforeArgument); Comments = getCommentsInRange(Ctx, BeforeArgument);
} else { } else {
// Fall back to parsing back from the start of the argument. // Fall back to parsing back from the start of the argument.
CharSourceRange ArgsRange = makeFileCharRange( CharSourceRange ArgsRange = makeFileCharRange(
Args[I]->getLocStart(), Args[NumArgs - 1]->getLocEnd()); Args[I]->getBeginLoc(), Args[NumArgs - 1]->getLocEnd());
Comments = getCommentsBeforeLoc(Ctx, ArgsRange.getBegin()); Comments = getCommentsBeforeLoc(Ctx, ArgsRange.getBegin());
} }
for (auto Comment : Comments) { for (auto Comment : Comments) {
llvm::SmallVector<StringRef, 2> Matches; llvm::SmallVector<StringRef, 2> Matches;
if (IdentRE.match(Comment.second, &Matches) && if (IdentRE.match(Comment.second, &Matches) &&
!sameName(Matches[2], II->getName(), StrictMode)) { !sameName(Matches[2], II->getName(), StrictMode)) {
{ {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

clang-tidy/bugprone/AssertSideEffectCheck.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines Finder->addMatcher(
hasUnaryOperand(DescendantWithSideEffect)))))) hasUnaryOperand(DescendantWithSideEffect))))))
.bind("condStmt"), .bind("condStmt"),
this); this);
} }
void AssertSideEffectCheck::check(const MatchFinder::MatchResult &Result) { void AssertSideEffectCheck::check(const MatchFinder::MatchResult &Result) {
const SourceManager &SM = *Result.SourceManager; const SourceManager &SM = *Result.SourceManager;
const LangOptions LangOpts = getLangOpts(); const LangOptions LangOpts = getLangOpts();
SourceLocation Loc = Result.Nodes.getNodeAs<Stmt>("condStmt")->getLocStart(); SourceLocation Loc = Result.Nodes.getNodeAs<Stmt>("condStmt")->getBeginLoc();
StringRef AssertMacroName; StringRef AssertMacroName;
while (Loc.isValid() && Loc.isMacroID()) { while (Loc.isValid() && Loc.isMacroID()) {
StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM, LangOpts); StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM, LangOpts);
// Check if this macro is an assert. // Check if this macro is an assert.
if (std::find(AssertMacros.begin(), AssertMacros.end(), MacroName) != if (std::find(AssertMacros.begin(), AssertMacros.end(), MacroName) !=
AssertMacros.end()) { AssertMacros.end()) {
Show All 14 Lines

clang-tidy/bugprone/BoolPointerImplicitConversionCheck.cpp

Show All 30 Lines
} }
void BoolPointerImplicitConversionCheck::check( void BoolPointerImplicitConversionCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
auto *If = Result.Nodes.getNodeAs<IfStmt>("if"); auto *If = Result.Nodes.getNodeAs<IfStmt>("if");
auto *Var = Result.Nodes.getNodeAs<DeclRefExpr>("expr"); auto *Var = Result.Nodes.getNodeAs<DeclRefExpr>("expr");
// Ignore macros. // Ignore macros.
if (Var->getLocStart().isMacroID()) if (Var->getBeginLoc().isMacroID())
return; return;
// Only allow variable accesses for now, no function calls or member exprs. // Only allow variable accesses for now, no function calls or member exprs.
// Check that we don't dereference the variable anywhere within the if. This // Check that we don't dereference the variable anywhere within the if. This
// avoids false positives for checks of the pointer for nullptr before it is // avoids false positives for checks of the pointer for nullptr before it is
// dereferenced. If there is a dereferencing operator on this variable don't // dereferenced. If there is a dereferencing operator on this variable don't
// emit a diagnostic. Also ignore array subscripts. // emit a diagnostic. Also ignore array subscripts.
const Decl *D = Var->getDecl(); const Decl *D = Var->getDecl();
Show All 10 Lines if (!match(findAll(
!match(findAll(callExpr(hasAnyArgument(ignoringParenImpCasts(DeclRef)))), !match(findAll(callExpr(hasAnyArgument(ignoringParenImpCasts(DeclRef)))),
*If, *Result.Context) *If, *Result.Context)
.empty() || .empty() ||
!match(findAll(cxxDeleteExpr(has(ignoringParenImpCasts(expr(DeclRef))))), !match(findAll(cxxDeleteExpr(has(ignoringParenImpCasts(expr(DeclRef))))),
*If, *Result.Context) *If, *Result.Context)
.empty()) .empty())
return; return;
diag(Var->getLocStart(), "dubious check of 'bool *' against 'nullptr', did " diag(Var->getBeginLoc(), "dubious check of 'bool *' against 'nullptr', did "
"you mean to dereference it?") "you mean to dereference it?")
<< FixItHint::CreateInsertion(Var->getLocStart(), "*"); << FixItHint::CreateInsertion(Var->getBeginLoc(), "*");
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/CopyConstructorInitCheck.cpp

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Linesvoid CopyConstructorInitCheck::check(const MatchFinder::MatchResult &Result) {
if (FixItInitList.empty() || ParamName.empty() || ShouldNotDoFixit) if (FixItInitList.empty() || ParamName.empty() || ShouldNotDoFixit)
return; return;
std::string FixItMsg{FixItInitList.substr(0, FixItInitList.size() - 2)}; std::string FixItMsg{FixItInitList.substr(0, FixItInitList.size() - 2)};
SourceLocation FixItLoc; SourceLocation FixItLoc;
// There is no initialization list in this constructor. // There is no initialization list in this constructor.
if (!HasWrittenInitializer) { if (!HasWrittenInitializer) {
FixItLoc = Ctor->getBody()->getLocStart(); FixItLoc = Ctor->getBody()->getBeginLoc();
FixItMsg = " : " + FixItMsg; FixItMsg = " : " + FixItMsg;
} else { } else {
// We apply the missing ctors at the beginning of the initialization list. // We apply the missing ctors at the beginning of the initialization list.
FixItLoc = (*Ctor->init_begin())->getSourceLocation(); FixItLoc = (*Ctor->init_begin())->getSourceLocation();
FixItMsg += ','; FixItMsg += ',';
} }
FixItMsg += ' '; FixItMsg += ' ';
Diag << FixItHint::CreateInsertion(FixItLoc, FixItMsg); Diag << FixItHint::CreateInsertion(FixItLoc, FixItMsg);
} // namespace misc } // namespace misc
} // namespace misc } // namespace misc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/DanglingHandleCheck.cpp

Show First 20 Lines • Show All 172 Lines • ▼ Show 20 Lines
void DanglingHandleCheck::registerMatchers(MatchFinder *Finder) { void DanglingHandleCheck::registerMatchers(MatchFinder *Finder) {
registerMatchersForVariables(Finder); registerMatchersForVariables(Finder);
registerMatchersForReturn(Finder); registerMatchersForReturn(Finder);
} }
void DanglingHandleCheck::check(const MatchFinder::MatchResult &Result) { void DanglingHandleCheck::check(const MatchFinder::MatchResult &Result) {
auto *Handle = Result.Nodes.getNodeAs<CXXRecordDecl>("handle"); auto *Handle = Result.Nodes.getNodeAs<CXXRecordDecl>("handle");
diag(Result.Nodes.getNodeAs<Stmt>("bad_stmt")->getLocStart(), diag(Result.Nodes.getNodeAs<Stmt>("bad_stmt")->getBeginLoc(),
"%0 outlives its value") "%0 outlives its value")
<< Handle->getQualifiedNameAsString(); << Handle->getQualifiedNameAsString();
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/InaccurateEraseCheck.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines Finder->addMatcher(
this); this);
} }
void InaccurateEraseCheck::check(const MatchFinder::MatchResult &Result) { void InaccurateEraseCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MemberCall = const auto *MemberCall =
Result.Nodes.getNodeAs<CXXMemberCallExpr>("erase"); Result.Nodes.getNodeAs<CXXMemberCallExpr>("erase");
const auto *EndExpr = const auto *EndExpr =
Result.Nodes.getNodeAs<CXXMemberCallExpr>("end"); Result.Nodes.getNodeAs<CXXMemberCallExpr>("end");
const SourceLocation Loc = MemberCall->getLocStart(); const SourceLocation Loc = MemberCall->getBeginLoc();
FixItHint Hint; FixItHint Hint;
if (!Loc.isMacroID() && EndExpr) { if (!Loc.isMacroID() && EndExpr) {
const auto *AlgCall = Result.Nodes.getNodeAs<CallExpr>("alg"); const auto *AlgCall = Result.Nodes.getNodeAs<CallExpr>("alg");
std::string ReplacementText = Lexer::getSourceText( std::string ReplacementText = Lexer::getSourceText(
CharSourceRange::getTokenRange(EndExpr->getSourceRange()), CharSourceRange::getTokenRange(EndExpr->getSourceRange()),
*Result.SourceManager, getLangOpts()); *Result.SourceManager, getLangOpts());
Show All 13 Lines

clang-tidy/bugprone/IncorrectRoundingsCheck.cpp

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines MatchFinder->addMatcher(
hasImplicitDestinationType(isInteger()), hasImplicitDestinationType(isInteger()),
ignoringParenCasts(binaryOperator(hasOperatorName("+"), OneSideHalf))) ignoringParenCasts(binaryOperator(hasOperatorName("+"), OneSideHalf)))
.bind("CastExpr"), .bind("CastExpr"),
this); this);
} }
void IncorrectRoundingsCheck::check(const MatchFinder::MatchResult &Result) { void IncorrectRoundingsCheck::check(const MatchFinder::MatchResult &Result) {
const auto *CastExpr = Result.Nodes.getNodeAs<ImplicitCastExpr>("CastExpr"); const auto *CastExpr = Result.Nodes.getNodeAs<ImplicitCastExpr>("CastExpr");
diag(CastExpr->getLocStart(), diag(CastExpr->getBeginLoc(),
"casting (double + 0.5) to integer leads to incorrect rounding; " "casting (double + 0.5) to integer leads to incorrect rounding; "
"consider using lround (#include <cmath>) instead"); "consider using lround (#include <cmath>) instead");
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/IntegerDivisionCheck.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines Finder->addMatcher(
expr(Exceptions, expr(Exceptions,
hasAncestor(castExpr(equalsBoundNode("FloatCast"))))))) hasAncestor(castExpr(equalsBoundNode("FloatCast")))))))
.bind("IntDiv"), .bind("IntDiv"),
this); this);
} }
void IntegerDivisionCheck::check(const MatchFinder::MatchResult &Result) { void IntegerDivisionCheck::check(const MatchFinder::MatchResult &Result) {
const auto *IntDiv = Result.Nodes.getNodeAs<BinaryOperator>("IntDiv"); const auto *IntDiv = Result.Nodes.getNodeAs<BinaryOperator>("IntDiv");
diag(IntDiv->getLocStart(), "result of integer division used in a floating " diag(IntDiv->getBeginLoc(), "result of integer division used in a floating "
"point context; possible loss of precision"); "point context; possible loss of precision");
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/MisplacedOperatorInStrlenInAllocCheck.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Linesvoid MisplacedOperatorInStrlenInAllocCheck::check(
const StringRef RHSText = Lexer::getSourceText( const StringRef RHSText = Lexer::getSourceText(
CharSourceRange::getTokenRange(BinOp->getRHS()->getSourceRange()), CharSourceRange::getTokenRange(BinOp->getRHS()->getSourceRange()),
*Result.SourceManager, getLangOpts()); *Result.SourceManager, getLangOpts());
auto Hint = FixItHint::CreateReplacement( auto Hint = FixItHint::CreateReplacement(
StrLen->getSourceRange(), StrLen->getSourceRange(),
(StrLenBegin + LHSText + StrLenEnd + " + " + RHSText).str()); (StrLenBegin + LHSText + StrLenEnd + " + " + RHSText).str());
diag(Alloc->getLocStart(), diag(Alloc->getBeginLoc(),
"addition operator is applied to the argument of %0 instead of its " "addition operator is applied to the argument of %0 instead of its "
"result") << StrLen->getDirectCallee()->getName() << Hint; "result") << StrLen->getDirectCallee()->getName() << Hint;
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/MisplacedWideningCastCheck.cpp

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Lines if ((FirstSize = relativeCharSizesW(First)) != 0 &&
return FirstSize > SecondSize; return FirstSize > SecondSize;
return false; return false;
} }
void MisplacedWideningCastCheck::check(const MatchFinder::MatchResult &Result) { void MisplacedWideningCastCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Cast = Result.Nodes.getNodeAs<CastExpr>("Cast"); const auto *Cast = Result.Nodes.getNodeAs<CastExpr>("Cast");
if (!CheckImplicitCasts && isa<ImplicitCastExpr>(Cast)) if (!CheckImplicitCasts && isa<ImplicitCastExpr>(Cast))
return; return;
if (Cast->getLocStart().isMacroID()) if (Cast->getBeginLoc().isMacroID())
return; return;
const auto *Calc = Result.Nodes.getNodeAs<Expr>("Calc"); const auto *Calc = Result.Nodes.getNodeAs<Expr>("Calc");
if (Calc->getLocStart().isMacroID()) if (Calc->getBeginLoc().isMacroID())
return; return;
if (Cast->isTypeDependent() || Cast->isValueDependent() || if (Cast->isTypeDependent() || Cast->isValueDependent() ||
Calc->isTypeDependent() || Calc->isValueDependent()) Calc->isTypeDependent() || Calc->isValueDependent())
return; return;
ASTContext &Context = *Result.Context; ASTContext &Context = *Result.Context;
Show All 17 Lines if (CastBuiltinType && CalcBuiltinType &&
return; return;
} }
// Don't write a warning if we can easily see that the result is not // Don't write a warning if we can easily see that the result is not
// truncated. // truncated.
if (Context.getIntWidth(CalcType) >= getMaxCalculationWidth(Context, Calc)) if (Context.getIntWidth(CalcType) >= getMaxCalculationWidth(Context, Calc))
return; return;
diag(Cast->getLocStart(), "either cast from %0 to %1 is ineffective, or " diag(Cast->getBeginLoc(), "either cast from %0 to %1 is ineffective, or "
"there is loss of precision before the conversion") "there is loss of precision before the conversion")
<< CalcType << CastType; << CalcType << CastType;
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/MoveForwardingReferenceCheck.cpp

Show All 23 Linesstatic void replaceMoveWithForward(const UnresolvedLookupExpr *Callee,
const TemplateTypeParmDecl *TypeParmDecl, const TemplateTypeParmDecl *TypeParmDecl,
DiagnosticBuilder &Diag, DiagnosticBuilder &Diag,
const ASTContext &Context) { const ASTContext &Context) {
const SourceManager &SM = Context.getSourceManager(); const SourceManager &SM = Context.getSourceManager();
const LangOptions &LangOpts = Context.getLangOpts(); const LangOptions &LangOpts = Context.getLangOpts();
CharSourceRange CallRange = CharSourceRange CallRange =
Lexer::makeFileCharRange(CharSourceRange::getTokenRange( Lexer::makeFileCharRange(CharSourceRange::getTokenRange(
Callee->getLocStart(), Callee->getLocEnd()), Callee->getBeginLoc(), Callee->getLocEnd()),
SM, LangOpts); SM, LangOpts);
if (CallRange.isValid()) { if (CallRange.isValid()) {
const std::string TypeName = const std::string TypeName =
TypeParmDecl->getIdentifier() TypeParmDecl->getIdentifier()
? TypeParmDecl->getName().str() ? TypeParmDecl->getName().str()
: (llvm::Twine("decltype(") + ParmVar->getName() + ")").str(); : (llvm::Twine("decltype(") + ParmVar->getName() + ")").str();
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

clang-tidy/bugprone/MultipleStatementMacroCheck.cpp

Show All 13 Lines
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
namespace { namespace {
AST_MATCHER(Expr, isInMacro) { return Node.getLocStart().isMacroID(); } AST_MATCHER(Expr, isInMacro) { return Node.getBeginLoc().isMacroID(); }
/// \brief Find the next statement after `S`. /// \brief Find the next statement after `S`.
const Stmt *nextStmt(const MatchFinder::MatchResult &Result, const Stmt *S) { const Stmt *nextStmt(const MatchFinder::MatchResult &Result, const Stmt *S) {
auto Parents = Result.Context->getParents(*S); auto Parents = Result.Context->getParents(*S);
if (Parents.empty()) if (Parents.empty())
return nullptr; return nullptr;
const auto *Parent = Parents[0].get<Stmt>(); const auto *Parent = Parents[0].get<Stmt>();
if (!Parent) if (!Parent)
Show All 37 Lines
void MultipleStatementMacroCheck::check( void MultipleStatementMacroCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *Inner = Result.Nodes.getNodeAs<Expr>("inner"); const auto *Inner = Result.Nodes.getNodeAs<Expr>("inner");
const auto *Outer = Result.Nodes.getNodeAs<Stmt>("outer"); const auto *Outer = Result.Nodes.getNodeAs<Stmt>("outer");
const auto *Next = nextStmt(Result, Outer); const auto *Next = nextStmt(Result, Outer);
if (!Next) if (!Next)
return; return;
SourceLocation OuterLoc = Outer->getLocStart(); SourceLocation OuterLoc = Outer->getBeginLoc();
if (Result.Nodes.getNodeAs<Stmt>("else")) if (Result.Nodes.getNodeAs<Stmt>("else"))
OuterLoc = cast<IfStmt>(Outer)->getElseLoc(); OuterLoc = cast<IfStmt>(Outer)->getElseLoc();
auto InnerRanges = getExpansionRanges(Inner->getLocStart(), Result); auto InnerRanges = getExpansionRanges(Inner->getBeginLoc(), Result);
auto OuterRanges = getExpansionRanges(OuterLoc, Result); auto OuterRanges = getExpansionRanges(OuterLoc, Result);
auto NextRanges = getExpansionRanges(Next->getLocStart(), Result); auto NextRanges = getExpansionRanges(Next->getBeginLoc(), Result);
// Remove all the common ranges, starting from the top (the last ones in the // Remove all the common ranges, starting from the top (the last ones in the
// list). // list).
while (!InnerRanges.empty() && !OuterRanges.empty() && !NextRanges.empty() && while (!InnerRanges.empty() && !OuterRanges.empty() && !NextRanges.empty() &&
InnerRanges.back() == OuterRanges.back() && InnerRanges.back() == OuterRanges.back() &&
InnerRanges.back() == NextRanges.back()) { InnerRanges.back() == NextRanges.back()) {
InnerRanges.pop_back(); InnerRanges.pop_back();
OuterRanges.pop_back(); OuterRanges.pop_back();
Show All 17 Lines

clang-tidy/bugprone/SizeofContainerCheck.cpp

Show All 34 Lines Finder->addMatcher(
this); this);
} }
void SizeofContainerCheck::check(const MatchFinder::MatchResult &Result) { void SizeofContainerCheck::check(const MatchFinder::MatchResult &Result) {
const auto *SizeOf = const auto *SizeOf =
Result.Nodes.getNodeAs<UnaryExprOrTypeTraitExpr>("sizeof"); Result.Nodes.getNodeAs<UnaryExprOrTypeTraitExpr>("sizeof");
auto Diag = auto Diag =
diag(SizeOf->getLocStart(), "sizeof() doesn't return the size of the " diag(SizeOf->getBeginLoc(), "sizeof() doesn't return the size of the "
"container; did you mean .size()?"); "container; did you mean .size()?");
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/SizeofExpressionCheck.cpp

Show First 20 Lines • Show All 210 Lines • ▼ Show 20 Lines Finder->addMatcher(
.bind("sizeof-sizeof-expr"), .bind("sizeof-sizeof-expr"),
this); this);
} }
void SizeofExpressionCheck::check(const MatchFinder::MatchResult &Result) { void SizeofExpressionCheck::check(const MatchFinder::MatchResult &Result) {
const ASTContext &Ctx = *Result.Context; const ASTContext &Ctx = *Result.Context;
if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-constant")) { if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-constant")) {
diag(E->getLocStart(), diag(E->getBeginLoc(),
"suspicious usage of 'sizeof(K)'; did you mean 'K'?"); "suspicious usage of 'sizeof(K)'; did you mean 'K'?");
} else if (const auto *E = } else if (const auto *E =
Result.Nodes.getNodeAs<Expr>("sizeof-integer-call")) { Result.Nodes.getNodeAs<Expr>("sizeof-integer-call")) {
diag(E->getLocStart(), "suspicious usage of 'sizeof()' on an expression " diag(E->getBeginLoc(), "suspicious usage of 'sizeof()' on an expression "
"that results in an integer"); "that results in an integer");
} else if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-this")) { } else if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-this")) {
diag(E->getLocStart(), diag(E->getBeginLoc(),
"suspicious usage of 'sizeof(this)'; did you mean 'sizeof(*this)'"); "suspicious usage of 'sizeof(this)'; did you mean 'sizeof(*this)'");
} else if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-charp")) { } else if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-charp")) {
diag(E->getLocStart(), diag(E->getBeginLoc(),
"suspicious usage of 'sizeof(char*)'; do you mean 'strlen'?"); "suspicious usage of 'sizeof(char*)'; do you mean 'strlen'?");
} else if (const auto *E = } else if (const auto *E =
Result.Nodes.getNodeAs<Expr>("sizeof-pointer-to-aggregate")) { Result.Nodes.getNodeAs<Expr>("sizeof-pointer-to-aggregate")) {
diag(E->getLocStart(), diag(E->getBeginLoc(),
"suspicious usage of 'sizeof(A*)'; pointer to aggregate"); "suspicious usage of 'sizeof(A*)'; pointer to aggregate");
} else if (const auto *E = } else if (const auto *E =
Result.Nodes.getNodeAs<Expr>("sizeof-compare-constant")) { Result.Nodes.getNodeAs<Expr>("sizeof-compare-constant")) {
diag(E->getLocStart(), diag(E->getBeginLoc(),
"suspicious comparison of 'sizeof(expr)' to a constant"); "suspicious comparison of 'sizeof(expr)' to a constant");
} else if (const auto *E = } else if (const auto *E =
Result.Nodes.getNodeAs<Expr>("sizeof-comma-expr")) { Result.Nodes.getNodeAs<Expr>("sizeof-comma-expr")) {
diag(E->getLocStart(), "suspicious usage of 'sizeof(..., ...)'"); diag(E->getBeginLoc(), "suspicious usage of 'sizeof(..., ...)'");
} else if (const auto *E = } else if (const auto *E =
Result.Nodes.getNodeAs<Expr>("sizeof-divide-expr")) { Result.Nodes.getNodeAs<Expr>("sizeof-divide-expr")) {
const auto *NumTy = Result.Nodes.getNodeAs<Type>("num-type"); const auto *NumTy = Result.Nodes.getNodeAs<Type>("num-type");
const auto *DenomTy = Result.Nodes.getNodeAs<Type>("denom-type"); const auto *DenomTy = Result.Nodes.getNodeAs<Type>("denom-type");
const auto *ElementTy = Result.Nodes.getNodeAs<Type>("elem-type"); const auto *ElementTy = Result.Nodes.getNodeAs<Type>("elem-type");
const auto *PointedTy = Result.Nodes.getNodeAs<Type>("elem-ptr-type"); const auto *PointedTy = Result.Nodes.getNodeAs<Type>("elem-ptr-type");
CharUnits NumeratorSize = getSizeOfType(Ctx, NumTy); CharUnits NumeratorSize = getSizeOfType(Ctx, NumTy);
CharUnits DenominatorSize = getSizeOfType(Ctx, DenomTy); CharUnits DenominatorSize = getSizeOfType(Ctx, DenomTy);
CharUnits ElementSize = getSizeOfType(Ctx, ElementTy); CharUnits ElementSize = getSizeOfType(Ctx, ElementTy);
if (DenominatorSize > CharUnits::Zero() && if (DenominatorSize > CharUnits::Zero() &&
!NumeratorSize.isMultipleOf(DenominatorSize)) { !NumeratorSize.isMultipleOf(DenominatorSize)) {
diag(E->getLocStart(), "suspicious usage of 'sizeof(...)/sizeof(...)';" diag(E->getBeginLoc(), "suspicious usage of 'sizeof(...)/sizeof(...)';"
" numerator is not a multiple of denominator"); " numerator is not a multiple of denominator");
} else if (ElementSize > CharUnits::Zero() && } else if (ElementSize > CharUnits::Zero() &&
DenominatorSize > CharUnits::Zero() && DenominatorSize > CharUnits::Zero() &&
ElementSize != DenominatorSize) { ElementSize != DenominatorSize) {
diag(E->getLocStart(), "suspicious usage of 'sizeof(...)/sizeof(...)';" diag(E->getBeginLoc(), "suspicious usage of 'sizeof(...)/sizeof(...)';"
" numerator is not a multiple of denominator"); " numerator is not a multiple of denominator");
} else if (NumTy && DenomTy && NumTy == DenomTy) { } else if (NumTy && DenomTy && NumTy == DenomTy) {
diag(E->getLocStart(), diag(E->getBeginLoc(),
"suspicious usage of sizeof pointer 'sizeof(T)/sizeof(T)'"); "suspicious usage of sizeof pointer 'sizeof(T)/sizeof(T)'");
} else if (PointedTy && DenomTy && PointedTy == DenomTy) { } else if (PointedTy && DenomTy && PointedTy == DenomTy) {
diag(E->getLocStart(), diag(E->getBeginLoc(),
"suspicious usage of sizeof pointer 'sizeof(T*)/sizeof(T)'"); "suspicious usage of sizeof pointer 'sizeof(T*)/sizeof(T)'");
} else if (NumTy && DenomTy && NumTy->isPointerType() && } else if (NumTy && DenomTy && NumTy->isPointerType() &&
DenomTy->isPointerType()) { DenomTy->isPointerType()) {
diag(E->getLocStart(), diag(E->getBeginLoc(),
"suspicious usage of sizeof pointer 'sizeof(P*)/sizeof(Q*)'"); "suspicious usage of sizeof pointer 'sizeof(P*)/sizeof(Q*)'");
} }
} else if (const auto *E = } else if (const auto *E =
Result.Nodes.getNodeAs<Expr>("sizeof-sizeof-expr")) { Result.Nodes.getNodeAs<Expr>("sizeof-sizeof-expr")) {
diag(E->getLocStart(), "suspicious usage of 'sizeof(sizeof(...))'"); diag(E->getBeginLoc(), "suspicious usage of 'sizeof(sizeof(...))'");
} else if (const auto *E = } else if (const auto *E =
Result.Nodes.getNodeAs<Expr>("sizeof-multiply-sizeof")) { Result.Nodes.getNodeAs<Expr>("sizeof-multiply-sizeof")) {
diag(E->getLocStart(), "suspicious 'sizeof' by 'sizeof' multiplication"); diag(E->getBeginLoc(), "suspicious 'sizeof' by 'sizeof' multiplication");
} }
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/StringConstructorCheck.cpp

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Lines Finder->addMatcher(
.bind("constructor"), .bind("constructor"),
this); this);
} }
void StringConstructorCheck::check(const MatchFinder::MatchResult &Result) { void StringConstructorCheck::check(const MatchFinder::MatchResult &Result) {
const ASTContext &Ctx = *Result.Context; const ASTContext &Ctx = *Result.Context;
const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("constructor"); const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("constructor");
assert(E && "missing constructor expression"); assert(E && "missing constructor expression");
SourceLocation Loc = E->getLocStart(); SourceLocation Loc = E->getBeginLoc();
if (Result.Nodes.getNodeAs<Expr>("swapped-parameter")) { if (Result.Nodes.getNodeAs<Expr>("swapped-parameter")) {
const Expr *P0 = E->getArg(0); const Expr *P0 = E->getArg(0);
const Expr *P1 = E->getArg(1); const Expr *P1 = E->getArg(1);
diag(Loc, "string constructor parameters are probably swapped;" diag(Loc, "string constructor parameters are probably swapped;"
" expecting string(count, character)") " expecting string(count, character)")
<< tooling::fixit::createReplacement(*P0, *P1, Ctx) << tooling::fixit::createReplacement(*P0, *P1, Ctx)
<< tooling::fixit::createReplacement(*P1, *P0, Ctx); << tooling::fixit::createReplacement(*P1, *P0, Ctx);
Show All 19 Lines

clang-tidy/bugprone/StringIntegerAssignmentCheck.cpp

Show All 33 Lines Finder->addMatcher(
.bind("expr"))), .bind("expr"))),
unless(isInTemplateInstantiation())), unless(isInTemplateInstantiation())),
this); this);
} }
void StringIntegerAssignmentCheck::check( void StringIntegerAssignmentCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *Argument = Result.Nodes.getNodeAs<Expr>("expr"); const auto *Argument = Result.Nodes.getNodeAs<Expr>("expr");
SourceLocation Loc = Argument->getLocStart(); SourceLocation Loc = Argument->getBeginLoc();
auto Diag = auto Diag =
diag(Loc, "an integer is interpreted as a character code when assigning " diag(Loc, "an integer is interpreted as a character code when assigning "
"it to a string; if this is intended, cast the integer to the " "it to a string; if this is intended, cast the integer to the "
"appropriate character type; if you want a string " "appropriate character type; if you want a string "
"representation, use the appropriate conversion facility"); "representation, use the appropriate conversion facility");
if (Loc.isMacroID()) if (Loc.isMacroID())
Show All 36 Lines

clang-tidy/bugprone/StringLiteralWithEmbeddedNulCheck.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Linesvoid StringLiteralWithEmbeddedNulCheck::check(
if (const auto *SL = Result.Nodes.getNodeAs<StringLiteral>("strlit")) { if (const auto *SL = Result.Nodes.getNodeAs<StringLiteral>("strlit")) {
for (size_t Offset = 0, Length = SL->getLength(); Offset < Length; for (size_t Offset = 0, Length = SL->getLength(); Offset < Length;
++Offset) { ++Offset) {
// Find a sequence of character like "\0x12". // Find a sequence of character like "\0x12".
if (Offset + 3 < Length && SL->getCodeUnit(Offset) == '\0' && if (Offset + 3 < Length && SL->getCodeUnit(Offset) == '\0' &&
SL->getCodeUnit(Offset + 1) == 'x' && SL->getCodeUnit(Offset + 1) == 'x' &&
isDigit(SL->getCodeUnit(Offset + 2)) && isDigit(SL->getCodeUnit(Offset + 2)) &&
isDigit(SL->getCodeUnit(Offset + 3))) { isDigit(SL->getCodeUnit(Offset + 3))) {
diag(SL->getLocStart(), "suspicious embedded NUL character"); diag(SL->getBeginLoc(), "suspicious embedded NUL character");
return; return;
} }
} }
} }
if (const auto *SL = Result.Nodes.getNodeAs<StringLiteral>("truncated")) { if (const auto *SL = Result.Nodes.getNodeAs<StringLiteral>("truncated")) {
diag(SL->getLocStart(), diag(SL->getBeginLoc(),
"truncated string literal with embedded NUL character"); "truncated string literal with embedded NUL character");
} }
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/SuspiciousMemsetUsageCheck.cpp

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
void SuspiciousMemsetUsageCheck::check(const MatchFinder::MatchResult &Result) { void SuspiciousMemsetUsageCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *CharZeroFill = if (const auto *CharZeroFill =
Result.Nodes.getNodeAs<CharacterLiteral>("char-zero-fill")) { Result.Nodes.getNodeAs<CharacterLiteral>("char-zero-fill")) {
// Case 1: fill_char of memset() is a character '0'. Probably an // Case 1: fill_char of memset() is a character '0'. Probably an
// integer zero was intended. // integer zero was intended.
SourceRange CharRange = CharZeroFill->getSourceRange(); SourceRange CharRange = CharZeroFill->getSourceRange();
auto Diag = auto Diag =
diag(CharZeroFill->getLocStart(), "memset fill value is char '0', " diag(CharZeroFill->getBeginLoc(), "memset fill value is char '0', "
"potentially mistaken for int 0"); "potentially mistaken for int 0");
// Only suggest a fix if no macros are involved. // Only suggest a fix if no macros are involved.
if (CharRange.getBegin().isMacroID()) if (CharRange.getBegin().isMacroID())
return; return;
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
CharSourceRange::getTokenRange(CharRange), "0"); CharSourceRange::getTokenRange(CharRange), "0");
} }
else if (const auto *NumFill = else if (const auto *NumFill =
Result.Nodes.getNodeAs<IntegerLiteral>("num-fill")) { Result.Nodes.getNodeAs<IntegerLiteral>("num-fill")) {
// Case 2: fill_char of memset() is larger in size than an unsigned char // Case 2: fill_char of memset() is larger in size than an unsigned char
// so it gets truncated during conversion. // so it gets truncated during conversion.
llvm::APSInt NumValue; llvm::APSInt NumValue;
const auto UCharMax = (1 << Result.Context->getCharWidth()) - 1; const auto UCharMax = (1 << Result.Context->getCharWidth()) - 1;
if (!NumFill->EvaluateAsInt(NumValue, *Result.Context) || if (!NumFill->EvaluateAsInt(NumValue, *Result.Context) ||
(NumValue >= 0 && NumValue <= UCharMax)) (NumValue >= 0 && NumValue <= UCharMax))
return; return;
diag(NumFill->getLocStart(), "memset fill value is out of unsigned " diag(NumFill->getBeginLoc(), "memset fill value is out of unsigned "
"character range, gets truncated"); "character range, gets truncated");
} }
else if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call")) { else if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call")) {
// Case 3: byte_count of memset() is zero. This is most likely an // Case 3: byte_count of memset() is zero. This is most likely an
// argument swap. // argument swap.
const Expr *FillChar = Call->getArg(1); const Expr *FillChar = Call->getArg(1);
Show All 11 Lines else if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call")) {
if (!FillChar->isValueDependent() && if (!FillChar->isValueDependent() &&
FillChar->EvaluateAsInt(Value1, *Result.Context) && FillChar->EvaluateAsInt(Value1, *Result.Context) &&
(Value1 == 0 || Value1.isNegative())) (Value1 == 0 || Value1.isNegative()))
return; return;
// `byte_count` is known to be zero at compile time, and `fill_char` is // `byte_count` is known to be zero at compile time, and `fill_char` is
// either not known or known to be a positive integer. Emit a warning // either not known or known to be a positive integer. Emit a warning
// and fix-its to swap the arguments. // and fix-its to swap the arguments.
auto D = diag(Call->getLocStart(), auto D = diag(Call->getBeginLoc(),
"memset of size zero, potentially swapped arguments"); "memset of size zero, potentially swapped arguments");
StringRef RHSString = tooling::fixit::getText(*ByteCount, *Result.Context); StringRef RHSString = tooling::fixit::getText(*ByteCount, *Result.Context);
StringRef LHSString = tooling::fixit::getText(*FillChar, *Result.Context); StringRef LHSString = tooling::fixit::getText(*FillChar, *Result.Context);
if (LHSString.empty() || RHSString.empty()) if (LHSString.empty() || RHSString.empty())
return; return;
D << tooling::fixit::createReplacement(*FillChar, RHSString) D << tooling::fixit::createReplacement(*FillChar, RHSString)
<< tooling::fixit::createReplacement(*ByteCount, LHSString); << tooling::fixit::createReplacement(*ByteCount, LHSString);
} }
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/SuspiciousMissingCommaCheck.cpp

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Lines for (unsigned int i = 0; i < Size; ++i) {
} }
} }
// Warn only when concatenation is not common in this initializer list. // Warn only when concatenation is not common in this initializer list.
// The current threshold is set to less than 1/5 of the string literals. // The current threshold is set to less than 1/5 of the string literals.
if (double(Count) / Size > RatioThreshold) if (double(Count) / Size > RatioThreshold)
return; return;
diag(ConcatenatedLiteral->getLocStart(), diag(ConcatenatedLiteral->getBeginLoc(),
"suspicious string literal, probably missing a comma"); "suspicious string literal, probably missing a comma");
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/SuspiciousSemicolonCheck.cpp

Show All 28 Lines Finder->addMatcher(
this); this);
} }
void SuspiciousSemicolonCheck::check(const MatchFinder::MatchResult &Result) { void SuspiciousSemicolonCheck::check(const MatchFinder::MatchResult &Result) {
if (Result.Context->getDiagnostics().hasUncompilableErrorOccurred()) if (Result.Context->getDiagnostics().hasUncompilableErrorOccurred())
return; return;
const auto *Semicolon = Result.Nodes.getNodeAs<NullStmt>("semi"); const auto *Semicolon = Result.Nodes.getNodeAs<NullStmt>("semi");
SourceLocation LocStart = Semicolon->getLocStart(); SourceLocation LocStart = Semicolon->getBeginLoc();
if (LocStart.isMacroID()) if (LocStart.isMacroID())
return; return;
ASTContext &Ctxt = *Result.Context; ASTContext &Ctxt = *Result.Context;
auto Token = utils::lexer::getPreviousToken(Ctxt, LocStart); auto Token = utils::lexer::getPreviousToken(Ctxt, LocStart);
auto &SM = *Result.SourceManager; auto &SM = *Result.SourceManager;
unsigned SemicolonLine = SM.getSpellingLineNumber(LocStart); unsigned SemicolonLine = SM.getSpellingLineNumber(LocStart);
Show All 9 Linesvoid SuspiciousSemicolonCheck::check(const MatchFinder::MatchResult &Result) {
FileID FID = SM.getFileID(LocEnd); FileID FID = SM.getFileID(LocEnd);
llvm::MemoryBuffer *Buffer = SM.getBuffer(FID, LocEnd); llvm::MemoryBuffer *Buffer = SM.getBuffer(FID, LocEnd);
Lexer Lexer(SM.getLocForStartOfFile(FID), Ctxt.getLangOpts(), Lexer Lexer(SM.getLocForStartOfFile(FID), Ctxt.getLangOpts(),
Buffer->getBufferStart(), SM.getCharacterData(LocEnd) + 1, Buffer->getBufferStart(), SM.getCharacterData(LocEnd) + 1,
Buffer->getBufferEnd()); Buffer->getBufferEnd());
if (Lexer.LexFromRawLexer(Token)) if (Lexer.LexFromRawLexer(Token))
return; return;
unsigned BaseIndent = SM.getSpellingColumnNumber(Statement->getLocStart()); unsigned BaseIndent = SM.getSpellingColumnNumber(Statement->getBeginLoc());
unsigned NewTokenIndent = SM.getSpellingColumnNumber(Token.getLocation()); unsigned NewTokenIndent = SM.getSpellingColumnNumber(Token.getLocation());
unsigned NewTokenLine = SM.getSpellingLineNumber(Token.getLocation()); unsigned NewTokenLine = SM.getSpellingLineNumber(Token.getLocation());
if (!IsIfStmt && NewTokenIndent <= BaseIndent && if (!IsIfStmt && NewTokenIndent <= BaseIndent &&
Token.getKind() != tok::l_brace && NewTokenLine != SemicolonLine) Token.getKind() != tok::l_brace && NewTokenLine != SemicolonLine)
return; return;
diag(LocStart, "potentially unintended semicolon") diag(LocStart, "potentially unintended semicolon")
<< FixItHint::CreateRemoval(SourceRange(LocStart, LocEnd)); << FixItHint::CreateRemoval(SourceRange(LocStart, LocEnd));
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/SuspiciousStringCompareCheck.cpp

Show First 20 Lines • Show All 171 Lines • ▼ Show 20 Linesvoid SuspiciousStringCompareCheck::check(
const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call"); const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
assert(Decl != nullptr && Call != nullptr); assert(Decl != nullptr && Call != nullptr);
if (Result.Nodes.getNodeAs<Stmt>("missing-comparison")) { if (Result.Nodes.getNodeAs<Stmt>("missing-comparison")) {
SourceLocation EndLoc = Lexer::getLocForEndOfToken( SourceLocation EndLoc = Lexer::getLocForEndOfToken(
Call->getRParenLoc(), 0, Result.Context->getSourceManager(), Call->getRParenLoc(), 0, Result.Context->getSourceManager(),
getLangOpts()); getLangOpts());
diag(Call->getLocStart(), diag(Call->getBeginLoc(),
"function %0 is called without explicitly comparing result") "function %0 is called without explicitly comparing result")
<< Decl << FixItHint::CreateInsertion(EndLoc, " != 0"); << Decl << FixItHint::CreateInsertion(EndLoc, " != 0");
} }
if (const auto *E = Result.Nodes.getNodeAs<Expr>("logical-not-comparison")) { if (const auto *E = Result.Nodes.getNodeAs<Expr>("logical-not-comparison")) {
SourceLocation EndLoc = Lexer::getLocForEndOfToken( SourceLocation EndLoc = Lexer::getLocForEndOfToken(
Call->getRParenLoc(), 0, Result.Context->getSourceManager(), Call->getRParenLoc(), 0, Result.Context->getSourceManager(),
getLangOpts()); getLangOpts());
SourceLocation NotLoc = E->getLocStart(); SourceLocation NotLoc = E->getBeginLoc();
diag(Call->getLocStart(), diag(Call->getBeginLoc(),
"function %0 is compared using logical not operator") "function %0 is compared using logical not operator")
<< Decl << FixItHint::CreateRemoval( << Decl << FixItHint::CreateRemoval(
CharSourceRange::getTokenRange(NotLoc, NotLoc)) CharSourceRange::getTokenRange(NotLoc, NotLoc))
<< FixItHint::CreateInsertion(EndLoc, " == 0"); << FixItHint::CreateInsertion(EndLoc, " == 0");
} }
if (Result.Nodes.getNodeAs<Stmt>("invalid-comparison")) { if (Result.Nodes.getNodeAs<Stmt>("invalid-comparison")) {
diag(Call->getLocStart(), diag(Call->getBeginLoc(),
"function %0 is compared to a suspicious constant") "function %0 is compared to a suspicious constant")
<< Decl; << Decl;
} }
if (const auto *BinOp = if (const auto *BinOp =
Result.Nodes.getNodeAs<BinaryOperator>("suspicious-operator")) { Result.Nodes.getNodeAs<BinaryOperator>("suspicious-operator")) {
diag(Call->getLocStart(), "results of function %0 used by operator '%1'") diag(Call->getBeginLoc(), "results of function %0 used by operator '%1'")
<< Decl << BinOp->getOpcodeStr(); << Decl << BinOp->getOpcodeStr();
} }
if (Result.Nodes.getNodeAs<Stmt>("invalid-conversion")) { if (Result.Nodes.getNodeAs<Stmt>("invalid-conversion")) {
diag(Call->getLocStart(), "function %0 has suspicious implicit cast") diag(Call->getBeginLoc(), "function %0 has suspicious implicit cast")
<< Decl; << Decl;
} }
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/SwappedArgumentsCheck.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines for (unsigned I = 1, E = Call->getNumArgs(); I < E; ++I) {
const Expr *LHSFrom = ignoreNoOpCasts(LHSCast->getSubExpr()); const Expr *LHSFrom = ignoreNoOpCasts(LHSCast->getSubExpr());
const Expr *RHSFrom = ignoreNoOpCasts(RHSCast->getSubExpr()); const Expr *RHSFrom = ignoreNoOpCasts(RHSCast->getSubExpr());
if (LHS->getType() == RHS->getType() || if (LHS->getType() == RHS->getType() ||
LHS->getType() != RHSFrom->getType() || LHS->getType() != RHSFrom->getType() ||
RHS->getType() != LHSFrom->getType()) RHS->getType() != LHSFrom->getType())
continue; continue;
// Emit a warning and fix-its that swap the arguments. // Emit a warning and fix-its that swap the arguments.
diag(Call->getLocStart(), "argument with implicit conversion from %0 " diag(Call->getBeginLoc(), "argument with implicit conversion from %0 "
"to %1 followed by argument converted from " "to %1 followed by argument converted from "
"%2 to %3, potentially swapped arguments.") "%2 to %3, potentially swapped arguments.")
<< LHS->getType() << LHSFrom->getType() << RHS->getType() << LHS->getType() << LHSFrom->getType() << RHS->getType()
<< RHSFrom->getType() << RHSFrom->getType()
<< tooling::fixit::createReplacement(*LHS, *RHS, Ctx) << tooling::fixit::createReplacement(*LHS, *RHS, Ctx)
<< tooling::fixit::createReplacement(*RHS, *LHS, Ctx); << tooling::fixit::createReplacement(*RHS, *LHS, Ctx);
// Remember that we emitted a warning for this argument. // Remember that we emitted a warning for this argument.
UsedArgs.insert(RHSCast); UsedArgs.insert(RHSCast);
} }
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/TerminatingContinueCheck.cpp

Show All 33 Lines Finder->addMatcher(
.bind("continue"), .bind("continue"),
this); this);
} }
void TerminatingContinueCheck::check(const MatchFinder::MatchResult &Result) { void TerminatingContinueCheck::check(const MatchFinder::MatchResult &Result) {
const auto *ContStmt = Result.Nodes.getNodeAs<ContinueStmt>("continue"); const auto *ContStmt = Result.Nodes.getNodeAs<ContinueStmt>("continue");
auto Diag = auto Diag =
diag(ContStmt->getLocStart(), diag(ContStmt->getBeginLoc(),
"'continue' in loop with false condition is equivalent to 'break'") "'continue' in loop with false condition is equivalent to 'break'")
<< tooling::fixit::createReplacement(*ContStmt, "break"); << tooling::fixit::createReplacement(*ContStmt, "break");
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/ThrowKeywordMissingCheck.cpp

Show All 36 Lines Finder->addMatcher(
.bind("temporary-exception-not-thrown"), .bind("temporary-exception-not-thrown"),
this); this);
} }
void ThrowKeywordMissingCheck::check(const MatchFinder::MatchResult &Result) { void ThrowKeywordMissingCheck::check(const MatchFinder::MatchResult &Result) {
const auto *TemporaryExpr = const auto *TemporaryExpr =
Result.Nodes.getNodeAs<Expr>("temporary-exception-not-thrown"); Result.Nodes.getNodeAs<Expr>("temporary-exception-not-thrown");
diag(TemporaryExpr->getLocStart(), "suspicious exception object created but " diag(TemporaryExpr->getBeginLoc(), "suspicious exception object created but "
"not thrown; did you mean 'throw %0'?") "not thrown; did you mean 'throw %0'?")
<< TemporaryExpr->getType().getBaseTypeIdentifier()->getName(); << TemporaryExpr->getType().getBaseTypeIdentifier()->getName();
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/UndefinedMemoryManipulationCheck.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
} }
void UndefinedMemoryManipulationCheck::check( void UndefinedMemoryManipulationCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("dest")) { if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("dest")) {
QualType DestType = Call->getArg(0)->IgnoreImplicit()->getType(); QualType DestType = Call->getArg(0)->IgnoreImplicit()->getType();
if (!DestType->getPointeeType().isNull()) if (!DestType->getPointeeType().isNull())
DestType = DestType->getPointeeType(); DestType = DestType->getPointeeType();
diag(Call->getLocStart(), "undefined behavior, destination object type %0 " diag(Call->getBeginLoc(), "undefined behavior, destination object type %0 "
"is not TriviallyCopyable") "is not TriviallyCopyable")
<< DestType; << DestType;
} }
if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("src")) { if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("src")) {
QualType SourceType = Call->getArg(1)->IgnoreImplicit()->getType(); QualType SourceType = Call->getArg(1)->IgnoreImplicit()->getType();
if (!SourceType->getPointeeType().isNull()) if (!SourceType->getPointeeType().isNull())
SourceType = SourceType->getPointeeType(); SourceType = SourceType->getPointeeType();
diag(Call->getLocStart(), diag(Call->getBeginLoc(),
"undefined behavior, source object type %0 is not TriviallyCopyable") "undefined behavior, source object type %0 is not TriviallyCopyable")
<< SourceType; << SourceType;
} }
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/UndelegatedConstructorCheck.cpp

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Lines Finder->addMatcher(
.bind("construct"))), .bind("construct"))),
unless(isInTemplateInstantiation())), unless(isInTemplateInstantiation())),
this); this);
} }
void UndelegatedConstructorCheck::check( void UndelegatedConstructorCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("construct"); const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("construct");
diag(E->getLocStart(), "did you intend to call a delegated constructor? " diag(E->getBeginLoc(), "did you intend to call a delegated constructor? "
"A temporary object is created here instead"); "A temporary object is created here instead");
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/UnusedRaiiCheck.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines Finder->addMatcher(
this); this);
} }
void UnusedRaiiCheck::check(const MatchFinder::MatchResult &Result) { void UnusedRaiiCheck::check(const MatchFinder::MatchResult &Result) {
const auto *E = Result.Nodes.getNodeAs<Expr>("expr"); const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
// We ignore code expanded from macros to reduce the number of false // We ignore code expanded from macros to reduce the number of false
// positives. // positives.
if (E->getLocStart().isMacroID()) if (E->getBeginLoc().isMacroID())
return; return;
// Don't emit a warning for the last statement in the surrounding compund // Don't emit a warning for the last statement in the surrounding compund
// statement. // statement.
const auto *CS = Result.Nodes.getNodeAs<CompoundStmt>("compound"); const auto *CS = Result.Nodes.getNodeAs<CompoundStmt>("compound");
if (E == CS->body_back()) if (E == CS->body_back())
return; return;
// Emit a warning. // Emit a warning.
auto D = diag(E->getLocStart(), "object destroyed immediately after " auto D = diag(E->getBeginLoc(), "object destroyed immediately after "
"creation; did you mean to name the object?"); "creation; did you mean to name the object?");
const char *Replacement = " give_me_a_name"; const char *Replacement = " give_me_a_name";
// If this is a default ctor we have to remove the parens or we'll introduce a // If this is a default ctor we have to remove the parens or we'll introduce a
// most vexing parse. // most vexing parse.
const auto *BTE = Result.Nodes.getNodeAs<CXXBindTemporaryExpr>("temp"); const auto *BTE = Result.Nodes.getNodeAs<CXXBindTemporaryExpr>("temp");
if (const auto *TOE = dyn_cast<CXXTemporaryObjectExpr>(BTE->getSubExpr())) if (const auto *TOE = dyn_cast<CXXTemporaryObjectExpr>(BTE->getSubExpr()))
if (TOE->getNumArgs() == 0) { if (TOE->getNumArgs() == 0) {
Show All 21 Lines

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines Finder->addMatcher(
stmt(anyOf(UnusedInCompoundStmt, UnusedInIfStmt, UnusedInWhileStmt, stmt(anyOf(UnusedInCompoundStmt, UnusedInIfStmt, UnusedInWhileStmt,
UnusedInDoStmt, UnusedInForStmt, UnusedInRangeForStmt, UnusedInDoStmt, UnusedInForStmt, UnusedInRangeForStmt,
UnusedInCaseStmt)), UnusedInCaseStmt)),
this); this);
} }
void UnusedReturnValueCheck::check(const MatchFinder::MatchResult &Result) { void UnusedReturnValueCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *Matched = Result.Nodes.getNodeAs<CallExpr>("match")) { if (const auto *Matched = Result.Nodes.getNodeAs<CallExpr>("match")) {
diag(Matched->getLocStart(), diag(Matched->getBeginLoc(),
"the value returned by this function should be used") "the value returned by this function should be used")
<< Matched->getSourceRange(); << Matched->getSourceRange();
diag(Matched->getLocStart(), diag(Matched->getBeginLoc(),
"cast the expression to void to silence this warning", "cast the expression to void to silence this warning",
DiagnosticIDs::Note); DiagnosticIDs::Note);
} }
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/bugprone/VirtualNearMissCheck.cpp

Show First 20 Lines • Show All 251 Lines • ▼ Show 20 Lines if (const auto *BaseRD = BaseSpec.getType()->getAsCXXRecordDecl()) {
if (checkOverrideWithoutName(Context, BaseMD, DerivedMD)) { if (checkOverrideWithoutName(Context, BaseMD, DerivedMD)) {
// A "virtual near miss" is found. // A "virtual near miss" is found.
auto Range = CharSourceRange::getTokenRange( auto Range = CharSourceRange::getTokenRange(
SourceRange(DerivedMD->getLocation())); SourceRange(DerivedMD->getLocation()));
bool ApplyFix = !BaseMD->isTemplateInstantiation() && bool ApplyFix = !BaseMD->isTemplateInstantiation() &&
!DerivedMD->isTemplateInstantiation(); !DerivedMD->isTemplateInstantiation();
auto Diag = auto Diag =
diag(DerivedMD->getLocStart(), diag(DerivedMD->getBeginLoc(),
"method '%0' has a similar name and the same signature as " "method '%0' has a similar name and the same signature as "
"virtual method '%1'; did you mean to override it?") "virtual method '%1'; did you mean to override it?")
<< DerivedMD->getQualifiedNameAsString() << DerivedMD->getQualifiedNameAsString()
<< BaseMD->getQualifiedNameAsString(); << BaseMD->getQualifiedNameAsString();
if (ApplyFix) if (ApplyFix)
Diag << FixItHint::CreateReplacement(Range, BaseMD->getName()); Diag << FixItHint::CreateReplacement(Range, BaseMD->getName());
} }
} }
} }
} }
} }
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/cert/LimitedRandomnessCheck.cpp

Show All 24 Lines
} }
void LimitedRandomnessCheck::check(const MatchFinder::MatchResult &Result) { void LimitedRandomnessCheck::check(const MatchFinder::MatchResult &Result) {
std::string msg = ""; std::string msg = "";
if (getLangOpts().CPlusPlus) if (getLangOpts().CPlusPlus)
msg = "; use C++11 random library instead"; msg = "; use C++11 random library instead";
const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("randomGenerator"); const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("randomGenerator");
diag(MatchedDecl->getLocStart(), "rand() has limited randomness" + msg); diag(MatchedDecl->getBeginLoc(), "rand() has limited randomness" + msg);
} }
} // namespace cert } // namespace cert
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/cppcoreguidelines/AvoidGotoCheck.cpp

Show All 13 Lines
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
namespace { namespace {
AST_MATCHER(GotoStmt, isForwardJumping) { AST_MATCHER(GotoStmt, isForwardJumping) {
return Node.getLocStart() < Node.getLabel()->getLocStart(); return Node.getBeginLoc() < Node.getLabel()->getBeginLoc();
} }
} // namespace } // namespace
void AvoidGotoCheck::registerMatchers(MatchFinder *Finder) { void AvoidGotoCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
// TODO: This check does not recognize `IndirectGotoStmt` which is a // TODO: This check does not recognize `IndirectGotoStmt` which is a
Show All 13 Lines Finder->addMatcher(gotoStmt(anyOf(unless(hasAncestor(NestedLoop)),
this); this);
} }
void AvoidGotoCheck::check(const MatchFinder::MatchResult &Result) { void AvoidGotoCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Goto = Result.Nodes.getNodeAs<GotoStmt>("goto"); const auto *Goto = Result.Nodes.getNodeAs<GotoStmt>("goto");
diag(Goto->getGotoLoc(), "avoid using 'goto' for flow control") diag(Goto->getGotoLoc(), "avoid using 'goto' for flow control")
<< Goto->getSourceRange(); << Goto->getSourceRange();
diag(Goto->getLabel()->getLocStart(), "label defined here", diag(Goto->getLabel()->getBeginLoc(), "label defined here",
DiagnosticIDs::Note); DiagnosticIDs::Note);
} }
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines Finder->addMatcher(
hasLHS(hasType(isInteger())), hasRHS(IsFloatExpr), hasLHS(hasType(isInteger())), hasRHS(IsFloatExpr),
unless(isInTemplateInstantiation())) unless(isInTemplateInstantiation()))
.bind("op"), .bind("op"),
this); this);
} }
void NarrowingConversionsCheck::check(const MatchFinder::MatchResult &Result) { void NarrowingConversionsCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *Op = Result.Nodes.getNodeAs<BinaryOperator>("op")) { if (const auto *Op = Result.Nodes.getNodeAs<BinaryOperator>("op")) {
if (Op->getLocStart().isMacroID()) if (Op->getBeginLoc().isMacroID())
return; return;
diag(Op->getOperatorLoc(), "narrowing conversion from %0 to %1") diag(Op->getOperatorLoc(), "narrowing conversion from %0 to %1")
<< Op->getRHS()->getType() << Op->getLHS()->getType(); << Op->getRHS()->getType() << Op->getLHS()->getType();
return; return;
} }
const auto *Cast = Result.Nodes.getNodeAs<ImplicitCastExpr>("cast"); const auto *Cast = Result.Nodes.getNodeAs<ImplicitCastExpr>("cast");
if (Cast->getLocStart().isMacroID()) if (Cast->getBeginLoc().isMacroID())
return; return;
diag(Cast->getExprLoc(), "narrowing conversion from %0 to %1") diag(Cast->getExprLoc(), "narrowing conversion from %0 to %1")
<< Cast->getSubExpr()->getType() << Cast->getType(); << Cast->getSubExpr()->getType() << Cast->getType();
} }
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/cppcoreguidelines/NoMallocCheck.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines if ((Call = Result.Nodes.getNodeAs<CallExpr>("allocation")))
Recommendation = "consider a container or a smart pointer"; Recommendation = "consider a container or a smart pointer";
else if ((Call = Result.Nodes.getNodeAs<CallExpr>("realloc"))) else if ((Call = Result.Nodes.getNodeAs<CallExpr>("realloc")))
Recommendation = "consider std::vector or std::string"; Recommendation = "consider std::vector or std::string";
else if ((Call = Result.Nodes.getNodeAs<CallExpr>("free"))) else if ((Call = Result.Nodes.getNodeAs<CallExpr>("free")))
Recommendation = "use RAII"; Recommendation = "use RAII";
assert(Call && "Unhandled binding in the Matcher"); assert(Call && "Unhandled binding in the Matcher");
diag(Call->getLocStart(), "do not manage memory manually; %0") diag(Call->getBeginLoc(), "do not manage memory manually; %0")
<< Recommendation << SourceRange(Call->getLocStart(), Call->getLocEnd()); << Recommendation << SourceRange(Call->getBeginLoc(), Call->getLocEnd());
} }
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

Show First 20 Lines • Show All 197 Lines • ▼ Show 20 Lines
bool OwningMemoryCheck::handleDeletion(const BoundNodes &Nodes) { bool OwningMemoryCheck::handleDeletion(const BoundNodes &Nodes) {
// Result of delete matchers. // Result of delete matchers.
const auto *DeleteStmt = Nodes.getNodeAs<CXXDeleteExpr>("delete_expr"); const auto *DeleteStmt = Nodes.getNodeAs<CXXDeleteExpr>("delete_expr");
const auto *DeletedVariable = const auto *DeletedVariable =
Nodes.getNodeAs<DeclRefExpr>("deleted_variable"); Nodes.getNodeAs<DeclRefExpr>("deleted_variable");
// Deletion of non-owners, with `delete variable;` // Deletion of non-owners, with `delete variable;`
if (DeleteStmt) { if (DeleteStmt) {
diag(DeleteStmt->getLocStart(), diag(DeleteStmt->getBeginLoc(),
"deleting a pointer through a type that is " "deleting a pointer through a type that is "
"not marked 'gsl::owner<>'; consider using a " "not marked 'gsl::owner<>'; consider using a "
"smart pointer instead") "smart pointer instead")
<< DeletedVariable->getSourceRange(); << DeletedVariable->getSourceRange();
// FIXME: The declaration of the variable that was deleted can be // FIXME: The declaration of the variable that was deleted can be
// rewritten. // rewritten.
const ValueDecl *Decl = DeletedVariable->getDecl(); const ValueDecl *Decl = DeletedVariable->getDecl();
diag(Decl->getLocStart(), "variable declared here", DiagnosticIDs::Note) diag(Decl->getBeginLoc(), "variable declared here", DiagnosticIDs::Note)
<< Decl->getSourceRange(); << Decl->getSourceRange();
return true; return true;
} }
return false; return false;
} }
bool OwningMemoryCheck::handleLegacyConsumers(const BoundNodes &Nodes) { bool OwningMemoryCheck::handleLegacyConsumers(const BoundNodes &Nodes) {
// Result of matching for legacy consumer-functions like `::free()`. // Result of matching for legacy consumer-functions like `::free()`.
const auto *LegacyConsumer = Nodes.getNodeAs<CallExpr>("legacy_consumer"); const auto *LegacyConsumer = Nodes.getNodeAs<CallExpr>("legacy_consumer");
// FIXME: `freopen` should be handled seperately because it takes the filename // FIXME: `freopen` should be handled seperately because it takes the filename
// as a pointer, which should not be an owner. The argument that is an owner // as a pointer, which should not be an owner. The argument that is an owner
// is known and the false positive coming from the filename can be avoided. // is known and the false positive coming from the filename can be avoided.
if (LegacyConsumer) { if (LegacyConsumer) {
diag(LegacyConsumer->getLocStart(), diag(LegacyConsumer->getBeginLoc(),
"calling legacy resource function without passing a 'gsl::owner<>'") "calling legacy resource function without passing a 'gsl::owner<>'")
<< LegacyConsumer->getSourceRange(); << LegacyConsumer->getSourceRange();
return true; return true;
} }
return false; return false;
} }
bool OwningMemoryCheck::handleExpectedOwner(const BoundNodes &Nodes) { bool OwningMemoryCheck::handleExpectedOwner(const BoundNodes &Nodes) {
// Result of function call matchers. // Result of function call matchers.
const auto *ExpectedOwner = Nodes.getNodeAs<Expr>("expected_owner_argument"); const auto *ExpectedOwner = Nodes.getNodeAs<Expr>("expected_owner_argument");
// Expected function argument to be owner. // Expected function argument to be owner.
if (ExpectedOwner) { if (ExpectedOwner) {
diag(ExpectedOwner->getLocStart(), diag(ExpectedOwner->getBeginLoc(),
"expected argument of type 'gsl::owner<>'; got %0") "expected argument of type 'gsl::owner<>'; got %0")
<< ExpectedOwner->getType() << ExpectedOwner->getSourceRange(); << ExpectedOwner->getType() << ExpectedOwner->getSourceRange();
return true; return true;
} }
return false; return false;
} }
/// Assignment and initialization of owner variables. /// Assignment and initialization of owner variables.
bool OwningMemoryCheck::handleAssignmentAndInit(const BoundNodes &Nodes) { bool OwningMemoryCheck::handleAssignmentAndInit(const BoundNodes &Nodes) {
const auto *OwnerAssignment = const auto *OwnerAssignment =
Nodes.getNodeAs<BinaryOperator>("owner_assignment"); Nodes.getNodeAs<BinaryOperator>("owner_assignment");
const auto *OwnerInitialization = const auto *OwnerInitialization =
Nodes.getNodeAs<VarDecl>("owner_initialization"); Nodes.getNodeAs<VarDecl>("owner_initialization");
const auto *OwnerInitializer = const auto *OwnerInitializer =
Nodes.getNodeAs<CXXCtorInitializer>("owner_member_initializer"); Nodes.getNodeAs<CXXCtorInitializer>("owner_member_initializer");
// Assignments to owners. // Assignments to owners.
if (OwnerAssignment) { if (OwnerAssignment) {
diag(OwnerAssignment->getLocStart(), diag(OwnerAssignment->getBeginLoc(),
"expected assignment source to be of type 'gsl::owner<>'; got %0") "expected assignment source to be of type 'gsl::owner<>'; got %0")
<< OwnerAssignment->getRHS()->getType() << OwnerAssignment->getRHS()->getType()
<< OwnerAssignment->getSourceRange(); << OwnerAssignment->getSourceRange();
return true; return true;
} }
// Initialization of owners. // Initialization of owners.
if (OwnerInitialization) { if (OwnerInitialization) {
diag(OwnerInitialization->getLocStart(), diag(OwnerInitialization->getBeginLoc(),
"expected initialization with value of type 'gsl::owner<>'; got %0") "expected initialization with value of type 'gsl::owner<>'; got %0")
<< OwnerInitialization->getAnyInitializer()->getType() << OwnerInitialization->getAnyInitializer()->getType()
<< OwnerInitialization->getSourceRange(); << OwnerInitialization->getSourceRange();
return true; return true;
} }
// Initializer of class constructors that initialize owners. // Initializer of class constructors that initialize owners.
if (OwnerInitializer) { if (OwnerInitializer) {
Show All 19 Linesbool OwningMemoryCheck::handleAssignmentFromNewOwner(const BoundNodes &Nodes) {
const auto *BadOwnerArgument = const auto *BadOwnerArgument =
Nodes.getNodeAs<Expr>("bad_owner_creation_argument"); Nodes.getNodeAs<Expr>("bad_owner_creation_argument");
const auto *BadOwnerParameter = const auto *BadOwnerParameter =
Nodes.getNodeAs<ParmVarDecl>("bad_owner_creation_parameter"); Nodes.getNodeAs<ParmVarDecl>("bad_owner_creation_parameter");
// Bad assignments to non-owners, where the RHS is a newly created owner. // Bad assignments to non-owners, where the RHS is a newly created owner.
if (BadOwnerAssignment) { if (BadOwnerAssignment) {
diag(BadOwnerAssignment->getLocStart(), diag(BadOwnerAssignment->getBeginLoc(),
"assigning newly created 'gsl::owner<>' to non-owner %0") "assigning newly created 'gsl::owner<>' to non-owner %0")
<< BadOwnerAssignment->getLHS()->getType() << BadOwnerAssignment->getLHS()->getType()
<< BadOwnerAssignment->getSourceRange(); << BadOwnerAssignment->getSourceRange();
return true; return true;
} }
// Bad initialization of non-owners, where the RHS is a newly created owner. // Bad initialization of non-owners, where the RHS is a newly created owner.
if (BadOwnerInitialization) { if (BadOwnerInitialization) {
diag(BadOwnerInitialization->getLocStart(), diag(BadOwnerInitialization->getBeginLoc(),
"initializing non-owner %0 with a newly created 'gsl::owner<>'") "initializing non-owner %0 with a newly created 'gsl::owner<>'")
<< BadOwnerInitialization->getType() << BadOwnerInitialization->getType()
<< BadOwnerInitialization->getSourceRange(); << BadOwnerInitialization->getSourceRange();
// FIXME: FixitHint to rewrite the type of the initialized variable // FIXME: FixitHint to rewrite the type of the initialized variable
// as 'gsl::owner<OriginalType>' // as 'gsl::owner<OriginalType>'
// If the type of the variable was deduced, the wrapping owner typedef is // If the type of the variable was deduced, the wrapping owner typedef is
// eliminated, therefore the check emits a special note for that case. // eliminated, therefore the check emits a special note for that case.
if (Nodes.getNodeAs<AutoType>("deduced_type")) { if (Nodes.getNodeAs<AutoType>("deduced_type")) {
diag(BadOwnerInitialization->getLocStart(), diag(BadOwnerInitialization->getBeginLoc(),
"type deduction did not result in an owner", DiagnosticIDs::Note); "type deduction did not result in an owner", DiagnosticIDs::Note);
} }
return true; return true;
} }
// Function call, where one arguments is a newly created owner, but the // Function call, where one arguments is a newly created owner, but the
// parameter type is not. // parameter type is not.
if (BadOwnerArgument) { if (BadOwnerArgument) {
assert(BadOwnerParameter && assert(BadOwnerParameter &&
"parameter for the problematic argument not found"); "parameter for the problematic argument not found");
diag(BadOwnerArgument->getLocStart(), "initializing non-owner argument of " diag(BadOwnerArgument->getBeginLoc(), "initializing non-owner argument of "
"type %0 with a newly created " "type %0 with a newly created "
"'gsl::owner<>'") "'gsl::owner<>'")
<< BadOwnerParameter->getType() << BadOwnerArgument->getSourceRange(); << BadOwnerParameter->getType() << BadOwnerArgument->getSourceRange();
return true; return true;
} }
return false; return false;
} }
bool OwningMemoryCheck::handleReturnValues(const BoundNodes &Nodes) { bool OwningMemoryCheck::handleReturnValues(const BoundNodes &Nodes) {
// Function return statements, that are owners/resources, but the function // Function return statements, that are owners/resources, but the function
// declaration does not declare its return value as owner. // declaration does not declare its return value as owner.
const auto *BadReturnType = Nodes.getNodeAs<ReturnStmt>("bad_owner_return"); const auto *BadReturnType = Nodes.getNodeAs<ReturnStmt>("bad_owner_return");
const auto *Function = Nodes.getNodeAs<FunctionDecl>("function_decl"); const auto *Function = Nodes.getNodeAs<FunctionDecl>("function_decl");
// Function return values, that should be owners but aren't. // Function return values, that should be owners but aren't.
if (BadReturnType) { if (BadReturnType) {
// The returned value is a resource or variable that was not annotated with // The returned value is a resource or variable that was not annotated with
// owner<> and the function return type is not owner<>. // owner<> and the function return type is not owner<>.
diag(BadReturnType->getLocStart(), diag(BadReturnType->getBeginLoc(),
"returning a newly created resource of " "returning a newly created resource of "
"type %0 or 'gsl::owner<>' from a " "type %0 or 'gsl::owner<>' from a "
"function whose return type is not 'gsl::owner<>'") "function whose return type is not 'gsl::owner<>'")
<< Function->getReturnType() << BadReturnType->getSourceRange(); << Function->getReturnType() << BadReturnType->getSourceRange();
// FIXME: Rewrite the return type as 'gsl::owner<OriginalType>' // FIXME: Rewrite the return type as 'gsl::owner<OriginalType>'
return true; return true;
} }
return false; return false;
} }
bool OwningMemoryCheck::handleOwnerMembers(const BoundNodes &Nodes) { bool OwningMemoryCheck::handleOwnerMembers(const BoundNodes &Nodes) {
// Classes, that have owners as member, but do not declare destructors // Classes, that have owners as member, but do not declare destructors
// accordingly. // accordingly.
const auto *BadClass = Nodes.getNodeAs<CXXRecordDecl>("non_destructor_class"); const auto *BadClass = Nodes.getNodeAs<CXXRecordDecl>("non_destructor_class");
// Classes, that contains owners, but do not declare destructors. // Classes, that contains owners, but do not declare destructors.
if (BadClass) { if (BadClass) {
const auto *DeclaredOwnerMember = const auto *DeclaredOwnerMember =
Nodes.getNodeAs<FieldDecl>("undestructed_owner_member"); Nodes.getNodeAs<FieldDecl>("undestructed_owner_member");
assert(DeclaredOwnerMember && assert(DeclaredOwnerMember &&
"match on class with bad destructor but without a declared owner"); "match on class with bad destructor but without a declared owner");
diag(DeclaredOwnerMember->getLocStart(), diag(DeclaredOwnerMember->getBeginLoc(),
"member variable of type 'gsl::owner<>' requires the class %0 to " "member variable of type 'gsl::owner<>' requires the class %0 to "
"implement a destructor to release the owned resource") "implement a destructor to release the owned resource")
<< BadClass; << BadClass;
return true; return true;
} }
return false; return false;
} }
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/cppcoreguidelines/ProTypeCstyleCastCheck.cpp

Show All 40 Lines
void ProTypeCstyleCastCheck::check(const MatchFinder::MatchResult &Result) { void ProTypeCstyleCastCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedCast = Result.Nodes.getNodeAs<CStyleCastExpr>("cast"); const auto *MatchedCast = Result.Nodes.getNodeAs<CStyleCastExpr>("cast");
if (MatchedCast->getCastKind() == CK_BitCast || if (MatchedCast->getCastKind() == CK_BitCast ||
MatchedCast->getCastKind() == CK_LValueBitCast || MatchedCast->getCastKind() == CK_LValueBitCast ||
MatchedCast->getCastKind() == CK_IntegralToPointer || MatchedCast->getCastKind() == CK_IntegralToPointer ||
MatchedCast->getCastKind() == CK_PointerToIntegral || MatchedCast->getCastKind() == CK_PointerToIntegral ||
MatchedCast->getCastKind() == CK_ReinterpretMemberPointer) { MatchedCast->getCastKind() == CK_ReinterpretMemberPointer) {
diag(MatchedCast->getLocStart(), diag(MatchedCast->getBeginLoc(),
"do not use C-style cast to convert between unrelated types"); "do not use C-style cast to convert between unrelated types");
return; return;
} }
QualType SourceType = MatchedCast->getSubExpr()->getType(); QualType SourceType = MatchedCast->getSubExpr()->getType();
if (MatchedCast->getCastKind() == CK_BaseToDerived) { if (MatchedCast->getCastKind() == CK_BaseToDerived) {
const auto *SourceDecl = SourceType->getPointeeCXXRecordDecl(); const auto *SourceDecl = SourceType->getPointeeCXXRecordDecl();
if (!SourceDecl) // The cast is from object to reference. if (!SourceDecl) // The cast is from object to reference.
SourceDecl = SourceType->getAsCXXRecordDecl(); SourceDecl = SourceType->getAsCXXRecordDecl();
if (!SourceDecl) if (!SourceDecl)
return; return;
if (SourceDecl->isPolymorphic()) { if (SourceDecl->isPolymorphic()) {
// Leave type spelling exactly as it was (unlike // Leave type spelling exactly as it was (unlike
// getTypeAsWritten().getAsString() which would spell enum types 'enum // getTypeAsWritten().getAsString() which would spell enum types 'enum
// X'). // X').
StringRef DestTypeString = Lexer::getSourceText( StringRef DestTypeString = Lexer::getSourceText(
CharSourceRange::getTokenRange( CharSourceRange::getTokenRange(
MatchedCast->getLParenLoc().getLocWithOffset(1), MatchedCast->getLParenLoc().getLocWithOffset(1),
MatchedCast->getRParenLoc().getLocWithOffset(-1)), MatchedCast->getRParenLoc().getLocWithOffset(-1)),
*Result.SourceManager, getLangOpts()); *Result.SourceManager, getLangOpts());
auto diag_builder = diag( auto diag_builder = diag(
MatchedCast->getLocStart(), MatchedCast->getBeginLoc(),
"do not use C-style cast to downcast from a base to a derived class; " "do not use C-style cast to downcast from a base to a derived class; "
"use dynamic_cast instead"); "use dynamic_cast instead");
const Expr *SubExpr = const Expr *SubExpr =
MatchedCast->getSubExprAsWritten()->IgnoreImpCasts(); MatchedCast->getSubExprAsWritten()->IgnoreImpCasts();
std::string CastText = ("dynamic_cast<" + DestTypeString + ">").str(); std::string CastText = ("dynamic_cast<" + DestTypeString + ">").str();
if (!isa<ParenExpr>(SubExpr)) { if (!isa<ParenExpr>(SubExpr)) {
CastText.push_back('('); CastText.push_back('(');
diag_builder << FixItHint::CreateInsertion( diag_builder << FixItHint::CreateInsertion(
Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0, Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0,
*Result.SourceManager, getLangOpts()), *Result.SourceManager, getLangOpts()),
")"); ")");
} }
auto ParenRange = CharSourceRange::getTokenRange( auto ParenRange = CharSourceRange::getTokenRange(
MatchedCast->getLParenLoc(), MatchedCast->getRParenLoc()); MatchedCast->getLParenLoc(), MatchedCast->getRParenLoc());
diag_builder << FixItHint::CreateReplacement(ParenRange, CastText); diag_builder << FixItHint::CreateReplacement(ParenRange, CastText);
} else { } else {
diag( diag(
MatchedCast->getLocStart(), MatchedCast->getBeginLoc(),
"do not use C-style cast to downcast from a base to a derived class"); "do not use C-style cast to downcast from a base to a derived class");
} }
return; return;
} }
if (MatchedCast->getCastKind() == CK_NoOp && if (MatchedCast->getCastKind() == CK_NoOp &&
needsConstCast(SourceType, MatchedCast->getType())) { needsConstCast(SourceType, MatchedCast->getType())) {
diag(MatchedCast->getLocStart(), diag(MatchedCast->getBeginLoc(),
"do not use C-style cast to cast away constness"); "do not use C-style cast to cast away constness");
} }
} }
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Lines SourceLocation getLocation(const ASTContext &Context,
const CXXConstructorDecl &Constructor) const { const CXXConstructorDecl &Constructor) const {
assert((Where != nullptr || Placement == InitializerPlacement::New) && assert((Where != nullptr || Placement == InitializerPlacement::New) &&
"Location should be relative to an existing initializer or this " "Location should be relative to an existing initializer or this "
"insertion represents a new initializer list."); "insertion represents a new initializer list.");
SourceLocation Location; SourceLocation Location;
switch (Placement) { switch (Placement) {
case InitializerPlacement::New: case InitializerPlacement::New:
Location = utils::lexer::getPreviousToken( Location = utils::lexer::getPreviousToken(
Context, Constructor.getBody()->getLocStart()) Context, Constructor.getBody()->getBeginLoc())
.getLocation(); .getLocation();
break; break;
case InitializerPlacement::Before: case InitializerPlacement::Before:
Location = utils::lexer::getPreviousToken( Location = utils::lexer::getPreviousToken(
Context, Where->getSourceRange().getBegin()) Context, Where->getSourceRange().getBegin())
.getLocation(); .getLocation();
break; break;
case InitializerPlacement::After: case InitializerPlacement::After:
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines forEachField(ClassDecl, ClassDecl.fields(),
[&](const FieldDecl *F) { Decls.push_back(F); }); [&](const FieldDecl *F) { Decls.push_back(F); });
} }
template <typename T> template <typename T>
void fixInitializerList(const ASTContext &Context, DiagnosticBuilder &Diag, void fixInitializerList(const ASTContext &Context, DiagnosticBuilder &Diag,
const CXXConstructorDecl *Ctor, const CXXConstructorDecl *Ctor,
const SmallPtrSetImpl<const T *> &DeclsToInit) { const SmallPtrSetImpl<const T *> &DeclsToInit) {
// Do not propose fixes in macros since we cannot place them correctly. // Do not propose fixes in macros since we cannot place them correctly.
if (Ctor->getLocStart().isMacroID()) if (Ctor->getBeginLoc().isMacroID())
return; return;
SmallVector<const NamedDecl *, 16> OrderedDecls; SmallVector<const NamedDecl *, 16> OrderedDecls;
getInitializationsInOrder(*Ctor->getParent(), OrderedDecls); getInitializationsInOrder(*Ctor->getParent(), OrderedDecls);
for (const auto &Insertion : for (const auto &Insertion :
computeInsertions(Ctor->inits(), OrderedDecls, DeclsToInit)) { computeInsertions(Ctor->inits(), OrderedDecls, DeclsToInit)) {
if (!Insertion.Initializers.empty()) if (!Insertion.Initializers.empty())
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Linesvoid ProTypeMemberInitCheck::checkMissingMemberInitializer(
// Collect all the fields we need to initialize, including indirect fields. // Collect all the fields we need to initialize, including indirect fields.
SmallPtrSet<const FieldDecl *, 16> AllFieldsToInit; SmallPtrSet<const FieldDecl *, 16> AllFieldsToInit;
forEachField(ClassDecl, FieldsToInit, forEachField(ClassDecl, FieldsToInit,
[&](const FieldDecl *F) { AllFieldsToInit.insert(F); }); [&](const FieldDecl *F) { AllFieldsToInit.insert(F); });
if (AllFieldsToInit.empty()) if (AllFieldsToInit.empty())
return; return;
DiagnosticBuilder Diag = DiagnosticBuilder Diag =
diag(Ctor ? Ctor->getLocStart() : ClassDecl.getLocation(), diag(Ctor ? Ctor->getBeginLoc() : ClassDecl.getLocation(),
IsUnion IsUnion
? "union constructor should initialize one of these fields: %0" ? "union constructor should initialize one of these fields: %0"
: "constructor does not initialize these fields: %0") : "constructor does not initialize these fields: %0")
<< toCommaSeparatedString(OrderedFields, AllFieldsToInit); << toCommaSeparatedString(OrderedFields, AllFieldsToInit);
// Do not propose fixes for constructors in macros since we cannot place them // Do not propose fixes for constructors in macros since we cannot place them
// correctly. // correctly.
if (Ctor && Ctor->getLocStart().isMacroID()) if (Ctor && Ctor->getBeginLoc().isMacroID())
return; return;
// Collect all fields but only suggest a fix for the first member of unions, // Collect all fields but only suggest a fix for the first member of unions,
// as initializing more than one union member is an error. // as initializing more than one union member is an error.
SmallPtrSet<const FieldDecl *, 16> FieldsToFix; SmallPtrSet<const FieldDecl *, 16> FieldsToFix;
SmallPtrSet<const RecordDecl *, 4> UnionsSeen; SmallPtrSet<const RecordDecl *, 4> UnionsSeen;
forEachField(ClassDecl, OrderedFields, [&](const FieldDecl *F) { forEachField(ClassDecl, OrderedFields, [&](const FieldDecl *F) {
if (!FieldsToInit.count(F)) if (!FieldsToInit.count(F))
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines for (const CXXCtorInitializer *Init : Ctor->inits()) {
BasesToInit.erase(Init->getBaseClass()->getAsCXXRecordDecl()); BasesToInit.erase(Init->getBaseClass()->getAsCXXRecordDecl());
} }
} }
if (BasesToInit.empty()) if (BasesToInit.empty())
return; return;
DiagnosticBuilder Diag = DiagnosticBuilder Diag =
diag(Ctor ? Ctor->getLocStart() : ClassDecl.getLocation(), diag(Ctor ? Ctor->getBeginLoc() : ClassDecl.getLocation(),
"constructor does not initialize these bases: %0") "constructor does not initialize these bases: %0")
<< toCommaSeparatedString(AllBases, BasesToInit); << toCommaSeparatedString(AllBases, BasesToInit);
if (Ctor) if (Ctor)
fixInitializerList(Context, Diag, Ctor, BasesToInit); fixInitializerList(Context, Diag, Ctor, BasesToInit);
} }
void ProTypeMemberInitCheck::checkUninitializedTrivialType( void ProTypeMemberInitCheck::checkUninitializedTrivialType(
const ASTContext &Context, const VarDecl *Var) { const ASTContext &Context, const VarDecl *Var) {
DiagnosticBuilder Diag = DiagnosticBuilder Diag =
diag(Var->getLocStart(), "uninitialized record type: %0") << Var; diag(Var->getBeginLoc(), "uninitialized record type: %0") << Var;
Diag << FixItHint::CreateInsertion( Diag << FixItHint::CreateInsertion(
getLocationForEndOfToken(Context, Var->getSourceRange().getEnd()), getLocationForEndOfToken(Context, Var->getSourceRange().getEnd()),
Context.getLangOpts().CPlusPlus11 ? "{}" : " = {}"); Context.getLangOpts().CPlusPlus11 ? "{}" : " = {}");
} }
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

Show All 21 Linesvoid DefaultArgumentsCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(parmVarDecl(hasDefaultArgument()).bind("decl"), this); Finder->addMatcher(parmVarDecl(hasDefaultArgument()).bind("decl"), this);
} }
void DefaultArgumentsCheck::check(const MatchFinder::MatchResult &Result) { void DefaultArgumentsCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *S = if (const auto *S =
Result.Nodes.getNodeAs<CXXDefaultArgExpr>("stmt")) { Result.Nodes.getNodeAs<CXXDefaultArgExpr>("stmt")) {
diag(S->getUsedLocation(), diag(S->getUsedLocation(),
"calling a function that uses a default argument is disallowed"); "calling a function that uses a default argument is disallowed");
diag(S->getParam()->getLocStart(), diag(S->getParam()->getBeginLoc(),
"default parameter was declared here", "default parameter was declared here",
DiagnosticIDs::Note); DiagnosticIDs::Note);
} else if (const ParmVarDecl *D = } else if (const ParmVarDecl *D =
Result.Nodes.getNodeAs<ParmVarDecl>("decl")) { Result.Nodes.getNodeAs<ParmVarDecl>("decl")) {
SourceRange DefaultArgRange = D->getDefaultArgRange(); SourceRange DefaultArgRange = D->getDefaultArgRange();
if (DefaultArgRange.getEnd() != D->getLocEnd()) { if (DefaultArgRange.getEnd() != D->getLocEnd()) {
return; return;
} else if (DefaultArgRange.getBegin().isMacroID()) { } else if (DefaultArgRange.getBegin().isMacroID()) {
diag(D->getLocStart(), diag(D->getBeginLoc(),
"declaring a parameter with a default argument is disallowed"); "declaring a parameter with a default argument is disallowed");
} else { } else {
SourceLocation StartLocation = D->getName().empty() ? SourceLocation StartLocation = D->getName().empty() ?
D->getLocStart() : D->getLocation(); D->getBeginLoc() : D->getLocation();
SourceRange RemovalRange(Lexer::getLocForEndOfToken( SourceRange RemovalRange(Lexer::getLocForEndOfToken(
StartLocation, 0, StartLocation, 0,
*Result.SourceManager, *Result.SourceManager,
Result.Context->getLangOpts() Result.Context->getLangOpts()
), ),
DefaultArgRange.getEnd() DefaultArgRange.getEnd()
); );
diag(D->getLocStart(), diag(D->getBeginLoc(),
"declaring a parameter with a default argument is disallowed") "declaring a parameter with a default argument is disallowed")
<< D << D
<< FixItHint::CreateRemoval(RemovalRange); << FixItHint::CreateRemoval(RemovalRange);
} }
} }
} }
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/fuchsia/MultipleInheritanceCheck.cpp

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Lines if (const auto *D = Result.Nodes.getNodeAs<CXXRecordDecl>("decl")) {
for (const auto &V : D->vbases()) { for (const auto &V : D->vbases()) {
const auto *Ty = V.getType()->getAs<RecordType>(); const auto *Ty = V.getType()->getAs<RecordType>();
if (!Ty) continue; if (!Ty) continue;
const auto *Base = cast<CXXRecordDecl>(Ty->getDecl()->getDefinition()); const auto *Base = cast<CXXRecordDecl>(Ty->getDecl()->getDefinition());
if (!isInterface(Base)) NumConcrete++; if (!isInterface(Base)) NumConcrete++;
} }
if (NumConcrete > 1) { if (NumConcrete > 1) {
diag(D->getLocStart(), diag(D->getBeginLoc(),
"inheriting mulitple classes that aren't " "inheriting mulitple classes that aren't "
"pure virtual is discouraged"); "pure virtual is discouraged");
} }
} }
} }
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/fuchsia/OverloadedOperatorCheck.cpp

Show All 29 Linesvoid OverloadedOperatorCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(functionDecl(isFuchsiaOverloadedOperator()).bind("decl"), Finder->addMatcher(functionDecl(isFuchsiaOverloadedOperator()).bind("decl"),
this); this);
} }
void OverloadedOperatorCheck::check(const MatchFinder::MatchResult &Result) { void OverloadedOperatorCheck::check(const MatchFinder::MatchResult &Result) {
const auto *D = Result.Nodes.getNodeAs<FunctionDecl>("decl"); const auto *D = Result.Nodes.getNodeAs<FunctionDecl>("decl");
assert(D && "No FunctionDecl captured!"); assert(D && "No FunctionDecl captured!");
SourceLocation Loc = D->getLocStart(); SourceLocation Loc = D->getBeginLoc();
if (Loc.isValid()) if (Loc.isValid())
diag(Loc, "overloading %0 is disallowed") << D; diag(Loc, "overloading %0 is disallowed") << D;
} }
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/fuchsia/StaticallyConstructedObjectsCheck.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines Finder->addMatcher(
isConstantInitializer())))))) isConstantInitializer()))))))
.bind("decl"), .bind("decl"),
this); this);
} }
void StaticallyConstructedObjectsCheck::check( void StaticallyConstructedObjectsCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
if (const auto *D = Result.Nodes.getNodeAs<VarDecl>("decl")) if (const auto *D = Result.Nodes.getNodeAs<VarDecl>("decl"))
diag(D->getLocStart(), "static objects are disallowed; if possible, use a " diag(D->getBeginLoc(), "static objects are disallowed; if possible, use a "
"constexpr constructor instead"); "constexpr constructor instead");
} }
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/fuchsia/TrailingReturnCheck.cpp

Show All 37 Lines Finder->addMatcher(
unless(anyOf(returns(decltypeType()), unless(anyOf(returns(decltypeType()),
hasParent(cxxRecordDecl(isLambda())))))) hasParent(cxxRecordDecl(isLambda()))))))
.bind("decl"), .bind("decl"),
this); this);
} }
void TrailingReturnCheck::check(const MatchFinder::MatchResult &Result) { void TrailingReturnCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *D = Result.Nodes.getNodeAs<Decl>("decl")) if (const auto *D = Result.Nodes.getNodeAs<Decl>("decl"))
diag(D->getLocStart(), diag(D->getBeginLoc(),
"a trailing return type is disallowed for this type of declaration"); "a trailing return type is disallowed for this type of declaration");
} }
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/fuchsia/VirtualInheritanceCheck.cpp

Show All 29 Lines
void VirtualInheritanceCheck::registerMatchers(MatchFinder *Finder) { void VirtualInheritanceCheck::registerMatchers(MatchFinder *Finder) {
// Defining classes using direct virtual inheritance is disallowed. // Defining classes using direct virtual inheritance is disallowed.
Finder->addMatcher(cxxRecordDecl(hasDirectVirtualBaseClass()).bind("decl"), Finder->addMatcher(cxxRecordDecl(hasDirectVirtualBaseClass()).bind("decl"),
this); this);
} }
void VirtualInheritanceCheck::check(const MatchFinder::MatchResult &Result) { void VirtualInheritanceCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *D = Result.Nodes.getNodeAs<CXXRecordDecl>("decl")) if (const auto *D = Result.Nodes.getNodeAs<CXXRecordDecl>("decl"))
diag(D->getLocStart(), "direct virtual inheritance is disallowed"); diag(D->getBeginLoc(), "direct virtual inheritance is disallowed");
} }
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/google/AvoidCStyleCastsCheck.cpp

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Linesvoid AvoidCStyleCastsCheck::check(const MatchFinder::MatchResult &Result) {
const QualType DestTypeAsWritten = const QualType DestTypeAsWritten =
CastExpr->getTypeAsWritten().getUnqualifiedType(); CastExpr->getTypeAsWritten().getUnqualifiedType();
const QualType SourceTypeAsWritten = const QualType SourceTypeAsWritten =
CastExpr->getSubExprAsWritten()->getType().getUnqualifiedType(); CastExpr->getSubExprAsWritten()->getType().getUnqualifiedType();
const QualType SourceType = SourceTypeAsWritten.getCanonicalType(); const QualType SourceType = SourceTypeAsWritten.getCanonicalType();
const QualType DestType = DestTypeAsWritten.getCanonicalType(); const QualType DestType = DestTypeAsWritten.getCanonicalType();
auto ReplaceRange = CharSourceRange::getCharRange( auto ReplaceRange = CharSourceRange::getCharRange(
CastExpr->getLParenLoc(), CastExpr->getSubExprAsWritten()->getLocStart()); CastExpr->getLParenLoc(), CastExpr->getSubExprAsWritten()->getBeginLoc());
bool FnToFnCast = bool FnToFnCast =
isFunction(SourceTypeAsWritten) && isFunction(DestTypeAsWritten); isFunction(SourceTypeAsWritten) && isFunction(DestTypeAsWritten);
if (CastExpr->getCastKind() == CK_NoOp && !FnToFnCast) { if (CastExpr->getCastKind() == CK_NoOp && !FnToFnCast) {
// Function pointer/reference casts may be needed to resolve ambiguities in // Function pointer/reference casts may be needed to resolve ambiguities in
// case of overloaded functions, so detection of redundant casts is trickier // case of overloaded functions, so detection of redundant casts is trickier
// in this case. Don't emit "redundant cast" warnings for function // in this case. Don't emit "redundant cast" warnings for function
// pointer/reference types. // pointer/reference types.
if (SourceTypeAsWritten == DestTypeAsWritten) { if (SourceTypeAsWritten == DestTypeAsWritten) {
diag(CastExpr->getLocStart(), "redundant cast to the same type") diag(CastExpr->getBeginLoc(), "redundant cast to the same type")
<< FixItHint::CreateRemoval(ReplaceRange); << FixItHint::CreateRemoval(ReplaceRange);
return; return;
} }
} }
// The rest of this check is only relevant to C++. // The rest of this check is only relevant to C++.
// We also disable it for Objective-C++. // We also disable it for Objective-C++.
if (!getLangOpts().CPlusPlus || getLangOpts().ObjC1 || getLangOpts().ObjC2) if (!getLangOpts().CPlusPlus || getLangOpts().ObjC1 || getLangOpts().ObjC2)
return; return;
// Ignore code inside extern "C" {} blocks. // Ignore code inside extern "C" {} blocks.
if (!match(expr(hasAncestor(linkageSpecDecl())), *CastExpr, *Result.Context) if (!match(expr(hasAncestor(linkageSpecDecl())), *CastExpr, *Result.Context)
.empty()) .empty())
return; return;
// Ignore code in .c files and headers included from them, even if they are // Ignore code in .c files and headers included from them, even if they are
// compiled as C++. // compiled as C++.
if (getCurrentMainFile().endswith(".c")) if (getCurrentMainFile().endswith(".c"))
return; return;
SourceManager &SM = *Result.SourceManager; SourceManager &SM = *Result.SourceManager;
// Ignore code in .c files #included in other files (which shouldn't be done, // Ignore code in .c files #included in other files (which shouldn't be done,
// but people still do this for test and other purposes). // but people still do this for test and other purposes).
if (SM.getFilename(SM.getSpellingLoc(CastExpr->getLocStart())).endswith(".c")) if (SM.getFilename(SM.getSpellingLoc(CastExpr->getBeginLoc())).endswith(".c"))
return; return;
// Leave type spelling exactly as it was (unlike // Leave type spelling exactly as it was (unlike
// getTypeAsWritten().getAsString() which would spell enum types 'enum X'). // getTypeAsWritten().getAsString() which would spell enum types 'enum X').
StringRef DestTypeString = StringRef DestTypeString =
Lexer::getSourceText(CharSourceRange::getTokenRange( Lexer::getSourceText(CharSourceRange::getTokenRange(
CastExpr->getLParenLoc().getLocWithOffset(1), CastExpr->getLParenLoc().getLocWithOffset(1),
CastExpr->getRParenLoc().getLocWithOffset(-1)), CastExpr->getRParenLoc().getLocWithOffset(-1)),
SM, getLangOpts()); SM, getLangOpts());
auto Diag = auto Diag =
diag(CastExpr->getLocStart(), "C-style casts are discouraged; use %0"); diag(CastExpr->getBeginLoc(), "C-style casts are discouraged; use %0");
auto ReplaceWithCast = [&](std::string CastText) { auto ReplaceWithCast = [&](std::string CastText) {
const Expr *SubExpr = CastExpr->getSubExprAsWritten()->IgnoreImpCasts(); const Expr *SubExpr = CastExpr->getSubExprAsWritten()->IgnoreImpCasts();
if (!isa<ParenExpr>(SubExpr)) { if (!isa<ParenExpr>(SubExpr)) {
CastText.push_back('('); CastText.push_back('(');
Diag << FixItHint::CreateInsertion( Diag << FixItHint::CreateInsertion(
Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0, SM, Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0, SM,
getLangOpts()), getLangOpts()),
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

clang-tidy/google/ExplicitMakePairCheck.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linesvoid ExplicitMakePairCheck::check(const MatchFinder::MatchResult &Result) {
const Expr *Arg0 = Call->getArg(0)->IgnoreParenImpCasts(); const Expr *Arg0 = Call->getArg(0)->IgnoreParenImpCasts();
const Expr *Arg1 = Call->getArg(1)->IgnoreParenImpCasts(); const Expr *Arg1 = Call->getArg(1)->IgnoreParenImpCasts();
// If types don't match, we suggest replacing with std::pair and explicit // If types don't match, we suggest replacing with std::pair and explicit
// template arguments. Otherwise just remove the template arguments from // template arguments. Otherwise just remove the template arguments from
// make_pair. // make_pair.
if (Arg0->getType() != Call->getArg(0)->getType() || if (Arg0->getType() != Call->getArg(0)->getType() ||
Arg1->getType() != Call->getArg(1)->getType()) { Arg1->getType() != Call->getArg(1)->getType()) {
diag(Call->getLocStart(), "for C++11-compatibility, use pair directly") diag(Call->getBeginLoc(), "for C++11-compatibility, use pair directly")
<< FixItHint::CreateReplacement( << FixItHint::CreateReplacement(
SourceRange(DeclRef->getLocStart(), DeclRef->getLAngleLoc()), SourceRange(DeclRef->getBeginLoc(), DeclRef->getLAngleLoc()),
"std::pair<"); "std::pair<");
} else { } else {
diag(Call->getLocStart(), diag(Call->getBeginLoc(),
"for C++11-compatibility, omit template arguments from make_pair") "for C++11-compatibility, omit template arguments from make_pair")
<< FixItHint::CreateRemoval( << FixItHint::CreateRemoval(
SourceRange(DeclRef->getLAngleLoc(), DeclRef->getRAngleLoc())); SourceRange(DeclRef->getLAngleLoc(), DeclRef->getRAngleLoc()));
} }
} }
} // namespace build } // namespace build
} // namespace google } // namespace google
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/google/GlobalNamesInHeadersCheck.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines Finder->addMatcher(decl(anyOf(usingDecl(), usingDirectiveDecl()),
hasDeclContext(translationUnitDecl())) hasDeclContext(translationUnitDecl()))
.bind("using_decl"), .bind("using_decl"),
this); this);
} }
void GlobalNamesInHeadersCheck::check(const MatchFinder::MatchResult &Result) { void GlobalNamesInHeadersCheck::check(const MatchFinder::MatchResult &Result) {
const auto *D = Result.Nodes.getNodeAs<Decl>("using_decl"); const auto *D = Result.Nodes.getNodeAs<Decl>("using_decl");
// If it comes from a macro, we'll assume it is fine. // If it comes from a macro, we'll assume it is fine.
if (D->getLocStart().isMacroID()) if (D->getBeginLoc().isMacroID())
return; return;
// Ignore if it comes from the "main" file ... // Ignore if it comes from the "main" file ...
if (Result.SourceManager->isInMainFile( if (Result.SourceManager->isInMainFile(
Result.SourceManager->getExpansionLoc(D->getLocStart()))) { Result.SourceManager->getExpansionLoc(D->getBeginLoc()))) {
// unless that file is a header. // unless that file is a header.
if (!utils::isSpellingLocInHeaderFile( if (!utils::isSpellingLocInHeaderFile(
D->getLocStart(), *Result.SourceManager, HeaderFileExtensions)) D->getBeginLoc(), *Result.SourceManager, HeaderFileExtensions))
return; return;
} }
if (const auto *UsingDirective = dyn_cast<UsingDirectiveDecl>(D)) { if (const auto *UsingDirective = dyn_cast<UsingDirectiveDecl>(D)) {
if (UsingDirective->getNominatedNamespace()->isAnonymousNamespace()) { if (UsingDirective->getNominatedNamespace()->isAnonymousNamespace()) {
// Anynoumous namespaces inject a using directive into the AST to import // Anynoumous namespaces inject a using directive into the AST to import
// the names into the containing namespace. // the names into the containing namespace.
// We should not have them in headers, but there is another warning for // We should not have them in headers, but there is another warning for
// that. // that.
return; return;
} }
} }
diag(D->getLocStart(), diag(D->getBeginLoc(),
"using declarations in the global namespace in headers are prohibited"); "using declarations in the global namespace in headers are prohibited");
} }
} // namespace readability } // namespace readability
} // namespace google } // namespace google
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/google/IntegerTypesCheck.cpp

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines Finder->addMatcher(typeLoc(loc(isInteger()),
callee(functionDecl(hasAttr(attr::Format))))))) callee(functionDecl(hasAttr(attr::Format)))))))
.bind("tl"), .bind("tl"),
this); this);
IdentTable = llvm::make_unique<IdentifierTable>(getLangOpts()); IdentTable = llvm::make_unique<IdentifierTable>(getLangOpts());
} }
void IntegerTypesCheck::check(const MatchFinder::MatchResult &Result) { void IntegerTypesCheck::check(const MatchFinder::MatchResult &Result) {
auto TL = *Result.Nodes.getNodeAs<TypeLoc>("tl"); auto TL = *Result.Nodes.getNodeAs<TypeLoc>("tl");
SourceLocation Loc = TL.getLocStart(); SourceLocation Loc = TL.getBeginLoc();
if (Loc.isInvalid() || Loc.isMacroID()) if (Loc.isInvalid() || Loc.isMacroID())
return; return;
// Look through qualification. // Look through qualification.
if (auto QualLoc = TL.getAs<QualifiedTypeLoc>()) if (auto QualLoc = TL.getAs<QualifiedTypeLoc>())
TL = QualLoc.getUnqualifiedLoc(); TL = QualLoc.getUnqualifiedLoc();
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

clang-tidy/google/OverloadedUnaryAndCheck.cpp

Show All 37 Lines Finder->addMatcher(
unless(cxxMethodDecl()), unless(cxxMethodDecl()),
functionDecl(parameterCountIs(1), hasOverloadedOperatorName("&")) functionDecl(parameterCountIs(1), hasOverloadedOperatorName("&"))
.bind("overload"))), .bind("overload"))),
this); this);
} }
void OverloadedUnaryAndCheck::check(const MatchFinder::MatchResult &Result) { void OverloadedUnaryAndCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Decl = Result.Nodes.getNodeAs<FunctionDecl>("overload"); const auto *Decl = Result.Nodes.getNodeAs<FunctionDecl>("overload");
diag(Decl->getLocStart(), diag(Decl->getBeginLoc(),
"do not overload unary operator&, it is dangerous."); "do not overload unary operator&, it is dangerous.");
} }
} // namespace runtime } // namespace runtime
} // namespace google } // namespace google
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/google/UnnamedNamespaceInHeaderCheck.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesvoid UnnamedNamespaceInHeaderCheck::registerMatchers(
if (getLangOpts().CPlusPlus) if (getLangOpts().CPlusPlus)
Finder->addMatcher(namespaceDecl(isAnonymous()).bind("anonymousNamespace"), Finder->addMatcher(namespaceDecl(isAnonymous()).bind("anonymousNamespace"),
this); this);
} }
void UnnamedNamespaceInHeaderCheck::check( void UnnamedNamespaceInHeaderCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *N = Result.Nodes.getNodeAs<NamespaceDecl>("anonymousNamespace"); const auto *N = Result.Nodes.getNodeAs<NamespaceDecl>("anonymousNamespace");
SourceLocation Loc = N->getLocStart(); SourceLocation Loc = N->getBeginLoc();
if (!Loc.isValid()) if (!Loc.isValid())
return; return;
if (utils::isPresumedLocInHeaderFile(Loc, *Result.SourceManager, if (utils::isPresumedLocInHeaderFile(Loc, *Result.SourceManager,
HeaderFileExtensions)) HeaderFileExtensions))
diag(Loc, "do not use unnamed namespaces in header files"); diag(Loc, "do not use unnamed namespaces in header files");
} }
} // namespace build } // namespace build
} // namespace google } // namespace google
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/google/UsingNamespaceDirectiveCheck.cpp

Show All 24 Linesvoid UsingNamespaceDirectiveCheck::registerMatchers(
// provide any benefit to other languages, despite being benign. // provide any benefit to other languages, despite being benign.
if (getLangOpts().CPlusPlus) if (getLangOpts().CPlusPlus)
Finder->addMatcher(usingDirectiveDecl().bind("usingNamespace"), this); Finder->addMatcher(usingDirectiveDecl().bind("usingNamespace"), this);
} }
void UsingNamespaceDirectiveCheck::check( void UsingNamespaceDirectiveCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *U = Result.Nodes.getNodeAs<UsingDirectiveDecl>("usingNamespace"); const auto *U = Result.Nodes.getNodeAs<UsingDirectiveDecl>("usingNamespace");
SourceLocation Loc = U->getLocStart(); SourceLocation Loc = U->getBeginLoc();
if (U->isImplicit() || !Loc.isValid()) if (U->isImplicit() || !Loc.isValid())
return; return;
// Do not warn if namespace is a std namespace with user-defined literals. The // Do not warn if namespace is a std namespace with user-defined literals. The
// user-defined literals can only be used with a using directive. // user-defined literals can only be used with a using directive.
if (isStdLiteralsNamespace(U->getNominatedNamespace())) if (isStdLiteralsNamespace(U->getNominatedNamespace()))
return; return;
Show All 25 Lines

clang-tidy/hicpp/ExceptionBaseclassCheck.cpp

Show All 29 Lines Finder->addMatcher(
anything()))) anything())))
.bind("bad_throw"), .bind("bad_throw"),
this); this);
} }
void ExceptionBaseclassCheck::check(const MatchFinder::MatchResult &Result) { void ExceptionBaseclassCheck::check(const MatchFinder::MatchResult &Result) {
const auto *BadThrow = Result.Nodes.getNodeAs<CXXThrowExpr>("bad_throw"); const auto *BadThrow = Result.Nodes.getNodeAs<CXXThrowExpr>("bad_throw");
diag(BadThrow->getSubExpr()->getLocStart(), "throwing an exception whose " diag(BadThrow->getSubExpr()->getBeginLoc(), "throwing an exception whose "
"type %0 is not derived from " "type %0 is not derived from "
"'std::exception'") "'std::exception'")
<< BadThrow->getSubExpr()->getType() << BadThrow->getSourceRange(); << BadThrow->getSubExpr()->getType() << BadThrow->getSourceRange();
const auto *TypeDecl = Result.Nodes.getNodeAs<NamedDecl>("decl"); const auto *TypeDecl = Result.Nodes.getNodeAs<NamedDecl>("decl");
if (TypeDecl != nullptr) if (TypeDecl != nullptr)
diag(TypeDecl->getLocStart(), "type defined here", DiagnosticIDs::Note); diag(TypeDecl->getBeginLoc(), "type defined here", DiagnosticIDs::Note);
} }
} // namespace hicpp } // namespace hicpp
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/hicpp/MultiwayPathsCoveredCheck.cpp

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines else if (T->isIntegralType(Context))
return twoPow(Context.getTypeSize(T)); return twoPow(Context.getTypeSize(T));
else else
return 1; return 1;
} }
void MultiwayPathsCoveredCheck::check(const MatchFinder::MatchResult &Result) { void MultiwayPathsCoveredCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *ElseIfWithoutElse = if (const auto *ElseIfWithoutElse =
Result.Nodes.getNodeAs<IfStmt>("else-if")) { Result.Nodes.getNodeAs<IfStmt>("else-if")) {
diag(ElseIfWithoutElse->getLocStart(), diag(ElseIfWithoutElse->getBeginLoc(),
"potentially uncovered codepath; add an ending else statement"); "potentially uncovered codepath; add an ending else statement");
return; return;
} }
const auto *Switch = Result.Nodes.getNodeAs<SwitchStmt>("switch"); const auto *Switch = Result.Nodes.getNodeAs<SwitchStmt>("switch");
std::size_t SwitchCaseCount; std::size_t SwitchCaseCount;
bool SwitchHasDefault; bool SwitchHasDefault;
std::tie(SwitchCaseCount, SwitchHasDefault) = countCaseLabels(Switch); std::tie(SwitchCaseCount, SwitchHasDefault) = countCaseLabels(Switch);
Show All 9 Lines if (!SwitchHasDefault && SwitchCaseCount > 0) {
handleSwitchWithoutDefault(Switch, SwitchCaseCount, Result); handleSwitchWithoutDefault(Switch, SwitchCaseCount, Result);
return; return;
} }
// Warns for degenerated 'switch' statements that neither define a case nor // Warns for degenerated 'switch' statements that neither define a case nor
// a default label. // a default label.
// FIXME: Evaluate, if emitting a fix-it to simplify that statement is // FIXME: Evaluate, if emitting a fix-it to simplify that statement is
// reasonable. // reasonable.
if (!SwitchHasDefault && SwitchCaseCount == 0) { if (!SwitchHasDefault && SwitchCaseCount == 0) {
diag(Switch->getLocStart(), diag(Switch->getBeginLoc(),
"switch statement without labels has no effect"); "switch statement without labels has no effect");
return; return;
} }
llvm_unreachable("matched a case, that was not explicitly handled"); llvm_unreachable("matched a case, that was not explicitly handled");
} }
void MultiwayPathsCoveredCheck::handleSwitchWithDefault( void MultiwayPathsCoveredCheck::handleSwitchWithDefault(
const SwitchStmt *Switch, std::size_t CaseCount) { const SwitchStmt *Switch, std::size_t CaseCount) {
assert(CaseCount > 0 && "Switch statement with supposedly one default " assert(CaseCount > 0 && "Switch statement with supposedly one default "
"branch did not contain any case labels"); "branch did not contain any case labels");
if (CaseCount == 1 || CaseCount == 2) if (CaseCount == 1 || CaseCount == 2)
diag(Switch->getLocStart(), diag(Switch->getBeginLoc(),
CaseCount == 1 CaseCount == 1
? "degenerated switch with default label only" ? "degenerated switch with default label only"
: "switch could be better written as an if/else statement"); : "switch could be better written as an if/else statement");
} }
void MultiwayPathsCoveredCheck::handleSwitchWithoutDefault( void MultiwayPathsCoveredCheck::handleSwitchWithoutDefault(
const SwitchStmt *Switch, std::size_t CaseCount, const SwitchStmt *Switch, std::size_t CaseCount,
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
Show All 23 Lines if (const auto *BitfieldDecl =
return twoPow(BitfieldDecl->getBitWidthValue(*Result.Context)); return twoPow(BitfieldDecl->getBitWidthValue(*Result.Context));
} }
return static_cast<std::size_t>(0); return static_cast<std::size_t>(0);
}(); }();
// FIXME: Transform the 'switch' into an 'if' for CaseCount == 1. // FIXME: Transform the 'switch' into an 'if' for CaseCount == 1.
if (CaseCount < MaxPathsPossible) if (CaseCount < MaxPathsPossible)
diag(Switch->getLocStart(), diag(Switch->getBeginLoc(),
CaseCount == 1 ? "switch with only one case; use an if statement" CaseCount == 1 ? "switch with only one case; use an if statement"
: "potential uncovered code path; add a default label"); : "potential uncovered code path; add a default label");
} }
} // namespace hicpp } // namespace hicpp
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/hicpp/SignedBitwiseCheck.cpp

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Linesvoid SignedBitwiseCheck::check(const MatchFinder::MatchResult &Result) {
assert(SignedOperand && assert(SignedOperand &&
"No signed operand found in problematic bitwise operations"); "No signed operand found in problematic bitwise operations");
bool IsUnary = false; bool IsUnary = false;
SourceLocation Location; SourceLocation Location;
if (const auto *UnaryOp = N.getNodeAs<UnaryOperator>("unary-signed")) { if (const auto *UnaryOp = N.getNodeAs<UnaryOperator>("unary-signed")) {
IsUnary = true; IsUnary = true;
Location = UnaryOp->getLocStart(); Location = UnaryOp->getBeginLoc();
} else { } else {
if (const auto *BinaryOp = if (const auto *BinaryOp =
N.getNodeAs<BinaryOperator>("binary-no-sign-interference")) N.getNodeAs<BinaryOperator>("binary-no-sign-interference"))
Location = BinaryOp->getLocStart(); Location = BinaryOp->getBeginLoc();
else if (const auto *BinaryOp = else if (const auto *BinaryOp =
N.getNodeAs<BinaryOperator>("binary-sign-interference")) N.getNodeAs<BinaryOperator>("binary-sign-interference"))
Location = BinaryOp->getLocStart(); Location = BinaryOp->getBeginLoc();
else else
llvm_unreachable("unexpected matcher result"); llvm_unreachable("unexpected matcher result");
} }
diag(Location, "use of a signed integer operand with a " diag(Location, "use of a signed integer operand with a "
"%select{binary|unary}0 bitwise operator") "%select{binary|unary}0 bitwise operator")
<< IsUnary << SignedOperand->getSourceRange(); << IsUnary << SignedOperand->getSourceRange();
} }
} // namespace hicpp } // namespace hicpp
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/llvm/TwineLocalCheck.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines SourceRange TypeRange =
VD->getTypeSourceInfo()->getTypeLoc().getSourceRange(); VD->getTypeSourceInfo()->getTypeLoc().getSourceRange();
// A real Twine, turn it into a std::string. // A real Twine, turn it into a std::string.
if (VD->getType()->getCanonicalTypeUnqualified() == if (VD->getType()->getCanonicalTypeUnqualified() ==
C->getType()->getCanonicalTypeUnqualified()) { C->getType()->getCanonicalTypeUnqualified()) {
SourceLocation EndLoc = Lexer::getLocForEndOfToken( SourceLocation EndLoc = Lexer::getLocForEndOfToken(
VD->getInit()->getLocEnd(), 0, *Result.SourceManager, getLangOpts()); VD->getInit()->getLocEnd(), 0, *Result.SourceManager, getLangOpts());
Diag << FixItHint::CreateReplacement(TypeRange, "std::string") Diag << FixItHint::CreateReplacement(TypeRange, "std::string")
<< FixItHint::CreateInsertion(VD->getInit()->getLocStart(), "(") << FixItHint::CreateInsertion(VD->getInit()->getBeginLoc(), "(")
<< FixItHint::CreateInsertion(EndLoc, ").str()"); << FixItHint::CreateInsertion(EndLoc, ").str()");
} else { } else {
// Just an implicit conversion. Insert the real type. // Just an implicit conversion. Insert the real type.
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
TypeRange, TypeRange,
C->getType().getAsString(Result.Context->getPrintingPolicy())); C->getType().getAsString(Result.Context->getPrintingPolicy()));
} }
} }
} }
} // namespace llvm } // namespace llvm
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/misc/DefinitionsInHeadersCheck.cpp

Show All 16 Lines
namespace tidy { namespace tidy {
namespace misc { namespace misc {
namespace { namespace {
AST_MATCHER_P(NamedDecl, usesHeaderFileExtension, AST_MATCHER_P(NamedDecl, usesHeaderFileExtension,
utils::HeaderFileExtensionsSet, HeaderFileExtensions) { utils::HeaderFileExtensionsSet, HeaderFileExtensions) {
return utils::isExpansionLocInHeaderFile( return utils::isExpansionLocInHeaderFile(
Node.getLocStart(), Finder->getASTContext().getSourceManager(), Node.getBeginLoc(), Finder->getASTContext().getSourceManager(),
HeaderFileExtensions); HeaderFileExtensions);
} }
} // namespace } // namespace
DefinitionsInHeadersCheck::DefinitionsInHeadersCheck(StringRef Name, DefinitionsInHeadersCheck::DefinitionsInHeadersCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

clang-tidy/misc/RedundantExpressionCheck.cpp

Show First 20 Lines • Show All 878 Lines • ▼ Show 20 Lines if((Value != 0 && ~Value != 0) || Sym->getExprLoc().isMacroID())
return; return;
SourceLocation Loc = IneffectiveOperator->getOperatorLoc(); SourceLocation Loc = IneffectiveOperator->getOperatorLoc();
BinaryOperatorKind Opcode = IneffectiveOperator->getOpcode(); BinaryOperatorKind Opcode = IneffectiveOperator->getOpcode();
if (exprEvaluatesToZero(Opcode, Value)) { if (exprEvaluatesToZero(Opcode, Value)) {
diag(Loc, "expression always evaluates to 0"); diag(Loc, "expression always evaluates to 0");
} else if (exprEvaluatesToBitwiseNegatedZero(Opcode, Value)) { } else if (exprEvaluatesToBitwiseNegatedZero(Opcode, Value)) {
SourceRange ConstExprRange(ConstExpr->getLocStart(), SourceRange ConstExprRange(ConstExpr->getBeginLoc(),
ConstExpr->getLocEnd()); ConstExpr->getLocEnd());
StringRef ConstExprText = Lexer::getSourceText( StringRef ConstExprText = Lexer::getSourceText(
CharSourceRange::getTokenRange(ConstExprRange), *Result.SourceManager, CharSourceRange::getTokenRange(ConstExprRange), *Result.SourceManager,
Result.Context->getLangOpts()); Result.Context->getLangOpts());
diag(Loc, "expression always evaluates to '%0'") << ConstExprText; diag(Loc, "expression always evaluates to '%0'") << ConstExprText;
} else if (exprEvaluatesToSymbolic(Opcode, Value)) { } else if (exprEvaluatesToSymbolic(Opcode, Value)) {
SourceRange SymExprRange(Sym->getLocStart(), Sym->getLocEnd()); SourceRange SymExprRange(Sym->getBeginLoc(), Sym->getLocEnd());
StringRef ExprText = Lexer::getSourceText( StringRef ExprText = Lexer::getSourceText(
CharSourceRange::getTokenRange(SymExprRange), *Result.SourceManager, CharSourceRange::getTokenRange(SymExprRange), *Result.SourceManager,
Result.Context->getLangOpts()); Result.Context->getLangOpts());
diag(Loc, "expression always evaluates to '%0'") << ExprText; diag(Loc, "expression always evaluates to '%0'") << ExprText;
} }
} }
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

clang-tidy/misc/StaticAssertCheck.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Linesvoid StaticAssertCheck::check(const MatchFinder::MatchResult &Result) {
const SourceManager &SM = ASTCtx->getSourceManager(); const SourceManager &SM = ASTCtx->getSourceManager();
const auto *CondStmt = Result.Nodes.getNodeAs<Stmt>("condStmt"); const auto *CondStmt = Result.Nodes.getNodeAs<Stmt>("condStmt");
const auto *Condition = Result.Nodes.getNodeAs<Expr>("condition"); const auto *Condition = Result.Nodes.getNodeAs<Expr>("condition");
const auto *IsAlwaysFalse = Result.Nodes.getNodeAs<Expr>("isAlwaysFalse"); const auto *IsAlwaysFalse = Result.Nodes.getNodeAs<Expr>("isAlwaysFalse");
const auto *AssertMSG = Result.Nodes.getNodeAs<StringLiteral>("assertMSG"); const auto *AssertMSG = Result.Nodes.getNodeAs<StringLiteral>("assertMSG");
const auto *AssertExprRoot = const auto *AssertExprRoot =
Result.Nodes.getNodeAs<BinaryOperator>("assertExprRoot"); Result.Nodes.getNodeAs<BinaryOperator>("assertExprRoot");
const auto *CastExpr = Result.Nodes.getNodeAs<CStyleCastExpr>("castExpr"); const auto *CastExpr = Result.Nodes.getNodeAs<CStyleCastExpr>("castExpr");
SourceLocation AssertExpansionLoc = CondStmt->getLocStart(); SourceLocation AssertExpansionLoc = CondStmt->getBeginLoc();
if (!AssertExpansionLoc.isValid() || !AssertExpansionLoc.isMacroID()) if (!AssertExpansionLoc.isValid() || !AssertExpansionLoc.isMacroID())
return; return;
StringRef MacroName = StringRef MacroName =
Lexer::getImmediateMacroName(AssertExpansionLoc, SM, Opts); Lexer::getImmediateMacroName(AssertExpansionLoc, SM, Opts);
if (MacroName != "assert" || Condition->isValueDependent() || if (MacroName != "assert" || Condition->isValueDependent() ||
Show All 24 Lines if (AssertLoc.isValid() && !AssertLoc.isMacroID() &&
FixItHints.push_back( FixItHints.push_back(
FixItHint::CreateReplacement(SourceRange(AssertLoc), "static_assert")); FixItHint::CreateReplacement(SourceRange(AssertLoc), "static_assert"));
std::string StaticAssertMSG = ", \"\""; std::string StaticAssertMSG = ", \"\"";
if (AssertExprRoot) { if (AssertExprRoot) {
FixItHints.push_back(FixItHint::CreateRemoval( FixItHints.push_back(FixItHint::CreateRemoval(
SourceRange(AssertExprRoot->getOperatorLoc()))); SourceRange(AssertExprRoot->getOperatorLoc())));
FixItHints.push_back(FixItHint::CreateRemoval( FixItHints.push_back(FixItHint::CreateRemoval(
SourceRange(AssertMSG->getLocStart(), AssertMSG->getLocEnd()))); SourceRange(AssertMSG->getBeginLoc(), AssertMSG->getLocEnd())));
StaticAssertMSG = (Twine(", \"") + AssertMSG->getString() + "\"").str(); StaticAssertMSG = (Twine(", \"") + AssertMSG->getString() + "\"").str();
} }
FixItHints.push_back( FixItHints.push_back(
FixItHint::CreateInsertion(LastParenLoc, StaticAssertMSG)); FixItHint::CreateInsertion(LastParenLoc, StaticAssertMSG));
} }
diag(AssertLoc, "found assert() that could be replaced by static_assert()") diag(AssertLoc, "found assert() that could be replaced by static_assert()")
Show All 37 Lines

clang-tidy/misc/ThrowByValueCatchByReferenceCheck.cpp

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines if (qualType->isPointerType()) {
auto *inner = subExpr->IgnoreParenImpCasts(); auto *inner = subExpr->IgnoreParenImpCasts();
if (isa<StringLiteral>(inner)) if (isa<StringLiteral>(inner))
return; return;
// If it's a variable from a catch statement, we return as well. // If it's a variable from a catch statement, we return as well.
auto *declRef = dyn_cast<DeclRefExpr>(inner); auto *declRef = dyn_cast<DeclRefExpr>(inner);
if (declRef && isCatchVariable(declRef)) { if (declRef && isCatchVariable(declRef)) {
return; return;
} }
diag(subExpr->getLocStart(), "throw expression throws a pointer; it should " diag(subExpr->getBeginLoc(), "throw expression throws a pointer; it should "
"throw a non-pointer value instead"); "throw a non-pointer value instead");
} }
// If the throw statement does not throw by pointer then it throws by value // If the throw statement does not throw by pointer then it throws by value
// which is ok. // which is ok.
// There are addition checks that emit diagnosis messages if the thrown value // There are addition checks that emit diagnosis messages if the thrown value
// is not an RValue. See: // is not an RValue. See:
// https://www.securecoding.cert.org/confluence/display/cplusplus/ERR09-CPP.+Throw+anonymous+temporaries // https://www.securecoding.cert.org/confluence/display/cplusplus/ERR09-CPP.+Throw+anonymous+temporaries
// This behavior can be influenced by an option. // This behavior can be influenced by an option.
Show All 26 Lines else if (constructorCall &&
if (currentSubExpr->isLValue()) { if (currentSubExpr->isLValue()) {
if (auto *tmp = dyn_cast<DeclRefExpr>(currentSubExpr)) if (auto *tmp = dyn_cast<DeclRefExpr>(currentSubExpr))
emit = !isFunctionOrCatchVar(tmp); emit = !isFunctionOrCatchVar(tmp);
else if (isa<CallExpr>(currentSubExpr)) else if (isa<CallExpr>(currentSubExpr))
emit = true; emit = true;
} }
} }
if (emit) if (emit)
diag(subExpr->getLocStart(), diag(subExpr->getBeginLoc(),
"throw expression should throw anonymous temporary values instead"); "throw expression should throw anonymous temporary values instead");
} }
} }
void ThrowByValueCatchByReferenceCheck::diagnoseCatchLocations( void ThrowByValueCatchByReferenceCheck::diagnoseCatchLocations(
const CXXCatchStmt *catchStmt, ASTContext &context) { const CXXCatchStmt *catchStmt, ASTContext &context) {
if (!catchStmt) if (!catchStmt)
return; return;
auto caughtType = catchStmt->getCaughtType(); auto caughtType = catchStmt->getCaughtType();
if (caughtType.isNull()) if (caughtType.isNull())
return; return;
auto *varDecl = catchStmt->getExceptionDecl(); auto *varDecl = catchStmt->getExceptionDecl();
if (const auto *PT = caughtType.getCanonicalType()->getAs<PointerType>()) { if (const auto *PT = caughtType.getCanonicalType()->getAs<PointerType>()) {
const char *diagMsgCatchReference = "catch handler catches a pointer value; " const char *diagMsgCatchReference = "catch handler catches a pointer value; "
"should throw a non-pointer value and " "should throw a non-pointer value and "
"catch by reference instead"; "catch by reference instead";
// We do not diagnose when catching pointer to strings since we also allow // We do not diagnose when catching pointer to strings since we also allow
// throwing string literals. // throwing string literals.
if (!PT->getPointeeType()->isAnyCharacterType()) if (!PT->getPointeeType()->isAnyCharacterType())
diag(varDecl->getLocStart(), diagMsgCatchReference); diag(varDecl->getBeginLoc(), diagMsgCatchReference);
} else if (!caughtType->isReferenceType()) { } else if (!caughtType->isReferenceType()) {
const char *diagMsgCatchReference = "catch handler catches by value; " const char *diagMsgCatchReference = "catch handler catches by value; "
"should catch by reference instead"; "should catch by reference instead";
// If it's not a pointer and not a reference then it must be caught "by // If it's not a pointer and not a reference then it must be caught "by
// value". In this case we should emit a diagnosis message unless the type // value". In this case we should emit a diagnosis message unless the type
// is trivial. // is trivial.
if (!caughtType.isTrivialType(context)) if (!caughtType.isTrivialType(context))
diag(varDecl->getLocStart(), diagMsgCatchReference); diag(varDecl->getBeginLoc(), diagMsgCatchReference);
} }
} }
} // namespace misc } // namespace misc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Linesvoid UnconventionalAssignOperatorCheck::registerMatchers(
Finder->addMatcher(returnStmt(IsBadReturnStatement, forFunction(IsGoodAssign)) Finder->addMatcher(returnStmt(IsBadReturnStatement, forFunction(IsGoodAssign))
.bind("returnStmt"), .bind("returnStmt"),
this); this);
} }
void UnconventionalAssignOperatorCheck::check( void UnconventionalAssignOperatorCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
if (const auto *RetStmt = Result.Nodes.getNodeAs<ReturnStmt>("returnStmt")) { if (const auto *RetStmt = Result.Nodes.getNodeAs<ReturnStmt>("returnStmt")) {
diag(RetStmt->getLocStart(), "operator=() should always return '*this'"); diag(RetStmt->getBeginLoc(), "operator=() should always return '*this'");
} else { } else {
static const char *const Messages[][2] = { static const char *const Messages[][2] = {
{"ReturnType", "operator=() should return '%0&'"}, {"ReturnType", "operator=() should return '%0&'"},
{"ArgumentType", "operator=() should take '%0 const&', '%0&&' or '%0'"}, {"ArgumentType", "operator=() should take '%0 const&', '%0&&' or '%0'"},
{"cv", "operator=() should not be marked '%1'"}}; {"cv", "operator=() should not be marked '%1'"}};
const auto *Method = Result.Nodes.getNodeAs<CXXMethodDecl>("method"); const auto *Method = Result.Nodes.getNodeAs<CXXMethodDecl>("method");
for (const auto &Message : Messages) { for (const auto &Message : Messages) {
if (Result.Nodes.getNodeAs<Decl>(Message[0])) if (Result.Nodes.getNodeAs<Decl>(Message[0]))
diag(Method->getLocStart(), Message[1]) diag(Method->getBeginLoc(), Message[1])
<< Method->getParent()->getName() << Method->getParent()->getName()
<< (Method->isConst() ? "const" : "virtual"); << (Method->isConst() ? "const" : "virtual");
} }
} }
} }
} // namespace misc } // namespace misc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/misc/UnusedAliasDeclsCheck.cpp

Show All 28 Linesvoid UnusedAliasDeclsCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(namespaceAliasDecl(isExpansionInMainFile()).bind("alias"), Finder->addMatcher(namespaceAliasDecl(isExpansionInMainFile()).bind("alias"),
this); this);
Finder->addMatcher(nestedNameSpecifier().bind("nns"), this); Finder->addMatcher(nestedNameSpecifier().bind("nns"), this);
} }
void UnusedAliasDeclsCheck::check(const MatchFinder::MatchResult &Result) { void UnusedAliasDeclsCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *AliasDecl = Result.Nodes.getNodeAs<NamedDecl>("alias")) { if (const auto *AliasDecl = Result.Nodes.getNodeAs<NamedDecl>("alias")) {
FoundDecls[AliasDecl] = CharSourceRange::getCharRange( FoundDecls[AliasDecl] = CharSourceRange::getCharRange(
AliasDecl->getLocStart(), AliasDecl->getBeginLoc(),
Lexer::findLocationAfterToken( Lexer::findLocationAfterToken(
AliasDecl->getLocEnd(), tok::semi, *Result.SourceManager, AliasDecl->getLocEnd(), tok::semi, *Result.SourceManager,
getLangOpts(), getLangOpts(),
/*SkipTrailingWhitespaceAndNewLine=*/true)); /*SkipTrailingWhitespaceAndNewLine=*/true));
return; return;
} }
if (const auto *NestedName = if (const auto *NestedName =
Show All 19 Lines

clang-tidy/misc/UnusedParametersCheck.cpp

Show All 35 Lines Finder->addMatcher(
this); this);
} }
template <typename T> template <typename T>
static CharSourceRange removeNode(const MatchFinder::MatchResult &Result, static CharSourceRange removeNode(const MatchFinder::MatchResult &Result,
const T *PrevNode, const T *Node, const T *PrevNode, const T *Node,
const T *NextNode) { const T *NextNode) {
if (NextNode) if (NextNode)
return CharSourceRange::getCharRange(Node->getLocStart(), return CharSourceRange::getCharRange(Node->getBeginLoc(),
NextNode->getLocStart()); NextNode->getBeginLoc());
if (PrevNode) if (PrevNode)
return CharSourceRange::getTokenRange( return CharSourceRange::getTokenRange(
Lexer::getLocForEndOfToken(PrevNode->getLocEnd(), 0, Lexer::getLocForEndOfToken(PrevNode->getLocEnd(), 0,
*Result.SourceManager, *Result.SourceManager,
Result.Context->getLangOpts()), Result.Context->getLangOpts()),
Node->getLocEnd()); Node->getLocEnd());
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

clang-tidy/misc/UnusedUsingDeclsCheck.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
// FIXME: We ignore using-decls defined in function definitions at the // FIXME: We ignore using-decls defined in function definitions at the
// moment because of false positives caused by ADL and different function // moment because of false positives caused by ADL and different function
// scopes. // scopes.
if (isa<FunctionDecl>(Using->getDeclContext())) if (isa<FunctionDecl>(Using->getDeclContext()))
return; return;
UsingDeclContext Context(Using); UsingDeclContext Context(Using);
Context.UsingDeclRange = CharSourceRange::getCharRange( Context.UsingDeclRange = CharSourceRange::getCharRange(
Using->getLocStart(), Using->getBeginLoc(),
Lexer::findLocationAfterToken( Lexer::findLocationAfterToken(
Using->getLocEnd(), tok::semi, *Result.SourceManager, getLangOpts(), Using->getLocEnd(), tok::semi, *Result.SourceManager, getLangOpts(),
/*SkipTrailingWhitespaceAndNewLine=*/true)); /*SkipTrailingWhitespaceAndNewLine=*/true));
for (const auto *UsingShadow : Using->shadows()) { for (const auto *UsingShadow : Using->shadows()) {
const auto *TargetDecl = UsingShadow->getTargetDecl()->getCanonicalDecl(); const auto *TargetDecl = UsingShadow->getTargetDecl()->getCanonicalDecl();
if (ShouldCheckDecl(TargetDecl)) if (ShouldCheckDecl(TargetDecl))
Context.UsingTargetDecls.insert(TargetDecl); Context.UsingTargetDecls.insert(TargetDecl);
} }
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

clang-tidy/modernize/AvoidBindCheck.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines for (size_t I = 1, ArgCount = C->getNumArgs(); I < ArgCount; ++I) {
const Expr *E = C->getArg(I); const Expr *E = C->getArg(I);
BindArgument B; BindArgument B;
if (const auto *M = dyn_cast<MaterializeTemporaryExpr>(E)) { if (const auto *M = dyn_cast<MaterializeTemporaryExpr>(E)) {
const auto *TE = M->GetTemporaryExpr(); const auto *TE = M->GetTemporaryExpr();
B.Kind = isa<CallExpr>(TE) ? BK_CallExpr : BK_Temporary; B.Kind = isa<CallExpr>(TE) ? BK_CallExpr : BK_Temporary;
} }
B.Tokens = Lexer::getSourceText( B.Tokens = Lexer::getSourceText(
CharSourceRange::getTokenRange(E->getLocStart(), E->getLocEnd()), CharSourceRange::getTokenRange(E->getBeginLoc(), E->getLocEnd()),
*Result.SourceManager, Result.Context->getLangOpts()); *Result.SourceManager, Result.Context->getLangOpts());
SmallVector<StringRef, 2> Matches; SmallVector<StringRef, 2> Matches;
if (B.Kind == BK_Other && MatchPlaceholder.match(B.Tokens, &Matches)) { if (B.Kind == BK_Other && MatchPlaceholder.match(B.Tokens, &Matches)) {
B.Kind = BK_Placeholder; B.Kind = BK_Placeholder;
B.PlaceHolderIndex = std::stoi(Matches[1]); B.PlaceHolderIndex = std::stoi(Matches[1]);
} }
BindArguments.push_back(B); BindArguments.push_back(B);
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines Finder->addMatcher(
callee(namedDecl(hasName("::std::bind"))), callee(namedDecl(hasName("::std::bind"))),
hasArgument(0, declRefExpr(to(functionDecl().bind("f"))).bind("ref"))) hasArgument(0, declRefExpr(to(functionDecl().bind("f"))).bind("ref")))
.bind("bind"), .bind("bind"),
this); this);
} }
void AvoidBindCheck::check(const MatchFinder::MatchResult &Result) { void AvoidBindCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("bind"); const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("bind");
auto Diag = diag(MatchedDecl->getLocStart(), "prefer a lambda to std::bind"); auto Diag = diag(MatchedDecl->getBeginLoc(), "prefer a lambda to std::bind");
const auto Args = buildBindArguments(Result, MatchedDecl); const auto Args = buildBindArguments(Result, MatchedDecl);
// Do not attempt to create fixits for nested call expressions. // Do not attempt to create fixits for nested call expressions.
// FIXME: Create lambda capture variables to capture output of calls. // FIXME: Create lambda capture variables to capture output of calls.
// NOTE: Supporting nested std::bind will be more difficult due to placeholder // NOTE: Supporting nested std::bind will be more difficult due to placeholder
// sharing between outer and inner std:bind invocations. // sharing between outer and inner std:bind invocations.
if (llvm::any_of(Args, if (llvm::any_of(Args,
Show All 39 Lines

clang-tidy/modernize/MakeSmartPtrCheck.cpp

Show First 20 Lines • Show All 193 Lines • ▼ Show 20 Lines
} }
void MakeSmartPtrCheck::checkReset(SourceManager &SM, void MakeSmartPtrCheck::checkReset(SourceManager &SM,
const CXXMemberCallExpr *Reset, const CXXMemberCallExpr *Reset,
const CXXNewExpr *New) { const CXXNewExpr *New) {
const auto *Expr = cast<MemberExpr>(Reset->getCallee()); const auto *Expr = cast<MemberExpr>(Reset->getCallee());
SourceLocation OperatorLoc = Expr->getOperatorLoc(); SourceLocation OperatorLoc = Expr->getOperatorLoc();
SourceLocation ResetCallStart = Reset->getExprLoc(); SourceLocation ResetCallStart = Reset->getExprLoc();
SourceLocation ExprStart = Expr->getLocStart(); SourceLocation ExprStart = Expr->getBeginLoc();
SourceLocation ExprEnd = SourceLocation ExprEnd =
Lexer::getLocForEndOfToken(Expr->getLocEnd(), 0, SM, getLangOpts()); Lexer::getLocForEndOfToken(Expr->getLocEnd(), 0, SM, getLangOpts());
bool InMacro = ExprStart.isMacroID(); bool InMacro = ExprStart.isMacroID();
if (InMacro && IgnoreMacros) { if (InMacro && IgnoreMacros) {
return; return;
} }
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Lines if (const auto *NewConstruct = New->getConstructExpr()) {
NewConstruct->getParenOrBraceRange().getEnd().getLocWithOffset(-1)); NewConstruct->getParenOrBraceRange().getEnd().getLocWithOffset(-1));
} }
} else { } else {
// Aggregate initialization. // Aggregate initialization.
// smart_ptr<Pair>(new Pair{first, second}); // smart_ptr<Pair>(new Pair{first, second});
// Has to be replaced with: // Has to be replaced with:
// smart_ptr<Pair>(Pair{first, second}); // smart_ptr<Pair>(Pair{first, second});
InitRange = SourceRange( InitRange = SourceRange(
New->getAllocatedTypeSourceInfo()->getTypeLoc().getLocStart(), New->getAllocatedTypeSourceInfo()->getTypeLoc().getBeginLoc(),
New->getInitializer()->getSourceRange().getEnd()); New->getInitializer()->getSourceRange().getEnd());
} }
Diag << FixItHint::CreateRemoval( Diag << FixItHint::CreateRemoval(
CharSourceRange::getCharRange(NewStart, InitRange.getBegin())); CharSourceRange::getCharRange(NewStart, InitRange.getBegin()));
Diag << FixItHint::CreateRemoval( Diag << FixItHint::CreateRemoval(
SourceRange(InitRange.getEnd().getLocWithOffset(1), NewEnd)); SourceRange(InitRange.getEnd().getLocWithOffset(1), NewEnd));
break; break;
} }
Show All 18 Lines

clang-tidy/modernize/PassByValueCheck.cpp

Show First 20 Lines • Show All 188 Lines • ▼ Show 20 Lines if (!paramReferredExactlyOnce(Ctor, ParamDecl))
return; return;
// If the parameter is trivial to copy, don't move it. Moving a trivivally // If the parameter is trivial to copy, don't move it. Moving a trivivally
// copyable type will cause a problem with performance-move-const-arg // copyable type will cause a problem with performance-move-const-arg
if (ParamDecl->getType().getNonReferenceType().isTriviallyCopyableType( if (ParamDecl->getType().getNonReferenceType().isTriviallyCopyableType(
*Result.Context)) *Result.Context))
return; return;
auto Diag = diag(ParamDecl->getLocStart(), "pass by value and use std::move"); auto Diag = diag(ParamDecl->getBeginLoc(), "pass by value and use std::move");
// Iterate over all declarations of the constructor. // Iterate over all declarations of the constructor.
for (const ParmVarDecl *ParmDecl : collectParamDecls(Ctor, ParamDecl)) { for (const ParmVarDecl *ParmDecl : collectParamDecls(Ctor, ParamDecl)) {
auto ParamTL = ParmDecl->getTypeSourceInfo()->getTypeLoc(); auto ParamTL = ParmDecl->getTypeSourceInfo()->getTypeLoc();
auto RefTL = ParamTL.getAs<ReferenceTypeLoc>(); auto RefTL = ParamTL.getAs<ReferenceTypeLoc>();
// Do not replace if it is already a value, skip. // Do not replace if it is already a value, skip.
if (RefTL.isNull()) if (RefTL.isNull())
continue; continue;
TypeLoc ValueTL = RefTL.getPointeeLoc(); TypeLoc ValueTL = RefTL.getPointeeLoc();
auto TypeRange = CharSourceRange::getTokenRange(ParmDecl->getLocStart(), auto TypeRange = CharSourceRange::getTokenRange(ParmDecl->getBeginLoc(),
ParamTL.getLocEnd()); ParamTL.getLocEnd());
std::string ValueStr = Lexer::getSourceText(CharSourceRange::getTokenRange( std::string ValueStr = Lexer::getSourceText(CharSourceRange::getTokenRange(
ValueTL.getSourceRange()), ValueTL.getSourceRange()),
SM, getLangOpts()) SM, getLangOpts())
.str(); .str();
ValueStr += ' '; ValueStr += ' ';
Diag << FixItHint::CreateReplacement(TypeRange, ValueStr); Diag << FixItHint::CreateReplacement(TypeRange, ValueStr);
} }
Show All 17 Lines

clang-tidy/modernize/RawStringLiteralCheck.cpp

Show First 20 Lines • Show All 123 Lines • ▼ Show 20 Lines if (!getLangOpts().CPlusPlus11)
return; return;
Finder->addMatcher( Finder->addMatcher(
stringLiteral(unless(hasParent(predefinedExpr()))).bind("lit"), this); stringLiteral(unless(hasParent(predefinedExpr()))).bind("lit"), this);
} }
void RawStringLiteralCheck::check(const MatchFinder::MatchResult &Result) { void RawStringLiteralCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("lit"); const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("lit");
if (Literal->getLocStart().isMacroID()) if (Literal->getBeginLoc().isMacroID())
return; return;
if (containsEscapedCharacters(Result, Literal, DisallowedChars)) { if (containsEscapedCharacters(Result, Literal, DisallowedChars)) {
std::string Replacement = asRawStringLiteral(Literal, DelimiterStem); std::string Replacement = asRawStringLiteral(Literal, DelimiterStem);
if (ReplaceShorterLiterals || if (ReplaceShorterLiterals ||
Replacement.length() <= Replacement.length() <=
Lexer::MeasureTokenLength(Literal->getLocStart(), Lexer::MeasureTokenLength(Literal->getBeginLoc(),
*Result.SourceManager, getLangOpts())) *Result.SourceManager, getLangOpts()))
replaceWithRawStringLiteral(Result, Literal, Replacement); replaceWithRawStringLiteral(Result, Literal, Replacement);
} }
} }
void RawStringLiteralCheck::replaceWithRawStringLiteral( void RawStringLiteralCheck::replaceWithRawStringLiteral(
const MatchFinder::MatchResult &Result, const StringLiteral *Literal, const MatchFinder::MatchResult &Result, const StringLiteral *Literal,
StringRef Replacement) { StringRef Replacement) {
CharSourceRange CharRange = Lexer::makeFileCharRange( CharSourceRange CharRange = Lexer::makeFileCharRange(
CharSourceRange::getTokenRange(Literal->getSourceRange()), CharSourceRange::getTokenRange(Literal->getSourceRange()),
*Result.SourceManager, getLangOpts()); *Result.SourceManager, getLangOpts());
diag(Literal->getLocStart(), diag(Literal->getBeginLoc(),
"escaped string literal can be written as a raw string literal") "escaped string literal can be written as a raw string literal")
<< FixItHint::CreateReplacement(CharRange, Replacement); << FixItHint::CreateReplacement(CharRange, Replacement);
} }
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/modernize/RedundantVoidArgCheck.cpp

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines if (const auto *Function = Nodes.getNodeAs<FunctionDecl>(FunctionId)) {
processLambdaExpr(Result, Lambda); processLambdaExpr(Result, Lambda);
} }
} }
void RedundantVoidArgCheck::processFunctionDecl( void RedundantVoidArgCheck::processFunctionDecl(
const MatchFinder::MatchResult &Result, const FunctionDecl *Function) { const MatchFinder::MatchResult &Result, const FunctionDecl *Function) {
if (Function->isThisDeclarationADefinition()) { if (Function->isThisDeclarationADefinition()) {
const Stmt *Body = Function->getBody(); const Stmt *Body = Function->getBody();
SourceLocation Start = Function->getLocStart(); SourceLocation Start = Function->getBeginLoc();
SourceLocation End = SourceLocation End =
Body ? Body->getLocStart().getLocWithOffset(-1) : Function->getLocEnd(); Body ? Body->getBeginLoc().getLocWithOffset(-1) : Function->getLocEnd();
removeVoidArgumentTokens(Result, SourceRange(Start, End), removeVoidArgumentTokens(Result, SourceRange(Start, End),
"function definition"); "function definition");
} else { } else {
removeVoidArgumentTokens(Result, Function->getSourceRange(), removeVoidArgumentTokens(Result, Function->getSourceRange(),
"function declaration"); "function declaration");
} }
} }
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines if (protoTypeHasNoParms(Member->getType())) {
removeVoidArgumentTokens(Result, Member->getSourceRange(), removeVoidArgumentTokens(Result, Member->getSourceRange(),
"field declaration"); "field declaration");
} }
} }
void RedundantVoidArgCheck::processVarDecl( void RedundantVoidArgCheck::processVarDecl(
const MatchFinder::MatchResult &Result, const VarDecl *Var) { const MatchFinder::MatchResult &Result, const VarDecl *Var) {
if (protoTypeHasNoParms(Var->getType())) { if (protoTypeHasNoParms(Var->getType())) {
SourceLocation Begin = Var->getLocStart(); SourceLocation Begin = Var->getBeginLoc();
if (Var->hasInit()) { if (Var->hasInit()) {
SourceLocation InitStart = SourceLocation InitStart =
Result.SourceManager->getExpansionLoc(Var->getInit()->getLocStart()) Result.SourceManager->getExpansionLoc(Var->getInit()->getBeginLoc())
.getLocWithOffset(-1); .getLocWithOffset(-1);
removeVoidArgumentTokens(Result, SourceRange(Begin, InitStart), removeVoidArgumentTokens(Result, SourceRange(Begin, InitStart),
"variable declaration with initializer"); "variable declaration with initializer");
} else { } else {
removeVoidArgumentTokens(Result, Var->getSourceRange(), removeVoidArgumentTokens(Result, Var->getSourceRange(),
"variable declaration"); "variable declaration");
} }
} }
Show All 19 Lines
} }
void RedundantVoidArgCheck::processLambdaExpr( void RedundantVoidArgCheck::processLambdaExpr(
const MatchFinder::MatchResult &Result, const LambdaExpr *Lambda) { const MatchFinder::MatchResult &Result, const LambdaExpr *Lambda) {
if (Lambda->getLambdaClass()->getLambdaCallOperator()->getNumParams() == 0 && if (Lambda->getLambdaClass()->getLambdaCallOperator()->getNumParams() == 0 &&
Lambda->hasExplicitParameters()) { Lambda->hasExplicitParameters()) {
SourceLocation Begin = SourceLocation Begin =
Lambda->getIntroducerRange().getEnd().getLocWithOffset(1); Lambda->getIntroducerRange().getEnd().getLocWithOffset(1);
SourceLocation End = Lambda->getBody()->getLocStart().getLocWithOffset(-1); SourceLocation End = Lambda->getBody()->getBeginLoc().getLocWithOffset(-1);
removeVoidArgumentTokens(Result, SourceRange(Begin, End), removeVoidArgumentTokens(Result, SourceRange(Begin, End),
"lambda expression"); "lambda expression");
} }
} }
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines Options.store(Opts, "IncludeStyle",
utils::IncludeSorter::toString(IncludeStyle)); utils::IncludeSorter::toString(IncludeStyle));
} }
void ReplaceRandomShuffleCheck::check(const MatchFinder::MatchResult &Result) { void ReplaceRandomShuffleCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedDecl = Result.Nodes.getNodeAs<DeclRefExpr>("name"); const auto *MatchedDecl = Result.Nodes.getNodeAs<DeclRefExpr>("name");
const auto *MatchedArgumentThree = Result.Nodes.getNodeAs<Expr>("randomFunc"); const auto *MatchedArgumentThree = Result.Nodes.getNodeAs<Expr>("randomFunc");
const auto *MatchedCallExpr = Result.Nodes.getNodeAs<CallExpr>("match"); const auto *MatchedCallExpr = Result.Nodes.getNodeAs<CallExpr>("match");
if (MatchedCallExpr->getLocStart().isMacroID()) if (MatchedCallExpr->getBeginLoc().isMacroID())
return; return;
auto Diag = [&] { auto Diag = [&] {
if (MatchedCallExpr->getNumArgs() == 3) { if (MatchedCallExpr->getNumArgs() == 3) {
auto DiagL = auto DiagL =
diag(MatchedCallExpr->getLocStart(), diag(MatchedCallExpr->getBeginLoc(),
"'std::random_shuffle' has been removed in C++17; use " "'std::random_shuffle' has been removed in C++17; use "
"'std::shuffle' and an alternative random mechanism instead"); "'std::shuffle' and an alternative random mechanism instead");
DiagL << FixItHint::CreateReplacement( DiagL << FixItHint::CreateReplacement(
MatchedArgumentThree->getSourceRange(), MatchedArgumentThree->getSourceRange(),
"std::mt19937(std::random_device()())"); "std::mt19937(std::random_device()())");
return DiagL; return DiagL;
} else { } else {
auto DiagL = diag(MatchedCallExpr->getLocStart(), auto DiagL = diag(MatchedCallExpr->getBeginLoc(),
"'std::random_shuffle' has been removed in C++17; use " "'std::random_shuffle' has been removed in C++17; use "
"'std::shuffle' instead"); "'std::shuffle' instead");
DiagL << FixItHint::CreateInsertion( DiagL << FixItHint::CreateInsertion(
MatchedCallExpr->getRParenLoc(), MatchedCallExpr->getRParenLoc(),
", std::mt19937(std::random_device()())"); ", std::mt19937(std::random_device()())");
return DiagL; return DiagL;
} }
}(); }();
std::string NewName = "shuffle"; std::string NewName = "shuffle";
StringRef ContainerText = Lexer::getSourceText( StringRef ContainerText = Lexer::getSourceText(
CharSourceRange::getTokenRange(MatchedDecl->getSourceRange()), CharSourceRange::getTokenRange(MatchedDecl->getSourceRange()),
*Result.SourceManager, getLangOpts()); *Result.SourceManager, getLangOpts());
if (ContainerText.startswith("std::")) if (ContainerText.startswith("std::"))
NewName = "std::" + NewName; NewName = "std::" + NewName;
Diag << FixItHint::CreateRemoval(MatchedDecl->getSourceRange()); Diag << FixItHint::CreateRemoval(MatchedDecl->getSourceRange());
Diag << FixItHint::CreateInsertion(MatchedDecl->getLocStart(), NewName); Diag << FixItHint::CreateInsertion(MatchedDecl->getBeginLoc(), NewName);
if (Optional<FixItHint> IncludeFixit = if (Optional<FixItHint> IncludeFixit =
IncludeInserter->CreateIncludeInsertion( IncludeInserter->CreateIncludeInsertion(
Result.Context->getSourceManager().getFileID( Result.Context->getSourceManager().getFileID(
MatchedCallExpr->getLocStart()), MatchedCallExpr->getBeginLoc()),
"random", /*IsAngled=*/true)) "random", /*IsAngled=*/true))
Diag << IncludeFixit.getValue(); Diag << IncludeFixit.getValue();
} }
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/modernize/ShrinkToFitCheck.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
} }
void ShrinkToFitCheck::check(const MatchFinder::MatchResult &Result) { void ShrinkToFitCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MemberCall = const auto *MemberCall =
Result.Nodes.getNodeAs<CXXMemberCallExpr>("CopyAndSwapTrick"); Result.Nodes.getNodeAs<CXXMemberCallExpr>("CopyAndSwapTrick");
const auto *Container = Result.Nodes.getNodeAs<Expr>("ContainerToShrink"); const auto *Container = Result.Nodes.getNodeAs<Expr>("ContainerToShrink");
FixItHint Hint; FixItHint Hint;
if (!MemberCall->getLocStart().isMacroID()) { if (!MemberCall->getBeginLoc().isMacroID()) {
const LangOptions &Opts = getLangOpts(); const LangOptions &Opts = getLangOpts();
std::string ReplacementText; std::string ReplacementText;
if (const auto *UnaryOp = llvm::dyn_cast<UnaryOperator>(Container)) { if (const auto *UnaryOp = llvm::dyn_cast<UnaryOperator>(Container)) {
ReplacementText = ReplacementText =
Lexer::getSourceText(CharSourceRange::getTokenRange( Lexer::getSourceText(CharSourceRange::getTokenRange(
UnaryOp->getSubExpr()->getSourceRange()), UnaryOp->getSubExpr()->getSourceRange()),
*Result.SourceManager, Opts); *Result.SourceManager, Opts);
ReplacementText += "->shrink_to_fit()"; ReplacementText += "->shrink_to_fit()";
} else { } else {
ReplacementText = Lexer::getSourceText( ReplacementText = Lexer::getSourceText(
CharSourceRange::getTokenRange(Container->getSourceRange()), CharSourceRange::getTokenRange(Container->getSourceRange()),
*Result.SourceManager, Opts); *Result.SourceManager, Opts);
ReplacementText += ".shrink_to_fit()"; ReplacementText += ".shrink_to_fit()";
} }
Hint = FixItHint::CreateReplacement(MemberCall->getSourceRange(), Hint = FixItHint::CreateReplacement(MemberCall->getSourceRange(),
ReplacementText); ReplacementText);
} }
diag(MemberCall->getLocStart(), "the shrink_to_fit method should be used " diag(MemberCall->getBeginLoc(), "the shrink_to_fit method should be used "
"to reduce the capacity of a shrinkable " "to reduce the capacity of a shrinkable "
"container") "container")
<< Hint; << Hint;
} }
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/modernize/UnaryStaticAssertCheck.cpp

Show All 26 Lines
void UnaryStaticAssertCheck::check(const MatchFinder::MatchResult &Result) { void UnaryStaticAssertCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedDecl = const auto *MatchedDecl =
Result.Nodes.getNodeAs<StaticAssertDecl>("static_assert"); Result.Nodes.getNodeAs<StaticAssertDecl>("static_assert");
const StringLiteral *AssertMessage = MatchedDecl->getMessage(); const StringLiteral *AssertMessage = MatchedDecl->getMessage();
SourceLocation Loc = MatchedDecl->getLocation(); SourceLocation Loc = MatchedDecl->getLocation();
if (!AssertMessage || AssertMessage->getLength() || if (!AssertMessage || AssertMessage->getLength() ||
AssertMessage->getLocStart().isMacroID() || Loc.isMacroID()) AssertMessage->getBeginLoc().isMacroID() || Loc.isMacroID())
return; return;
diag(Loc, diag(Loc,
"use unary 'static_assert' when the string literal is an empty string") "use unary 'static_assert' when the string literal is an empty string")
<< FixItHint::CreateRemoval(AssertMessage->getSourceRange()); << FixItHint::CreateRemoval(AssertMessage->getSourceRange());
} }
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/modernize/UseBoolLiteralsCheck.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linesvoid UseBoolLiteralsCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Cast = Result.Nodes.getNodeAs<Expr>("cast"); const auto *Cast = Result.Nodes.getNodeAs<Expr>("cast");
bool LiteralBooleanValue = Literal->getValue().getBoolValue(); bool LiteralBooleanValue = Literal->getValue().getBoolValue();
if (Literal->isInstantiationDependent()) if (Literal->isInstantiationDependent())
return; return;
const Expr *Expression = Cast ? Cast : Literal; const Expr *Expression = Cast ? Cast : Literal;
bool InMacro = Expression->getLocStart().isMacroID(); bool InMacro = Expression->getBeginLoc().isMacroID();
if (InMacro && IgnoreMacros) if (InMacro && IgnoreMacros)
return; return;
auto Diag = auto Diag =
diag(Expression->getExprLoc(), diag(Expression->getExprLoc(),
"converting integer literal to bool, use bool literal instead"); "converting integer literal to bool, use bool literal instead");
if (!InMacro) if (!InMacro)
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
Expression->getSourceRange(), LiteralBooleanValue ? "true" : "false"); Expression->getSourceRange(), LiteralBooleanValue ? "true" : "false");
} }
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/modernize/UseDefaultMemberInitCheck.cpp

Show First 20 Lines • Show All 196 Lines • ▼ Show 20 Linesvoid UseDefaultMemberInitCheck::check(const MatchFinder::MatchResult &Result) {
else else
llvm_unreachable("Bad Callback. No node provided."); llvm_unreachable("Bad Callback. No node provided.");
} }
void UseDefaultMemberInitCheck::checkDefaultInit( void UseDefaultMemberInitCheck::checkDefaultInit(
const MatchFinder::MatchResult &Result, const CXXCtorInitializer *Init) { const MatchFinder::MatchResult &Result, const CXXCtorInitializer *Init) {
const FieldDecl *Field = Init->getAnyMember(); const FieldDecl *Field = Init->getAnyMember();
SourceLocation StartLoc = Field->getLocStart(); SourceLocation StartLoc = Field->getBeginLoc();
if (StartLoc.isMacroID() && IgnoreMacros) if (StartLoc.isMacroID() && IgnoreMacros)
return; return;
SourceLocation FieldEnd = SourceLocation FieldEnd =
Lexer::getLocForEndOfToken(Field->getSourceRange().getEnd(), 0, Lexer::getLocForEndOfToken(Field->getSourceRange().getEnd(), 0,
*Result.SourceManager, getLangOpts()); *Result.SourceManager, getLangOpts());
SourceLocation LParenEnd = Lexer::getLocForEndOfToken( SourceLocation LParenEnd = Lexer::getLocForEndOfToken(
Init->getLParenLoc(), 0, *Result.SourceManager, getLangOpts()); Init->getLParenLoc(), 0, *Result.SourceManager, getLangOpts());
Show All 34 Lines

clang-tidy/modernize/UseEqualsDefaultCheck.cpp

Show First 20 Lines • Show All 292 Lines • ▼ Show 20 Lines if (!isCopyAssignmentAndCanBeDefaulted(Result.Context, SpecialFunctionDecl))
return; return;
SpecialFunctionName = "copy-assignment operator"; SpecialFunctionName = "copy-assignment operator";
} }
// The location of the body is more useful inside a macro as spelling and // The location of the body is more useful inside a macro as spelling and
// expansion locations are reported. // expansion locations are reported.
SourceLocation Location = SpecialFunctionDecl->getLocation(); SourceLocation Location = SpecialFunctionDecl->getLocation();
if (Location.isMacroID()) if (Location.isMacroID())
Location = Body->getLocStart(); Location = Body->getBeginLoc();
auto Diag = diag(Location, "use '= default' to define a trivial " + auto Diag = diag(Location, "use '= default' to define a trivial " +
SpecialFunctionName); SpecialFunctionName);
if (ApplyFix) if (ApplyFix)
Diag << FixItHint::CreateReplacement(Body->getSourceRange(), "= default;") Diag << FixItHint::CreateReplacement(Body->getSourceRange(), "= default;")
<< RemoveInitializers; << RemoveInitializers;
} }
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/modernize/UseNullptrCheck.cpp

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines if (!VisitedPreviously) {
// Reset state as we unwind back up the tree. // Reset state as we unwind back up the tree.
CastFound = false; CastFound = false;
Visited = false; Visited = false;
} }
return true; return true;
} }
bool VisitStmt(Stmt *S) { bool VisitStmt(Stmt *S) {
if (SM.getFileLoc(S->getLocStart()) != CastLoc) if (SM.getFileLoc(S->getBeginLoc()) != CastLoc)
return true; return true;
Visited = true; Visited = true;
const ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(S); const ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(S);
if (Cast && (Cast->getCastKind() == CK_NullToPointer || if (Cast && (Cast->getCastKind() == CK_NullToPointer ||
Cast->getCastKind() == CK_NullToMemberPointer)) Cast->getCastKind() == CK_NullToMemberPointer))
CastFound = true; CastFound = true;
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines bool VisitStmt(Stmt *S) {
if (!FirstSubExpr) if (!FirstSubExpr)
FirstSubExpr = CastSubExpr; FirstSubExpr = CastSubExpr;
if (C->getCastKind() != CK_NullToPointer && if (C->getCastKind() != CK_NullToPointer &&
C->getCastKind() != CK_NullToMemberPointer) { C->getCastKind() != CK_NullToMemberPointer) {
return true; return true;
} }
SourceLocation StartLoc = FirstSubExpr->getLocStart(); SourceLocation StartLoc = FirstSubExpr->getBeginLoc();
SourceLocation EndLoc = FirstSubExpr->getLocEnd(); SourceLocation EndLoc = FirstSubExpr->getLocEnd();
// If the location comes from a macro arg expansion, *all* uses of that // If the location comes from a macro arg expansion, *all* uses of that
// arg must be checked to result in NullTo(Member)Pointer casts. // arg must be checked to result in NullTo(Member)Pointer casts.
// //
// If the location comes from a macro body expansion, check to see if its // If the location comes from a macro body expansion, check to see if its
// coming from one of the allowed 'NULL' macros. // coming from one of the allowed 'NULL' macros.
if (SM.isMacroArgExpansion(StartLoc) && SM.isMacroArgExpansion(EndLoc)) { if (SM.isMacroArgExpansion(StartLoc) && SM.isMacroArgExpansion(EndLoc)) {
Show All 38 Linesprivate:
bool skipSubTree() { bool skipSubTree() {
PruneSubtree = true; PruneSubtree = true;
return true; return true;
} }
/// \brief Tests that all expansions of a macro arg, one of which expands to /// \brief Tests that all expansions of a macro arg, one of which expands to
/// result in \p CE, yield NullTo(Member)Pointer casts. /// result in \p CE, yield NullTo(Member)Pointer casts.
bool allArgUsesValid(const CastExpr *CE) { bool allArgUsesValid(const CastExpr *CE) {
SourceLocation CastLoc = CE->getLocStart(); SourceLocation CastLoc = CE->getBeginLoc();
// Step 1: Get location of macro arg and location of the macro the arg was // Step 1: Get location of macro arg and location of the macro the arg was
// provided to. // provided to.
SourceLocation ArgLoc, MacroLoc; SourceLocation ArgLoc, MacroLoc;
if (!getMacroAndArgLocations(CastLoc, ArgLoc, MacroLoc)) if (!getMacroAndArgLocations(CastLoc, ArgLoc, MacroLoc))
return false; return false;
// Step 2: Find the first ancestor that doesn't expand from this macro. // Step 2: Find the first ancestor that doesn't expand from this macro.
▲ Show 20 Lines • Show All 151 Lines • ▼ Show 20 Lines while (true) {
return false; return false;
} }
} }
const ast_type_traits::DynTypedNode &Parent = Parents[0]; const ast_type_traits::DynTypedNode &Parent = Parents[0];
SourceLocation Loc; SourceLocation Loc;
if (const auto *D = Parent.get<Decl>()) if (const auto *D = Parent.get<Decl>())
Loc = D->getLocStart(); Loc = D->getBeginLoc();
else if (const auto *S = Parent.get<Stmt>()) else if (const auto *S = Parent.get<Stmt>())
Loc = S->getLocStart(); Loc = S->getBeginLoc();
// TypeLoc and NestedNameSpecifierLoc are members of the parent map. Skip // TypeLoc and NestedNameSpecifierLoc are members of the parent map. Skip
// them and keep going up. // them and keep going up.
if (Loc.isValid()) { if (Loc.isValid()) {
if (!expandsFrom(Loc, MacroLoc)) { if (!expandsFrom(Loc, MacroLoc)) {
Result = Parent; Result = Parent;
return true; return true;
} }
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

clang-tidy/modernize/UseTransparentFunctorsCheck.cpp

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
} }
void UseTransparentFunctorsCheck::check( void UseTransparentFunctorsCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *FuncClass = const auto *FuncClass =
Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("FunctorClass"); Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("FunctorClass");
if (const auto *FuncInst = if (const auto *FuncInst =
Result.Nodes.getNodeAs<CXXConstructExpr>("FuncInst")) { Result.Nodes.getNodeAs<CXXConstructExpr>("FuncInst")) {
diag(FuncInst->getLocStart(), Message) diag(FuncInst->getBeginLoc(), Message)
<< (FuncClass->getName() + "<>").str(); << (FuncClass->getName() + "<>").str();
return; return;
} }
const auto *Functor = Result.Nodes.getNodeAs<TemplateArgument>("Functor"); const auto *Functor = Result.Nodes.getNodeAs<TemplateArgument>("Functor");
const auto FunctorParentLoc = const auto FunctorParentLoc =
Result.Nodes.getNodeAs<TypeLoc>("FunctorParentLoc") Result.Nodes.getNodeAs<TypeLoc>("FunctorParentLoc")
->getAs<TemplateSpecializationTypeLoc>(); ->getAs<TemplateSpecializationTypeLoc>();
Show All 35 Lines

clang-tidy/modernize/UseUncaughtExceptionsCheck.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
void UseUncaughtExceptionsCheck::check(const MatchFinder::MatchResult &Result) { void UseUncaughtExceptionsCheck::check(const MatchFinder::MatchResult &Result) {
SourceLocation BeginLoc; SourceLocation BeginLoc;
SourceLocation EndLoc; SourceLocation EndLoc;
const CallExpr *C = Result.Nodes.getNodeAs<CallExpr>("init_call_expr"); const CallExpr *C = Result.Nodes.getNodeAs<CallExpr>("init_call_expr");
bool WarnOnly = false; bool WarnOnly = false;
if (C) { if (C) {
BeginLoc = C->getLocStart(); BeginLoc = C->getBeginLoc();
EndLoc = C->getLocEnd(); EndLoc = C->getLocEnd();
} else if (const auto *E = Result.Nodes.getNodeAs<CallExpr>("call_expr")) { } else if (const auto *E = Result.Nodes.getNodeAs<CallExpr>("call_expr")) {
BeginLoc = E->getLocStart(); BeginLoc = E->getBeginLoc();
EndLoc = E->getLocEnd(); EndLoc = E->getLocEnd();
} else if (const auto *D = } else if (const auto *D =
Result.Nodes.getNodeAs<DeclRefExpr>("decl_ref_expr")) { Result.Nodes.getNodeAs<DeclRefExpr>("decl_ref_expr")) {
BeginLoc = D->getLocStart(); BeginLoc = D->getBeginLoc();
EndLoc = D->getLocEnd(); EndLoc = D->getLocEnd();
WarnOnly = true; WarnOnly = true;
} else { } else {
const auto *U = Result.Nodes.getNodeAs<UsingDecl>("using_decl"); const auto *U = Result.Nodes.getNodeAs<UsingDecl>("using_decl");
assert(U && "Null pointer, no node provided"); assert(U && "Null pointer, no node provided");
BeginLoc = U->getNameInfo().getBeginLoc(); BeginLoc = U->getNameInfo().getBeginLoc();
EndLoc = U->getNameInfo().getEndLoc(); EndLoc = U->getNameInfo().getEndLoc();
} }
Show All 29 Lines

clang-tidy/modernize/UseUsingCheck.cpp

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
void UseUsingCheck::check(const MatchFinder::MatchResult &Result) { void UseUsingCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedDecl = Result.Nodes.getNodeAs<TypedefDecl>("typedef"); const auto *MatchedDecl = Result.Nodes.getNodeAs<TypedefDecl>("typedef");
if (MatchedDecl->getLocation().isInvalid()) if (MatchedDecl->getLocation().isInvalid())
return; return;
auto &Context = *Result.Context; auto &Context = *Result.Context;
auto &SM = *Result.SourceManager; auto &SM = *Result.SourceManager;
SourceLocation StartLoc = MatchedDecl->getLocStart(); SourceLocation StartLoc = MatchedDecl->getBeginLoc();
if (StartLoc.isMacroID() && IgnoreMacros) if (StartLoc.isMacroID() && IgnoreMacros)
return; return;
auto Diag = auto Diag =
diag(StartLoc, "use 'using' instead of 'typedef'"); diag(StartLoc, "use 'using' instead of 'typedef'");
// do not fix if there is macro or array // do not fix if there is macro or array
Show All 19 Lines

clang-tidy/objc/AvoidNSErrorInitCheck.cpp

Show All 25 Lines Finder->addMatcher(objcMessageExpr(hasSelector("init"),
hasReceiverType(asString("NSError *"))) hasReceiverType(asString("NSError *")))
.bind("nserrorInit"), .bind("nserrorInit"),
this); this);
} }
void AvoidNSErrorInitCheck::check(const MatchFinder::MatchResult &Result) { void AvoidNSErrorInitCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedExpr = const auto *MatchedExpr =
Result.Nodes.getNodeAs<ObjCMessageExpr>("nserrorInit"); Result.Nodes.getNodeAs<ObjCMessageExpr>("nserrorInit");
diag(MatchedExpr->getLocStart(), diag(MatchedExpr->getBeginLoc(),
"use errorWithDomain:code:userInfo: or initWithDomain:code:userInfo: to " "use errorWithDomain:code:userInfo: or initWithDomain:code:userInfo: to "
"create a new NSError"); "create a new NSError");
} }
} // namespace objc } // namespace objc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/objc/AvoidSpinlockCheck.cpp

Show All 21 Lines Finder->addMatcher(
callExpr(callee((functionDecl(hasAnyName( callExpr(callee((functionDecl(hasAnyName(
"OSSpinlockLock", "OSSpinlockUnlock", "OSSpinlockTry"))))) "OSSpinlockLock", "OSSpinlockUnlock", "OSSpinlockTry")))))
.bind("spinlock"), .bind("spinlock"),
this); this);
} }
void AvoidSpinlockCheck::check(const MatchFinder::MatchResult &Result) { void AvoidSpinlockCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedExpr = Result.Nodes.getNodeAs<CallExpr>("spinlock"); const auto *MatchedExpr = Result.Nodes.getNodeAs<CallExpr>("spinlock");
diag(MatchedExpr->getLocStart(), diag(MatchedExpr->getBeginLoc(),
"use os_unfair_lock_lock() or dispatch queue APIs instead of the " "use os_unfair_lock_lock() or dispatch queue APIs instead of the "
"deprecated OSSpinLock"); "deprecated OSSpinLock");
} }
} // namespace objc } // namespace objc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/performance/FasterStringFindCheck.cpp

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
void FasterStringFindCheck::check(const MatchFinder::MatchResult &Result) { void FasterStringFindCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("literal"); const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("literal");
const auto *FindFunc = Result.Nodes.getNodeAs<FunctionDecl>("func"); const auto *FindFunc = Result.Nodes.getNodeAs<FunctionDecl>("func");
auto Replacement = MakeCharacterLiteral(Literal); auto Replacement = MakeCharacterLiteral(Literal);
if (!Replacement) if (!Replacement)
return; return;
diag(Literal->getLocStart(), "%0 called with a string literal consisting of " diag(Literal->getBeginLoc(), "%0 called with a string literal consisting of "
"a single character; consider using the more " "a single character; consider using the more "
"effective overload accepting a character") "effective overload accepting a character")
<< FindFunc << FixItHint::CreateReplacement( << FindFunc << FixItHint::CreateReplacement(
CharSourceRange::getTokenRange(Literal->getLocStart(), CharSourceRange::getTokenRange(Literal->getBeginLoc(),
Literal->getLocEnd()), Literal->getLocEnd()),
*Replacement); *Replacement);
} }
} // namespace performance } // namespace performance
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/performance/ForRangeCopyCheck.cpp

Show All 35 Linesvoid ForRangeCopyCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(cxxForRangeStmt(hasLoopVariable(LoopVar.bind("loopVar"))) Finder->addMatcher(cxxForRangeStmt(hasLoopVariable(LoopVar.bind("loopVar")))
.bind("forRange"), .bind("forRange"),
this); this);
} }
void ForRangeCopyCheck::check(const MatchFinder::MatchResult &Result) { void ForRangeCopyCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Var = Result.Nodes.getNodeAs<VarDecl>("loopVar"); const auto *Var = Result.Nodes.getNodeAs<VarDecl>("loopVar");
// Ignore code in macros since we can't place the fixes correctly. // Ignore code in macros since we can't place the fixes correctly.
if (Var->getLocStart().isMacroID()) if (Var->getBeginLoc().isMacroID())
return; return;
if (handleConstValueCopy(*Var, *Result.Context)) if (handleConstValueCopy(*Var, *Result.Context))
return; return;
const auto *ForRange = Result.Nodes.getNodeAs<CXXForRangeStmt>("forRange"); const auto *ForRange = Result.Nodes.getNodeAs<CXXForRangeStmt>("forRange");
handleCopyIsOnlyConstReferenced(*Var, *ForRange, *Result.Context); handleCopyIsOnlyConstReferenced(*Var, *ForRange, *Result.Context);
} }
bool ForRangeCopyCheck::handleConstValueCopy(const VarDecl &LoopVar, bool ForRangeCopyCheck::handleConstValueCopy(const VarDecl &LoopVar,
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

clang-tidy/performance/ImplicitConversionInLoopCheck.cpp

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Linesvoid ImplicitConversionInLoopCheck::ReportAndFix(
QualType ConstType = OperatorCall->getType().withConst(); QualType ConstType = OperatorCall->getType().withConst();
QualType ConstRefType = Context->getLValueReferenceType(ConstType); QualType ConstRefType = Context->getLValueReferenceType(ConstType);
const char Message[] = const char Message[] =
"the type of the loop variable %0 is different from the one returned " "the type of the loop variable %0 is different from the one returned "
"by the iterator and generates an implicit conversion; you can either " "by the iterator and generates an implicit conversion; you can either "
"change the type to the matching one (%1 but 'const auto&' is always a " "change the type to the matching one (%1 but 'const auto&' is always a "
"valid option) or remove the reference to make it explicit that you are " "valid option) or remove the reference to make it explicit that you are "
"creating a new value"; "creating a new value";
diag(VD->getLocStart(), Message) << VD << ConstRefType; diag(VD->getBeginLoc(), Message) << VD << ConstRefType;
} }
} // namespace performance } // namespace performance
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/performance/InefficientAlgorithmCheck.cpp

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines const QualType AlgCmp =
Arg->getType().getUnqualifiedType().getCanonicalType(); Arg->getType().getUnqualifiedType().getCanonicalType();
const unsigned CmpPosition = const unsigned CmpPosition =
(IneffContName.find("map") == llvm::StringRef::npos) ? 1 : 2; (IneffContName.find("map") == llvm::StringRef::npos) ? 1 : 2;
const QualType ContainerCmp = IneffCont->getTemplateArgs()[CmpPosition] const QualType ContainerCmp = IneffCont->getTemplateArgs()[CmpPosition]
.getAsType() .getAsType()
.getUnqualifiedType() .getUnqualifiedType()
.getCanonicalType(); .getCanonicalType();
if (AlgCmp != ContainerCmp) { if (AlgCmp != ContainerCmp) {
diag(Arg->getLocStart(), diag(Arg->getBeginLoc(),
"different comparers used in the algorithm and the container"); "different comparers used in the algorithm and the container");
return; return;
} }
} }
const auto *AlgDecl = AlgCall->getDirectCallee(); const auto *AlgDecl = AlgCall->getDirectCallee();
if (!AlgDecl) if (!AlgDecl)
return; return;
Show All 37 Lines StringRef ParamText = Lexer::getSourceText(
LangOpts); LangOpts);
std::string ReplacementText = std::string ReplacementText =
(llvm::Twine(ContainerText) + (PtrToContainer ? "->" : ".") + (llvm::Twine(ContainerText) + (PtrToContainer ? "->" : ".") +
AlgDecl->getName() + "(" + ParamText + ")") AlgDecl->getName() + "(" + ParamText + ")")
.str(); .str();
Hint = FixItHint::CreateReplacement(CallRange, ReplacementText); Hint = FixItHint::CreateReplacement(CallRange, ReplacementText);
} }
diag(AlgCall->getLocStart(), diag(AlgCall->getBeginLoc(),
"this STL algorithm call should be replaced with a container method") "this STL algorithm call should be replaced with a container method")
<< Hint; << Hint;
} }
} // namespace performance } // namespace performance
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/performance/InefficientVectorOperationCheck.cpp

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Lines for (const auto *Ref : AllVectorVarRefs) {
// Skip cases where there are usages (defined as DeclRefExpr that refers to // Skip cases where there are usages (defined as DeclRefExpr that refers to
// "v") of vector variable `v` before the for loop. We consider these usages // "v") of vector variable `v` before the for loop. We consider these usages
// are operations causing memory preallocation (e.g. "v.resize(n)", // are operations causing memory preallocation (e.g. "v.resize(n)",
// "v.reserve(n)"). // "v.reserve(n)").
// //
// FIXME: make it more intelligent to identify the pre-allocating operations // FIXME: make it more intelligent to identify the pre-allocating operations
// before the for loop. // before the for loop.
if (SM.isBeforeInTranslationUnit(Ref->getLocation(), if (SM.isBeforeInTranslationUnit(Ref->getLocation(),
LoopStmt->getLocStart())) { LoopStmt->getBeginLoc())) {
return; return;
} }
} }
llvm::StringRef VectorVarName = Lexer::getSourceText( llvm::StringRef VectorVarName = Lexer::getSourceText(
CharSourceRange::getTokenRange( CharSourceRange::getTokenRange(
VectorAppendCall->getImplicitObjectArgument()->getSourceRange()), VectorAppendCall->getImplicitObjectArgument()->getSourceRange()),
SM, Context->getLangOpts()); SM, Context->getLangOpts());
Show All 15 Lines if (RangeLoop) {
// Handle counter-based loop cases. // Handle counter-based loop cases.
StringRef LoopEndSource = Lexer::getSourceText( StringRef LoopEndSource = Lexer::getSourceText(
CharSourceRange::getTokenRange(LoopEndExpr->getSourceRange()), SM, CharSourceRange::getTokenRange(LoopEndExpr->getSourceRange()), SM,
Context->getLangOpts()); Context->getLangOpts());
ReserveStmt = (VectorVarName + ".reserve(" + LoopEndSource + ");\n").str(); ReserveStmt = (VectorVarName + ".reserve(" + LoopEndSource + ");\n").str();
} }
auto Diag = auto Diag =
diag(VectorAppendCall->getLocStart(), diag(VectorAppendCall->getBeginLoc(),
"%0 is called inside a loop; " "%0 is called inside a loop; "
"consider pre-allocating the vector capacity before the loop") "consider pre-allocating the vector capacity before the loop")
<< VectorAppendCall->getMethodDecl()->getDeclName(); << VectorAppendCall->getMethodDecl()->getDeclName();
if (!ReserveStmt.empty()) if (!ReserveStmt.empty())
Diag << FixItHint::CreateInsertion(LoopStmt->getLocStart(), ReserveStmt); Diag << FixItHint::CreateInsertion(LoopStmt->getBeginLoc(), ReserveStmt);
} }
} // namespace performance } // namespace performance
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/performance/MoveConstArgCheck.cpp

Show All 17 Lines
namespace performance { namespace performance {
static void ReplaceCallWithArg(const CallExpr *Call, DiagnosticBuilder &Diag, static void ReplaceCallWithArg(const CallExpr *Call, DiagnosticBuilder &Diag,
const SourceManager &SM, const SourceManager &SM,
const LangOptions &LangOpts) { const LangOptions &LangOpts) {
const Expr *Arg = Call->getArg(0); const Expr *Arg = Call->getArg(0);
CharSourceRange BeforeArgumentsRange = Lexer::makeFileCharRange( CharSourceRange BeforeArgumentsRange = Lexer::makeFileCharRange(
CharSourceRange::getCharRange(Call->getLocStart(), Arg->getLocStart()), CharSourceRange::getCharRange(Call->getBeginLoc(), Arg->getBeginLoc()),
SM, LangOpts); SM, LangOpts);
CharSourceRange AfterArgumentsRange = Lexer::makeFileCharRange( CharSourceRange AfterArgumentsRange = Lexer::makeFileCharRange(
CharSourceRange::getCharRange(Call->getLocEnd(), CharSourceRange::getCharRange(Call->getLocEnd(),
Call->getLocEnd().getLocWithOffset(1)), Call->getLocEnd().getLocWithOffset(1)),
SM, LangOpts); SM, LangOpts);
if (BeforeArgumentsRange.isValid() && AfterArgumentsRange.isValid()) { if (BeforeArgumentsRange.isValid() && AfterArgumentsRange.isValid()) {
Diag << FixItHint::CreateRemoval(BeforeArgumentsRange) Diag << FixItHint::CreateRemoval(BeforeArgumentsRange)
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

clang-tidy/performance/TypePromotionInMathFnCheck.cpp

Show First 20 Lines • Show All 189 Lines • ▼ Show 20 Lines auto Diag = diag(Call->getExprLoc(), "call to '%0' promotes float to double")
Call->getCallee()->getSourceRange(), NewFnName); Call->getCallee()->getSourceRange(), NewFnName);
// Suggest including <cmath> if the function we're suggesting is declared in // Suggest including <cmath> if the function we're suggesting is declared in
// <cmath> and it's not already included. We never have to suggest including // <cmath> and it's not already included. We never have to suggest including
// <math.h>, because the functions we're suggesting moving away from are all // <math.h>, because the functions we're suggesting moving away from are all
// declared in <math.h>. // declared in <math.h>.
if (FnInCmath) if (FnInCmath)
if (auto IncludeFixit = IncludeInserter->CreateIncludeInsertion( if (auto IncludeFixit = IncludeInserter->CreateIncludeInsertion(
Result.Context->getSourceManager().getFileID(Call->getLocStart()), Result.Context->getSourceManager().getFileID(Call->getBeginLoc()),
"cmath", /*IsAngled=*/true)) "cmath", /*IsAngled=*/true))
Diag << *IncludeFixit; Diag << *IncludeFixit;
} }
} // namespace performance } // namespace performance
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/performance/UnnecessaryValueParamCheck.cpp

Show First 20 Lines • Show All 145 Lines • ▼ Show 20 Lines auto Diag =
<< paramNameOrIndex(Param->getName(), Index); << paramNameOrIndex(Param->getName(), Index);
// Do not propose fixes when: // Do not propose fixes when:
// 1. the ParmVarDecl is in a macro, since we cannot place them correctly // 1. the ParmVarDecl is in a macro, since we cannot place them correctly
// 2. the function is virtual as it might break overrides // 2. the function is virtual as it might break overrides
// 3. the function is referenced outside of a call expression within the // 3. the function is referenced outside of a call expression within the
// compilation unit as the signature change could introduce build errors. // compilation unit as the signature change could introduce build errors.
// 4. the function is an explicit template specialization. // 4. the function is an explicit template specialization.
const auto *Method = llvm::dyn_cast<CXXMethodDecl>(Function); const auto *Method = llvm::dyn_cast<CXXMethodDecl>(Function);
if (Param->getLocStart().isMacroID() || (Method && Method->isVirtual()) || if (Param->getBeginLoc().isMacroID() || (Method && Method->isVirtual()) ||
isReferencedOutsideOfCallExpr(*Function, *Result.Context) || isReferencedOutsideOfCallExpr(*Function, *Result.Context) ||
isExplicitTemplateSpecialization(*Function)) isExplicitTemplateSpecialization(*Function))
return; return;
for (const auto *FunctionDecl = Function; FunctionDecl != nullptr; for (const auto *FunctionDecl = Function; FunctionDecl != nullptr;
FunctionDecl = FunctionDecl->getPreviousDecl()) { FunctionDecl = FunctionDecl->getPreviousDecl()) {
const auto &CurrentParam = *FunctionDecl->getParamDecl(Index); const auto &CurrentParam = *FunctionDecl->getParamDecl(Index);
Diag << utils::fixit::changeVarDeclToReference(CurrentParam, Diag << utils::fixit::changeVarDeclToReference(CurrentParam,
*Result.Context); *Result.Context);
Show All 16 Linesvoid UnnecessaryValueParamCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "IncludeStyle", Options.store(Opts, "IncludeStyle",
utils::IncludeSorter::toString(IncludeStyle)); utils::IncludeSorter::toString(IncludeStyle));
} }
void UnnecessaryValueParamCheck::handleMoveFix(const ParmVarDecl &Var, void UnnecessaryValueParamCheck::handleMoveFix(const ParmVarDecl &Var,
const DeclRefExpr &CopyArgument, const DeclRefExpr &CopyArgument,
const ASTContext &Context) { const ASTContext &Context) {
auto Diag = diag(CopyArgument.getLocStart(), auto Diag = diag(CopyArgument.getBeginLoc(),
"parameter %0 is passed by value and only copied once; " "parameter %0 is passed by value and only copied once; "
"consider moving it to avoid unnecessary copies") "consider moving it to avoid unnecessary copies")
<< &Var; << &Var;
// Do not propose fixes in macros since we cannot place them correctly. // Do not propose fixes in macros since we cannot place them correctly.
if (CopyArgument.getLocStart().isMacroID()) if (CopyArgument.getBeginLoc().isMacroID())
return; return;
const auto &SM = Context.getSourceManager(); const auto &SM = Context.getSourceManager();
auto EndLoc = Lexer::getLocForEndOfToken(CopyArgument.getLocation(), 0, SM, auto EndLoc = Lexer::getLocForEndOfToken(CopyArgument.getLocation(), 0, SM,
Context.getLangOpts()); Context.getLangOpts());
Diag << FixItHint::CreateInsertion(CopyArgument.getLocStart(), "std::move(") Diag << FixItHint::CreateInsertion(CopyArgument.getBeginLoc(), "std::move(")
<< FixItHint::CreateInsertion(EndLoc, ")"); << FixItHint::CreateInsertion(EndLoc, ")");
if (auto IncludeFixit = Inserter->CreateIncludeInsertion( if (auto IncludeFixit = Inserter->CreateIncludeInsertion(
SM.getFileID(CopyArgument.getLocStart()), "utility", SM.getFileID(CopyArgument.getBeginLoc()), "utility",
/*IsAngled=*/true)) /*IsAngled=*/true))
Diag << *IncludeFixit; Diag << *IncludeFixit;
} }
} // namespace performance } // namespace performance
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/readability/AvoidConstParamsInDecls.cpp

Show All 16 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
namespace { namespace {
SourceRange getTypeRange(const ParmVarDecl &Param) { SourceRange getTypeRange(const ParmVarDecl &Param) {
if (Param.getIdentifier() != nullptr) if (Param.getIdentifier() != nullptr)
return SourceRange(Param.getLocStart(), return SourceRange(Param.getBeginLoc(),
Param.getLocEnd().getLocWithOffset(-1)); Param.getLocEnd().getLocWithOffset(-1));
return Param.getSourceRange(); return Param.getSourceRange();
} }
} // namespace } // namespace
void AvoidConstParamsInDecls::registerMatchers(MatchFinder *Finder) { void AvoidConstParamsInDecls::registerMatchers(MatchFinder *Finder) {
const auto ConstParamDecl = const auto ConstParamDecl =
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
void AvoidConstParamsInDecls::check(const MatchFinder::MatchResult &Result) { void AvoidConstParamsInDecls::check(const MatchFinder::MatchResult &Result) {
const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func"); const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func");
const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param"); const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param");
if (!Param->getType().isLocalConstQualified()) if (!Param->getType().isLocalConstQualified())
return; return;
auto Diag = diag(Param->getLocStart(), auto Diag = diag(Param->getBeginLoc(),
"parameter %0 is const-qualified in the function " "parameter %0 is const-qualified in the function "
"declaration; const-qualification of parameters only has an " "declaration; const-qualification of parameters only has an "
"effect in function definitions"); "effect in function definitions");
if (Param->getName().empty()) { if (Param->getName().empty()) {
for (unsigned int i = 0; i < Func->getNumParams(); ++i) { for (unsigned int i = 0; i < Func->getNumParams(); ++i) {
if (Param == Func->getParamDecl(i)) { if (Param == Func->getParamDecl(i)) {
Diag << (i + 1); Diag << (i + 1);
break; break;
} }
} }
} else { } else {
Diag << Param; Diag << Param;
} }
if (Param->getLocStart().isMacroID() != Param->getLocEnd().isMacroID()) { if (Param->getBeginLoc().isMacroID() != Param->getLocEnd().isMacroID()) {
// Do not offer a suggestion if the part of the variable declaration comes // Do not offer a suggestion if the part of the variable declaration comes
// from a macro. // from a macro.
return; return;
} }
CharSourceRange FileRange = Lexer::makeFileCharRange( CharSourceRange FileRange = Lexer::makeFileCharRange(
CharSourceRange::getTokenRange(getTypeRange(*Param)), CharSourceRange::getTokenRange(getTypeRange(*Param)),
*Result.SourceManager, getLangOpts()); *Result.SourceManager, getLangOpts());
Show All 14 Lines

clang-tidy/readability/BracesAroundStatementsCheck.cpp

Show First 20 Lines • Show All 168 Lines • ▼ Show 20 Lines
/// Find location of right parenthesis closing condition. /// Find location of right parenthesis closing condition.
template <typename IfOrWhileStmt> template <typename IfOrWhileStmt>
SourceLocation SourceLocation
BracesAroundStatementsCheck::findRParenLoc(const IfOrWhileStmt *S, BracesAroundStatementsCheck::findRParenLoc(const IfOrWhileStmt *S,
const SourceManager &SM, const SourceManager &SM,
const ASTContext *Context) { const ASTContext *Context) {
// Skip macros. // Skip macros.
if (S->getLocStart().isMacroID()) if (S->getBeginLoc().isMacroID())
return SourceLocation(); return SourceLocation();
SourceLocation CondEndLoc = S->getCond()->getLocEnd(); SourceLocation CondEndLoc = S->getCond()->getLocEnd();
if (const DeclStmt *CondVar = S->getConditionVariableDeclStmt()) if (const DeclStmt *CondVar = S->getConditionVariableDeclStmt())
CondEndLoc = CondVar->getLocEnd(); CondEndLoc = CondVar->getLocEnd();
if (!CondEndLoc.isValid()) { if (!CondEndLoc.isValid()) {
return SourceLocation(); return SourceLocation();
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines CharSourceRange FileRange = Lexer::makeFileCharRange(
Context->getLangOpts()); Context->getLangOpts());
if (FileRange.isInvalid()) if (FileRange.isInvalid())
return false; return false;
// Convert InitialLoc to file location, if it's on the same macro expansion // Convert InitialLoc to file location, if it's on the same macro expansion
// level as the start of the statement. We also need file locations for // level as the start of the statement. We also need file locations for
// Lexer::getLocForEndOfToken working properly. // Lexer::getLocForEndOfToken working properly.
InitialLoc = Lexer::makeFileCharRange( InitialLoc = Lexer::makeFileCharRange(
CharSourceRange::getCharRange(InitialLoc, S->getLocStart()), CharSourceRange::getCharRange(InitialLoc, S->getBeginLoc()),
SM, Context->getLangOpts()) SM, Context->getLangOpts())
.getBegin(); .getBegin();
if (InitialLoc.isInvalid()) if (InitialLoc.isInvalid())
return false; return false;
SourceLocation StartLoc = SourceLocation StartLoc =
Lexer::getLocForEndOfToken(InitialLoc, 0, SM, Context->getLangOpts()); Lexer::getLocForEndOfToken(InitialLoc, 0, SM, Context->getLangOpts());
// StartLoc points at the location of the opening brace to be inserted. // StartLoc points at the location of the opening brace to be inserted.
Show All 35 Lines

clang-tidy/readability/ContainerSizeEmptyCheck.cpp

Show First 20 Lines • Show All 195 Lines • ▼ Show 20 Lines if (const auto *UnaryOp =
Hint = FixItHint::CreateReplacement(UnaryOp->getSourceRange(), Hint = FixItHint::CreateReplacement(UnaryOp->getSourceRange(),
ReplacementText); ReplacementText);
else else
Hint = FixItHint::CreateReplacement(MemberCall->getSourceRange(), Hint = FixItHint::CreateReplacement(MemberCall->getSourceRange(),
"!" + ReplacementText); "!" + ReplacementText);
} }
if (MemberCall) { if (MemberCall) {
diag(MemberCall->getLocStart(), diag(MemberCall->getBeginLoc(),
"the 'empty' method should be used to check " "the 'empty' method should be used to check "
"for emptiness instead of 'size'") "for emptiness instead of 'size'")
<< Hint; << Hint;
} else { } else {
diag(BinCmp->getLocStart(), diag(BinCmp->getBeginLoc(),
"the 'empty' method should be used to check " "the 'empty' method should be used to check "
"for emptiness instead of comparing to an empty object") "for emptiness instead of comparing to an empty object")
<< Hint; << Hint;
} }
const auto *Container = Result.Nodes.getNodeAs<NamedDecl>("container"); const auto *Container = Result.Nodes.getNodeAs<NamedDecl>("container");
const auto *Empty = Result.Nodes.getNodeAs<FunctionDecl>("empty"); const auto *Empty = Result.Nodes.getNodeAs<FunctionDecl>("empty");
diag(Empty->getLocation(), "method %0::empty() defined here", diag(Empty->getLocation(), "method %0::empty() defined here",
DiagnosticIDs::Note) DiagnosticIDs::Note)
<< Container; << Container;
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/readability/DeleteNullPointerCheck.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines Finder->addMatcher(
this); this);
} }
void DeleteNullPointerCheck::check(const MatchFinder::MatchResult &Result) { void DeleteNullPointerCheck::check(const MatchFinder::MatchResult &Result) {
const auto *IfWithDelete = Result.Nodes.getNodeAs<IfStmt>("ifWithDelete"); const auto *IfWithDelete = Result.Nodes.getNodeAs<IfStmt>("ifWithDelete");
const auto *Compound = Result.Nodes.getNodeAs<CompoundStmt>("compound"); const auto *Compound = Result.Nodes.getNodeAs<CompoundStmt>("compound");
auto Diag = diag( auto Diag = diag(
IfWithDelete->getLocStart(), IfWithDelete->getBeginLoc(),
"'if' statement is unnecessary; deleting null pointer has no effect"); "'if' statement is unnecessary; deleting null pointer has no effect");
if (IfWithDelete->getElse()) if (IfWithDelete->getElse())
return; return;
// FIXME: generate fixit for this case. // FIXME: generate fixit for this case.
Diag << FixItHint::CreateRemoval(CharSourceRange::getTokenRange( Diag << FixItHint::CreateRemoval(CharSourceRange::getTokenRange(
IfWithDelete->getLocStart(), IfWithDelete->getBeginLoc(),
Lexer::getLocForEndOfToken(IfWithDelete->getCond()->getLocEnd(), 0, Lexer::getLocForEndOfToken(IfWithDelete->getCond()->getLocEnd(), 0,
*Result.SourceManager, *Result.SourceManager,
Result.Context->getLangOpts()))); Result.Context->getLangOpts())));
if (Compound) { if (Compound) {
Diag << FixItHint::CreateRemoval( Diag << FixItHint::CreateRemoval(
CharSourceRange::getTokenRange(Compound->getLBracLoc())); CharSourceRange::getTokenRange(Compound->getLBracLoc()));
Diag << FixItHint::CreateRemoval( Diag << FixItHint::CreateRemoval(
CharSourceRange::getTokenRange(Compound->getRBracLoc())); CharSourceRange::getTokenRange(Compound->getRBracLoc()));
} }
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/readability/DeletedDefaultCheck.cpp

Show All 35 Lines
} }
void DeletedDefaultCheck::check(const MatchFinder::MatchResult &Result) { void DeletedDefaultCheck::check(const MatchFinder::MatchResult &Result) {
const StringRef Message = "%0 is explicitly defaulted but implicitly " const StringRef Message = "%0 is explicitly defaulted but implicitly "
"deleted, probably because %1; definition can " "deleted, probably because %1; definition can "
"either be removed or explicitly deleted"; "either be removed or explicitly deleted";
if (const auto *Constructor = if (const auto *Constructor =
Result.Nodes.getNodeAs<CXXConstructorDecl>("constructor")) { Result.Nodes.getNodeAs<CXXConstructorDecl>("constructor")) {
auto Diag = diag(Constructor->getLocStart(), Message); auto Diag = diag(Constructor->getBeginLoc(), Message);
if (Constructor->isDefaultConstructor()) { if (Constructor->isDefaultConstructor()) {
Diag << "default constructor" Diag << "default constructor"
<< "a non-static data member or a base class is lacking a default " << "a non-static data member or a base class is lacking a default "
"constructor"; "constructor";
} else if (Constructor->isCopyConstructor()) { } else if (Constructor->isCopyConstructor()) {
Diag << "copy constructor" Diag << "copy constructor"
<< "a non-static data member or a base class is not copyable"; << "a non-static data member or a base class is not copyable";
} else if (Constructor->isMoveConstructor()) { } else if (Constructor->isMoveConstructor()) {
Diag << "move constructor" Diag << "move constructor"
<< "a non-static data member or a base class is neither copyable " << "a non-static data member or a base class is neither copyable "
"nor movable"; "nor movable";
} }
} else if (const auto *Assignment = } else if (const auto *Assignment =
Result.Nodes.getNodeAs<CXXMethodDecl>("method-decl")) { Result.Nodes.getNodeAs<CXXMethodDecl>("method-decl")) {
diag(Assignment->getLocStart(), Message) diag(Assignment->getBeginLoc(), Message)
<< (Assignment->isCopyAssignmentOperator() ? "copy assignment operator" << (Assignment->isCopyAssignmentOperator() ? "copy assignment operator"
: "move assignment operator") : "move assignment operator")
<< "a base class or a non-static data member is not assignable, e.g. " << "a base class or a non-static data member is not assignable, e.g. "
"because the latter is marked 'const'"; "because the latter is marked 'const'";
} }
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/readability/FunctionSizeCheck.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines bool TraverseStmt(Stmt *Node) {
return true; return true;
} }
bool TraverseCompoundStmt(CompoundStmt *Node) { bool TraverseCompoundStmt(CompoundStmt *Node) {
// If this new compound statement is located in a compound statement, which // If this new compound statement is located in a compound statement, which
// is already nested NestingThreshold levels deep, record the start location // is already nested NestingThreshold levels deep, record the start location
// of this new compound statement. // of this new compound statement.
if (CurrentNestingLevel == Info.NestingThreshold) if (CurrentNestingLevel == Info.NestingThreshold)
Info.NestingThresholders.push_back(Node->getLocStart()); Info.NestingThresholders.push_back(Node->getBeginLoc());
++CurrentNestingLevel; ++CurrentNestingLevel;
Base::TraverseCompoundStmt(Node); Base::TraverseCompoundStmt(Node);
--CurrentNestingLevel; --CurrentNestingLevel;
return true; return true;
} }
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Linesvoid FunctionSizeCheck::check(const MatchFinder::MatchResult &Result) {
auto &FI = Visitor.Info; auto &FI = Visitor.Info;
if (FI.Statements == 0) if (FI.Statements == 0)
return; return;
// Count the lines including whitespace and comments. Really simple. // Count the lines including whitespace and comments. Really simple.
if (const Stmt *Body = Func->getBody()) { if (const Stmt *Body = Func->getBody()) {
SourceManager *SM = Result.SourceManager; SourceManager *SM = Result.SourceManager;
if (SM->isWrittenInSameFile(Body->getLocStart(), Body->getLocEnd())) { if (SM->isWrittenInSameFile(Body->getBeginLoc(), Body->getLocEnd())) {
FI.Lines = SM->getSpellingLineNumber(Body->getLocEnd()) - FI.Lines = SM->getSpellingLineNumber(Body->getLocEnd()) -
SM->getSpellingLineNumber(Body->getLocStart()); SM->getSpellingLineNumber(Body->getBeginLoc());
} }
} }
unsigned ActualNumberParameters = Func->getNumParams(); unsigned ActualNumberParameters = Func->getNumParams();
if (FI.Lines > LineThreshold || FI.Statements > StatementThreshold || if (FI.Lines > LineThreshold || FI.Statements > StatementThreshold ||
FI.Branches > BranchThreshold || FI.Branches > BranchThreshold ||
ActualNumberParameters > ParameterThreshold || ActualNumberParameters > ParameterThreshold ||
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

clang-tidy/readability/IdentifierNamingCheck.cpp

Show First 20 Lines • Show All 835 Lines • ▼ Show 20 Lines if (const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>("decl")) {
std::string KindName = fixupWithCase(StyleNames[SK], CT_LowerCase); std::string KindName = fixupWithCase(StyleNames[SK], CT_LowerCase);
std::replace(KindName.begin(), KindName.end(), '_', ' '); std::replace(KindName.begin(), KindName.end(), '_', ' ');
std::string Fixup = fixupWithStyle(Name, Style); std::string Fixup = fixupWithStyle(Name, Style);
if (StringRef(Fixup).equals(Name)) { if (StringRef(Fixup).equals(Name)) {
if (!IgnoreFailedSplit) { if (!IgnoreFailedSplit) {
LLVM_DEBUG(llvm::dbgs() LLVM_DEBUG(llvm::dbgs()
<< Decl->getLocStart().printToString(*Result.SourceManager) << Decl->getBeginLoc().printToString(*Result.SourceManager)
<< llvm::format(": unable to split words for %s '%s'\n", << llvm::format(": unable to split words for %s '%s'\n",
KindName.c_str(), Name.str().c_str())); KindName.c_str(), Name.str().c_str()));
} }
} else { } else {
NamingCheckFailure &Failure = NamingCheckFailures[NamingCheckId( NamingCheckFailure &Failure = NamingCheckFailures[NamingCheckId(
Decl->getLocation(), Decl->getNameAsString())]; Decl->getLocation(), Decl->getNameAsString())];
SourceRange Range = SourceRange Range =
DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation()) DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

clang-tidy/readability/ImplicitBoolConversionCheck.cpp

Show All 18 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
namespace { namespace {
AST_MATCHER(Stmt, isMacroExpansion) { AST_MATCHER(Stmt, isMacroExpansion) {
SourceManager &SM = Finder->getASTContext().getSourceManager(); SourceManager &SM = Finder->getASTContext().getSourceManager();
SourceLocation Loc = Node.getLocStart(); SourceLocation Loc = Node.getBeginLoc();
return SM.isMacroBodyExpansion(Loc) || SM.isMacroArgExpansion(Loc); return SM.isMacroBodyExpansion(Loc) || SM.isMacroArgExpansion(Loc);
} }
bool isNULLMacroExpansion(const Stmt *Statement, ASTContext &Context) { bool isNULLMacroExpansion(const Stmt *Statement, ASTContext &Context) {
SourceManager &SM = Context.getSourceManager(); SourceManager &SM = Context.getSourceManager();
const LangOptions &LO = Context.getLangOpts(); const LangOptions &LO = Context.getLangOpts();
SourceLocation Loc = Statement->getLocStart(); SourceLocation Loc = Statement->getBeginLoc();
return SM.isMacroBodyExpansion(Loc) && return SM.isMacroBodyExpansion(Loc) &&
Lexer::getImmediateMacroName(Loc, SM, LO) == "NULL"; Lexer::getImmediateMacroName(Loc, SM, LO) == "NULL";
} }
AST_MATCHER(Stmt, isNULLMacroExpansion) { AST_MATCHER(Stmt, isNULLMacroExpansion) {
return isNULLMacroExpansion(&Node, Finder->getASTContext()); return isNULLMacroExpansion(&Node, Finder->getASTContext());
} }
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
void fixGenericExprCastToBool(DiagnosticBuilder &Diag, void fixGenericExprCastToBool(DiagnosticBuilder &Diag,
const ImplicitCastExpr *Cast, const Stmt *Parent, const ImplicitCastExpr *Cast, const Stmt *Parent,
ASTContext &Context) { ASTContext &Context) {
// In case of expressions like (! integer), we should remove the redundant not // In case of expressions like (! integer), we should remove the redundant not
// operator and use inverted comparison (integer == 0). // operator and use inverted comparison (integer == 0).
bool InvertComparison = bool InvertComparison =
Parent != nullptr && isUnaryLogicalNotOperator(Parent); Parent != nullptr && isUnaryLogicalNotOperator(Parent);
if (InvertComparison) { if (InvertComparison) {
SourceLocation ParentStartLoc = Parent->getLocStart(); SourceLocation ParentStartLoc = Parent->getBeginLoc();
SourceLocation ParentEndLoc = SourceLocation ParentEndLoc =
cast<UnaryOperator>(Parent)->getSubExpr()->getLocStart(); cast<UnaryOperator>(Parent)->getSubExpr()->getBeginLoc();
Diag << FixItHint::CreateRemoval( Diag << FixItHint::CreateRemoval(
CharSourceRange::getCharRange(ParentStartLoc, ParentEndLoc)); CharSourceRange::getCharRange(ParentStartLoc, ParentEndLoc));
Parent = Context.getParents(*Parent)[0].get<Stmt>(); Parent = Context.getParents(*Parent)[0].get<Stmt>();
} }
const Expr *SubExpr = Cast->getSubExpr(); const Expr *SubExpr = Cast->getSubExpr();
bool NeedInnerParens = areParensNeededForStatement(SubExpr); bool NeedInnerParens = areParensNeededForStatement(SubExpr);
bool NeedOuterParens = bool NeedOuterParens =
Parent != nullptr && areParensNeededForStatement(Parent); Parent != nullptr && areParensNeededForStatement(Parent);
std::string StartLocInsertion; std::string StartLocInsertion;
if (NeedOuterParens) { if (NeedOuterParens) {
StartLocInsertion += "("; StartLocInsertion += "(";
} }
if (NeedInnerParens) { if (NeedInnerParens) {
StartLocInsertion += "("; StartLocInsertion += "(";
} }
if (!StartLocInsertion.empty()) { if (!StartLocInsertion.empty()) {
Diag << FixItHint::CreateInsertion(Cast->getLocStart(), StartLocInsertion); Diag << FixItHint::CreateInsertion(Cast->getBeginLoc(), StartLocInsertion);
} }
std::string EndLocInsertion; std::string EndLocInsertion;
if (NeedInnerParens) { if (NeedInnerParens) {
EndLocInsertion += ")"; EndLocInsertion += ")";
} }
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
void fixGenericExprCastFromBool(DiagnosticBuilder &Diag, void fixGenericExprCastFromBool(DiagnosticBuilder &Diag,
const ImplicitCastExpr *Cast, const ImplicitCastExpr *Cast,
ASTContext &Context, StringRef OtherType) { ASTContext &Context, StringRef OtherType) {
const Expr *SubExpr = Cast->getSubExpr(); const Expr *SubExpr = Cast->getSubExpr();
bool NeedParens = !isa<ParenExpr>(SubExpr); bool NeedParens = !isa<ParenExpr>(SubExpr);
Diag << FixItHint::CreateInsertion( Diag << FixItHint::CreateInsertion(
Cast->getLocStart(), Cast->getBeginLoc(),
(Twine("static_cast<") + OtherType + ">" + (NeedParens ? "(" : "")) (Twine("static_cast<") + OtherType + ">" + (NeedParens ? "(" : ""))
.str()); .str());
if (NeedParens) { if (NeedParens) {
SourceLocation EndLoc = Lexer::getLocForEndOfToken( SourceLocation EndLoc = Lexer::getLocForEndOfToken(
Cast->getLocEnd(), 0, Context.getSourceManager(), Cast->getLocEnd(), 0, Context.getSourceManager(),
Context.getLangOpts()); Context.getLangOpts());
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Lines if (AllowPointerConditions &&
return; return;
} }
if (AllowIntegerConditions && Cast->getCastKind() == CK_IntegralToBoolean && if (AllowIntegerConditions && Cast->getCastKind() == CK_IntegralToBoolean &&
isCastAllowedInCondition(Cast, Context)) { isCastAllowedInCondition(Cast, Context)) {
return; return;
} }
auto Diag = diag(Cast->getLocStart(), "implicit conversion %0 -> bool") auto Diag = diag(Cast->getBeginLoc(), "implicit conversion %0 -> bool")
<< Cast->getSubExpr()->getType(); << Cast->getSubExpr()->getType();
StringRef EquivalentLiteral = StringRef EquivalentLiteral =
getEquivalentBoolLiteralForExpr(Cast->getSubExpr(), Context); getEquivalentBoolLiteralForExpr(Cast->getSubExpr(), Context);
if (!EquivalentLiteral.empty()) { if (!EquivalentLiteral.empty()) {
Diag << tooling::fixit::createReplacement(*Cast, EquivalentLiteral); Diag << tooling::fixit::createReplacement(*Cast, EquivalentLiteral);
} else { } else {
fixGenericExprCastToBool(Diag, Cast, Parent, Context); fixGenericExprCastToBool(Diag, Cast, Parent, Context);
} }
} }
void ImplicitBoolConversionCheck::handleCastFromBool( void ImplicitBoolConversionCheck::handleCastFromBool(
const ImplicitCastExpr *Cast, const ImplicitCastExpr *NextImplicitCast, const ImplicitCastExpr *Cast, const ImplicitCastExpr *NextImplicitCast,
ASTContext &Context) { ASTContext &Context) {
QualType DestType = QualType DestType =
NextImplicitCast ? NextImplicitCast->getType() : Cast->getType(); NextImplicitCast ? NextImplicitCast->getType() : Cast->getType();
auto Diag = diag(Cast->getLocStart(), "implicit conversion bool -> %0") auto Diag = diag(Cast->getBeginLoc(), "implicit conversion bool -> %0")
<< DestType; << DestType;
if (const auto *BoolLiteral = if (const auto *BoolLiteral =
dyn_cast<CXXBoolLiteralExpr>(Cast->getSubExpr())) { dyn_cast<CXXBoolLiteralExpr>(Cast->getSubExpr())) {
Diag << tooling::fixit::createReplacement( Diag << tooling::fixit::createReplacement(
*Cast, getEquivalentForBoolLiteral(BoolLiteral, DestType, Context)); *Cast, getEquivalentForBoolLiteral(BoolLiteral, DestType, Context));
} else { } else {
fixGenericExprCastFromBool(Diag, Cast, Context, DestType.getAsString()); fixGenericExprCastFromBool(Diag, Cast, Context, DestType.getAsString());
} }
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

Show First 20 Lines • Show All 318 Lines • ▼ Show 20 Lines InconsistentDeclarationsContainer InconsistentDeclarations =
ParameterSourceDeclaration, ParameterSourceDeclaration,
*Result.SourceManager, Strict); *Result.SourceManager, Strict);
if (InconsistentDeclarations.empty()) { if (InconsistentDeclarations.empty()) {
// Avoid unnecessary further visits. // Avoid unnecessary further visits.
markRedeclarationsAsVisited(OriginalDeclaration); markRedeclarationsAsVisited(OriginalDeclaration);
return; return;
} }
SourceLocation StartLoc = OriginalDeclaration->getLocStart(); SourceLocation StartLoc = OriginalDeclaration->getBeginLoc();
if (StartLoc.isMacroID() && IgnoreMacros) { if (StartLoc.isMacroID() && IgnoreMacros) {
markRedeclarationsAsVisited(OriginalDeclaration); markRedeclarationsAsVisited(OriginalDeclaration);
return; return;
} }
if (OriginalDeclaration->getTemplatedKind() == if (OriginalDeclaration->getTemplatedKind() ==
FunctionDecl::TK_FunctionTemplateSpecialization) { FunctionDecl::TK_FunctionTemplateSpecialization) {
formatDiagnostics(this, ParameterSourceDeclaration, OriginalDeclaration, formatDiagnostics(this, ParameterSourceDeclaration, OriginalDeclaration,
Show All 25 Lines

clang-tidy/readability/MisleadingIndentationCheck.cpp

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines if (const auto *CurrentIf = dyn_cast<IfStmt>(CurrentStmt)) {
Inner = CurrentWhile->getBody(); Inner = CurrentWhile->getBody();
} else { } else {
continue; continue;
} }
if (isa<CompoundStmt>(Inner)) if (isa<CompoundStmt>(Inner))
continue; continue;
SourceLocation InnerLoc = Inner->getLocStart(); SourceLocation InnerLoc = Inner->getBeginLoc();
SourceLocation OuterLoc = CurrentStmt->getLocStart(); SourceLocation OuterLoc = CurrentStmt->getBeginLoc();
if (SM.getExpansionLineNumber(InnerLoc) == if (SM.getExpansionLineNumber(InnerLoc) ==
SM.getExpansionLineNumber(OuterLoc)) SM.getExpansionLineNumber(OuterLoc))
continue; continue;
const Stmt *NextStmt = CStmt->body_begin()[i + 1]; const Stmt *NextStmt = CStmt->body_begin()[i + 1];
SourceLocation NextLoc = NextStmt->getLocStart(); SourceLocation NextLoc = NextStmt->getBeginLoc();
if (InnerLoc.isMacroID() || OuterLoc.isMacroID() || NextLoc.isMacroID()) if (InnerLoc.isMacroID() || OuterLoc.isMacroID() || NextLoc.isMacroID())
continue; continue;
if (SM.getExpansionColumnNumber(InnerLoc) == if (SM.getExpansionColumnNumber(InnerLoc) ==
SM.getExpansionColumnNumber(NextLoc)) { SM.getExpansionColumnNumber(NextLoc)) {
diag(NextLoc, "misleading indentation: statement is indented too deeply"); diag(NextLoc, "misleading indentation: statement is indented too deeply");
diag(OuterLoc, "did you mean this line to be inside this '%0'", diag(OuterLoc, "did you mean this line to be inside this '%0'",
Show All 25 Lines

clang-tidy/readability/MisplacedArrayIndexCheck.cpp

Show All 24 Lines Finder->addMatcher(arraySubscriptExpr(hasLHS(hasType(isInteger())),
.bind("expr"), .bind("expr"),
this); this);
} }
void MisplacedArrayIndexCheck::check(const MatchFinder::MatchResult &Result) { void MisplacedArrayIndexCheck::check(const MatchFinder::MatchResult &Result) {
const auto *ArraySubscriptE = const auto *ArraySubscriptE =
Result.Nodes.getNodeAs<ArraySubscriptExpr>("expr"); Result.Nodes.getNodeAs<ArraySubscriptExpr>("expr");
auto Diag = diag(ArraySubscriptE->getLocStart(), "confusing array subscript " auto Diag = diag(ArraySubscriptE->getBeginLoc(), "confusing array subscript "
"expression, usually the " "expression, usually the "
"index is inside the []"); "index is inside the []");
// Only try to fixit when LHS and RHS can be swapped directly without changing // Only try to fixit when LHS and RHS can be swapped directly without changing
// the logic. // the logic.
const Expr *RHSE = ArraySubscriptE->getRHS()->IgnoreParenImpCasts(); const Expr *RHSE = ArraySubscriptE->getRHS()->IgnoreParenImpCasts();
if (!isa<StringLiteral>(RHSE) && !isa<DeclRefExpr>(RHSE) && if (!isa<StringLiteral>(RHSE) && !isa<DeclRefExpr>(RHSE) &&
!isa<MemberExpr>(RHSE)) !isa<MemberExpr>(RHSE))
Show All 16 Lines

clang-tidy/readability/NamedParameterCheck.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines for (unsigned I = 0, E = Function->getNumParams(); I != E; ++I) {
// Don't warn on the dummy argument on post-inc and post-dec operators. // Don't warn on the dummy argument on post-inc and post-dec operators.
if ((Function->getOverloadedOperator() == OO_PlusPlus || if ((Function->getOverloadedOperator() == OO_PlusPlus ||
Function->getOverloadedOperator() == OO_MinusMinus) && Function->getOverloadedOperator() == OO_MinusMinus) &&
Parm->getType()->isSpecificBuiltinType(BuiltinType::Int)) Parm->getType()->isSpecificBuiltinType(BuiltinType::Int))
continue; continue;
// Sanity check the source locations. // Sanity check the source locations.
if (!Parm->getLocation().isValid() || Parm->getLocation().isMacroID() || if (!Parm->getLocation().isValid() || Parm->getLocation().isMacroID() ||
!SM.isWrittenInSameFile(Parm->getLocStart(), Parm->getLocation())) !SM.isWrittenInSameFile(Parm->getBeginLoc(), Parm->getLocation()))
continue; continue;
// Skip gmock testing::Unused parameters. // Skip gmock testing::Unused parameters.
if (auto Typedef = Parm->getType()->getAs<clang::TypedefType>()) if (auto Typedef = Parm->getType()->getAs<clang::TypedefType>())
if (Typedef->getDecl()->getQualifiedNameAsString() == "testing::Unused") if (Typedef->getDecl()->getQualifiedNameAsString() == "testing::Unused")
continue; continue;
// Skip std::nullptr_t. // Skip std::nullptr_t.
if (Parm->getType().getCanonicalType()->isNullPtrType()) if (Parm->getType().getCanonicalType()->isNullPtrType())
continue; continue;
// Look for comments. We explicitly want to allow idioms like // Look for comments. We explicitly want to allow idioms like
// void foo(int /*unused*/) // void foo(int /*unused*/)
const char *Begin = SM.getCharacterData(Parm->getLocStart()); const char *Begin = SM.getCharacterData(Parm->getBeginLoc());
const char *End = SM.getCharacterData(Parm->getLocation()); const char *End = SM.getCharacterData(Parm->getLocation());
StringRef Data(Begin, End - Begin); StringRef Data(Begin, End - Begin);
if (Data.find("/*") != StringRef::npos) if (Data.find("/*") != StringRef::npos)
continue; continue;
UnnamedParams.push_back(std::make_pair(Function, I)); UnnamedParams.push_back(std::make_pair(Function, I));
} }
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

clang-tidy/readability/NamespaceCommentCheck.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines if (InsertLineBreak)
Fix.append("\n"); Fix.append("\n");
return Fix; return Fix;
} }
void NamespaceCommentCheck::check(const MatchFinder::MatchResult &Result) { void NamespaceCommentCheck::check(const MatchFinder::MatchResult &Result) {
const auto *ND = Result.Nodes.getNodeAs<NamespaceDecl>("namespace"); const auto *ND = Result.Nodes.getNodeAs<NamespaceDecl>("namespace");
const SourceManager &Sources = *Result.SourceManager; const SourceManager &Sources = *Result.SourceManager;
if (!locationsInSameFile(Sources, ND->getLocStart(), ND->getRBraceLoc())) if (!locationsInSameFile(Sources, ND->getBeginLoc(), ND->getRBraceLoc()))
return; return;
// Don't require closing comments for namespaces spanning less than certain // Don't require closing comments for namespaces spanning less than certain
// number of lines. // number of lines.
unsigned StartLine = Sources.getSpellingLineNumber(ND->getLocStart()); unsigned StartLine = Sources.getSpellingLineNumber(ND->getBeginLoc());
unsigned EndLine = Sources.getSpellingLineNumber(ND->getRBraceLoc()); unsigned EndLine = Sources.getSpellingLineNumber(ND->getRBraceLoc());
if (EndLine - StartLine + 1 <= ShortNamespaceLines) if (EndLine - StartLine + 1 <= ShortNamespaceLines)
return; return;
// Find next token after the namespace closing brace. // Find next token after the namespace closing brace.
SourceLocation AfterRBrace = ND->getRBraceLoc().getLocWithOffset(1); SourceLocation AfterRBrace = ND->getRBraceLoc().getLocWithOffset(1);
SourceLocation Loc = AfterRBrace; SourceLocation Loc = AfterRBrace;
Token Tok; Token Tok;
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

clang-tidy/readability/NonConstParameterCheck.cpp

Show First 20 Lines • Show All 140 Lines • ▼ Show 20 Lines for (const auto &It : Parameters) {
SmallVector<FixItHint, 8> Fixes; SmallVector<FixItHint, 8> Fixes;
auto *Function = auto *Function =
dyn_cast_or_null<const FunctionDecl>(Par->getParentFunctionOrMethod()); dyn_cast_or_null<const FunctionDecl>(Par->getParentFunctionOrMethod());
if (!Function) if (!Function)
continue; continue;
unsigned Index = Par->getFunctionScopeIndex(); unsigned Index = Par->getFunctionScopeIndex();
for (FunctionDecl *FnDecl : Function->redecls()) for (FunctionDecl *FnDecl : Function->redecls())
Fixes.push_back(FixItHint::CreateInsertion( Fixes.push_back(FixItHint::CreateInsertion(
FnDecl->getParamDecl(Index)->getLocStart(), "const ")); FnDecl->getParamDecl(Index)->getBeginLoc(), "const "));
diag(Par->getLocation(), "pointer parameter '%0' can be pointer to const") diag(Par->getLocation(), "pointer parameter '%0' can be pointer to const")
<< Par->getName() << Fixes; << Par->getName() << Fixes;
} }
} }
void NonConstParameterCheck::markCanNotBeConst(const Expr *E, void NonConstParameterCheck::markCanNotBeConst(const Expr *E,
bool CanNotBeConst) { bool CanNotBeConst) {
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

clang-tidy/readability/RedundantDeclarationCheck.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Linesvoid RedundantDeclarationCheck::check(const MatchFinder::MatchResult &Result) {
const bool DifferentHeaders = const bool DifferentHeaders =
!SM.isInMainFile(D->getLocation()) && !SM.isInMainFile(D->getLocation()) &&
!SM.isWrittenInSameFile(Prev->getLocation(), D->getLocation()); !SM.isWrittenInSameFile(Prev->getLocation(), D->getLocation());
bool MultiVar = false; bool MultiVar = false;
if (const auto *VD = dyn_cast<VarDecl>(D)) { if (const auto *VD = dyn_cast<VarDecl>(D)) {
// Is this a multivariable declaration? // Is this a multivariable declaration?
for (const auto Other : VD->getDeclContext()->decls()) { for (const auto Other : VD->getDeclContext()->decls()) {
if (Other != D && Other->getLocStart() == VD->getLocStart()) { if (Other != D && Other->getBeginLoc() == VD->getBeginLoc()) {
MultiVar = true; MultiVar = true;
break; break;
} }
} }
} }
SourceLocation EndLoc = Lexer::getLocForEndOfToken( SourceLocation EndLoc = Lexer::getLocForEndOfToken(
D->getSourceRange().getEnd(), 0, SM, Result.Context->getLangOpts()); D->getSourceRange().getEnd(), 0, SM, Result.Context->getLangOpts());
Show All 12 Lines

clang-tidy/readability/RedundantSmartptrGetCheck.cpp

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 Lines if (IsPtrToPtr && IsMemberExpr) {
return; return;
} }
StringRef SmartptrText = Lexer::getSourceText( StringRef SmartptrText = Lexer::getSourceText(
CharSourceRange::getTokenRange(Smartptr->getSourceRange()), CharSourceRange::getTokenRange(Smartptr->getSourceRange()),
*Result.SourceManager, getLangOpts()); *Result.SourceManager, getLangOpts());
// Replace foo->get() with *foo, and foo.get() with foo. // Replace foo->get() with *foo, and foo.get() with foo.
std::string Replacement = Twine(IsPtrToPtr ? "*" : "", SmartptrText).str(); std::string Replacement = Twine(IsPtrToPtr ? "*" : "", SmartptrText).str();
diag(GetCall->getLocStart(), "redundant get() call on smart pointer") diag(GetCall->getBeginLoc(), "redundant get() call on smart pointer")
<< FixItHint::CreateReplacement(GetCall->getSourceRange(), Replacement); << FixItHint::CreateReplacement(GetCall->getSourceRange(), Replacement);
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/readability/RedundantStringCStrCheck.cpp

Show First 20 Lines • Show All 183 Lines • ▼ Show 20 Linesvoid RedundantStringCStrCheck::check(const MatchFinder::MatchResult &Result) {
bool Arrow = Member->isArrow(); bool Arrow = Member->isArrow();
// Replace the "call" node with the "arg" node, prefixed with '*' // Replace the "call" node with the "arg" node, prefixed with '*'
// if the call was using '->' rather than '.'. // if the call was using '->' rather than '.'.
std::string ArgText = std::string ArgText =
Arrow ? formatDereference(Result, *Arg) : getText(Result, *Arg).str(); Arrow ? formatDereference(Result, *Arg) : getText(Result, *Arg).str();
if (ArgText.empty()) if (ArgText.empty())
return; return;
diag(Call->getLocStart(), "redundant call to %0") diag(Call->getBeginLoc(), "redundant call to %0")
<< Member->getMemberDecl() << Member->getMemberDecl()
<< FixItHint::CreateReplacement(Call->getSourceRange(), ArgText); << FixItHint::CreateReplacement(Call->getSourceRange(), ArgText);
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/readability/SimplifyBooleanExprCheck.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
const char SimplifyConditionDiagnostic[] = const char SimplifyConditionDiagnostic[] =
"redundant boolean literal in if statement condition"; "redundant boolean literal in if statement condition";
const char SimplifyConditionalReturnDiagnostic[] = const char SimplifyConditionalReturnDiagnostic[] =
"redundant boolean literal in conditional return statement"; "redundant boolean literal in conditional return statement";
const CXXBoolLiteralExpr *getBoolLiteral(const MatchFinder::MatchResult &Result, const CXXBoolLiteralExpr *getBoolLiteral(const MatchFinder::MatchResult &Result,
StringRef Id) { StringRef Id) {
const auto *Literal = Result.Nodes.getNodeAs<CXXBoolLiteralExpr>(Id); const auto *Literal = Result.Nodes.getNodeAs<CXXBoolLiteralExpr>(Id);
return (Literal && Literal->getLocStart().isMacroID()) ? nullptr : Literal; return (Literal && Literal->getBeginLoc().isMacroID()) ? nullptr : Literal;
} }
internal::Matcher<Stmt> returnsBool(bool Value, StringRef Id = "ignored") { internal::Matcher<Stmt> returnsBool(bool Value, StringRef Id = "ignored") {
auto SimpleReturnsBool = auto SimpleReturnsBool =
returnStmt(has(cxxBoolLiteral(equals(Value)).bind(Id))) returnStmt(has(cxxBoolLiteral(equals(Value)).bind(Id)))
.bind("returns-bool"); .bind("returns-bool");
return anyOf(SimpleReturnsBool, return anyOf(SimpleReturnsBool,
compoundStmt(statementCountIs(1), has(SimpleReturnsBool))); compoundStmt(statementCountIs(1), has(SimpleReturnsBool)));
▲ Show 20 Lines • Show All 293 Lines • ▼ Show 20 Linesvoid SimplifyBooleanExprCheck::reportBinOp(
const Expr *Other = nullptr; const Expr *Other = nullptr;
if ((Bool = dyn_cast<CXXBoolLiteralExpr>(LHS))) if ((Bool = dyn_cast<CXXBoolLiteralExpr>(LHS)))
Other = RHS; Other = RHS;
else if ((Bool = dyn_cast<CXXBoolLiteralExpr>(RHS))) else if ((Bool = dyn_cast<CXXBoolLiteralExpr>(RHS)))
Other = LHS; Other = LHS;
else else
return; return;
if (Bool->getLocStart().isMacroID()) if (Bool->getBeginLoc().isMacroID())
return; return;
// FIXME: why do we need this? // FIXME: why do we need this?
if (!isa<CXXBoolLiteralExpr>(Other) && containsBoolLiteral(Other)) if (!isa<CXXBoolLiteralExpr>(Other) && containsBoolLiteral(Other))
return; return;
bool BoolValue = Bool->getValue(); bool BoolValue = Bool->getValue();
auto replaceWithExpression = [this, &Result, LHS, RHS, Bool]( auto replaceWithExpression = [this, &Result, LHS, RHS, Bool](
const Expr *ReplaceWith, bool Negated) { const Expr *ReplaceWith, bool Negated) {
std::string Replacement = std::string Replacement =
replacementExpression(Result, Negated, ReplaceWith); replacementExpression(Result, Negated, ReplaceWith);
SourceRange Range(LHS->getLocStart(), RHS->getLocEnd()); SourceRange Range(LHS->getBeginLoc(), RHS->getLocEnd());
issueDiag(Result, Bool->getLocStart(), SimplifyOperatorDiagnostic, Range, issueDiag(Result, Bool->getBeginLoc(), SimplifyOperatorDiagnostic, Range,
Replacement); Replacement);
}; };
switch (Op->getOpcode()) { switch (Op->getOpcode()) {
case BO_LAnd: case BO_LAnd:
if (BoolValue) { if (BoolValue) {
// expr && true -> expr // expr && true -> expr
replaceWithExpression(Other, /*Negated=*/false); replaceWithExpression(Other, /*Negated=*/false);
▲ Show 20 Lines • Show All 174 Lines • ▼ Show 20 Linesvoid SimplifyBooleanExprCheck::issueDiag(
if (!containsDiscardedTokens(Result, CharRange)) if (!containsDiscardedTokens(Result, CharRange))
Diag << FixItHint::CreateReplacement(CharRange, Replacement); Diag << FixItHint::CreateReplacement(CharRange, Replacement);
} }
void SimplifyBooleanExprCheck::replaceWithThenStatement( void SimplifyBooleanExprCheck::replaceWithThenStatement(
const MatchFinder::MatchResult &Result, const MatchFinder::MatchResult &Result,
const CXXBoolLiteralExpr *TrueConditionRemoved) { const CXXBoolLiteralExpr *TrueConditionRemoved) {
const auto *IfStatement = Result.Nodes.getNodeAs<IfStmt>(IfStmtId); const auto *IfStatement = Result.Nodes.getNodeAs<IfStmt>(IfStmtId);
issueDiag(Result, TrueConditionRemoved->getLocStart(), issueDiag(Result, TrueConditionRemoved->getBeginLoc(),
SimplifyConditionDiagnostic, IfStatement->getSourceRange(), SimplifyConditionDiagnostic, IfStatement->getSourceRange(),
getText(Result, *IfStatement->getThen())); getText(Result, *IfStatement->getThen()));
} }
void SimplifyBooleanExprCheck::replaceWithElseStatement( void SimplifyBooleanExprCheck::replaceWithElseStatement(
const MatchFinder::MatchResult &Result, const MatchFinder::MatchResult &Result,
const CXXBoolLiteralExpr *FalseConditionRemoved) { const CXXBoolLiteralExpr *FalseConditionRemoved) {
const auto *IfStatement = Result.Nodes.getNodeAs<IfStmt>(IfStmtId); const auto *IfStatement = Result.Nodes.getNodeAs<IfStmt>(IfStmtId);
const Stmt *ElseStatement = IfStatement->getElse(); const Stmt *ElseStatement = IfStatement->getElse();
issueDiag(Result, FalseConditionRemoved->getLocStart(), issueDiag(Result, FalseConditionRemoved->getBeginLoc(),
SimplifyConditionDiagnostic, IfStatement->getSourceRange(), SimplifyConditionDiagnostic, IfStatement->getSourceRange(),
ElseStatement ? getText(Result, *ElseStatement) : ""); ElseStatement ? getText(Result, *ElseStatement) : "");
} }
void SimplifyBooleanExprCheck::replaceWithCondition( void SimplifyBooleanExprCheck::replaceWithCondition(
const MatchFinder::MatchResult &Result, const ConditionalOperator *Ternary, const MatchFinder::MatchResult &Result, const ConditionalOperator *Ternary,
bool Negated) { bool Negated) {
std::string Replacement = std::string Replacement =
replacementExpression(Result, Negated, Ternary->getCond()); replacementExpression(Result, Negated, Ternary->getCond());
issueDiag(Result, Ternary->getTrueExpr()->getLocStart(), issueDiag(Result, Ternary->getTrueExpr()->getBeginLoc(),
"redundant boolean literal in ternary expression result", "redundant boolean literal in ternary expression result",
Ternary->getSourceRange(), Replacement); Ternary->getSourceRange(), Replacement);
} }
void SimplifyBooleanExprCheck::replaceWithReturnCondition( void SimplifyBooleanExprCheck::replaceWithReturnCondition(
const MatchFinder::MatchResult &Result, const IfStmt *If, bool Negated) { const MatchFinder::MatchResult &Result, const IfStmt *If, bool Negated) {
StringRef Terminator = isa<CompoundStmt>(If->getElse()) ? ";" : ""; StringRef Terminator = isa<CompoundStmt>(If->getElse()) ? ";" : "";
std::string Condition = replacementExpression(Result, Negated, If->getCond()); std::string Condition = replacementExpression(Result, Negated, If->getCond());
std::string Replacement = ("return " + Condition + Terminator).str(); std::string Replacement = ("return " + Condition + Terminator).str();
SourceLocation Start = SourceLocation Start =
Result.Nodes.getNodeAs<CXXBoolLiteralExpr>(ThenLiteralId)->getLocStart(); Result.Nodes.getNodeAs<CXXBoolLiteralExpr>(ThenLiteralId)->getBeginLoc();
issueDiag(Result, Start, SimplifyConditionalReturnDiagnostic, issueDiag(Result, Start, SimplifyConditionalReturnDiagnostic,
If->getSourceRange(), Replacement); If->getSourceRange(), Replacement);
} }
void SimplifyBooleanExprCheck::replaceCompoundReturnWithCondition( void SimplifyBooleanExprCheck::replaceCompoundReturnWithCondition(
const MatchFinder::MatchResult &Result, const CompoundStmt *Compound, const MatchFinder::MatchResult &Result, const CompoundStmt *Compound,
bool Negated) { bool Negated) {
const auto *Ret = Result.Nodes.getNodeAs<ReturnStmt>(CompoundReturnId); const auto *Ret = Result.Nodes.getNodeAs<ReturnStmt>(CompoundReturnId);
Show All 15 Lines if (const auto *If = dyn_cast<IfStmt>(*Current)) {
if (*After == Ret) { if (*After == Ret) {
if (!ChainedConditionalReturn && BeforeIf) if (!ChainedConditionalReturn && BeforeIf)
continue; continue;
const Expr *Condition = If->getCond(); const Expr *Condition = If->getCond();
std::string Replacement = std::string Replacement =
"return " + replacementExpression(Result, Negated, Condition); "return " + replacementExpression(Result, Negated, Condition);
issueDiag( issueDiag(
Result, Lit->getLocStart(), SimplifyConditionalReturnDiagnostic, Result, Lit->getBeginLoc(), SimplifyConditionalReturnDiagnostic,
SourceRange(If->getLocStart(), Ret->getLocEnd()), Replacement); SourceRange(If->getBeginLoc(), Ret->getLocEnd()), Replacement);
return; return;
} }
BeforeIf = If; BeforeIf = If;
} }
} else { } else {
BeforeIf = nullptr; BeforeIf = nullptr;
} }
} }
} }
void SimplifyBooleanExprCheck::replaceWithAssignment( void SimplifyBooleanExprCheck::replaceWithAssignment(
const MatchFinder::MatchResult &Result, const IfStmt *IfAssign, const MatchFinder::MatchResult &Result, const IfStmt *IfAssign,
bool Negated) { bool Negated) {
SourceRange Range = IfAssign->getSourceRange(); SourceRange Range = IfAssign->getSourceRange();
StringRef VariableName = StringRef VariableName =
getText(Result, *Result.Nodes.getNodeAs<Expr>(IfAssignVariableId)); getText(Result, *Result.Nodes.getNodeAs<Expr>(IfAssignVariableId));
StringRef Terminator = isa<CompoundStmt>(IfAssign->getElse()) ? ";" : ""; StringRef Terminator = isa<CompoundStmt>(IfAssign->getElse()) ? ";" : "";
std::string Condition = std::string Condition =
replacementExpression(Result, Negated, IfAssign->getCond()); replacementExpression(Result, Negated, IfAssign->getCond());
std::string Replacement = std::string Replacement =
(VariableName + " = " + Condition + Terminator).str(); (VariableName + " = " + Condition + Terminator).str();
SourceLocation Location = SourceLocation Location =
Result.Nodes.getNodeAs<CXXBoolLiteralExpr>(IfAssignLocId)->getLocStart(); Result.Nodes.getNodeAs<CXXBoolLiteralExpr>(IfAssignLocId)->getBeginLoc();
issueDiag(Result, Location, issueDiag(Result, Location,
"redundant boolean literal in conditional assignment", Range, "redundant boolean literal in conditional assignment", Range,
Replacement); Replacement);
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/readability/SimplifySubscriptExprCheck.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines if (Result.Context->getSourceManager().isMacroBodyExpansion(
return; return;
const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member"); const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
auto DiagBuilder = auto DiagBuilder =
diag(Member->getMemberLoc(), diag(Member->getMemberLoc(),
"accessing an element of the container does not require a call to " "accessing an element of the container does not require a call to "
"'data()'; did you mean to use 'operator[]'?"); "'data()'; did you mean to use 'operator[]'?");
if (Member->isArrow()) if (Member->isArrow())
DiagBuilder << FixItHint::CreateInsertion(Member->getLocStart(), "(*") DiagBuilder << FixItHint::CreateInsertion(Member->getBeginLoc(), "(*")
<< FixItHint::CreateInsertion(Member->getOperatorLoc(), ")"); << FixItHint::CreateInsertion(Member->getOperatorLoc(), ")");
DiagBuilder << FixItHint::CreateRemoval( DiagBuilder << FixItHint::CreateRemoval(
{Member->getOperatorLoc(), Call->getLocEnd()}); {Member->getOperatorLoc(), Call->getLocEnd()});
} }
void SimplifySubscriptExprCheck::storeOptions( void SimplifySubscriptExprCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "Types", utils::options::serializeStringList(Types)); Options.store(Opts, "Types", utils::options::serializeStringList(Types));
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/readability/StaticAccessedThroughInstanceCheck.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines Finder->addMatcher(
this); this);
} }
void StaticAccessedThroughInstanceCheck::check( void StaticAccessedThroughInstanceCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *MemberExpression = const auto *MemberExpression =
Result.Nodes.getNodeAs<MemberExpr>("memberExpression"); Result.Nodes.getNodeAs<MemberExpr>("memberExpression");
if (MemberExpression->getLocStart().isMacroID()) if (MemberExpression->getBeginLoc().isMacroID())
return; return;
const Expr *BaseExpr = MemberExpression->getBase(); const Expr *BaseExpr = MemberExpression->getBase();
// Do not warn for overlaoded -> operators. // Do not warn for overlaoded -> operators.
if (isa<CXXOperatorCallExpr>(BaseExpr)) if (isa<CXXOperatorCallExpr>(BaseExpr))
return; return;
QualType BaseType = QualType BaseType =
BaseExpr->getType()->isPointerType() BaseExpr->getType()->isPointerType()
? BaseExpr->getType()->getPointeeType().getUnqualifiedType() ? BaseExpr->getType()->getPointeeType().getUnqualifiedType()
: BaseExpr->getType().getUnqualifiedType(); : BaseExpr->getType().getUnqualifiedType();
const ASTContext *AstContext = Result.Context; const ASTContext *AstContext = Result.Context;
PrintingPolicy PrintingPolicyWithSupressedTag(AstContext->getLangOpts()); PrintingPolicy PrintingPolicyWithSupressedTag(AstContext->getLangOpts());
PrintingPolicyWithSupressedTag.SuppressTagKeyword = true; PrintingPolicyWithSupressedTag.SuppressTagKeyword = true;
std::string BaseTypeName = std::string BaseTypeName =
BaseType.getAsString(PrintingPolicyWithSupressedTag); BaseType.getAsString(PrintingPolicyWithSupressedTag);
SourceLocation MemberExprStartLoc = MemberExpression->getLocStart(); SourceLocation MemberExprStartLoc = MemberExpression->getBeginLoc();
auto Diag = auto Diag =
diag(MemberExprStartLoc, "static member accessed through instance"); diag(MemberExprStartLoc, "static member accessed through instance");
if (BaseExpr->HasSideEffects(*AstContext) || if (BaseExpr->HasSideEffects(*AstContext) ||
getNameSpecifierNestingLevel(BaseType) > NameSpecifierNestingThreshold) getNameSpecifierNestingLevel(BaseType) > NameSpecifierNestingThreshold)
return; return;
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
CharSourceRange::getCharRange(MemberExprStartLoc, CharSourceRange::getCharRange(MemberExprStartLoc,
MemberExpression->getMemberLoc()), MemberExpression->getMemberLoc()),
BaseTypeName + "::"); BaseTypeName + "::");
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/readability/StringCompareCheck.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines Finder->addMatcher(
hasEitherOperand(StrCompare.bind("compare")), hasEitherOperand(StrCompare.bind("compare")),
hasEitherOperand(integerLiteral(equals(0)).bind("zero"))) hasEitherOperand(integerLiteral(equals(0)).bind("zero")))
.bind("match2"), .bind("match2"),
this); this);
} }
void StringCompareCheck::check(const MatchFinder::MatchResult &Result) { void StringCompareCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *Matched = Result.Nodes.getNodeAs<Stmt>("match1")) { if (const auto *Matched = Result.Nodes.getNodeAs<Stmt>("match1")) {
diag(Matched->getLocStart(), CompareMessage); diag(Matched->getBeginLoc(), CompareMessage);
return; return;
} }
if (const auto *Matched = Result.Nodes.getNodeAs<Stmt>("match2")) { if (const auto *Matched = Result.Nodes.getNodeAs<Stmt>("match2")) {
const ASTContext &Ctx = *Result.Context; const ASTContext &Ctx = *Result.Context;
if (const auto *Zero = Result.Nodes.getNodeAs<Stmt>("zero")) { if (const auto *Zero = Result.Nodes.getNodeAs<Stmt>("zero")) {
const auto *Str1 = Result.Nodes.getNodeAs<MemberExpr>("str1"); const auto *Str1 = Result.Nodes.getNodeAs<MemberExpr>("str1");
const auto *Str2 = Result.Nodes.getNodeAs<Stmt>("str2"); const auto *Str2 = Result.Nodes.getNodeAs<Stmt>("str2");
const auto *Compare = Result.Nodes.getNodeAs<Stmt>("compare"); const auto *Compare = Result.Nodes.getNodeAs<Stmt>("compare");
auto Diag = diag(Matched->getLocStart(), CompareMessage); auto Diag = diag(Matched->getBeginLoc(), CompareMessage);
if (Str1->isArrow()) if (Str1->isArrow())
Diag << FixItHint::CreateInsertion(Str1->getLocStart(), "*"); Diag << FixItHint::CreateInsertion(Str1->getBeginLoc(), "*");
Diag << tooling::fixit::createReplacement(*Zero, *Str2, Ctx) Diag << tooling::fixit::createReplacement(*Zero, *Str2, Ctx)
<< tooling::fixit::createReplacement(*Compare, *Str1->getBase(), << tooling::fixit::createReplacement(*Compare, *Str1->getBase(),
Ctx); Ctx);
} }
} }
// FIXME: Add fixit to fix the code for case one and two (match1). // FIXME: Add fixit to fix the code for case one and two (match1).
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/readability/UniqueptrDeleteReleaseCheck.cpp

Show All 36 Lines Finder->addMatcher(
this); this);
} }
void UniqueptrDeleteReleaseCheck::check( void UniqueptrDeleteReleaseCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *PtrExpr = Result.Nodes.getNodeAs<Expr>("uptr"); const auto *PtrExpr = Result.Nodes.getNodeAs<Expr>("uptr");
const auto *DeleteExpr = Result.Nodes.getNodeAs<Expr>("delete"); const auto *DeleteExpr = Result.Nodes.getNodeAs<Expr>("delete");
if (PtrExpr->getLocStart().isMacroID()) if (PtrExpr->getBeginLoc().isMacroID())
return; return;
// Ignore dependent types. // Ignore dependent types.
// It can give us false positives, so we go with false negatives instead to // It can give us false positives, so we go with false negatives instead to
// be safe. // be safe.
if (PtrExpr->getType()->isDependentType()) if (PtrExpr->getType()->isDependentType())
return; return;
SourceLocation AfterPtr = Lexer::getLocForEndOfToken( SourceLocation AfterPtr = Lexer::getLocForEndOfToken(
PtrExpr->getLocEnd(), 0, *Result.SourceManager, getLangOpts()); PtrExpr->getLocEnd(), 0, *Result.SourceManager, getLangOpts());
diag(DeleteExpr->getLocStart(), diag(DeleteExpr->getBeginLoc(),
"prefer '= nullptr' to 'delete x.release()' to reset unique_ptr<> " "prefer '= nullptr' to 'delete x.release()' to reset unique_ptr<> "
"objects") "objects")
<< FixItHint::CreateRemoval(CharSourceRange::getCharRange( << FixItHint::CreateRemoval(CharSourceRange::getCharRange(
DeleteExpr->getLocStart(), PtrExpr->getLocStart())) DeleteExpr->getBeginLoc(), PtrExpr->getBeginLoc()))
<< FixItHint::CreateReplacement( << FixItHint::CreateReplacement(
CharSourceRange::getTokenRange(AfterPtr, DeleteExpr->getLocEnd()), CharSourceRange::getTokenRange(AfterPtr, DeleteExpr->getLocEnd()),
" = nullptr"); " = nullptr");
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/utils/ASTUtils.cpp

Show All 39 Linesbool IsBinaryOrTernary(const Expr *E) {
return false; return false;
} }
bool exprHasBitFlagWithSpelling(const Expr *Flags, const SourceManager &SM, bool exprHasBitFlagWithSpelling(const Expr *Flags, const SourceManager &SM,
const LangOptions &LangOpts, const LangOptions &LangOpts,
StringRef FlagName) { StringRef FlagName) {
// If the Flag is an integer constant, check it. // If the Flag is an integer constant, check it.
if (isa<IntegerLiteral>(Flags)) { if (isa<IntegerLiteral>(Flags)) {
if (!SM.isMacroBodyExpansion(Flags->getLocStart()) && if (!SM.isMacroBodyExpansion(Flags->getBeginLoc()) &&
!SM.isMacroArgExpansion(Flags->getLocStart())) !SM.isMacroArgExpansion(Flags->getBeginLoc()))
return false; return false;
// Get the macro name. // Get the macro name.
auto MacroName = Lexer::getSourceText( auto MacroName = Lexer::getSourceText(
CharSourceRange::getTokenRange(Flags->getSourceRange()), SM, LangOpts); CharSourceRange::getTokenRange(Flags->getSourceRange()), SM, LangOpts);
return MacroName == FlagName; return MacroName == FlagName;
} }
Show All 15 Lines

clang-tidy/utils/NamespaceAliaser.cpp

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines const auto HasConflictingAncestors =
.empty(); .empty();
if (HasConflictingAncestors || HasConflictingChildren) if (HasConflictingAncestors || HasConflictingChildren)
continue; continue;
std::string Declaration = std::string Declaration =
(llvm::Twine("\nnamespace ") + Abbreviation + " = " + Namespace + ";") (llvm::Twine("\nnamespace ") + Abbreviation + " = " + Namespace + ";")
.str(); .str();
SourceLocation Loc = SourceLocation Loc =
Lexer::getLocForEndOfToken(Function->getBody()->getLocStart(), 0, Lexer::getLocForEndOfToken(Function->getBody()->getBeginLoc(), 0,
SourceMgr, Context.getLangOpts()); SourceMgr, Context.getLangOpts());
AddedAliases[Function][Namespace.str()] = Abbreviation; AddedAliases[Function][Namespace.str()] = Abbreviation;
return FixItHint::CreateInsertion(Loc, Declaration); return FixItHint::CreateInsertion(Loc, Declaration);
} }
return None; return None;
} }
Show All 16 Lines

clang-tidy/utils/UsingInserter.cpp

Show All 35 LinesOptional<FixItHint> UsingInserter::createUsingDeclaration(
const FunctionDecl *Function = getSurroundingFunction(Context, Statement); const FunctionDecl *Function = getSurroundingFunction(Context, Statement);
if (!Function) if (!Function)
return None; return None;
if (AddedUsing.count(std::make_pair(Function, QualifiedName.str())) != 0) if (AddedUsing.count(std::make_pair(Function, QualifiedName.str())) != 0)
return None; return None;
SourceLocation InsertLoc = Lexer::getLocForEndOfToken( SourceLocation InsertLoc = Lexer::getLocForEndOfToken(
Function->getBody()->getLocStart(), 0, SourceMgr, Context.getLangOpts()); Function->getBody()->getBeginLoc(), 0, SourceMgr, Context.getLangOpts());
// Only use using declarations in the main file, not in includes. // Only use using declarations in the main file, not in includes.
if (SourceMgr.getFileID(InsertLoc) != SourceMgr.getMainFileID()) if (SourceMgr.getFileID(InsertLoc) != SourceMgr.getMainFileID())
return None; return None;
// FIXME: This declaration could be masked. Investigate if // FIXME: This declaration could be masked. Investigate if
// there is a way to avoid using Sema. // there is a way to avoid using Sema.
bool AlreadyHasUsingDecl = bool AlreadyHasUsingDecl =
Show All 37 Lines

clangd/CodeComplete.cpp

Show First 20 Lines • Show All 228 Lines • ▼ Show 20 Lines llvm::Optional<llvm::StringRef> headerToInsertIfNotPresent() const {
if (!IndexResult || !IndexResult->Detail || if (!IndexResult || !IndexResult->Detail ||
IndexResult->Detail->IncludeHeader.empty()) IndexResult->Detail->IncludeHeader.empty())
return llvm::None; return llvm::None;
if (SemaResult && SemaResult->Declaration) { if (SemaResult && SemaResult->Declaration) {
// Avoid inserting new #include if the declaration is found in the current // Avoid inserting new #include if the declaration is found in the current
// file e.g. the symbol is forward declared. // file e.g. the symbol is forward declared.
auto &SM = SemaResult->Declaration->getASTContext().getSourceManager(); auto &SM = SemaResult->Declaration->getASTContext().getSourceManager();
for (const Decl *RD : SemaResult->Declaration->redecls()) for (const Decl *RD : SemaResult->Declaration->redecls())
if (SM.isInMainFile(SM.getExpansionLoc(RD->getLocStart()))) if (SM.isInMainFile(SM.getExpansionLoc(RD->getBeginLoc())))
return llvm::None; return llvm::None;
} }
return IndexResult->Detail->IncludeHeader; return IndexResult->Detail->IncludeHeader;
} }
using Bundle = llvm::SmallVector<CompletionCandidate, 4>; using Bundle = llvm::SmallVector<CompletionCandidate, 4>;
}; };
using ScoredBundle = using ScoredBundle =
▲ Show 20 Lines • Show All 1,058 Lines • Show Last 20 Lines

clangd/CodeCompletionStrings.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines if (!Decl || llvm::isa<NamespaceDecl>(Decl)) {
return ""; return "";
} }
const RawComment *RC = getCompletionComment(Ctx, Decl); const RawComment *RC = getCompletionComment(Ctx, Decl);
if (!RC) if (!RC)
return ""; return "";
// Sanity check that the comment does not come from the PCH. We choose to not // Sanity check that the comment does not come from the PCH. We choose to not
// write them into PCH, because they are racy and slow to load. // write them into PCH, because they are racy and slow to load.
assert(!Ctx.getSourceManager().isLoadedSourceLocation(RC->getLocStart())); assert(!Ctx.getSourceManager().isLoadedSourceLocation(RC->getBeginLoc()));
std::string Doc = RC->getFormattedText(Ctx.getSourceManager(), Ctx.getDiagnostics()); std::string Doc = RC->getFormattedText(Ctx.getSourceManager(), Ctx.getDiagnostics());
if (!looksLikeDocComment(Doc)) if (!looksLikeDocComment(Doc))
return ""; return "";
return Doc; return Doc;
} }
std::string std::string
getParameterDocComment(const ASTContext &Ctx, getParameterDocComment(const ASTContext &Ctx,
const CodeCompleteConsumer::OverloadCandidate &Result, const CodeCompleteConsumer::OverloadCandidate &Result,
unsigned ArgIndex, bool CommentsFromHeaders) { unsigned ArgIndex, bool CommentsFromHeaders) {
auto *Func = Result.getFunction(); auto *Func = Result.getFunction();
if (!Func) if (!Func)
return ""; return "";
const RawComment *RC = getParameterComment(Ctx, Result, ArgIndex); const RawComment *RC = getParameterComment(Ctx, Result, ArgIndex);
if (!RC) if (!RC)
return ""; return "";
// Sanity check that the comment does not come from the PCH. We choose to not // Sanity check that the comment does not come from the PCH. We choose to not
// write them into PCH, because they are racy and slow to load. // write them into PCH, because they are racy and slow to load.
assert(!Ctx.getSourceManager().isLoadedSourceLocation(RC->getLocStart())); assert(!Ctx.getSourceManager().isLoadedSourceLocation(RC->getBeginLoc()));
std::string Doc = RC->getFormattedText(Ctx.getSourceManager(), Ctx.getDiagnostics()); std::string Doc = RC->getFormattedText(Ctx.getSourceManager(), Ctx.getDiagnostics());
if (!looksLikeDocComment(Doc)) if (!looksLikeDocComment(Doc))
return ""; return "";
return Doc; return Doc;
} }
void getSignature(const CodeCompletionString &CCS, std::string *Signature, void getSignature(const CodeCompletionString &CCS, std::string *Signature,
std::string *Snippet, std::string *RequiredQualifiers) { std::string *Snippet, std::string *RequiredQualifiers) {
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

clangd/XRefs.cpp

Show First 20 Lines • Show All 543 Lines • ▼ Show 20 Linespublic:
llvm::Optional<QualType> getDeducedType() { return DeducedType; } llvm::Optional<QualType> getDeducedType() { return DeducedType; }
// Handle auto initializers: // Handle auto initializers:
//- auto i = 1; //- auto i = 1;
//- decltype(auto) i = 1; //- decltype(auto) i = 1;
//- auto& i = 1; //- auto& i = 1;
bool VisitDeclaratorDecl(DeclaratorDecl *D) { bool VisitDeclaratorDecl(DeclaratorDecl *D) {
if (!D->getTypeSourceInfo() || if (!D->getTypeSourceInfo() ||
D->getTypeSourceInfo()->getTypeLoc().getLocStart() != SearchedLocation) D->getTypeSourceInfo()->getTypeLoc().getBeginLoc() != SearchedLocation)
return true; return true;
auto DeclT = D->getType(); auto DeclT = D->getType();
// "auto &" is represented as a ReferenceType containing an AutoType // "auto &" is represented as a ReferenceType containing an AutoType
if (const ReferenceType *RT = dyn_cast<ReferenceType>(DeclT.getTypePtr())) if (const ReferenceType *RT = dyn_cast<ReferenceType>(DeclT.getTypePtr()))
DeclT = RT->getPointeeType(); DeclT = RT->getPointeeType();
const AutoType *AT = dyn_cast<AutoType>(DeclT.getTypePtr()); const AutoType *AT = dyn_cast<AutoType>(DeclT.getTypePtr());
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

tool-template/ToolTemplate.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linespublic:
void run(const MatchFinder::MatchResult &Result) override { void run(const MatchFinder::MatchResult &Result) override {
// TODO: This routine will get called for each thing that the matchers // TODO: This routine will get called for each thing that the matchers
// find. // find.
// At this point, you can examine the match, and do whatever you want, // At this point, you can examine the match, and do whatever you want,
// including replacing the matched text with other text // including replacing the matched text with other text
auto *D = Result.Nodes.getNodeAs<NamedDecl>("decl"); auto *D = Result.Nodes.getNodeAs<NamedDecl>("decl");
assert(D); assert(D);
// Use AtomicChange to get a key. // Use AtomicChange to get a key.
if (D->getLocStart().isValid()) { if (D->getBeginLoc().isValid()) {
AtomicChange Change(*Result.SourceManager, D->getLocStart()); AtomicChange Change(*Result.SourceManager, D->getBeginLoc());
Context.reportResult(Change.getKey(), D->getQualifiedNameAsString()); Context.reportResult(Change.getKey(), D->getQualifiedNameAsString());
} }
} }
void onStartOfTranslationUnit() override { void onStartOfTranslationUnit() override {
Context.reportResult("START", "Start of TU."); Context.reportResult("START", "Start of TU.");
} }
void onEndOfTranslationUnit() override { void onEndOfTranslationUnit() override {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

unittests/clang-tidy/IncludeInserterTest.cpp

Show All 39 Lines void registerPPCallbacks(CompilerInstance &Compiler) override {
Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks()); Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override { void registerMatchers(ast_matchers::MatchFinder *Finder) override {
Finder->addMatcher(ast_matchers::declStmt().bind("stmt"), this); Finder->addMatcher(ast_matchers::declStmt().bind("stmt"), this);
} }
void check(const ast_matchers::MatchFinder::MatchResult &Result) override { void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
auto Diag = diag(Result.Nodes.getNodeAs<DeclStmt>("stmt")->getLocStart(), auto Diag = diag(Result.Nodes.getNodeAs<DeclStmt>("stmt")->getBeginLoc(),
"foo, bar"); "foo, bar");
for (StringRef header : HeadersToInclude()) { for (StringRef header : HeadersToInclude()) {
auto Fixit = Inserter->CreateIncludeInsertion( auto Fixit = Inserter->CreateIncludeInsertion(
Result.SourceManager->getMainFileID(), header, IsAngledInclude()); Result.SourceManager->getMainFileID(), header, IsAngledInclude());
if (Fixit) { if (Fixit) {
Diag << *Fixit; Diag << *Fixit;
} }
} }
▲ Show 20 Lines • Show All 556 Lines • Show Last 20 Lines

unittests/clang-tidy/NamespaceAliaserTest.cpp

Show All 30 Lines void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
if (!Aliaser) if (!Aliaser)
Aliaser.reset(new NamespaceAliaser(*Result.SourceManager)); Aliaser.reset(new NamespaceAliaser(*Result.SourceManager));
const auto *Call = Result.Nodes.getNodeAs<CallExpr>("foo"); const auto *Call = Result.Nodes.getNodeAs<CallExpr>("foo");
assert(Call != nullptr && "Did not find node \"foo\""); assert(Call != nullptr && "Did not find node \"foo\"");
auto Hint = Aliaser->createAlias(*Result.Context, *Call, "::foo::bar", auto Hint = Aliaser->createAlias(*Result.Context, *Call, "::foo::bar",
{"b", "some_alias"}); {"b", "some_alias"});
if (Hint.hasValue()) if (Hint.hasValue())
diag(Call->getLocStart(), "Fix for testing") << Hint.getValue(); diag(Call->getBeginLoc(), "Fix for testing") << Hint.getValue();
diag(Call->getLocStart(), "insert call") diag(Call->getBeginLoc(), "insert call")
<< FixItHint::CreateInsertion( << FixItHint::CreateInsertion(
Call->getLocStart(), Call->getBeginLoc(),
Aliaser->getNamespaceName(*Result.Context, *Call, "::foo::bar") + Aliaser->getNamespaceName(*Result.Context, *Call, "::foo::bar") +
"::"); "::");
} }
private: private:
std::unique_ptr<NamespaceAliaser> Aliaser; std::unique_ptr<NamespaceAliaser> Aliaser;
}; };
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

unittests/clang-tidy/OverlappingReplacementsTest.cpp

Show All 27 Linespublic:
UseCharCheck(StringRef CheckName, ClangTidyContext *Context) UseCharCheck(StringRef CheckName, ClangTidyContext *Context)
: ClangTidyCheck(CheckName, Context) {} : ClangTidyCheck(CheckName, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override { void registerMatchers(ast_matchers::MatchFinder *Finder) override {
using namespace ast_matchers; using namespace ast_matchers;
Finder->addMatcher(varDecl(hasType(isInteger())).bind(BoundDecl), this); Finder->addMatcher(varDecl(hasType(isInteger())).bind(BoundDecl), this);
} }
void check(const ast_matchers::MatchFinder::MatchResult &Result) override { void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
auto *VD = Result.Nodes.getNodeAs<VarDecl>(BoundDecl); auto *VD = Result.Nodes.getNodeAs<VarDecl>(BoundDecl);
diag(VD->getLocStart(), "use char") << FixItHint::CreateReplacement( diag(VD->getBeginLoc(), "use char") << FixItHint::CreateReplacement(
CharSourceRange::getTokenRange(VD->getLocStart(), VD->getLocStart()), CharSourceRange::getTokenRange(VD->getBeginLoc(), VD->getBeginLoc()),
"char"); "char");
} }
}; };
class IfFalseCheck : public ClangTidyCheck { class IfFalseCheck : public ClangTidyCheck {
public: public:
IfFalseCheck(StringRef CheckName, ClangTidyContext *Context) IfFalseCheck(StringRef CheckName, ClangTidyContext *Context)
: ClangTidyCheck(CheckName, Context) {} : ClangTidyCheck(CheckName, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override { void registerMatchers(ast_matchers::MatchFinder *Finder) override {
using namespace ast_matchers; using namespace ast_matchers;
Finder->addMatcher(ifStmt().bind(BoundIf), this); Finder->addMatcher(ifStmt().bind(BoundIf), this);
} }
void check(const ast_matchers::MatchFinder::MatchResult &Result) override { void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
auto *If = Result.Nodes.getNodeAs<IfStmt>(BoundIf); auto *If = Result.Nodes.getNodeAs<IfStmt>(BoundIf);
auto *Cond = If->getCond(); auto *Cond = If->getCond();
SourceRange Range = Cond->getSourceRange(); SourceRange Range = Cond->getSourceRange();
if (auto *D = If->getConditionVariable()) { if (auto *D = If->getConditionVariable()) {
Range = SourceRange(D->getLocStart(), D->getLocEnd()); Range = SourceRange(D->getBeginLoc(), D->getLocEnd());
} }
diag(Range.getBegin(), "the cake is a lie") << FixItHint::CreateReplacement( diag(Range.getBegin(), "the cake is a lie") << FixItHint::CreateReplacement(
CharSourceRange::getTokenRange(Range), "false"); CharSourceRange::getTokenRange(Range), "false");
} }
}; };
class RefactorCheck : public ClangTidyCheck { class RefactorCheck : public ClangTidyCheck {
public: public:
▲ Show 20 Lines • Show All 346 Lines • Show Last 20 Lines

unittests/clang-tidy/UsingInserterTest.cpp

Show All 33 Lines if (!Inserter)
Inserter.reset(new UsingInserter(*Result.SourceManager)); Inserter.reset(new UsingInserter(*Result.SourceManager));
const auto *Call = Result.Nodes.getNodeAs<clang::CallExpr>("foo"); const auto *Call = Result.Nodes.getNodeAs<clang::CallExpr>("foo");
assert(Call != nullptr && "Did not find node \"foo\""); assert(Call != nullptr && "Did not find node \"foo\"");
auto Hint = auto Hint =
Inserter->createUsingDeclaration(*Result.Context, *Call, "::foo::func"); Inserter->createUsingDeclaration(*Result.Context, *Call, "::foo::func");
if (Hint.hasValue()) if (Hint.hasValue())
diag(Call->getLocStart(), "Fix for testing") << Hint.getValue(); diag(Call->getBeginLoc(), "Fix for testing") << Hint.getValue();
diag(Call->getLocStart(), "insert call") diag(Call->getBeginLoc(), "insert call")
<< clang::FixItHint::CreateReplacement( << clang::FixItHint::CreateReplacement(
Call->getCallee()->getSourceRange(), Call->getCallee()->getSourceRange(),
Inserter->getShortName(*Result.Context, *Call, "::foo::func")); Inserter->getShortName(*Result.Context, *Call, "::foo::func"));
} }
private: private:
std::unique_ptr<UsingInserter> Inserter; std::unique_ptr<UsingInserter> Inserter;
}; };
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines