ab2d3ce47d
Applied fixes enabled by the LLVM's .clang-tidy configs. Reverted files where
fixes introduced compile errors:
clang-tools-extra/clang-tidy/hicpp/NoAssemblerCheck.cpp
clang-tools-extra/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.cpp
$ clang-tools-extra/clang-tidy/tool/run-clang-tidy.py -fix clang-tools-extra/clang-tidy/
Enabled checks:
llvm-else-after-return
llvm-header-guard
llvm-include-order
llvm-namespace-comment
llvm-prefer-isa-or-dyn-cast-in-conditionals
llvm-prefer-register-over-unsigned
llvm-qualified-auto
llvm-twine-local
misc-definitions-in-headers
misc-misplaced-const
misc-new-delete-overloads
misc-no-recursion
misc-non-copyable-objects
misc-redundant-expression
misc-static-assert
misc-throw-by-value-catch-by-reference
misc-unconventional-assign-operator
misc-uniqueptr-reset-release
misc-unused-alias-decls
misc-unused-using-decls
readability-identifier-naming
Reviewed By: aaron.ballman
Differential Revision: https://reviews.llvm.org/D95614
98 lines
3.7 KiB
C++
98 lines
3.7 KiB
C++
//===--- RedundantControlFlowCheck.cpp - clang-tidy------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "RedundantControlFlowCheck.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/ASTMatchers/ASTMatchFinder.h"
|
|
#include "clang/Lex/Lexer.h"
|
|
|
|
using namespace clang::ast_matchers;
|
|
|
|
namespace clang {
|
|
namespace tidy {
|
|
namespace readability {
|
|
|
|
namespace {
|
|
|
|
const char *const RedundantReturnDiag = "redundant return statement at the end "
|
|
"of a function with a void return type";
|
|
const char *const RedundantContinueDiag = "redundant continue statement at the "
|
|
"end of loop statement";
|
|
|
|
bool isLocationInMacroExpansion(const SourceManager &SM, SourceLocation Loc) {
|
|
return SM.isMacroBodyExpansion(Loc) || SM.isMacroArgExpansion(Loc);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void RedundantControlFlowCheck::registerMatchers(MatchFinder *Finder) {
|
|
Finder->addMatcher(
|
|
functionDecl(
|
|
isDefinition(), returns(voidType()),
|
|
has(compoundStmt(hasAnySubstatement(returnStmt(unless(has(expr())))))
|
|
.bind("return"))),
|
|
this);
|
|
auto CompoundContinue =
|
|
has(compoundStmt(hasAnySubstatement(continueStmt())).bind("continue"));
|
|
Finder->addMatcher(
|
|
stmt(anyOf(forStmt(), cxxForRangeStmt(), whileStmt(), doStmt()),
|
|
CompoundContinue),
|
|
this);
|
|
}
|
|
|
|
void RedundantControlFlowCheck::check(const MatchFinder::MatchResult &Result) {
|
|
if (const auto *Return = Result.Nodes.getNodeAs<CompoundStmt>("return"))
|
|
checkRedundantReturn(Result, Return);
|
|
else if (const auto *Continue =
|
|
Result.Nodes.getNodeAs<CompoundStmt>("continue"))
|
|
checkRedundantContinue(Result, Continue);
|
|
}
|
|
|
|
void RedundantControlFlowCheck::checkRedundantReturn(
|
|
const MatchFinder::MatchResult &Result, const CompoundStmt *Block) {
|
|
CompoundStmt::const_reverse_body_iterator Last = Block->body_rbegin();
|
|
if (const auto *Return = dyn_cast<ReturnStmt>(*Last))
|
|
issueDiagnostic(Result, Block, Return->getSourceRange(),
|
|
RedundantReturnDiag);
|
|
}
|
|
|
|
void RedundantControlFlowCheck::checkRedundantContinue(
|
|
const MatchFinder::MatchResult &Result, const CompoundStmt *Block) {
|
|
CompoundStmt::const_reverse_body_iterator Last = Block->body_rbegin();
|
|
if (const auto *Continue = dyn_cast<ContinueStmt>(*Last))
|
|
issueDiagnostic(Result, Block, Continue->getSourceRange(),
|
|
RedundantContinueDiag);
|
|
}
|
|
|
|
void RedundantControlFlowCheck::issueDiagnostic(
|
|
const MatchFinder::MatchResult &Result, const CompoundStmt *const Block,
|
|
const SourceRange &StmtRange, const char *const Diag) {
|
|
SourceManager &SM = *Result.SourceManager;
|
|
if (isLocationInMacroExpansion(SM, StmtRange.getBegin()))
|
|
return;
|
|
|
|
CompoundStmt::const_reverse_body_iterator Previous = ++Block->body_rbegin();
|
|
SourceLocation Start;
|
|
if (Previous != Block->body_rend())
|
|
Start = Lexer::findLocationAfterToken(
|
|
dyn_cast<Stmt>(*Previous)->getEndLoc(), tok::semi, SM, getLangOpts(),
|
|
/*SkipTrailingWhitespaceAndNewLine=*/true);
|
|
if (!Start.isValid())
|
|
Start = StmtRange.getBegin();
|
|
auto RemovedRange = CharSourceRange::getCharRange(
|
|
Start, Lexer::findLocationAfterToken(
|
|
StmtRange.getEnd(), tok::semi, SM, getLangOpts(),
|
|
/*SkipTrailingWhitespaceAndNewLine=*/true));
|
|
|
|
diag(StmtRange.getBegin(), Diag) << FixItHint::CreateRemoval(RemovedRange);
|
|
}
|
|
|
|
} // namespace readability
|
|
} // namespace tidy
|
|
} // namespace clang
|