[clang-tidy] Add readability-implicit-bool-cast check

[piotrdz]

Summary

This is another check that I ported to clang-tidy from my colobot-lint tool.

As previously discussed on cfe-dev mailing list, this is one of those checks that I think is general and useful enough for contribution to clang-tidy.

This patch contains implementation of check taken from colobot-lint, but also extended a great deal, including FixIt hints for automated refactoring, exhaustive testcases, and user documentation.

[Eugene.Zelenko]

I agree with Piotr idea to introduce option to enable/disable check for pointer casts. Same should be done for integers where zero/non-zero value is used by system calls to indicate success/failure or in case of strings – end of string. Without such options check may be too verbose on legacy code bases.

May be dedicated category for casts checks should be created? We have google-readability-casting (through it duplicates in many aspects -Wold-style-cast, see PR24370), cppcoreguidelines-pro-type-const-cast and cppcoreguidelines-pro-type-reinterpret-cast. Other possible check is PR24525.

[sbenza]

Thanks for the check.
I know a lot of people that would appreciate if these implicit conversions didn't exist. =)

clang-tidy/readability/ImplicitBoolCastCheck.cpp

32

We should move most of these matchers to ASTMatchers.h as they are very general.
For example, we already have isInteger() as a QualType matcher so adding isBool() makes sense.

36

Maybe name it isMacroExpansion like the functions in SourceManager.

39

Please use the punctuation symbols for the boolean operators. (ie || instead of 'or')
The rest of the LLVM project uses them and the code should be consistent.

45

No need for the nested anyOf(). You are already in an anyOf() context.

46

Use isInTemplateInstantiation() instead of 'hasAncestor(functionDecl(ast_matchers::isTemplateInstantiation()))'

50

wouldn't the cxxBoolLiteral() also pass the isBoolType() check?

89

What about removing from unary_not->getLocStart() until unary_not->getSubExpr()->getLocStart()?
Or if you just want to remove one token do
CharSourceRange::getTokenRange(unary_not->getLocStart(),unary_not->getLocStart()).

101

You also need to check for CXXOperatorCallExpr, but only for operators that require the parens.

112

I think it is better if we construct a prefix and a suffix strings and then add a single hint for each.
Having multiple insert hints in the same location is brittle.

136

There are more literals. For example, NULL (GNUNullExpr)

146

Why are you using the _or_null overloads everywhere?
Do you expect them to be null?

153

You can move the declaration into the if statement. It doesn't pollute the outer scope and allows you to have simpler variable names.
Eg:

if (const auto *FL = llvm::dyn_cast<FloatingLiteral>(LiteralExpression)) {
  return ...
}

166

use isa<>. You don't really need the pointer.

171

Use llvm_unreachable() instead

178

Just CastExpression->getLocEnd()
You are using getTokenRange so it already covers from the start of the start token to the end of the end token.

198

Construct a string and collapse all the insertions into a single one.

223

You might also want to add a case for pointers here.
'false' converts to pointer.
ie this is "valid" code:

bool is_null(void* p) { return p == false; }

231

just getLocEnd(), same as above.

254

isn't this createImplicitCastFromBoolMatcher() ?
if not it is very close.
Maybe you can modify createImplicitCastFromBoolMatcher to reuse it. It is only used once so no reason for it to exist otherwise.

255

remove anyOf()

262

why this anyOf()? It must have a parent stmt.

274

Instead of the custom hasOpcode(BO_EQ) you can use the provided hasOperatorName("==")

285

move declarations into if statement. same as above

docs/clang-tidy/checks/readability-implicit-bool-cast.rst

57

why do we prefer a static_cast<> here, but we use != 0 in the if() above?

test/clang-tidy/readability-implicit-bool-cast.cpp

3

You could have a single function template:
template <typename T>
void functionTaking(T);

Then call with explicit template type:

functionTaking<int>(boolean);

Might make the code below more explicit as you can see the real C++ type is the expression.

22

move the // CHECK* comments after the line you are checking. That is the convention on other tests.

22

The first check should have the full message, including the [name-of-check] suffix to make sure it is generated correctly.

160

// namespace ignoreImplicitCastFromBoolInTemplateInstantiations

328

What would happen with code like:

assert(false && "some message");

?

Will this rewrite it to:

assert(false && true);

?

367

// namespace ignoreImplicitCastToBoolInTemplateInstantiations

380

// namespace ignoreUserDefinedConversionOperator

[piotrdz]

@sbenza: Thanks for the review. I have added my comments with expanations as necessary, and I have already fixed some issues you reported. I'm not posting a new diff at this time, as I want to finish with remaining issues, and then post updated diff once I'm ready with everything. I'll also work on adding a config option to conditionally allow for pointer to bool casts, as discussed on cfe-dev mailing list.

clang-tidy/readability/ImplicitBoolCastCheck.cpp

32

I agree. The only question is, should I do this as part of this patch, or isn't it better to check in this code first, and later move the matchers to clang in separate commit? A separate problem is that I don't have commit rights myself, so in any case, I must ask someone else to do it for me.

89

Ah, so that's how I do it.

I must say that it is totally not obvious how to work with source ranges in this or similar situations.

I came up with this version with getting token location and "magic" -1, because this is the first thing that actually worked for me. Previously, I was banging my head against the wall, trying to use something obvious like CharSourceRange::getTokenRange(ParentStatement->getLocStart(), ParentStatement->getLocEnd()). Needless to say, it doesn't work as you would expect.

101

And I thought I had everything covered. You're right, I'll need to fix that.

136

Fair point. Currently NULL will not work also because it's seen as macro, and so eliminated by my unless(isMacroExpansion()). That case (e.g. functionTakingBool(NULL) is actually a bit weird, because the whole ImplicitCastExpr is marked as expanded from NULL macro, and not where it actually occurs in code.

I'll try fixing it later, but I don't relish this. Macros are just evil.

146

It's just a habit I picked up early on when working with Clang. I ran into too many crashes due to null pointers, so I decided to always write defensive code. I guess now that I know more about ins and outs of Clang, I can do without it.

153

Ah, as irony would have it, it's an example of an implicit bool cast which my check would warn against. But as they say, for every rule, there is an exception.

223

No, it doesn't work like that. false will decay to integer constant and result in compile error of trying to compare pointer to an integer:

/tmp/test.cpp:1:35: error: comparison between pointer and integer ('void *' and 'int') [clang-diagnostic-error]
bool test(void* ptr) { return ptr == false; }

At least this we can be sure of - booleans will not convert to pointers, thank heavens for that.

