560 lines · cpp
1// RUN: %check_clang_tidy %s readability-implicit-bool-conversion %t2// RUN: %check_clang_tidy -check-suffix=UPPER-CASE %s readability-implicit-bool-conversion %t -- \3// RUN: -config='{CheckOptions: { \4// RUN: readability-implicit-bool-conversion.UseUpperCaseLiteralSuffix: true \5// RUN: }}'6 7// We need NULL macro, but some buildbots don't like including <cstddef> header8// This is a portable way of getting it to work9#undef NULL10#define NULL 0L11 12template<typename T>13void functionTaking(T);14 15struct Struct {16 int member;17};18 19 20////////// Implicit conversion from bool.21 22void implicitConversionFromBoolSimpleCases() {23 bool boolean = true;24 25 functionTaking<bool>(boolean);26 27 functionTaking<int>(boolean);28 // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: implicit conversion 'bool' -> 'int' [readability-implicit-bool-conversion]29 // CHECK-FIXES: functionTaking<int>(static_cast<int>(boolean));30 31 functionTaking<unsigned long>(boolean);32 // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: implicit conversion 'bool' -> 'unsigned long'33 // CHECK-FIXES: functionTaking<unsigned long>(static_cast<unsigned long>(boolean));34 35 functionTaking<char>(boolean);36 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'bool' -> 'char'37 // CHECK-FIXES: functionTaking<char>(static_cast<char>(boolean));38 39 functionTaking<float>(boolean);40 // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: implicit conversion 'bool' -> 'float'41 // CHECK-FIXES: functionTaking<float>(static_cast<float>(boolean));42 43 functionTaking<double>(boolean);44 // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: implicit conversion 'bool' -> 'double'45 // CHECK-FIXES: functionTaking<double>(static_cast<double>(boolean));46}47 48float implicitConversionFromBoolInReturnValue() {49 bool boolean = false;50 return boolean;51 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: implicit conversion 'bool' -> 'float'52 // CHECK-FIXES: return static_cast<float>(boolean);53}54 55void implicitConversionFromBoolInSingleBoolExpressions(bool b1, bool b2) {56 bool boolean = true;57 boolean = b1 ^ b2;58 boolean = b1 && b2;59 boolean |= !b1 || !b2;60 boolean &= b1;61 boolean = b1 == true;62 boolean = b2 != false;63 64 int integer = boolean - 3;65 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: implicit conversion 'bool' -> 'int'66 // CHECK-FIXES: int integer = static_cast<int>(boolean) - 3;67 68 float floating = boolean / 0.3f;69 // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: implicit conversion 'bool' -> 'float'70 // CHECK-FIXES: float floating = static_cast<float>(boolean) / 0.3f;71 72 char character = boolean;73 // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: implicit conversion 'bool' -> 'char'74 // CHECK-FIXES: char character = static_cast<char>(boolean);75}76 77void implicitConversionFromBoollInComplexBoolExpressions() {78 bool boolean = true;79 bool anotherBoolean = false;80 81 int integer = boolean && anotherBoolean;82 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: implicit conversion 'bool' -> 'int'83 // CHECK-FIXES: int integer = static_cast<int>(boolean && anotherBoolean);84 85 unsigned long unsignedLong = (! boolean) + 4ul;86 // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: implicit conversion 'bool' -> 'unsigned long'87 // CHECK-FIXES: unsigned long unsignedLong = static_cast<unsigned long>(! boolean) + 4ul;88 89 float floating = (boolean || anotherBoolean) * 0.3f;90 // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: implicit conversion 'bool' -> 'float'91 // CHECK-FIXES: float floating = static_cast<float>(boolean || anotherBoolean) * 0.3f;92 93 double doubleFloating = (boolean && (anotherBoolean || boolean)) * 0.3;94 // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: implicit conversion 'bool' -> 'double'95 // CHECK-FIXES: double doubleFloating = static_cast<double>(boolean && (anotherBoolean || boolean)) * 0.3;96}97 98void implicitConversionFromBoolLiterals() {99 functionTaking<int>(true);100 // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: implicit conversion 'bool' -> 'int'101 // CHECK-FIXES: functionTaking<int>(1);102 103 functionTaking<unsigned long>(false);104 // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: implicit conversion 'bool' -> 'unsigned long'105 // CHECK-FIXES: functionTaking<unsigned long>(0u);106 // CHECK-FIXES-UPPER-CASE: functionTaking<unsigned long>(0U);107 108 functionTaking<signed char>(true);109 // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: implicit conversion 'bool' -> 'signed char'110 // CHECK-FIXES: functionTaking<signed char>(1);111 112 functionTaking<float>(false);113 // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: implicit conversion 'bool' -> 'float'114 // CHECK-FIXES: functionTaking<float>(0.0f);115 // CHECK-FIXES-UPPER-CASE: functionTaking<float>(0.0F);116 117 functionTaking<double>(true);118 // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: implicit conversion 'bool' -> 'double'119 // CHECK-FIXES: functionTaking<double>(1.0);120}121 122void implicitConversionFromBoolInComparisons() {123 bool boolean = true;124 int integer = 0;125 126 functionTaking<bool>(boolean == integer);127 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'bool' -> 'int'128 // CHECK-FIXES: functionTaking<bool>(static_cast<int>(boolean) == integer);129 130 functionTaking<bool>(integer != boolean);131 // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: implicit conversion 'bool' -> 'int'132 // CHECK-FIXES: functionTaking<bool>(integer != static_cast<int>(boolean));133}134 135void ignoreBoolComparisons() {136 bool boolean = true;137 bool anotherBoolean = false;138 139 functionTaking<bool>(boolean == anotherBoolean);140 functionTaking<bool>(boolean != anotherBoolean);141}142 143void ignoreExplicitCastsFromBool() {144 bool boolean = true;145 146 int integer = static_cast<int>(boolean) + 3;147 float floating = static_cast<float>(boolean) * 0.3f;148 char character = static_cast<char>(boolean);149}150 151void ignoreImplicitConversionFromBoolInMacroExpansions() {152 bool boolean = true;153 154 #define CAST_FROM_BOOL_IN_MACRO_BODY boolean + 3155 int integerFromMacroBody = CAST_FROM_BOOL_IN_MACRO_BODY;156 157 #define CAST_FROM_BOOL_IN_MACRO_ARGUMENT(x) x + 3158 int integerFromMacroArgument = CAST_FROM_BOOL_IN_MACRO_ARGUMENT(boolean);159}160 161namespace ignoreImplicitConversionFromBoolInTemplateInstantiations {162 163template<typename T>164void templateFunction() {165 bool boolean = true;166 T uknownType = boolean + 3;167}168 169void useOfTemplateFunction() {170 templateFunction<int>();171}172 173} // namespace ignoreImplicitConversionFromBoolInTemplateInstantiations174 175////////// Implicit conversions to bool.176 177void implicitConversionToBoolSimpleCases() {178 int integer = 10;179 functionTaking<bool>(integer);180 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int' -> 'bool'181 // CHECK-FIXES: functionTaking<bool>(integer != 0);182 183 unsigned long unsignedLong = 10;184 functionTaking<bool>(unsignedLong);185 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'unsigned long' -> 'bool'186 // CHECK-FIXES: functionTaking<bool>(unsignedLong != 0u);187 // CHECK-FIXES-UPPER-CASE: functionTaking<bool>(unsignedLong != 0U);188 189 float floating = 0.0f;190 functionTaking<bool>(floating);191 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'float' -> 'bool'192 // CHECK-FIXES: functionTaking<bool>(floating != 0.0f);193 // CHECK-FIXES-UPPER-CASE: functionTaking<bool>(floating != 0.0F);194 195 double doubleFloating = 1.0f;196 functionTaking<bool>(doubleFloating);197 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'double' -> 'bool'198 // CHECK-FIXES: functionTaking<bool>(doubleFloating != 0.0);199 200 signed char character = 'a';201 functionTaking<bool>(character);202 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'signed char' -> 'bool'203 // CHECK-FIXES: functionTaking<bool>(character != 0);204 205 int* pointer = nullptr;206 functionTaking<bool>(pointer);207 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int *' -> 'bool'208 // CHECK-FIXES: functionTaking<bool>(pointer != nullptr);209 210 auto pointerToMember = &Struct::member;211 functionTaking<bool>(pointerToMember);212 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int Struct::*' -> 'bool'213 // CHECK-FIXES: functionTaking<bool>(pointerToMember != nullptr);214}215 216void implicitConversionToBoolInSingleExpressions() {217 int integer = 10;218 bool boolComingFromInt = integer;219 // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: implicit conversion 'int' -> 'bool'220 // CHECK-FIXES: bool boolComingFromInt = integer != 0;221 222 float floating = 10.0f;223 bool boolComingFromFloat = floating;224 // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: implicit conversion 'float' -> 'bool'225 // CHECK-FIXES: bool boolComingFromFloat = floating != 0.0f;226 // CHECK-FIXES-UPPER-CASE: bool boolComingFromFloat = floating != 0.0F;227 228 signed char character = 'a';229 bool boolComingFromChar = character;230 // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: implicit conversion 'signed char' -> 'bool'231 // CHECK-FIXES: bool boolComingFromChar = character != 0;232 233 int* pointer = nullptr;234 bool boolComingFromPointer = pointer;235 // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: implicit conversion 'int *' -> 'bool'236 // CHECK-FIXES: bool boolComingFromPointer = pointer != nullptr;237}238 239void implicitConversionToBoolInComplexExpressions() {240 bool boolean = true;241 242 int integer = 10;243 int anotherInteger = 20;244 bool boolComingFromInteger = integer + anotherInteger;245 // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: implicit conversion 'int' -> 'bool'246 // CHECK-FIXES: bool boolComingFromInteger = (integer + anotherInteger) != 0;247 248 float floating = 0.2f;249 bool boolComingFromFloating = floating - 0.3f || boolean;250 // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: implicit conversion 'float' -> 'bool'251 // CHECK-FIXES: bool boolComingFromFloating = ((floating - 0.3f) != 0.0f) || boolean;252 // CHECK-FIXES-UPPER-CASE: bool boolComingFromFloating = ((floating - 0.3f) != 0.0F) || boolean;253 254 double doubleFloating = 0.3;255 bool boolComingFromDoubleFloating = (doubleFloating - 0.4) && boolean;256 // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: implicit conversion 'double' -> 'bool'257 // CHECK-FIXES: bool boolComingFromDoubleFloating = ((doubleFloating - 0.4) != 0.0) && boolean;258}259 260void implicitConversionInNegationExpressions() {261 int integer = 10;262 bool boolComingFromNegatedInt = !integer;263 // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: implicit conversion 'int' -> 'bool'264 // CHECK-FIXES: bool boolComingFromNegatedInt = integer == 0;265 266 float floating = 10.0f;267 bool boolComingFromNegatedFloat = ! floating;268 // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: implicit conversion 'float' -> 'bool'269 // CHECK-FIXES: bool boolComingFromNegatedFloat = floating == 0.0f;270 // CHECK-FIXES-UPPER-CASE: bool boolComingFromNegatedFloat = floating == 0.0F;271 272 signed char character = 'a';273 bool boolComingFromNegatedChar = (! character);274 // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: implicit conversion 'signed char' -> 'bool'275 // CHECK-FIXES: bool boolComingFromNegatedChar = (character == 0);276 277 int* pointer = nullptr;278 bool boolComingFromNegatedPointer = not pointer;279 // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: implicit conversion 'int *' -> 'bool'280 // CHECK-FIXES: bool boolComingFromNegatedPointer = pointer == nullptr;281}282 283void implicitConversionToBoolInControlStatements() {284 int integer = 10;285 if (integer) {}286 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: implicit conversion 'int' -> 'bool'287 // CHECK-FIXES: if (integer != 0) {}288 289 long int longInteger = 0.2f;290 for (;longInteger;) {}291 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: implicit conversion 'long' -> 'bool'292 // CHECK-FIXES: for (;longInteger != 0;) {}293 294 float floating = 0.3f;295 while (floating) {}296 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: implicit conversion 'float' -> 'bool'297 // CHECK-FIXES: while (floating != 0.0f) {}298 // CHECK-FIXES-UPPER-CASE: while (floating != 0.0F) {}299 300 double doubleFloating = 0.4;301 do {} while (doubleFloating);302 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: implicit conversion 'double' -> 'bool'303 // CHECK-FIXES: do {} while (doubleFloating != 0.0);304}305 306bool implicitConversionToBoolInReturnValue() {307 float floating = 1.0f;308 return floating;309 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: implicit conversion 'float' -> 'bool'310 // CHECK-FIXES: return floating != 0.0f;311 // CHECK-FIXES-UPPER-CASE: return floating != 0.0F;312}313 314void implicitConversionToBoolFromLiterals() {315 functionTaking<bool>(0);316 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int' -> 'bool'317 // CHECK-FIXES: functionTaking<bool>(false);318 319 functionTaking<bool>(1);320 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int' -> 'bool'321 // CHECK-FIXES: functionTaking<bool>(true);322 323 functionTaking<bool>(2ul);324 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'unsigned long' -> 'bool'325 // CHECK-FIXES: functionTaking<bool>(true);326 327 328 functionTaking<bool>(0.0f);329 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'float' -> 'bool'330 // CHECK-FIXES: functionTaking<bool>(false);331 332 functionTaking<bool>(1.0f);333 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'float' -> 'bool'334 // CHECK-FIXES: functionTaking<bool>(true);335 336 functionTaking<bool>(2.0);337 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'double' -> 'bool'338 // CHECK-FIXES: functionTaking<bool>(true);339 340 341 functionTaking<bool>('\0');342 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'char' -> 'bool'343 // CHECK-FIXES: functionTaking<bool>(false);344 345 functionTaking<bool>('a');346 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'char' -> 'bool'347 // CHECK-FIXES: functionTaking<bool>(true);348 349 350 functionTaking<bool>("");351 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'const char *' -> 'bool'352 // CHECK-FIXES: functionTaking<bool>(true);353 354 functionTaking<bool>("abc");355 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'const char *' -> 'bool'356 // CHECK-FIXES: functionTaking<bool>(true);357 358 functionTaking<bool>(NULL);359 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'long' -> 'bool'360 // CHECK-FIXES: functionTaking<bool>(false);361}362 363void implicitConversionToBoolFromUnaryMinusAndZeroLiterals() {364 functionTaking<bool>(-0);365 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int' -> 'bool'366 // CHECK-FIXES: functionTaking<bool>((-0) != 0);367 368 functionTaking<bool>(-0.0f);369 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'float' -> 'bool'370 // CHECK-FIXES: functionTaking<bool>((-0.0f) != 0.0f);371 // CHECK-FIXES-UPPER-CASE: functionTaking<bool>((-0.0f) != 0.0F);372 373 functionTaking<bool>(-0.0);374 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'double' -> 'bool'375 // CHECK-FIXES: functionTaking<bool>((-0.0) != 0.0);376}377 378void implicitConversionToBoolInWithOverloadedOperators() {379 struct UserStruct {380 int operator()(int x) { return x; }381 int operator+(int y) { return y; }382 };383 384 UserStruct s;385 386 functionTaking<bool>(s(0));387 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int' -> 'bool'388 // CHECK-FIXES: functionTaking<bool>(s(0) != 0);389 390 functionTaking<bool>(s + 2);391 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int' -> 'bool'392 // CHECK-FIXES: functionTaking<bool>((s + 2) != 0);393}394 395int functionReturningInt();396int* functionReturningPointer();397 398void ignoreImplicitConversionToBoolWhenDeclaringVariableInControlStatements() {399 if (int integer = functionReturningInt()) {}400 401 while (int* pointer = functionReturningPointer()) {}402}403 404void ignoreExplicitCastsToBool() {405 int integer = 10;406 bool boolComingFromInt = static_cast<bool>(integer);407 408 float floating = 10.0f;409 bool boolComingFromFloat = static_cast<bool>(floating);410 411 char character = 'a';412 bool boolComingFromChar = static_cast<bool>(character);413 414 int* pointer = nullptr;415 bool booleanComingFromPointer = static_cast<bool>(pointer);416}417 418void ignoreImplicitConversionToBoolInMacroExpansions() {419 int integer = 3;420 421 #define CAST_TO_BOOL_IN_MACRO_BODY integer && false422 bool boolFromMacroBody = CAST_TO_BOOL_IN_MACRO_BODY;423 424 #define CAST_TO_BOOL_IN_MACRO_ARGUMENT(x) x || true425 bool boolFromMacroArgument = CAST_TO_BOOL_IN_MACRO_ARGUMENT(integer);426}427 428namespace ignoreImplicitConversionToBoolInTemplateInstantiations {429 430template<typename T>431void templateFunction() {432 T unknownType = 0;433 bool boolean = unknownType;434}435 436void useOfTemplateFunction() {437 templateFunction<int>();438}439 440} // namespace ignoreImplicitConversionToBoolInTemplateInstantiations441 442namespace ignoreUserDefinedConversionOperator {443 444struct StructWithUserConversion {445 operator bool();446};447 448void useOfUserConversion() {449 StructWithUserConversion structure;450 functionTaking<bool>(structure);451}452 453} // namespace ignoreUserDefinedConversionOperator454 455namespace ignore_1bit_bitfields {456 457struct S {458 int a;459 int b : 1;460 int c : 2;461 462 S(bool a, bool b, bool c) : a(a), b(b), c(c) {}463 // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: implicit conversion 'bool' -> 'int'464 // CHECK-MESSAGES: :[[@LINE-2]]:45: warning: implicit conversion 'bool' -> 'int'465 // CHECK-FIXES: S(bool a, bool b, bool c) : a(static_cast<int>(a)), b(b), c(static_cast<int>(c)) {}466};467 468void f(S& s) {469 functionTaking<bool>(s.a);470 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int' -> 'bool'471 // CHECK-FIXES: functionTaking<bool>(s.a != 0);472 functionTaking<bool>(s.b);473 // CHECK-FIXES: functionTaking<bool>(s.b);474 s.a = true;475 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: implicit conversion 'bool' -> 'int'476 // CHECK-FIXES: s.a = 1;477 s.b = true;478 // CHECK-FIXES: s.b = true;479 s.c = true;480 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: implicit conversion 'bool' -> 'int'481 // CHECK-FIXES: s.c = 1;482 functionTaking<bool>(s.c);483 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: implicit conversion 'int' -> 'bool'484 // CHECK-FIXES: functionTaking<bool>(s.c != 0);485}486 487} // namespace ignore_1bit_bitfields488 489int implicitConversionReturnInt()490{491 return true;492 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: implicit conversion 'bool' -> 'int'493 // CHECK-FIXES: return 1;494}495 496int implicitConversionReturnIntWithParens()497{498 return (true);499 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: implicit conversion 'bool' -> 'int'500 // CHECK-FIXES: return 1;501}502 503 504bool implicitConversionReturnBool()505{506 return 1;507 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: implicit conversion 'int' -> 'bool'508 // CHECK-FIXES: return true;509}510 511bool implicitConversionReturnBoolWithParens()512{513 return (1);514 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: implicit conversion 'int' -> 'bool'515 // CHECK-FIXES: return true;516}517 518 519namespace PR47000 {520 int to_int(bool x) { return int{x}; }521 522 using IntType = int;523 int to_int2(bool x) { return IntType{x}; }524}525 526namespace PR71867 {527 bool foo(bool x) {528 return x ? 1 : false;529 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: implicit conversion 'int' -> 'bool'530 // CHECK-MESSAGES: :[[@LINE-2]]:20: warning: implicit conversion 'bool' -> 'int'531 // CHECK-FIXES: return (x ? 1 : 0) != 0;532 }533 534 bool boo(bool x) {535 return x ? true : 0;536 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: implicit conversion 'int' -> 'bool'537 // CHECK-MESSAGES: :[[@LINE-2]]:16: warning: implicit conversion 'bool' -> 'int'538 // CHECK-FIXES: return (x ? 1 : 0) != 0;539 }540}541 542namespace PR71848 {543 int fun() {544 bool foo = false;545 return( foo );546// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: implicit conversion 'bool' -> 'int' [readability-implicit-bool-conversion]547// CHECK-FIXES: return static_cast<int>( foo );548 }549}550 551namespace PR161318 { 552 int AddParenOutsideOfCompoundAssignOp() {553 int val = -1;554 while(val >>= 7) {555 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: implicit conversion 'int' -> 'bool' [readability-implicit-bool-conversion]556 // CHECK-FIXES: while((val >>= 7) != 0) {557 }558 }559}560