forked from OSchip/llvm-project
389 lines
13 KiB
C++
389 lines
13 KiB
C++
//===--- ImplicitBoolConversionCheck.cpp - clang-tidy----------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "ImplicitBoolConversionCheck.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/ASTMatchers/ASTMatchFinder.h"
|
|
#include "clang/Lex/Lexer.h"
|
|
#include "clang/Tooling/FixIt.h"
|
|
#include <queue>
|
|
|
|
using namespace clang::ast_matchers;
|
|
|
|
namespace clang {
|
|
namespace tidy {
|
|
namespace readability {
|
|
|
|
namespace {
|
|
|
|
AST_MATCHER(Stmt, isMacroExpansion) {
|
|
SourceManager &SM = Finder->getASTContext().getSourceManager();
|
|
SourceLocation Loc = Node.getLocStart();
|
|
return SM.isMacroBodyExpansion(Loc) || SM.isMacroArgExpansion(Loc);
|
|
}
|
|
|
|
bool isNULLMacroExpansion(const Stmt *Statement, ASTContext &Context) {
|
|
SourceManager &SM = Context.getSourceManager();
|
|
const LangOptions &LO = Context.getLangOpts();
|
|
SourceLocation Loc = Statement->getLocStart();
|
|
return SM.isMacroBodyExpansion(Loc) &&
|
|
Lexer::getImmediateMacroName(Loc, SM, LO) == "NULL";
|
|
}
|
|
|
|
AST_MATCHER(Stmt, isNULLMacroExpansion) {
|
|
return isNULLMacroExpansion(&Node, Finder->getASTContext());
|
|
}
|
|
|
|
StringRef getZeroLiteralToCompareWithForType(CastKind CastExprKind,
|
|
QualType Type,
|
|
ASTContext &Context) {
|
|
switch (CastExprKind) {
|
|
case CK_IntegralToBoolean:
|
|
return Type->isUnsignedIntegerType() ? "0u" : "0";
|
|
|
|
case CK_FloatingToBoolean:
|
|
return Context.hasSameType(Type, Context.FloatTy) ? "0.0f" : "0.0";
|
|
|
|
case CK_PointerToBoolean:
|
|
case CK_MemberPointerToBoolean: // Fall-through on purpose.
|
|
return Context.getLangOpts().CPlusPlus11 ? "nullptr" : "0";
|
|
|
|
default:
|
|
llvm_unreachable("Unexpected cast kind");
|
|
}
|
|
}
|
|
|
|
bool isUnaryLogicalNotOperator(const Stmt *Statement) {
|
|
const auto *UnaryOperatorExpr = dyn_cast<UnaryOperator>(Statement);
|
|
return UnaryOperatorExpr && UnaryOperatorExpr->getOpcode() == UO_LNot;
|
|
}
|
|
|
|
bool areParensNeededForOverloadedOperator(OverloadedOperatorKind OperatorKind) {
|
|
switch (OperatorKind) {
|
|
case OO_New:
|
|
case OO_Delete: // Fall-through on purpose.
|
|
case OO_Array_New:
|
|
case OO_Array_Delete:
|
|
case OO_ArrowStar:
|
|
case OO_Arrow:
|
|
case OO_Call:
|
|
case OO_Subscript:
|
|
return false;
|
|
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool areParensNeededForStatement(const Stmt *Statement) {
|
|
if (const auto *OperatorCall = dyn_cast<CXXOperatorCallExpr>(Statement)) {
|
|
return areParensNeededForOverloadedOperator(OperatorCall->getOperator());
|
|
}
|
|
|
|
return isa<BinaryOperator>(Statement) || isa<UnaryOperator>(Statement);
|
|
}
|
|
|
|
void fixGenericExprCastToBool(DiagnosticBuilder &Diag,
|
|
const ImplicitCastExpr *Cast, const Stmt *Parent,
|
|
ASTContext &Context) {
|
|
// In case of expressions like (! integer), we should remove the redundant not
|
|
// operator and use inverted comparison (integer == 0).
|
|
bool InvertComparison =
|
|
Parent != nullptr && isUnaryLogicalNotOperator(Parent);
|
|
if (InvertComparison) {
|
|
SourceLocation ParentStartLoc = Parent->getLocStart();
|
|
SourceLocation ParentEndLoc =
|
|
cast<UnaryOperator>(Parent)->getSubExpr()->getLocStart();
|
|
Diag << FixItHint::CreateRemoval(
|
|
CharSourceRange::getCharRange(ParentStartLoc, ParentEndLoc));
|
|
|
|
Parent = Context.getParents(*Parent)[0].get<Stmt>();
|
|
}
|
|
|
|
const Expr *SubExpr = Cast->getSubExpr();
|
|
|
|
bool NeedInnerParens = areParensNeededForStatement(SubExpr);
|
|
bool NeedOuterParens =
|
|
Parent != nullptr && areParensNeededForStatement(Parent);
|
|
|
|
std::string StartLocInsertion;
|
|
|
|
if (NeedOuterParens) {
|
|
StartLocInsertion += "(";
|
|
}
|
|
if (NeedInnerParens) {
|
|
StartLocInsertion += "(";
|
|
}
|
|
|
|
if (!StartLocInsertion.empty()) {
|
|
Diag << FixItHint::CreateInsertion(Cast->getLocStart(), StartLocInsertion);
|
|
}
|
|
|
|
std::string EndLocInsertion;
|
|
|
|
if (NeedInnerParens) {
|
|
EndLocInsertion += ")";
|
|
}
|
|
|
|
if (InvertComparison) {
|
|
EndLocInsertion += " == ";
|
|
} else {
|
|
EndLocInsertion += " != ";
|
|
}
|
|
|
|
EndLocInsertion += getZeroLiteralToCompareWithForType(
|
|
Cast->getCastKind(), SubExpr->getType(), Context);
|
|
|
|
if (NeedOuterParens) {
|
|
EndLocInsertion += ")";
|
|
}
|
|
|
|
SourceLocation EndLoc = Lexer::getLocForEndOfToken(
|
|
Cast->getLocEnd(), 0, Context.getSourceManager(), Context.getLangOpts());
|
|
Diag << FixItHint::CreateInsertion(EndLoc, EndLocInsertion);
|
|
}
|
|
|
|
StringRef getEquivalentBoolLiteralForExpr(const Expr *Expression,
|
|
ASTContext &Context) {
|
|
if (isNULLMacroExpansion(Expression, Context)) {
|
|
return "false";
|
|
}
|
|
|
|
if (const auto *IntLit = dyn_cast<IntegerLiteral>(Expression)) {
|
|
return (IntLit->getValue() == 0) ? "false" : "true";
|
|
}
|
|
|
|
if (const auto *FloatLit = dyn_cast<FloatingLiteral>(Expression)) {
|
|
llvm::APFloat FloatLitAbsValue = FloatLit->getValue();
|
|
FloatLitAbsValue.clearSign();
|
|
return (FloatLitAbsValue.bitcastToAPInt() == 0) ? "false" : "true";
|
|
}
|
|
|
|
if (const auto *CharLit = dyn_cast<CharacterLiteral>(Expression)) {
|
|
return (CharLit->getValue() == 0) ? "false" : "true";
|
|
}
|
|
|
|
if (isa<StringLiteral>(Expression->IgnoreCasts())) {
|
|
return "true";
|
|
}
|
|
|
|
return StringRef();
|
|
}
|
|
|
|
void fixGenericExprCastFromBool(DiagnosticBuilder &Diag,
|
|
const ImplicitCastExpr *Cast,
|
|
ASTContext &Context, StringRef OtherType) {
|
|
const Expr *SubExpr = Cast->getSubExpr();
|
|
bool NeedParens = !isa<ParenExpr>(SubExpr);
|
|
|
|
Diag << FixItHint::CreateInsertion(
|
|
Cast->getLocStart(),
|
|
(Twine("static_cast<") + OtherType + ">" + (NeedParens ? "(" : ""))
|
|
.str());
|
|
|
|
if (NeedParens) {
|
|
SourceLocation EndLoc = Lexer::getLocForEndOfToken(
|
|
Cast->getLocEnd(), 0, Context.getSourceManager(),
|
|
Context.getLangOpts());
|
|
|
|
Diag << FixItHint::CreateInsertion(EndLoc, ")");
|
|
}
|
|
}
|
|
|
|
StringRef getEquivalentForBoolLiteral(const CXXBoolLiteralExpr *BoolLiteral,
|
|
QualType DestType, ASTContext &Context) {
|
|
// Prior to C++11, false literal could be implicitly converted to pointer.
|
|
if (!Context.getLangOpts().CPlusPlus11 &&
|
|
(DestType->isPointerType() || DestType->isMemberPointerType()) &&
|
|
BoolLiteral->getValue() == false) {
|
|
return "0";
|
|
}
|
|
|
|
if (DestType->isFloatingType()) {
|
|
if (Context.hasSameType(DestType, Context.FloatTy)) {
|
|
return BoolLiteral->getValue() ? "1.0f" : "0.0f";
|
|
}
|
|
return BoolLiteral->getValue() ? "1.0" : "0.0";
|
|
}
|
|
|
|
if (DestType->isUnsignedIntegerType()) {
|
|
return BoolLiteral->getValue() ? "1u" : "0u";
|
|
}
|
|
return BoolLiteral->getValue() ? "1" : "0";
|
|
}
|
|
|
|
bool isCastAllowedInCondition(const ImplicitCastExpr *Cast,
|
|
ASTContext &Context) {
|
|
std::queue<const Stmt *> Q;
|
|
Q.push(Cast);
|
|
while (!Q.empty()) {
|
|
for (const auto &N : Context.getParents(*Q.front())) {
|
|
const Stmt *S = N.get<Stmt>();
|
|
if (!S)
|
|
return false;
|
|
if (isa<IfStmt>(S) || isa<ConditionalOperator>(S) || isa<ForStmt>(S) ||
|
|
isa<WhileStmt>(S) || isa<BinaryConditionalOperator>(S))
|
|
return true;
|
|
if (isa<ParenExpr>(S) || isa<ImplicitCastExpr>(S) ||
|
|
isUnaryLogicalNotOperator(S) ||
|
|
(isa<BinaryOperator>(S) && cast<BinaryOperator>(S)->isLogicalOp())) {
|
|
Q.push(S);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
Q.pop();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
ImplicitBoolConversionCheck::ImplicitBoolConversionCheck(
|
|
StringRef Name, ClangTidyContext *Context)
|
|
: ClangTidyCheck(Name, Context),
|
|
AllowIntegerConditions(Options.get("AllowIntegerConditions", false)),
|
|
AllowPointerConditions(Options.get("AllowPointerConditions", false)) {}
|
|
|
|
void ImplicitBoolConversionCheck::storeOptions(
|
|
ClangTidyOptions::OptionMap &Opts) {
|
|
Options.store(Opts, "AllowIntegerConditions", AllowIntegerConditions);
|
|
Options.store(Opts, "AllowPointerConditions", AllowPointerConditions);
|
|
}
|
|
|
|
void ImplicitBoolConversionCheck::registerMatchers(MatchFinder *Finder) {
|
|
// This check doesn't make much sense if we run it on language without
|
|
// built-in bool support.
|
|
if (!getLangOpts().Bool) {
|
|
return;
|
|
}
|
|
|
|
auto exceptionCases =
|
|
expr(anyOf(allOf(isMacroExpansion(), unless(isNULLMacroExpansion())),
|
|
hasParent(explicitCastExpr())));
|
|
auto implicitCastFromBool = implicitCastExpr(
|
|
anyOf(hasCastKind(CK_IntegralCast), hasCastKind(CK_IntegralToFloating),
|
|
// Prior to C++11 cast from bool literal to pointer was allowed.
|
|
allOf(anyOf(hasCastKind(CK_NullToPointer),
|
|
hasCastKind(CK_NullToMemberPointer)),
|
|
hasSourceExpression(cxxBoolLiteral()))),
|
|
hasSourceExpression(expr(hasType(booleanType()))),
|
|
unless(exceptionCases));
|
|
auto boolXor =
|
|
binaryOperator(hasOperatorName("^"), hasLHS(implicitCastFromBool),
|
|
hasRHS(implicitCastFromBool));
|
|
Finder->addMatcher(
|
|
implicitCastExpr(
|
|
anyOf(hasCastKind(CK_IntegralToBoolean),
|
|
hasCastKind(CK_FloatingToBoolean),
|
|
hasCastKind(CK_PointerToBoolean),
|
|
hasCastKind(CK_MemberPointerToBoolean)),
|
|
// Exclude case of using if or while statements with variable
|
|
// declaration, e.g.:
|
|
// if (int var = functionCall()) {}
|
|
unless(
|
|
hasParent(stmt(anyOf(ifStmt(), whileStmt()), has(declStmt())))),
|
|
// Exclude cases common to implicit cast to and from bool.
|
|
unless(exceptionCases), unless(has(boolXor)),
|
|
// Retrive also parent statement, to check if we need additional
|
|
// parens in replacement.
|
|
anyOf(hasParent(stmt().bind("parentStmt")), anything()),
|
|
unless(isInTemplateInstantiation()),
|
|
unless(hasAncestor(functionTemplateDecl())))
|
|
.bind("implicitCastToBool"),
|
|
this);
|
|
|
|
auto boolComparison = binaryOperator(
|
|
anyOf(hasOperatorName("=="), hasOperatorName("!=")),
|
|
hasLHS(implicitCastFromBool), hasRHS(implicitCastFromBool));
|
|
auto boolOpAssignment =
|
|
binaryOperator(anyOf(hasOperatorName("|="), hasOperatorName("&=")),
|
|
hasLHS(expr(hasType(booleanType()))));
|
|
Finder->addMatcher(
|
|
implicitCastExpr(
|
|
implicitCastFromBool,
|
|
// Exclude comparisons of bools, as they are always cast to integers
|
|
// in such context:
|
|
// bool_expr_a == bool_expr_b
|
|
// bool_expr_a != bool_expr_b
|
|
unless(hasParent(binaryOperator(
|
|
anyOf(boolComparison, boolXor, boolOpAssignment)))),
|
|
// Check also for nested casts, for example: bool -> int -> float.
|
|
anyOf(hasParent(implicitCastExpr().bind("furtherImplicitCast")),
|
|
anything()),
|
|
unless(isInTemplateInstantiation()),
|
|
unless(hasAncestor(functionTemplateDecl())))
|
|
.bind("implicitCastFromBool"),
|
|
this);
|
|
}
|
|
|
|
void ImplicitBoolConversionCheck::check(
|
|
const MatchFinder::MatchResult &Result) {
|
|
if (const auto *CastToBool =
|
|
Result.Nodes.getNodeAs<ImplicitCastExpr>("implicitCastToBool")) {
|
|
const auto *Parent = Result.Nodes.getNodeAs<Stmt>("parentStmt");
|
|
return handleCastToBool(CastToBool, Parent, *Result.Context);
|
|
}
|
|
|
|
if (const auto *CastFromBool =
|
|
Result.Nodes.getNodeAs<ImplicitCastExpr>("implicitCastFromBool")) {
|
|
const auto *NextImplicitCast =
|
|
Result.Nodes.getNodeAs<ImplicitCastExpr>("furtherImplicitCast");
|
|
return handleCastFromBool(CastFromBool, NextImplicitCast, *Result.Context);
|
|
}
|
|
}
|
|
|
|
void ImplicitBoolConversionCheck::handleCastToBool(const ImplicitCastExpr *Cast,
|
|
const Stmt *Parent,
|
|
ASTContext &Context) {
|
|
if (AllowPointerConditions &&
|
|
(Cast->getCastKind() == CK_PointerToBoolean ||
|
|
Cast->getCastKind() == CK_MemberPointerToBoolean) &&
|
|
isCastAllowedInCondition(Cast, Context)) {
|
|
return;
|
|
}
|
|
|
|
if (AllowIntegerConditions && Cast->getCastKind() == CK_IntegralToBoolean &&
|
|
isCastAllowedInCondition(Cast, Context)) {
|
|
return;
|
|
}
|
|
|
|
auto Diag = diag(Cast->getLocStart(), "implicit conversion %0 -> bool")
|
|
<< Cast->getSubExpr()->getType();
|
|
|
|
StringRef EquivalentLiteral =
|
|
getEquivalentBoolLiteralForExpr(Cast->getSubExpr(), Context);
|
|
if (!EquivalentLiteral.empty()) {
|
|
Diag << tooling::fixit::createReplacement(*Cast, EquivalentLiteral);
|
|
} else {
|
|
fixGenericExprCastToBool(Diag, Cast, Parent, Context);
|
|
}
|
|
}
|
|
|
|
void ImplicitBoolConversionCheck::handleCastFromBool(
|
|
const ImplicitCastExpr *Cast, const ImplicitCastExpr *NextImplicitCast,
|
|
ASTContext &Context) {
|
|
QualType DestType =
|
|
NextImplicitCast ? NextImplicitCast->getType() : Cast->getType();
|
|
auto Diag = diag(Cast->getLocStart(), "implicit conversion bool -> %0")
|
|
<< DestType;
|
|
|
|
if (const auto *BoolLiteral =
|
|
dyn_cast<CXXBoolLiteralExpr>(Cast->getSubExpr())) {
|
|
Diag << tooling::fixit::createReplacement(
|
|
*Cast, getEquivalentForBoolLiteral(BoolLiteral, DestType, Context));
|
|
} else {
|
|
fixGenericExprCastFromBool(Diag, Cast, Context, DestType.getAsString());
|
|
}
|
|
}
|
|
|
|
} // namespace readability
|
|
} // namespace tidy
|
|
} // namespace clang
|