254

This is matcher for implicit cast *to* bool, not *from* bool. They only seem to be similar. The only common part is this unless() part, which I extracted to function createExceptionCasesMatcher().

262

It doesn't have to be a Stmt. Consider: int integer = false;. Here, the parent of ImplicitCastExpr is a VarDecl.

docs/clang-tidy/checks/readability-implicit-bool-cast.rst

57

I can change it to ternary operator but it still looks ugly. Unfortunately, we run here into the same problem as in any other cast - it's just ugly code which pretends to be pretty.

The case of casting from something to bool type is easier to deal with, as such expression always corresponds to some kind of logical comparison. This check aims to make this comparison visible in code, rather than hidden, even under explicit cast like static_cast<bool>. So the choice of comparison operators comes naturally, and in my humble opinion, actually looks better in code than ugly static_cast.

But in the case of casting from bool to other type, we are casting away types, hoping that the conversion happens "out of the box". There just isn't a clear way of representing this in code, other than static_cast<type>. Okay, we can propose here a ternary operator as alternative: (cond) ? 1 : 0, but I feel that this is a bit too verbose, and actually less readable than the static_cast version. Besides, I'm not 100% sure, but I think it may actually change semantics (i.e. add branch to the output code where there wasn't any before). Casts such as these are just ugly and there is little we can do about that :-(.

I don't remember where, but I once read an interesting passage on the topic of casts. Quoting from memory:
"static_cast looks ugly in code, and it looks ugly on purpose. It is an indication that the programmer is trying to outsmart the type system in some way".

test/clang-tidy/readability-implicit-bool-cast.cpp

328

No, currently all macros are ignored, and personally, I think it is for the better. I simply don't like messing with macros, as that can have all sort of nasty consequences.

But even if the check would perform such replacement, I have to ask: is it really the fault of this check? Using assert() in such way is a prime example of "hacked" solution to a missing functionality (adding message displayed with the assert).

It would work perfectly, if it was used in a bit more sane manner, such as:

#define assert_with_message(condition, message) assert(condition && message)

assert_with_message(false, "some message");

Then, the implicit cast in macro body would be ignored, and the actual assert statement written in such way would be clearer.

[piotrdz]

I fixed the issues found in review and added a few other enhancements:

• add config options to allow integer and pointer casts in conditionals, e.g. "if (pointer)",
• add support for NULL macro cast to boolean,
• ignore usage of variable declaration in control statements, e.g. "if (int x = function())",
• add support case of false literal to pointer conversion in pre-C++11 standards
• propose NULL instead of nullptr in replacements in pre-C++11 standards

[piotrdz]

I think this is a more complete version, and we're getting closer to getting my patch committed. @sbenza: Do you agree?

clang-tidy/readability/ImplicitBoolCastCheck.cpp

153

Also, it turns out, I missed this case in my tests. I added appropriate exclusion for using variable declarations in this way.

223

Ah, my bad. clang-tidy tests use by default C++11. Of course this code will be accepted in older C++ standards. I added provisions for that case, and also changed nullptr to NULL in suggested replacements when nullptr is not available.

[sbenza]

clang-tidy/readability/ImplicitBoolCastCheck.cpp

34

I can submit the matchers for you.
I'll do that when the change is stable.

44

I was a little confused by the name. I thought the expansion was somehow a null expansion, not that it is the NULL macro.
Maybe should be isNULLMacroExpansion?

88

NULL might need an #include

89

A little explanation...
When you get getLocStart/getLocEnd you get the location of the start of the first token and the start of the last token.

Eg: in 'foo + bar' getLocStart points to 'f' and getLocEnd points to 'b'.

When you create a CharSourceRange you have two options:

• getTokenRange(): spans from the first char of the token at start to past-the-end of the token at end
• getCharRange(): spans the locations passed exactly.

getTokenRange(loc at 'f', loc at 'b') will give a range spanning 'foo + bar'
getCharRange(loc at 'f', loc at 'b') will give a range spanning 'foo + '

They are both useful. Sometimes you need a little extra help from the lexer of manually offsetting the locations.

Note that if the node spans only one token, then start/end will be the same location.

120

fold declaration into the if() condition

136

Macros are the nemesis of clang-tidy checks...

docs/clang-tidy/checks/readability-implicit-bool-cast.rst

57

I agree with all that, but that is not what the comment is saying.
As you say, we want to say 'integer != 0' and not 'static_cast<bool>(integer)'

test/clang-tidy/readability-implicit-bool-cast-cxx98.cpp

20 ↗

(On Diff #37707)

Don't add the [readability...] on each hit. Just the first one.

test/clang-tidy/readability-implicit-bool-cast.cpp

307

Just out of curiosity, does it handle -0.0 correctly?

328

Is there any non-macro assert-like API where people do the same trick?

[piotrdz]

Addressed latest review issues.

[piotrdz]

There you go, third revision. I think this version should be ready for commit.

clang-tidy/readability/ImplicitBoolCastCheck.cpp

88

I changed it to 0.

91

Thanks for explaining that, it makes sense to me now. Perhaps such description could be added to Doxygen documentation?

test/clang-tidy/readability-implicit-bool-cast.cpp

307

Yes, it will. -0.0 is parsed as expression using binary operator (operator unary minus + double const). It will be turned into (-0.0) != 0.0 which will evaluate to false, the same as original -0.0.

[sbenza]

docs/clang-tidy/checks/readability-implicit-bool-cast.rst

59

This is still a thing.
The replacement is not what this comment says.

test/clang-tidy/readability-implicit-bool-cast.cpp

307

This is for literals, so it will try to convert to the bool literal instead of using != 0.0
However, the check above does:

(FloatLit->getValue().bitcastToAPInt() == 0) ? "false" : "true";

and that will return "true" for -0.0, I think.

[piotrdz]

Addressed last issues in review

[piotrdz]

Any other comments?

docs/clang-tidy/checks/readability-implicit-bool-cast.rst

60

Sorry, somehow I missed that one. I meant to show casts from bool to int here, so the code is wrong, as you say.

test/clang-tidy/readability-implicit-bool-cast.cpp

308

No, it doesn't work like that. As I said:
-0.0 will *never* be parsed as a literal. These are two tokens in source code: unary minus AND a 0.0 floating point literal. The standard says that literals are only numbers and - is never a part of a literal.

However, I can grant that someone, somewhere might invent negative literals, so to be absolutely on the safe side, I changed the code in question to take the absolute value of literal.

And to prove that -0.0 is parsed as an expression, I added tests for that.

Also note that (-0.0) != 0.0 is perfectly fine as a replacement, as it still evaluates to false. The standard says that -0.0 behaves just like regular 0.0 in most aspects, including equality with 0.0 and so on. The only difference is seen in operations like division or multiplication, where it changes the sign of result accordingly.

[sbenza]

test/clang-tidy/readability-implicit-bool-cast.cpp

308

You are right.
I was thinking that -0.0 was a FloatingLiteral, but it is in fact a UnaryOperator with a FloatingLiteral inside. Sorry for the noise.

[piotrdz]

Thanks for accepting the review. However, I still have to ask someone to make the commit. Or should I obtain commit rights myself? If so, how do I do that?

[Eugene.Zelenko]

See http://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access.

[piotrdz]

I have obtained now commit rights but I want to make sure: I can commit this patch now that it is accepted? That is, accepting the review is the same as saying "LGTM", right?

[Eugene.Zelenko]

Accepted status is what is most important.

Please don't forget to mention Differential revision in commit comment, so is revision will be closed automatically. See example.

Please also be near computer for ~hour, just to make sure all build bots finished successfully. I learned this after breaking LLDB MSVC builds couple of times :-)

[piotrdz]

@eugene: thanks for clarifying that and your advice. I made the commit and it seems I didn't break anything, yet :-).

clang-tidy/readability/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyReadabilityModule
   BracesAroundStatementsCheck.cpp
   ContainerSizeEmptyCheck.cpp
   ElseAfterReturnCheck.cpp
   FunctionSizeCheck.cpp
   IdentifierNamingCheck.cpp
+  ImplicitBoolCastCheck.cpp
   InconsistentDeclarationParameterNameCheck.cpp
   NamedParameterCheck.cpp
   NamespaceCommentCheck.cpp
   ReadabilityTidyModule.cpp
   RedundantStringCStrCheck.cpp
   RedundantSmartptrGetCheck.cpp
   SimplifyBooleanExprCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTooling
   )

