Refactor: Simplify boolean expressions in clang with clang-tidy

[LegalizeAdulthood]

Summary

Simplify expressions involving boolean constants.

[dblaikie]

Looks good to me, please commit (after dropping parens)

lib/Driver/ToolChain.cpp

300

Drop the extra parens

lib/Lex/PreprocessingRecord.cpp

76–77

Drop the extra parens

lib/Sema/SemaOverload.cpp

9500

Drop extra parens

[LegalizeAdulthood]

lib/Driver/ToolChain.cpp

300

Fixed

lib/Lex/PreprocessingRecord.cpp

76–77

Fixed

lib/Sema/SemaOverload.cpp

9500

Fixed

[LegalizeAdulthood]

Drop unnecessary parens.

I do not have commit access, so would someone commit this for me please? Thanks.

lib/AST/Type.cpp

 
 bool FunctionProtoType::isNothrow(const ASTContext &Ctx,
                                   bool ResultIfDependent) const {
   ExceptionSpecificationType EST = getExceptionSpecType();
   assert(EST != EST_Unevaluated && EST != EST_Uninstantiated);
   if (EST == EST_DynamicNone || EST == EST_BasicNoexcept)
     return true;
 
-  if (EST == EST_Dynamic && ResultIfDependent == true) {
+  if (EST == EST_Dynamic && ResultIfDependent) {
     // A dynamic exception specification is throwing unless every exception
     // type is an (unexpanded) pack expansion type.
     for (unsigned I = 0, N = NumExceptions; I != N; ++I)
       if (!getExceptionType(I)->getAs<PackExpansionType>())
         return false;
     return ResultIfDependent;
   }
 

lib/Analysis/CFG.cpp

if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(S)) {
           // For 'x & 0' and 'x * 0', we can determine that
           // the value is always false.
           case BO_Mul:
           case BO_And: {
             // If either operand is zero, we know the value
             // must be false.
             llvm::APSInt IntVal;
             if (Bop->getLHS()->EvaluateAsInt(IntVal, *Context)) {
-              if (IntVal.getBoolValue() == false) {
+              if (!IntVal.getBoolValue()) {
                 return TryResult(false);
               }
             }
             if (Bop->getRHS()->EvaluateAsInt(IntVal, *Context)) {
-              if (IntVal.getBoolValue() == false) {
+              if (!IntVal.getBoolValue()) {
                 return TryResult(false);
               }
             }
           }
           break;
         }
       }
     }

lib/Basic/DiagnosticIDs.cpp

 /// Return \c true if any diagnostics were found in this group, even if they
 /// were filtered out due to having the wrong flavor.
 static bool getDiagnosticsInGroup(diag::Flavor Flavor,
                                   const WarningOption *Group,
                                   SmallVectorImpl<diag::kind> &Diags) {
   // An empty group is considered to be a warning group: we have empty groups
   // for GCC compatibility, and GCC does not have remarks.
   if (!Group->Members && !Group->SubGroups)
-    return Flavor == diag::Flavor::Remark ? true : false;
+    return Flavor == diag::Flavor::Remark;
 
   bool NotFound = true;
 
   // Add the members of the option diagnostic set.
   const int16_t *Member = DiagArrays + Group->Members;
   for (; *Member != -1; ++Member) {
     if (GetDiagInfo(*Member)->getFlavor() == Flavor) {
       NotFound = false;

lib/Driver/ToolChain.cpp

case llvm::Triple::thumbeb: {
     llvm::Triple Triple = getTriple();
     bool IsBigEndian = getTriple().getArch() == llvm::Triple::armeb ||
                        getTriple().getArch() == llvm::Triple::thumbeb;
 
     // Handle pseudo-target flags '-mlittle-endian'/'-EL' and
     // '-mbig-endian'/'-EB'.
     if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
                                  options::OPT_mbig_endian)) {
-      if (A->getOption().matches(options::OPT_mlittle_endian))
-        IsBigEndian = false;
-      else
-        IsBigEndian = true;
+      IsBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
     }
 
     // Thumb2 is the default for V7 on Darwin.
     //
     // FIXME: Thumb should just be another -target-feaure, not in the triple.
     StringRef Suffix = Triple.isOSBinFormatMachO()
       ? tools::arm::getLLVMArchSuffixForARM(tools::arm::getARMCPUForMArch(Args, Triple))
       : tools::arm::getLLVMArchSuffixForARM(tools::arm::getARMTargetCPU(Args, Triple));

lib/Lex/PreprocessingRecord.cpp

static bool isPreprocessedEntityIfInFileID(PreprocessedEntity *PPE, FileID FID,
                                            SourceManager &SM) {
   assert(!FID.isInvalid());
   if (!PPE)
     return false;
 
   SourceLocation Loc = PPE->getSourceRange().getBegin();
   if (Loc.isInvalid())
     return false;
-  
-  if (SM.isInFileID(SM.getFileLoc(Loc), FID))
-    return true;
-  else
-    return false;
+  return SM.isInFileID(SM.getFileLoc(Loc), FID);
 }
 
 /// \brief Returns true if the preprocessed entity that \arg PPEI iterator
 /// points to is coming from the file \arg FID.
 ///
 /// Can be used to avoid implicit deserializations of preallocated
 /// preprocessed entities if we only care about entities of a specific file
 /// and not from files \#included in the range given at

lib/Parse/ParseDecl.cpp

void Parser::ParseMicrosoftDeclSpec(ParsedAttributes &Attrs) {
   // you can specify multiple attributes per declspec.
   while (Tok.isNot(tok::r_paren)) {
     // Attribute not present.
     if (TryConsumeToken(tok::comma))
       continue;
 
     // We expect either a well-known identifier or a generic string.  Anything
     // else is a malformed declspec.
-    bool IsString = Tok.getKind() == tok::string_literal ? true : false;
+    bool IsString = Tok.getKind() == tok::string_literal;
     if (!IsString && Tok.getKind() != tok::identifier &&
         Tok.getKind() != tok::kw_restrict) {
       Diag(Tok, diag::err_ms_declspec_type);
       T.skipToEnd();
       return;
     }
 
     IdentifierInfo *AttrName;

lib/Sema/SemaOverload.cpp

if (!L->Viable) {
 
         // The conversion that can be fixed with a smaller number of changes,
         // comes first.
         unsigned numLFixes = L->Fix.NumConversionsFixed;
         unsigned numRFixes = R->Fix.NumConversionsFixed;
         numLFixes = (numLFixes == 0) ? UINT_MAX : numLFixes;
         numRFixes = (numRFixes == 0) ? UINT_MAX : numRFixes;
         if (numLFixes != numRFixes) {
-          if (numLFixes < numRFixes)
-            return true;
-          else
-            return false;
+          return numLFixes < numRFixes;
         }
 
         // If there's any ordering between the defined conversions...
         // FIXME: this might not be transitive.
         assert(L->NumConversions == R->NumConversions);
 
         int leftBetter = 0;
         unsigned I = (L->IgnoreObjectArgument || R->IgnoreObjectArgument);