[clang-tidy] Fix init-list handling in readability-implicit-bool-conversion

[PiotrZSL]

Summary

Adds support for explicit casts using initListExpr,
for example: int{boolValue} constructions.

Fixes: #47000

[ccotter]

lgtm

clang-tools-extra/clang-tidy/readability/ImplicitBoolConversionCheck.cpp

void ImplicitBoolConversionCheck::storeOptions(
   Options.store(Opts, "AllowPointerConditions", AllowPointerConditions);
 }
 
 void ImplicitBoolConversionCheck::registerMatchers(MatchFinder *Finder) {
   auto ExceptionCases =
       expr(anyOf(allOf(isMacroExpansion(), unless(isNULLMacroExpansion())),
                  has(ignoringImplicit(
                      memberExpr(hasDeclaration(fieldDecl(hasBitWidth(1)))))),
-                 hasParent(explicitCastExpr())));
+                 hasParent(explicitCastExpr()),
+                 expr(hasType(qualType().bind("type")),
+                      hasParent(initListExpr(hasParent(explicitCastExpr(
+                          hasType(qualType(equalsBoundNode("type"))))))))));
   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));
Finder->addMatcher(
                    // 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)),
                    // Retrieve also parent statement, to check if we need
                    // additional parens in replacement.
-                   anyOf(hasParent(stmt().bind("parentStmt")), anything()),
+                   optionally(hasParent(stmt().bind("parentStmt"))),
                    unless(isInTemplateInstantiation()),
                    unless(hasAncestor(functionTemplateDecl())))
                    .bind("implicitCastToBool")),
       this);
 
   auto BoolComparison = binaryOperator(hasAnyOperatorName("==", "!="),
                                        hasLHS(ImplicitCastFromBool),
                                        hasRHS(ImplicitCastFromBool));

clang-tools-extra/docs/ReleaseNotes.rst

- Renamed `HungarianNotation.CString` options `CharPrinter` and
   <clang-tidy/checks/readability/identifier-naming>` check.
 
 - Updated the Hungarian prefixes for enums in C files to match those used in C++
   files for improved readability, as checked by :doc:`readability-identifier-naming
   <clang-tidy/checks/readability/identifier-naming>`. To preserve the previous
   behavior of using `i` as the prefix for enum tags, set the `EnumConstantPrefix`
   option to `i` instead of using `EnumConstantHungarianPrefix`.
 
+- Fixed a false positive in :doc:`readability-implicit-bool-conversion
+  <clang-tidy/checks/readability/implicit-bool-conversion>` check warning would
+  be unnecessarily emitted for explicit cast using direct list initialization.
+
 - Added support to optionally ignore user-defined literals in
   :doc:`readability-magic-numbers<clang-tidy/checks/readability/magic-numbers>`.
 
 - Fixed a false positive in :doc:`readability-container-size-empty
   <clang-tidy/checks/readability/container-size-empty>` check when comparing
   ``std::array`` objects to default constructed ones. The behavior for this and
   other relevant classes can now be configured with a new option.
 

clang-tools-extra/test/clang-tidy/checkers/readability/implicit-bool-conversion.cpp

bool f(S& s) {
   // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: implicit conversion bool -> 'int'
   // CHECK-FIXES: s.c = 1;
   functionTaking<bool>(s.c);
   // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int' -> bool
   // CHECK-FIXES: functionTaking<bool>(s.c != 0);
 }
 
 } // namespace ignore_1bit_bitfields
+
+namespace PR47000 {
+  int to_int(bool x) { return int{x}; }
+
+  using IntType = int;
+  int to_int2(bool x) { return IntType{x}; }
+}