clang-tidy/readability/ImplicitBoolCastCheck.h

+//===--- ImplicitBoolCastCheck.h - clang-tidy--------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IMPLICIT_BOOL_CAST_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IMPLICIT_BOOL_CAST_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+
+/// \brief Checks for use of implicit bool casts in expressions.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/readability-implicit-bool-cast.html
+class ImplicitBoolCastCheck : public ClangTidyCheck {
+public:
+  ImplicitBoolCastCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  void handleCastToBool(const ImplicitCastExpr *CastExpression,
+                        const Stmt *ParentStatement, ASTContext &Context);
+  void handleCastFromBool(const ImplicitCastExpr *CastExpression,
+                          const ImplicitCastExpr *FurtherImplicitCastExpression,
+                          ASTContext &Context);
+};
+
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IMPLICIT_BOOL_CAST_H

clang-tidy/readability/ImplicitBoolCastCheck.cpp

+//===--- ImplicitBoolCastCheck.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 "ImplicitBoolCastCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+
+#include <iostream>
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+
+namespace {
+
+AST_MATCHER_P(CastExpr, hasCastKind, CastKind, Kind) {
+  return Node.getCastKind() == Kind;
+}
+
+AST_MATCHER_P(BinaryOperator, hasOpcode, BinaryOperatorKind, OperatorKind) {
+  return Node.getOpcode() == OperatorKind;
+}
+
+AST_MATCHER(QualType, isBoolType) {
+  return not Node.isNull() and Node->isBooleanType();
+}
+
+AST_MATCHER(Expr, comesFromMacroExpansion) {
+  SourceManager &SM = Finder->getASTContext().getSourceManager();
+  SourceLocation Loc = Node.getLocStart();
+  return SM.isMacroBodyExpansion(Loc) or SM.isMacroArgExpansion(Loc);
+}
+
+StatementMatcher createImplicitCastFromBoolMatcher() {
+  return implicitCastExpr(
+      unless(anyOf(hasParent(explicitCastExpr()), comesFromMacroExpansion(),
+                   anyOf(hasAncestor(functionDecl(
+                             ast_matchers::isTemplateInstantiation())),
+                         hasAncestor(functionTemplateDecl())))),
+      anyOf(hasCastKind(CK_IntegralCast), hasCastKind(CK_IntegralToFloating)),
+      hasSourceExpression(
+          anyOf(cxxBoolLiteral(), expr(hasType(qualType(isBoolType()))))));
+}
+
+StringRef
+getZeroLiteralToCompareWithForGivenType(CastKind CastExpressionKind,
+                                        QualType CastSubExpressionType,
+                                        ASTContext &Context) {
+  switch (CastExpressionKind) {
+  case CK_IntegralToBoolean:
+    return CastSubExpressionType->isUnsignedIntegerType() ? "0u" : "0";
+
+  case CK_FloatingToBoolean:
+    return Context.hasSameType(CastSubExpressionType, Context.FloatTy) ? "0.0f"
+                                                                       : "0.0";
+
+  case CK_PointerToBoolean:
+  case CK_MemberPointerToBoolean: // Fall-through on purpose.
+    return "nullptr";
+
+  default:
+    assert(false && "Unexpected cast kind");
+  }
+}
+
+bool isUnaryLogicalNotOperator(const Stmt *Statement) {
+  const auto *UnaryOperatorExpression =
+      llvm::dyn_cast_or_null<UnaryOperator>(Statement);
+  return UnaryOperatorExpression != nullptr &&
+         UnaryOperatorExpression->getOpcode() == UO_LNot;
+}
+
+void addFixItHintsForGenericExpressionCastToBool(
+    DiagnosticBuilder &Diagnostic, const ImplicitCastExpr *CastExpression,
+    const Stmt *ParentStatement, ASTContext &Context) {
+  // In case of expressions like (! integer), we should remove the redundant not
+  // operator and use inverted comparison (integer == 0).
+  bool InvertComparison = isUnaryLogicalNotOperator(ParentStatement);
+  if (InvertComparison) {
+    SourceLocation ParentStartLoc = ParentStatement->getLocStart();
+    SourceLocation ParentEndLoc = Lexer::getLocForEndOfToken(
+        ParentStatement->getLocStart(), -1, Context.getSourceManager(),
+        Context.getLangOpts());
+    Diagnostic.AddFixItHint(FixItHint::CreateRemoval(
+        CharSourceRange::getTokenRange(ParentStartLoc, ParentEndLoc)));
+
+    auto FurtherParents = Context.getParents(*ParentStatement);
+    ParentStatement = FurtherParents[0].get<Stmt>();
+  }
+
+  const Expr *SubExpression = CastExpression->getSubExpr();
+
+  bool NeedInnerParens = llvm::isa<BinaryOperator>(SubExpression) or
+                         llvm::isa<UnaryOperator>(SubExpression);
+  bool NeedOuterParens = ParentStatement != nullptr and
+                         (llvm::isa<BinaryOperator>(ParentStatement) or
+                          llvm::isa<UnaryOperator>(ParentStatement));
+
+  SourceLocation StartLoc = CastExpression->getLocStart();
+  SourceLocation EndLoc = Lexer::getLocForEndOfToken(
+      CastExpression->getLocEnd(), 0, Context.getSourceManager(),
+      Context.getLangOpts());
+
+  if (NeedOuterParens) {
+    Diagnostic.AddFixItHint(FixItHint::CreateInsertion(StartLoc, "("));
+  }
+  if (NeedInnerParens) {
+    Diagnostic.AddFixItHint(FixItHint::CreateInsertion(StartLoc, "("));
+    Diagnostic.AddFixItHint(FixItHint::CreateInsertion(EndLoc, ")"));
+  }
+
+  if (InvertComparison) {
+    Diagnostic.AddFixItHint(FixItHint::CreateInsertion(EndLoc, " == "));
+  } else {
+    Diagnostic.AddFixItHint(FixItHint::CreateInsertion(EndLoc, " != "));
+  }
+
+  Diagnostic.AddFixItHint(FixItHint::CreateInsertion(
+      EndLoc,
+      getZeroLiteralToCompareWithForGivenType(
+          CastExpression->getCastKind(), SubExpression->getType(), Context)));
+
+  if (NeedOuterParens) {
+    Diagnostic.AddFixItHint(FixItHint::CreateInsertion(EndLoc, ")"));
+  }
+}
+
+bool isLiteralExpression(const Expr *Expression) {
+  return llvm::isa<IntegerLiteral>(Expression) or
+         llvm::isa<FloatingLiteral>(Expression) or
+         llvm::isa<CharacterLiteral>(Expression) or
+         llvm::isa<StringLiteral>(Expression->IgnoreCasts());
+}
+
+StringRef
+getEquivalentBoolLiteralForOtherLiteral(const Expr *LiteralExpression) {
+  const auto *IntegerLiteralExpression =
+      llvm::dyn_cast_or_null<IntegerLiteral>(LiteralExpression);
+  if (IntegerLiteralExpression != nullptr) {
+    return (IntegerLiteralExpression->getValue() == 0) ? "false" : "true";
+  }
+
+  const auto *FloatingLiteralExpression =
+      llvm::dyn_cast_or_null<FloatingLiteral>(LiteralExpression);
+  if (FloatingLiteralExpression != nullptr) {
+    return (FloatingLiteralExpression->getValue().bitcastToAPInt() == 0)
+               ? "false"
+               : "true";
+  }
+
+  const auto *CharacterLiteralExpression =
+      llvm::dyn_cast_or_null<CharacterLiteral>(LiteralExpression);
+  if (CharacterLiteralExpression != nullptr) {
+    return (CharacterLiteralExpression->getValue() == 0) ? "false" : "true";
+  }
+
+  const auto *StringLiteralExpression =
+      llvm::dyn_cast_or_null<StringLiteral>(LiteralExpression->IgnoreCasts());
+  if (StringLiteralExpression != nullptr) {
+    return "true";
+  }
+
+  assert(false && "Unexpected literal expression");
+}
+
+void addFixItHintsForLiteralCastToBool(DiagnosticBuilder &Diagnostic,
+                                       const ImplicitCastExpr *CastExpression,
+                                       ASTContext &Context) {
+  SourceLocation StartLoc = CastExpression->getLocStart();
+  SourceLocation EndLoc = Lexer::getLocForEndOfToken(
+      CastExpression->getLocEnd(), -1, Context.getSourceManager(),
+      Context.getLangOpts());
+
+  Diagnostic.AddFixItHint(FixItHint::CreateReplacement(
+      CharSourceRange::getTokenRange(StartLoc, EndLoc),
+      getEquivalentBoolLiteralForOtherLiteral(CastExpression->getSubExpr())));
+}
+
+void addFixItHintsForGenericExpressionCastFromBool(
+    DiagnosticBuilder &Diagnostic, const ImplicitCastExpr *CastExpression,
+    ASTContext &Context, StringRef OtherType) {
+  const Expr *SubExpression = CastExpression->getSubExpr();
+  bool NeedParens = not llvm::isa<ParenExpr>(SubExpression);
+
+  SourceLocation StartLoc = CastExpression->getLocStart();
+  SourceLocation EndLoc = Lexer::getLocForEndOfToken(
+      CastExpression->getLocEnd(), 0, Context.getSourceManager(),
+      Context.getLangOpts());
+
+  Diagnostic.AddFixItHint(FixItHint::CreateInsertion(StartLoc, "static_cast<"));
+  Diagnostic.AddFixItHint(FixItHint::CreateInsertion(StartLoc, OtherType));
+  Diagnostic.AddFixItHint(FixItHint::CreateInsertion(StartLoc, ">"));
+
+  if (NeedParens) {
+    Diagnostic.AddFixItHint(FixItHint::CreateInsertion(StartLoc, "("));
+    Diagnostic.AddFixItHint(FixItHint::CreateInsertion(EndLoc, ")"));
+  }
+}
+
+StringRef getEquivalentNumericLiteralForBoolLiteral(
+    const CXXBoolLiteralExpr *BoolLiteralExpression, QualType DestinationType,
+    ASTContext &Context) {
+  if (DestinationType->isFloatingType()) {
+    if (BoolLiteralExpression->getValue() == true) {
+      return Context.hasSameType(DestinationType, Context.FloatTy) ? "1.0f"
+                                                                   : "1.0";
+    }
+    return Context.hasSameType(DestinationType, Context.FloatTy) ? "0.0f"
+                                                                 : "0.0";
+  }
+
+  if (BoolLiteralExpression->getValue() == true) {
+    return DestinationType->isUnsignedIntegerType() ? "1u" : "1";
+  }
+  return DestinationType->isUnsignedIntegerType() ? "0u" : "0";
+}
+
+void addFixItHintsForLiteralCastFromBool(DiagnosticBuilder &Diagnostic,
+                                         const ImplicitCastExpr *CastExpression,
+                                         ASTContext &Context,
+                                         QualType DestinationType) {
+  SourceLocation StartLoc = CastExpression->getLocStart();
+  SourceLocation EndLoc = Lexer::getLocForEndOfToken(
+      CastExpression->getLocEnd(), -1, Context.getSourceManager(),
+      Context.getLangOpts());
+  const auto *BoolLiteralExpression =
+      llvm::dyn_cast<CXXBoolLiteralExpr>(CastExpression->getSubExpr());
+
+  Diagnostic.AddFixItHint(FixItHint::CreateReplacement(
+      CharSourceRange::getTokenRange(StartLoc, EndLoc),
+      getEquivalentNumericLiteralForBoolLiteral(BoolLiteralExpression,
+                                                DestinationType, Context)));
+}
+
+} // anonymous namespace
+
+void ImplicitBoolCastCheck::registerMatchers(MatchFinder *Finder) {
+  // This check doesn't make much sense if we run it on language without
+  // built-in bool support.
+  if (not getLangOpts().Bool) {
+    return;
+  }
+
+  Finder->addMatcher(
+      implicitCastExpr(
+          unless(anyOf(hasParent(explicitCastExpr()), comesFromMacroExpansion(),
+                       anyOf(hasAncestor(functionDecl(
+                                 ast_matchers::isTemplateInstantiation())),
+                             hasAncestor(functionTemplateDecl())))),
+          anyOf(hasCastKind(CK_IntegralToBoolean),
+                hasCastKind(CK_FloatingToBoolean),
+                hasCastKind(CK_PointerToBoolean),
+                hasCastKind(CK_MemberPointerToBoolean)),
+          anyOf(hasParent(stmt().bind("parentStmt")), anything()))
+          .bind("implicitCastToBool"),
+      this);
+
+  Finder->addMatcher(
+      implicitCastExpr(
+          createImplicitCastFromBoolMatcher(),
+          // 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(hasOpcode(BO_EQ), hasOpcode(BO_NE)),
+                             hasLHS(createImplicitCastFromBoolMatcher()),
+                             hasRHS(createImplicitCastFromBoolMatcher())))),
+          // Check also for nested casts, for example: bool -> int -> float.
+          anyOf(hasParent(implicitCastExpr().bind("furtherImplicitCast")),
+                anything()))
+          .bind("implicitCastFromBool"),
+      this);
+}
+
+void ImplicitBoolCastCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *CastToBool =
+      Result.Nodes.getNodeAs<ImplicitCastExpr>("implicitCastToBool");
+  if (CastToBool != nullptr) {
+    const auto *ParentStatement = Result.Nodes.getNodeAs<Stmt>("parentStmt");
+    return handleCastToBool(CastToBool, ParentStatement, *Result.Context);
+  }
+
+  const auto *CastFromBool =
+      Result.Nodes.getNodeAs<ImplicitCastExpr>("implicitCastFromBool");
+  if (CastFromBool != nullptr) {
+    const auto *FurtherImplicitCastExpression =
+        Result.Nodes.getNodeAs<ImplicitCastExpr>("furtherImplicitCast");
+    return handleCastFromBool(CastFromBool, FurtherImplicitCastExpression,
+                              *Result.Context);
+  }
+}
+
+void ImplicitBoolCastCheck::handleCastToBool(
+    const ImplicitCastExpr *CastExpression, const Stmt *ParentStatement,
+    ASTContext &Context) {
+  std::string OtherType = CastExpression->getSubExpr()->getType().getAsString();
+  DiagnosticBuilder Diagnostic =
+      diag(CastExpression->getLocStart(), "implicit cast '%0' -> bool")
+      << OtherType;
+
+  if (isLiteralExpression(CastExpression->getSubExpr())) {
+    addFixItHintsForLiteralCastToBool(Diagnostic, CastExpression, Context);
+  } else {
+    addFixItHintsForGenericExpressionCastToBool(Diagnostic, CastExpression,
+                                                ParentStatement, Context);
+  }
+}
+
+void ImplicitBoolCastCheck::handleCastFromBool(
+    const ImplicitCastExpr *CastExpression,
+    const ImplicitCastExpr *FurtherImplicitCastExpression,
+    ASTContext &Context) {
+  QualType DestinationType = (FurtherImplicitCastExpression != nullptr)
+                                 ? FurtherImplicitCastExpression->getType()
+                                 : CastExpression->getType();
+  std::string DestinationTypeString = DestinationType.getAsString();
+  DiagnosticBuilder Diagnostic =
+      diag(CastExpression->getLocStart(), "implicit cast bool -> '%0'")
+      << DestinationTypeString;
+
+  if (llvm::isa<CXXBoolLiteralExpr>(CastExpression->getSubExpr())) {
+    addFixItHintsForLiteralCastFromBool(Diagnostic, CastExpression, Context,
+                                        DestinationType);
+  } else {
+    addFixItHintsForGenericExpressionCastFromBool(
+        Diagnostic, CastExpression, Context, DestinationTypeString);
+  }
+}
+
+} // namespace tidy
+} // namespace clang

