[clang-tidy] readability-implicit-bool-conversion: support implicit conversion to std::optional<bool>

[huangperry]

Summary

GitHub Issue #56009
Show implicit conversion warning to and from std::optional objects when running clang-tidy.
Examples:
std::optional<bool> a = 5;
std::optional<int> b = false;

[Eugene.Zelenko]

Please mention changes in Release Notes and add test case, but don't rely on STL implementation, see other tests as example for mock implementations.

[huangperry]

In D131517#3710734, @Eugene.Zelenko wrote:

Please mention changes in Release Notes and add test case, but don't rely on STL implementation, see other tests as example for mock implementations.

Will do! Should I be using gMock to mock std::optional?

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

 //===--- ImplicitBoolConversionCheck.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 "ImplicitBoolConversionCheck.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/ExprCXX.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 {
auto ExceptionCases =
                  has(ignoringImplicit(
                      memberExpr(hasDeclaration(fieldDecl(hasBitWidth(1)))))),
                  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(cxxBoolLiteral())),
+            hasDescendant(materializeTemporaryExpr(
+                allOf(hasType(booleanType()), hasDescendant(cxxBoolLiteral()))))),
       hasSourceExpression(expr(hasType(booleanType()))),
       unless(ExceptionCases));
   auto BoolXor =
       binaryOperator(hasOperatorName("^"), hasLHS(ImplicitCastFromBool),
                      hasRHS(ImplicitCastFromBool));
   Finder->addMatcher(
       traverse(TK_AsIs,
                implicitCastExpr(
                    anyOf(hasCastKind(CK_IntegralToBoolean),
                          hasCastKind(CK_FloatingToBoolean),
                          hasCastKind(CK_PointerToBoolean),
-                         hasCastKind(CK_MemberPointerToBoolean)),
+                         hasCastKind(CK_MemberPointerToBoolean),
+                         hasSourceExpression(cxxConstructExpr(
+                             hasType(classTemplateSpecializationDecl(
+                                 hasName("::std::optional"),
+                                 hasTemplateArgument(0, refersToType(booleanType())))),
+                             unless(hasArgument(0, expr(hasType(booleanType()))))))),
                    // 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)),
                    // Retrieve also parent statement, to check if we need