Clang-Tidy implicit bool conversion check use upercase suffixes

[kili]

Summary

Make the type suffix of the implicit bool conversion check upercase. So that the result does not fail the readability uppercase literall suffix check.

[kili]

Fix tests

[njames93]

Something stylistic like this should likely be configurable. Lowercase literals are a part of the language and there is likely a codebase out there that explicitly prefers them

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

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";
+    return Type->isUnsignedIntegerType() ? "0U" : "0";
 
   case CK_FloatingToBoolean:
-    return Context.hasSameType(Type, Context.FloatTy) ? "0.0f" : "0.0";
+    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");
   }
StringRef getEquivalentForBoolLiteral(const CXXBoolLiteralExpr *BoolLiteral,
   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.0F" : "0.0F";
     }
     return BoolLiteral->getValue() ? "1.0" : "0.0";
   }
 
   if (DestType->isUnsignedIntegerType()) {
-    return BoolLiteral->getValue() ? "1u" : "0u";
+    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);

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

 
 void implicitConversionFromBoolLiterals() {
   functionTaking<int>(true);
   // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: implicit conversion bool -> 'int'
   // CHECK-FIXES: functionTaking<int>(1);
 
   functionTaking<unsigned long>(false);
   // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: implicit conversion bool -> 'unsigned long'
-  // CHECK-FIXES: functionTaking<unsigned long>(0u);
+  // CHECK-FIXES: functionTaking<unsigned long>(0U);
 
   functionTaking<signed char>(true);
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: implicit conversion bool -> 'signed char'
   // CHECK-FIXES: functionTaking<signed char>(1);
 
   functionTaking<float>(false);
   // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: implicit conversion bool -> 'float'
-  // CHECK-FIXES: functionTaking<float>(0.0f);
+  // CHECK-FIXES: functionTaking<float>(0.0F);
 
   functionTaking<double>(true);
   // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: implicit conversion bool -> 'double'
   // CHECK-FIXES: functionTaking<double>(1.0);
 }
 
 void implicitConversionFromBoolInComparisons() {
   bool boolean = true;
void implicitConversionToBoolSimpleCases() {
   int integer = 10;
   functionTaking<bool>(integer);
   // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int' -> bool
   // CHECK-FIXES: functionTaking<bool>(integer != 0);
 
   unsigned long unsignedLong = 10;
   functionTaking<bool>(unsignedLong);
   // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'unsigned long' -> bool
-  // CHECK-FIXES: functionTaking<bool>(unsignedLong != 0u);
+  // CHECK-FIXES: functionTaking<bool>(unsignedLong != 0U);
 
   float floating = 0.0f;
   functionTaking<bool>(floating);
   // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'float' -> bool
-  // CHECK-FIXES: functionTaking<bool>(floating != 0.0f);
+  // CHECK-FIXES: functionTaking<bool>(floating != 0.0F);
 
   double doubleFloating = 1.0f;
   functionTaking<bool>(doubleFloating);
   // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'double' -> bool
   // CHECK-FIXES: functionTaking<bool>(doubleFloating != 0.0);
 
   signed char character = 'a';
   functionTaking<bool>(character);
void implicitConversionToBoolInSingleExpressions() {
   int integer = 10;
   bool boolComingFromInt = integer;
   // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: implicit conversion 'int' -> bool
   // CHECK-FIXES: bool boolComingFromInt = integer != 0;
 
   float floating = 10.0f;
   bool boolComingFromFloat = floating;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: implicit conversion 'float' -> bool
-  // CHECK-FIXES: bool boolComingFromFloat = floating != 0.0f;
+  // CHECK-FIXES: bool boolComingFromFloat = floating != 0.0F;
 
   signed char character = 'a';
   bool boolComingFromChar = character;
   // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: implicit conversion 'signed char' -> bool
   // CHECK-FIXES: bool boolComingFromChar = character != 0;
 
   int* pointer = nullptr;
   bool boolComingFromPointer = pointer;
   // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: implicit conversion 'int *' -> bool
   // CHECK-FIXES: bool boolComingFromPointer = pointer != nullptr;
 }
 
 void implicitConversionToBoolInComplexExpressions() {
   bool boolean = true;
 
   int integer = 10;
   int anotherInteger = 20;
   bool boolComingFromInteger = integer + anotherInteger;
   // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: implicit conversion 'int' -> bool
   // CHECK-FIXES: bool boolComingFromInteger = (integer + anotherInteger) != 0;
 
   float floating = 0.2f;
   bool boolComingFromFloating = floating - 0.3f || boolean;
   // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: implicit conversion 'float' -> bool
-  // CHECK-FIXES: bool boolComingFromFloating = ((floating - 0.3f) != 0.0f) || boolean;
+  // CHECK-FIXES: bool boolComingFromFloating = ((floating - 0.3f) != 0.0F) || boolean;
 
   double doubleFloating = 0.3;
   bool boolComingFromDoubleFloating = (doubleFloating - 0.4) && boolean;
   // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: implicit conversion 'double' -> bool
   // CHECK-FIXES: bool boolComingFromDoubleFloating = ((doubleFloating - 0.4) != 0.0) && boolean;
 }
 
 void implicitConversionInNegationExpressions() {
   int integer = 10;
   bool boolComingFromNegatedInt = !integer;
   // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: implicit conversion 'int' -> bool
   // CHECK-FIXES: bool boolComingFromNegatedInt = integer == 0;
 
   float floating = 10.0f;
   bool boolComingFromNegatedFloat = ! floating;
   // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: implicit conversion 'float' -> bool
-  // CHECK-FIXES: bool boolComingFromNegatedFloat = floating == 0.0f;
+  // CHECK-FIXES: bool boolComingFromNegatedFloat = floating == 0.0F;
 
   signed char character = 'a';
   bool boolComingFromNegatedChar = (! character);
   // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: implicit conversion 'signed char' -> bool
   // CHECK-FIXES: bool boolComingFromNegatedChar = (character == 0);
 
   int* pointer = nullptr;
   bool boolComingFromNegatedPointer = not pointer;
void implicitConversionToBoolInControlStatements() {
   long int longInteger = 0.2f;
   for (;longInteger;) {}
   // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: implicit conversion 'long' -> bool
   // CHECK-FIXES: for (;longInteger != 0;) {}
 
   float floating = 0.3f;
   while (floating) {}
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: implicit conversion 'float' -> bool
-  // CHECK-FIXES: while (floating != 0.0f) {}
+  // CHECK-FIXES: while (floating != 0.0F) {}
 
   double doubleFloating = 0.4;
   do {} while (doubleFloating);
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: implicit conversion 'double' -> bool
   // CHECK-FIXES: do {} while (doubleFloating != 0.0);
 }
 
 bool implicitConversionToBoolInReturnValue() {
   float floating = 1.0f;
   return floating;
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: implicit conversion 'float' -> bool
-  // CHECK-FIXES: return floating != 0.0f;
+  // CHECK-FIXES: return floating != 0.0F;
 }
 
 void implicitConversionToBoolFromLiterals() {
   functionTaking<bool>(0);
   // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int' -> bool
   // CHECK-FIXES: functionTaking<bool>(false);
 
   functionTaking<bool>(1);

 
 void implicitConversionToBoolFromUnaryMinusAndZeroLiterals() {
   functionTaking<bool>(-0);
   // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int' -> bool
   // CHECK-FIXES: functionTaking<bool>((-0) != 0);
 
   functionTaking<bool>(-0.0f);
   // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'float' -> bool
-  // CHECK-FIXES: functionTaking<bool>((-0.0f) != 0.0f);
+  // CHECK-FIXES: functionTaking<bool>((-0.0f) != 0.0F);
 
   functionTaking<bool>(-0.0);
   // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'double' -> bool
   // CHECK-FIXES: functionTaking<bool>((-0.0) != 0.0);
 }
 
 void implicitConversionToBoolInWithOverloadedOperators() {
   struct UserStruct {