clang-tidy/readability/ReadabilityTidyModule.cpp

 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "BracesAroundStatementsCheck.h"
 #include "ContainerSizeEmptyCheck.h"
 #include "ElseAfterReturnCheck.h"
 #include "FunctionSizeCheck.h"
 #include "IdentifierNamingCheck.h"
+#include "ImplicitBoolCastCheck.h"
 #include "InconsistentDeclarationParameterNameCheck.h"
 #include "NamedParameterCheck.h"
 #include "RedundantSmartptrGetCheck.h"
 #include "RedundantStringCStrCheck.h"
 #include "SimplifyBooleanExprCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 class ReadabilityModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<BracesAroundStatementsCheck>(
         "readability-braces-around-statements");
     CheckFactories.registerCheck<ContainerSizeEmptyCheck>(
         "readability-container-size-empty");
     CheckFactories.registerCheck<ElseAfterReturnCheck>(
         "readability-else-after-return");
     CheckFactories.registerCheck<FunctionSizeCheck>(
         "readability-function-size");
     CheckFactories.registerCheck<IdentifierNamingCheck>(
         "readability-identifier-naming");
+    CheckFactories.registerCheck<ImplicitBoolCastCheck>(
+        "readability-implicit-bool-cast");
     CheckFactories.registerCheck<InconsistentDeclarationParameterNameCheck>(
         "readability-inconsistent-declaration-parameter-name");
     CheckFactories.registerCheck<readability::NamedParameterCheck>(
         "readability-named-parameter");
     CheckFactories.registerCheck<RedundantSmartptrGetCheck>(
         "readability-redundant-smartptr-get");
     CheckFactories.registerCheck<RedundantStringCStrCheck>(
         "readability-redundant-string-cstr");

docs/clang-tidy/checks/list.rst

.. toctree::
    modernize-use-auto
    modernize-use-nullptr
    modernize-use-override
    readability-braces-around-statements
    readability-container-size-empty
    readability-else-after-return
    readability-function-size
    readability-identifier-naming
+   readability-implicit-bool-cast
    readability-inconsistent-declaration-parameter-name
    readability-named-parameter
    readability-redundant-smartptr-get
    readability-redundant-string-cstr
    readability-simplify-boolean-expr

docs/clang-tidy/checks/readability-implicit-bool-cast.rst

+readability-implicit-bool-cast
+==============================
+
+This check can be used to find implicit conversions between built-in types and
+booleans. Depending on use case, it may simply help with readability of the code,
+or in some cases, point to potential bugs which remain unnoticed due to implicit
+conversions.
+
+The following is a real-world example of bug which was hiding behind implicit
+bool cast:
+
+.. code:: c++
+
+  class Foo {
+    int m_foo;
+  public:
+    void setFoo(bool foo) { m_foo = foo; } // warning: implicit cast bool -> int
+    int getFoo() { return m_foo; }
+  };
+
+  void use(Foo& foo) {
+    bool value = foo.getFoo(); // warning: implicit cast int -> bool
+  }
+
+This code is the result of unsuccessful refactoring, where type of ``m_foo``
+changed from ``bool`` to ``int``. The programmer forgot to change all
+occurences of ``bool``, and the remaining code is no longer correct, yet it
+still compiles without any visible warnings.
+
+In addition to issuing warnings, FixIt hints are provided to help solve
+the reported issues. This can be used for improving readabilty of code, for example:
+
+.. code:: c++
+
+  void conversionsToBool() {
+    float floating;
+    bool boolean = floating;
+    // ^ propose replacement: bool boolean = floating != 0.0f;
+
+    int integer
+    if (integer) {}
+    // ^ propose replacement: if (integer != 0) {}
+
+    int* pointer;
+    if (!pointer) {}
+    // ^ propose replacement: if (pointer == nullptr) {}
+
+    while (1) {}
+    // ^ propose replacement: while (true) {}
+  }
+
+  void functionTakingBool(bool param);
+
+  void conversionsFromBool() {
+    int integer;
+    functionTakingBool(integer);
+    // ^ propose replacement: functionTakingBool(static_cast<bool>(integer));
+
+    functionTakingBool(1);
+    // ^ propose replacement: functionTakingBool(true);
+  }
+
+In general, the following cast types are checked:
+
+ - integer expression/literal to boolean
+ - floating expression/literal to boolean
+ - pointer/pointer to member/``nullptr`` to boolean
+ - boolean expression/literal to integer
+ - boolean expression/literal to floating
+
+The rules for generating FixIt hints are:
+ - in case of casts from other built-in type to bool, an explicit comparison
+   is proposed to make it clear what exaclty is being compared:
+
+   - ``bool boolean = floating;`` is changed to ``bool boolean = floating == 0.0f;``
+   - for other types, appropriate literals are used (``0``, ``0u``, ``0.0f``, ``0.0``, ``nullptr``)
+ - in case of negated expressions cast to bool, the proposed replacement with
+   comparison is simplified:
+
+   - ``if (!pointer)`` is changed to ``if (pointer == nullptr)``
+ - in case of casts from bool to other built-in types, an explicit ``static_cast``
+   is proposed to make it clear that a cast is taking place:
+
+   - ``int integer = boolean;`` is changed to ``int integer = static_cast<int>(boolean);``
+ - if the cast is performed on type literals, an equivalent literal is proposed,
+   according to what type is actually expected, for example:
+
+   - ``functionTakingBool(0);`` is changed to ``functionTakingBool(false);``
+   - ``functionTakingInt(true);`` is changed to ``functionTakingInt(1);``
+   - for other types, appropriate literals are used (``false``, ``true``, ``0``, ``1``, ``0u``, ``1u``,
+     ``0.0f``, ``1.0f``, ``0.0``, ``1.0f``)
+
+Occurences of implicit casts inside macros and template instantiations are
+deliberately ignored, as it is not clear how to deal with such cases.
 No newline at end of file

test/clang-tidy/readability-implicit-bool-cast.cpp

+// RUN: %python %S/check_clang_tidy.py %s readability-implicit-bool-cast %t
+
+void functionTakingBool(bool);
+void functionTakingInt(int);
+void functionTakingUnsignedLong(unsigned long);
+void functionTakingChar(char);
+void functionTakingFloat(float);
+void functionTakingDouble(double);
+
+struct Struct {
+  int member;
+};
+
+
+////////// Implicit cast from bool.
+
+void implicitCastFromBoolSimpleCases() {
+  bool boolean = true;
+
+  functionTakingBool(boolean);
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:21: warning: implicit cast bool -> 'int'
+  // CHECK-FIXES: functionTakingInt(static_cast<int>(boolean));
+  functionTakingInt(boolean);
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:30: warning: implicit cast bool -> 'unsigned long'
+  // CHECK-FIXES: functionTakingUnsignedLong(static_cast<unsigned long>(boolean));
+  functionTakingUnsignedLong(boolean);
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast bool -> 'char'
+  // CHECK-FIXES: functionTakingChar(static_cast<char>(boolean));
+  functionTakingChar(boolean);
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:23: warning: implicit cast bool -> 'float'
+  // CHECK-FIXES: functionTakingFloat(static_cast<float>(boolean));
+  functionTakingFloat(boolean);
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:24: warning: implicit cast bool -> 'double'
+  // CHECK-FIXES: functionTakingDouble(static_cast<double>(boolean));
+  functionTakingDouble(boolean);
+}
+
+float implicitCastFromBoolInReturnValue() {
+  bool boolean = false;
+  // CHECK-MESSAGES: :[[@LINE+2]]:10: warning: implicit cast bool -> 'float'
+  // CHECK-FIXES: return static_cast<float>(boolean);
+  return boolean;
+}
+
+void implicitCastFromBoolInSingleBoolExpressions() {
+  bool boolean = true;
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:17: warning: implicit cast bool -> 'int'
+  // CHECK-FIXES: int integer = static_cast<int>(boolean) - 3;
+  int integer = boolean - 3;
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:20: warning: implicit cast bool -> 'float'
+  // CHECK-FIXES: float floating = static_cast<float>(boolean) / 0.3f;
+  float floating = boolean / 0.3f;
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:20: warning: implicit cast bool -> 'char'
+  // CHECK-FIXES: char character = static_cast<char>(boolean);
+  char character = boolean;
+}
+
+void implicitCastFromBoollInComplexBoolExpressions() {
+  bool boolean = true;
+  bool anotherBoolean = false;
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:17: warning: implicit cast bool -> 'int'
+  // CHECK-FIXES: int integer = static_cast<int>(boolean && anotherBoolean);
+  int integer = boolean && anotherBoolean;
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:32: warning: implicit cast bool -> 'unsigned long'
+  // CHECK-FIXES: unsigned long unsignedLong = static_cast<unsigned long>(! boolean) + 4ul;
+  unsigned long unsignedLong = (! boolean) + 4ul;
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:20: warning: implicit cast bool -> 'float'
+  // CHECK-FIXES: float floating = static_cast<float>(boolean || anotherBoolean) * 0.3f;
+  float floating = (boolean || anotherBoolean) * 0.3f;
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:27: warning: implicit cast bool -> 'double'
+  // CHECK-FIXES: double doubleFloating = static_cast<double>(boolean && (anotherBoolean || boolean)) * 0.3;
+  double doubleFloating = (boolean && (anotherBoolean || boolean)) * 0.3;
+}
+
+void implicitCastFromBoolLiterals() {
+  // CHECK-MESSAGES: :[[@LINE+2]]:21: warning: implicit cast bool -> 'int'
+  // CHECK-FIXES: functionTakingInt(1);
+  functionTakingInt(true);
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:30: warning: implicit cast bool -> 'unsigned long'
+  // CHECK-FIXES: functionTakingUnsignedLong(0u);
+  functionTakingUnsignedLong(false);
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast bool -> 'char'
+  // CHECK-FIXES: functionTakingChar(1);
+  functionTakingChar(true);
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:23: warning: implicit cast bool -> 'float'
+  // CHECK-FIXES: functionTakingFloat(0.0f);
+  functionTakingFloat(false);
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:24: warning: implicit cast bool -> 'double'
+  // CHECK-FIXES: functionTakingDouble(1.0);
+  functionTakingDouble(true);
+}
+
+void implicitCastFromBoolInComparisons() {
+  bool boolean = true;
+  int integer = 0;
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast bool -> 'int'
+  // CHECK-FIXES: functionTakingBool(static_cast<int>(boolean) == integer);
+  functionTakingBool(boolean == integer);
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:33: warning: implicit cast bool -> 'int'
+  // CHECK-FIXES: functionTakingBool(integer != static_cast<int>(boolean));
+  functionTakingBool(integer != boolean);
+}
+
+void ignoreBoolComparisons() {
+  bool boolean = true;
+  bool anotherBoolean = false;
+
+  functionTakingBool(boolean == anotherBoolean);
+  functionTakingBool(boolean != anotherBoolean);
+}
+
+void ignoreExplicitCastsFromBool() {
+  bool boolean = true;
+
+  int integer = static_cast<int>(boolean) + 3;
+  float floating = static_cast<float>(boolean) * 0.3f;
+  char character = static_cast<char>(boolean);
+}
+
+void ignoreImplicitCastFromBoolInMacroExpansions() {
+  bool boolean = true;
+
+  #define CAST_FROM_BOOL_IN_MACRO_BODY boolean + 3
+  int integerFromMacroBody = CAST_FROM_BOOL_IN_MACRO_BODY;
+
+  #define CAST_FROM_BOOL_IN_MACRO_ARGUMENT(x) x + 3
+  int integerFromMacroArgument = CAST_FROM_BOOL_IN_MACRO_ARGUMENT(boolean);
+}
+
+namespace ignoreImplicitCastFromBoolInTemplateInstantiations {
+
+template<typename T>
+void templateFunction() {
+  bool boolean = true;
+  T uknownType = boolean + 3;
+}
+
+void useOfTemplateFunction() {
+  templateFunction<int>();
+}
+
+} // namespace
+
+////////// Implicit cast to bool.
+
+void implicitCastToBoolSimpleCases() {
+  int integer = 10;
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'int' -> bool
+  // CHECK-FIXES: functionTakingBool(integer != 0);
+  functionTakingBool(integer);
+
+  unsigned long unsignedLong = 10;
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'unsigned long' -> bool
+  // CHECK-FIXES: functionTakingBool(unsignedLong != 0u);
+  functionTakingBool(unsignedLong);
+
+  float floating = 0.0f;
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'float' -> bool
+  // CHECK-FIXES: functionTakingBool(floating != 0.0f);
+  functionTakingBool(floating);
+
+  double doubleFloating = 1.0f;
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'double' -> bool
+  // CHECK-FIXES: functionTakingBool(doubleFloating != 0.0);
+  functionTakingBool(doubleFloating);
+
+  char character = 'a';
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'char' -> bool
+  // CHECK-FIXES: functionTakingBool(character != 0);
+  functionTakingBool(character);
+
+  int* pointer = nullptr;
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'int *' -> bool
+  // CHECK-FIXES: functionTakingBool(pointer != nullptr);
+  functionTakingBool(pointer);
+
+  auto pointerToMember = &Struct::member;
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'int struct Struct::*' -> bool
+  // CHECK-FIXES: functionTakingBool(pointerToMember != nullptr);
+  functionTakingBool(pointerToMember);
+}
+
+void implicitCastToBoolInSingleExpressions() {
+  int integer = 10;
+  // CHECK-MESSAGES: :[[@LINE+2]]:28: warning: implicit cast 'int' -> bool
+  // CHECK-FIXES: bool boolComingFromInt = integer != 0;
+  bool boolComingFromInt = integer;
+
+  float floating = 10.0f;
+  // CHECK-MESSAGES: :[[@LINE+2]]:30: warning: implicit cast 'float' -> bool
+  // CHECK-FIXES: bool boolComingFromFloat = floating != 0.0f;
+  bool boolComingFromFloat = floating;
+
+  char character = 'a';
+  // CHECK-MESSAGES: :[[@LINE+2]]:29: warning: implicit cast 'char' -> bool
+  // CHECK-FIXES: bool boolComingFromChar = character != 0;
+  bool boolComingFromChar = character;
+
+  int* pointer = nullptr;
+  // CHECK-MESSAGES: :[[@LINE+2]]:32: warning: implicit cast 'int *' -> bool
+  // CHECK-FIXES: bool boolComingFromPointer = pointer != nullptr;
+  bool boolComingFromPointer = pointer;
+}
+
+void implicitCastToBoolInComplexExpressions() {
+  bool boolean = true;
+
+  int integer = 10;
+  int anotherInteger = 20;
+  // CHECK-MESSAGES: :[[@LINE+2]]:32: warning: implicit cast 'int' -> bool
+  // CHECK-FIXES: bool boolComingFromInteger = (integer + anotherInteger) != 0;
+  bool boolComingFromInteger = integer + anotherInteger;
+
+  float floating = 0.2f;
+  // CHECK-MESSAGES: :[[@LINE+2]]:33: warning: implicit cast 'float' -> bool
+  // CHECK-FIXES: bool boolComingFromFloating = ((floating - 0.3f) != 0.0f) || boolean;
+  bool boolComingFromFloating = floating - 0.3f || boolean;
+
+  double doubleFloating = 0.3;
+  // CHECK-MESSAGES: :[[@LINE+2]]:39: warning: implicit cast 'double' -> bool
+  // CHECK-FIXES: bool boolComingFromDoubleFloating = ((doubleFloating - 0.4) != 0.0) && boolean;
+  bool boolComingFromDoubleFloating = (doubleFloating - 0.4) && boolean;
+}
+
+void implicitCastInNegationExpressions() {
+  int integer = 10;
+  // CHECK-MESSAGES: :[[@LINE+2]]:36: warning: implicit cast 'int' -> bool
+  // CHECK-FIXES: bool boolComingFromNegatedInt = integer == 0;
+  bool boolComingFromNegatedInt = !integer;
+
+  float floating = 10.0f;
+  // CHECK-MESSAGES: :[[@LINE+2]]:39: warning: implicit cast 'float' -> bool
+  // CHECK-FIXES: bool boolComingFromNegatedFloat = floating == 0.0f;
+  bool boolComingFromNegatedFloat = ! floating;
+
+  char character = 'a';
+  // CHECK-MESSAGES: :[[@LINE+2]]:39: warning: implicit cast 'char' -> bool
+  // CHECK-FIXES: bool boolComingFromNegatedChar = ( character == 0);
+  bool boolComingFromNegatedChar = (! character);
+
+  int* pointer = nullptr;
+  // CHECK-MESSAGES: :[[@LINE+2]]:43: warning: implicit cast 'int *' -> bool
+  // CHECK-FIXES: bool boolComingFromNegatedPointer = pointer == nullptr;
+  bool boolComingFromNegatedPointer = not pointer;
+}
+
+void implicitCastToBoolInControlStatements() {
+  int integer = 10;
+  // CHECK-MESSAGES: :[[@LINE+2]]:7: warning: implicit cast 'int' -> bool
+  // CHECK-FIXES: if (integer != 0) {}
+  if (integer) {}
+
+  long int longInteger = 0.2f;
+  // CHECK-MESSAGES: :[[@LINE+2]]:9: warning: implicit cast 'long' -> bool
+  // CHECK-FIXES: for (;longInteger != 0;) {}
+  for (;longInteger;) {}
+
+  float floating = 0.3f;
+  // CHECK-MESSAGES: :[[@LINE+2]]:10: warning: implicit cast 'float' -> bool
+  // CHECK-FIXES: while (floating != 0.0f) {}
+  while (floating) {}
+
+  double doubleFloating = 0.4;
+  // CHECK-MESSAGES: :[[@LINE+2]]:16: warning: implicit cast 'double' -> bool
+  // CHECK-FIXES: do {} while (doubleFloating != 0.0);
+  do {} while (doubleFloating);
+}
+
+bool implicitCastToBoolInReturnValue() {
+  float floating = 1.0f;
+  // CHECK-MESSAGES: :[[@LINE+2]]:10: warning: implicit cast 'float' -> bool
+  // CHECK-FIXES: return floating != 0.0f;
+  return floating;
+}
+
+void implicitCastToBoolFromLiterals() {
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'int' -> bool
+  // CHECK-FIXES: functionTakingBool(false);
+  functionTakingBool(0);
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'int' -> bool
+  // CHECK-FIXES: functionTakingBool(true);
+  functionTakingBool(1);
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'unsigned long' -> bool
+  // CHECK-FIXES: functionTakingBool(true);
+  functionTakingBool(2ul);
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'float' -> bool
+  // CHECK-FIXES: functionTakingBool(false);
+  functionTakingBool(0.0f);
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'float' -> bool
+  // CHECK-FIXES: functionTakingBool(true);
+  functionTakingBool(1.0f);
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'double' -> bool
+  // CHECK-FIXES: functionTakingBool(true);
+  functionTakingBool(2.0);
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'char' -> bool
+  // CHECK-FIXES: functionTakingBool(false);
+  functionTakingBool('\0');
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'char' -> bool
+  // CHECK-FIXES: functionTakingBool(true);
+  functionTakingBool('a');
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'const char *' -> bool
+  // CHECK-FIXES: functionTakingBool(true);
+  functionTakingBool("");
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:22: warning: implicit cast 'const char *' -> bool
+  // CHECK-FIXES: functionTakingBool(true);
+  functionTakingBool("abc");
+}
+
+void ignoreExplicitCastsToBool() {
+  int integer = 10;
+  bool boolComingFromInt = static_cast<bool>(integer);
+
+  float floating = 10.0f;
+  bool boolComingFromFloat = static_cast<bool>(floating);
+
+  char character = 'a';
+  bool boolComingFromChar = static_cast<bool>(character);
+
+  int* pointer = nullptr;
+  bool booleanComingFromPointer = static_cast<bool>(pointer);
+}
+
+void ignoreImplicitCastToBoolInMacroExpansions() {
+  int integer = 3;
+
+  #define CAST_TO_BOOL_IN_MACRO_BODY integer && false
+  bool boolFromMacroBody = CAST_TO_BOOL_IN_MACRO_BODY;
+
+  #define CAST_TO_BOOL_IN_MACRO_ARGUMENT(x) x || true
+  bool boolFromMacroArgument = CAST_TO_BOOL_IN_MACRO_ARGUMENT(integer);
+}
+
+namespace ignoreImplicitCastToBoolInTemplateInstantiations {
+
+template<typename T>
+void templateFunction() {
+  T unknownType = 0;
+  bool boolean = unknownType;
+}
+
+void useOfTemplateFunction() {
+  templateFunction<int>();
+}
+
+} // namespace
+
+namespace ignoreUserDefinedConversionOperator {
+
+struct StructWithUserConversion {
+  operator bool();
+};
+
+void useOfUserConversion() {
+  StructWithUserConversion structure;
+  functionTakingBool(structure);
+}
+
+} // namespace