[clang-tidy] Convert config options that are bools to use the bool overload of get(GlobalOrLocal)?

[njames93]

Summary

This was done with a script that looks for calls to Options.get(GlobalOrLocal) that take an integer for the second argument and the result is either compared not equal to 0 or implicitly converted to bool. There may be other occurances

[njames93]

Added a few more cases by hand

[aaron.ballman]

LGTM, thanks for the cleanup!

clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.cpp

 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 ArgumentCommentCheck::ArgumentCommentCheck(StringRef Name,
                                            ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      StrictMode(Options.getLocalOrGlobal("StrictMode", 0) != 0),
-      IgnoreSingleArgument(Options.get("IgnoreSingleArgument", 0) != 0),
-      CommentBoolLiterals(Options.get("CommentBoolLiterals", 0) != 0),
-      CommentIntegerLiterals(Options.get("CommentIntegerLiterals", 0) != 0),
-      CommentFloatLiterals(Options.get("CommentFloatLiterals", 0) != 0),
-      CommentStringLiterals(Options.get("CommentStringLiterals", 0) != 0),
-      CommentUserDefinedLiterals(Options.get("CommentUserDefinedLiterals", 0) !=
-                                 0),
-      CommentCharacterLiterals(Options.get("CommentCharacterLiterals", 0) != 0),
-      CommentNullPtrs(Options.get("CommentNullPtrs", 0) != 0),
+      StrictMode(Options.getLocalOrGlobal("StrictMode", false)),
+      IgnoreSingleArgument(Options.get("IgnoreSingleArgument", false)),
+      CommentBoolLiterals(Options.get("CommentBoolLiterals", false)),
+      CommentIntegerLiterals(Options.get("CommentIntegerLiterals", false)),
+      CommentFloatLiterals(Options.get("CommentFloatLiterals", false)),
+      CommentStringLiterals(Options.get("CommentStringLiterals", false)),
+      CommentUserDefinedLiterals(
+          Options.get("CommentUserDefinedLiterals", false)),
+      CommentCharacterLiterals(Options.get("CommentCharacterLiterals", false)),
+      CommentNullPtrs(Options.get("CommentNullPtrs", false)),
       IdentRE("^(/\\* *)([_A-Za-z][_A-Za-z0-9]*)( *= *\\*/)$") {}
 
 void ArgumentCommentCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StrictMode", StrictMode);
   Options.store(Opts, "IgnoreSingleArgument", IgnoreSingleArgument);
   Options.store(Opts, "CommentBoolLiterals", CommentBoolLiterals);
   Options.store(Opts, "CommentIntegerLiterals", CommentIntegerLiterals);
   Options.store(Opts, "CommentFloatLiterals", CommentFloatLiterals);

clang-tools-extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.h

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
 
 private:
   // If non-zero it is specifying if the target environment is considered to
   // implement '_s' suffixed memory and string handler functions which are safer
   // than older version (e.g. 'memcpy_s()'). The default value is '1'.
-  const int WantToUseSafeFunctions;
+  const bool WantToUseSafeFunctions;
 
   bool UseSafeFunctions = false;
 
   void memoryHandlerFunctionFix(
       StringRef Name, const ast_matchers::MatchFinder::MatchResult &Result);
   void memcpyFix(StringRef Name,
                  const ast_matchers::MatchFinder::MatchResult &Result,
                  DiagnosticBuilder &Diag);

clang-tools-extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.cpp

 
 //===----------------------------------------------------------------------===//
 // Checker logic with the matchers.
 //===----------------------------------------------------------------------===//
 
 NotNullTerminatedResultCheck::NotNullTerminatedResultCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      WantToUseSafeFunctions(Options.get("WantToUseSafeFunctions", 1)) {}
+      WantToUseSafeFunctions(Options.get("WantToUseSafeFunctions", true)) {}
 
 void NotNullTerminatedResultCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WantToUseSafeFunctions", WantToUseSafeFunctions);
 }
 
 void NotNullTerminatedResultCheck::registerPPCallbacks(
     const SourceManager &SM, Preprocessor *pp, Preprocessor *ModuleExpanderPP) {

clang-tools-extra/clang-tidy/bugprone/SizeofExpressionCheck.cpp

CharUnits getSizeOfType(const ASTContext &Ctx, const Type *Ty) {
   return Ctx.getTypeSizeInChars(Ty);
 }
 
 } // namespace
 
 SizeofExpressionCheck::SizeofExpressionCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      WarnOnSizeOfConstant(Options.get("WarnOnSizeOfConstant", 1) != 0),
+      WarnOnSizeOfConstant(Options.get("WarnOnSizeOfConstant", true)),
       WarnOnSizeOfIntegerExpression(
-          Options.get("WarnOnSizeOfIntegerExpression", 0) != 0),
-      WarnOnSizeOfThis(Options.get("WarnOnSizeOfThis", 1) != 0),
+          Options.get("WarnOnSizeOfIntegerExpression", false)),
+      WarnOnSizeOfThis(Options.get("WarnOnSizeOfThis", true)),
       WarnOnSizeOfCompareToConstant(
-          Options.get("WarnOnSizeOfCompareToConstant", 1) != 0) {}
+          Options.get("WarnOnSizeOfCompareToConstant", true)) {}
 
 void SizeofExpressionCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnSizeOfConstant", WarnOnSizeOfConstant);
   Options.store(Opts, "WarnOnSizeOfIntegerExpression",
                 WarnOnSizeOfIntegerExpression);
   Options.store(Opts, "WarnOnSizeOfThis", WarnOnSizeOfThis);
   Options.store(Opts, "WarnOnSizeOfCompareToConstant",
                 WarnOnSizeOfCompareToConstant);

clang-tools-extra/clang-tidy/bugprone/StringConstructorCheck.cpp

 AST_MATCHER_P(IntegerLiteral, isBiggerThan, unsigned, N) {
   return Node.getValue().getZExtValue() > N;
 }
 } // namespace
 
 StringConstructorCheck::StringConstructorCheck(StringRef Name,
                                                ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      WarnOnLargeLength(Options.get("WarnOnLargeLength", 1) != 0),
+      WarnOnLargeLength(Options.get("WarnOnLargeLength", true)),
       LargeLengthThreshold(Options.get("LargeLengthThreshold", 0x800000)) {}
 
 void StringConstructorCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnLargeLength", WarnOnLargeLength);
   Options.store(Opts, "LargeLengthThreshold", LargeLengthThreshold);
 }
 
 void StringConstructorCheck::registerMatchers(MatchFinder *Finder) {

clang-tools-extra/clang-tidy/bugprone/SuspiciousEnumUsageCheck.cpp

return NonPowOfTwoCounter >= 1 && NonPowOfTwoCounter <= 2 &&
          NonPowOfTwoCounter < EnumLen / 2 &&
          (VR.MaxVal - VR.MinVal != EnumLen - 1) &&
          !(NonPowOfTwoCounter == 1 && isMaxValAllBitSetLiteral(EnumDec));
 }
 
 SuspiciousEnumUsageCheck::SuspiciousEnumUsageCheck(StringRef Name,
                                                    ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      StrictMode(Options.getLocalOrGlobal("StrictMode", 0)) {}
+      StrictMode(Options.getLocalOrGlobal("StrictMode", false)) {}
 
 void SuspiciousEnumUsageCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StrictMode", StrictMode);
 }
 
 void SuspiciousEnumUsageCheck::registerMatchers(MatchFinder *Finder) {
   const auto enumExpr = [](StringRef RefName, StringRef DeclName) {
     return expr(ignoringImpCasts(expr().bind(RefName)),

clang-tools-extra/clang-tidy/bugprone/SuspiciousStringCompareCheck.cpp

static const char KnownStringCompareFunctions[] = "__builtin_memcmp;"
                                                   "wcsicmp;"
                                                   "wcsncmp;"
                                                   "wcsnicmp;"
                                                   "wmemcmp;";
 
 SuspiciousStringCompareCheck::SuspiciousStringCompareCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      WarnOnImplicitComparison(Options.get("WarnOnImplicitComparison", 1)),
-      WarnOnLogicalNotComparison(Options.get("WarnOnLogicalNotComparison", 0)),
+      WarnOnImplicitComparison(Options.get("WarnOnImplicitComparison", true)),
+      WarnOnLogicalNotComparison(
+          Options.get("WarnOnLogicalNotComparison", false)),
       StringCompareLikeFunctions(
           Options.get("StringCompareLikeFunctions", "")) {}
 
 void SuspiciousStringCompareCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnImplicitComparison", WarnOnImplicitComparison);
   Options.store(Opts, "WarnOnLogicalNotComparison", WarnOnLogicalNotComparison);
   Options.store(Opts, "StringCompareLikeFunctions", StringCompareLikeFunctions);

clang-tools-extra/clang-tidy/cppcoreguidelines/MacroUsageCheck.h

 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-macro-usage.html
 class MacroUsageCheck : public ClangTidyCheck {
 public:
   MacroUsageCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
         AllowedRegexp(Options.get("AllowedRegexp", "^DEBUG_*")),
-        CheckCapsOnly(Options.get("CheckCapsOnly", 0)),
-        IgnoreCommandLineMacros(Options.get("IgnoreCommandLineMacros", 1)) {}
+        CheckCapsOnly(Options.get("CheckCapsOnly", false)),
+        IgnoreCommandLineMacros(Options.get("IgnoreCommandLineMacros", true)) {}
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
   void warnMacro(const MacroDirective *MD, StringRef MacroName);
   void warnNaming(const MacroDirective *MD, StringRef MacroName);

clang-tools-extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.cpp

 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 NarrowingConversionsCheck::NarrowingConversionsCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       WarnOnFloatingPointNarrowingConversion(
-          Options.get("WarnOnFloatingPointNarrowingConversion", 1)),
-      PedanticMode(Options.get("PedanticMode", 0)) {}
+          Options.get("WarnOnFloatingPointNarrowingConversion", true)),
+      PedanticMode(Options.get("PedanticMode", false)) {}
 
 void NarrowingConversionsCheck::registerMatchers(MatchFinder *Finder) {
   // ceil() and floor() are guaranteed to return integers, even though the type
   // is not integral.
   const auto IsCeilFloorCallExpr = expr(callExpr(callee(functionDecl(
       hasAnyName("::ceil", "::std::ceil", "::floor", "::std::floor")))));
 
   // Casts:

clang-tools-extra/clang-tidy/cppcoreguidelines/SpecialMemberFunctionsCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 SpecialMemberFunctionsCheck::SpecialMemberFunctionsCheck(
     StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      AllowMissingMoveFunctions(Options.get("AllowMissingMoveFunctions", 0)),
-      AllowSoleDefaultDtor(Options.get("AllowSoleDefaultDtor", 0)),
+    : ClangTidyCheck(Name, Context), AllowMissingMoveFunctions(Options.get(
+                                         "AllowMissingMoveFunctions", false)),
+      AllowSoleDefaultDtor(Options.get("AllowSoleDefaultDtor", false)),
       AllowMissingMoveFunctionsWhenCopyIsDeleted(
-          Options.get("AllowMissingMoveFunctionsWhenCopyIsDeleted", 0)) {}
+          Options.get("AllowMissingMoveFunctionsWhenCopyIsDeleted", false)) {}
 
 void SpecialMemberFunctionsCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "AllowMissingMoveFunctions", AllowMissingMoveFunctions);
   Options.store(Opts, "AllowSoleDefaultDtor", AllowSoleDefaultDtor);
   Options.store(Opts, "AllowMissingMoveFunctionsWhenCopyIsDeleted",
                 AllowMissingMoveFunctionsWhenCopyIsDeleted);
 }

clang-tools-extra/clang-tidy/hicpp/MultiwayPathsCoveredCheck.h

 /// without a final 'else'-branch.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/hicpp-multiway-paths-covered.html
 class MultiwayPathsCoveredCheck : public ClangTidyCheck {
 public:
   MultiwayPathsCoveredCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
-        WarnOnMissingElse(Options.get("WarnOnMissingElse", 0)) {}
+        WarnOnMissingElse(Options.get("WarnOnMissingElse", false)) {}
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   void handleSwitchWithDefault(const SwitchStmt *Switch, std::size_t CaseCount);
   void handleSwitchWithoutDefault(
       const SwitchStmt *Switch, std::size_t CaseCount,

clang-tools-extra/clang-tidy/misc/UnusedParametersCheck.cpp

private:
   std::unordered_map<const FunctionDecl *, IndexEntry> Index;
 };
 
 UnusedParametersCheck::~UnusedParametersCheck() = default;
 
 UnusedParametersCheck::UnusedParametersCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      StrictMode(Options.getLocalOrGlobal("StrictMode", 0) != 0) {}
+      StrictMode(Options.getLocalOrGlobal("StrictMode", false)) {}
 
 void UnusedParametersCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StrictMode", StrictMode);
 }
 
 void UnusedParametersCheck::warnOnUnusedParameter(
     const MatchFinder::MatchResult &Result, const FunctionDecl *Function,
     unsigned ParamIndex) {

clang-tools-extra/clang-tidy/modernize/AvoidBindCheck.cpp

getForwardedArgumentList(const LambdaProperties &P) {
   ArrayRef<BindArgument> Args = makeArrayRef(P.BindArguments);
   if (P.Callable.Type != CT_MemberFunction)
     return Args;
 
   return Args.drop_front();
 }
 AvoidBindCheck::AvoidBindCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      PermissiveParameterList(Options.get("PermissiveParameterList", 0) != 0) {}
+      PermissiveParameterList(Options.get("PermissiveParameterList", false)) {}
 
 void AvoidBindCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       callExpr(
           callee(namedDecl(
               anyOf(hasName("::boost::bind"), hasName("::std::bind")))),
           hasArgument(
               0, anyOf(expr(hasType(memberPointerType())).bind("ref"),

clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp

collectParamDecls(const CXXConstructorDecl *Ctor,
   return Results;
 }
 
 PassByValueCheck::PassByValueCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IncludeStyle(Options.getLocalOrGlobal("IncludeStyle",
                                             utils::IncludeSorter::getMapping(),
                                             utils::IncludeSorter::IS_LLVM)),
-      ValuesOnly(Options.get("ValuesOnly", 0) != 0) {}
+      ValuesOnly(Options.get("ValuesOnly", false)) {}
 
 void PassByValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IncludeStyle", IncludeStyle,
                 utils::IncludeSorter::getMapping());
   Options.store(Opts, "ValuesOnly", ValuesOnly);
 }
 
 void PassByValueCheck::registerMatchers(MatchFinder *Finder) {

clang-tools-extra/clang-tidy/modernize/UseAutoCheck.cpp

return declStmt(
             makeDeclWithCastMatcher(), makeDeclWithTemplateCastMatcher()));
 }
 
 } // namespace
 
 UseAutoCheck::UseAutoCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       MinTypeNameLength(Options.get("MinTypeNameLength", 5)),
-      RemoveStars(Options.get("RemoveStars", 0)) {}
+      RemoveStars(Options.get("RemoveStars", false)) {}
 
 void UseAutoCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "MinTypeNameLength", MinTypeNameLength);
   Options.store(Opts, "RemoveStars", RemoveStars ? 1 : 0);
 }
 
 void UseAutoCheck::registerMatchers(MatchFinder *Finder) {
     Finder->addMatcher(makeCombinedMatcher(), this);

clang-tools-extra/clang-tidy/modernize/UseDefaultMemberInitCheck.cpp

static bool sameValue(const Expr *E1, const Expr *E2) {
   default:
     return false;
   }
 }
 
 UseDefaultMemberInitCheck::UseDefaultMemberInitCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      UseAssignment(Options.get("UseAssignment", 0) != 0),
-      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true) != 0) {}
+      UseAssignment(Options.get("UseAssignment", false)),
+      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
 
 void UseDefaultMemberInitCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "UseAssignment", UseAssignment);
   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
 }
 
 void UseDefaultMemberInitCheck::registerMatchers(MatchFinder *Finder) {

clang-tools-extra/clang-tidy/modernize/UseEmplaceCheck.cpp

const auto DefaultContainersWithPushBack =
     "::std::vector; ::std::list; ::std::deque";
 const auto DefaultSmartPointers =
     "::std::shared_ptr; ::std::unique_ptr; ::std::auto_ptr; ::std::weak_ptr";
 const auto DefaultTupleTypes = "::std::pair; ::std::tuple";
 const auto DefaultTupleMakeFunctions = "::std::make_pair; ::std::make_tuple";
 } // namespace
 
 UseEmplaceCheck::UseEmplaceCheck(StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      IgnoreImplicitConstructors(Options.get("IgnoreImplicitConstructors", 0)),
+    : ClangTidyCheck(Name, Context), IgnoreImplicitConstructors(Options.get(
+                                         "IgnoreImplicitConstructors", false)),
       ContainersWithPushBack(utils::options::parseStringList(Options.get(
           "ContainersWithPushBack", DefaultContainersWithPushBack))),
       SmartPointers(utils::options::parseStringList(
           Options.get("SmartPointers", DefaultSmartPointers))),
       TupleTypes(utils::options::parseStringList(
           Options.get("TupleTypes", DefaultTupleTypes))),
       TupleMakeFunctions(utils::options::parseStringList(
           Options.get("TupleMakeFunctions", DefaultTupleMakeFunctions))) {}

clang-tools-extra/clang-tidy/modernize/UseEqualsDefaultCheck.cpp

StringRef Text = Lexer::getSourceText(
                                     Body->getRBracLoc()),
       Context->getSourceManager(), Context->getLangOpts(), &Invalid);
   return !Invalid && std::strspn(Text.data(), " \t\r\n") == Text.size();
 }
 
 UseEqualsDefaultCheck::UseEqualsDefaultCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true) != 0) {}
+      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
 
 void UseEqualsDefaultCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
 }
 
 void UseEqualsDefaultCheck::registerMatchers(MatchFinder *Finder) {
   // Destructor.
   Finder->addMatcher(cxxDestructorDecl(isDefinition()).bind(SpecialFunction),

clang-tools-extra/clang-tidy/modernize/UseEqualsDeleteCheck.h

 /// \endcode
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-delete.html
 class UseEqualsDeleteCheck : public ClangTidyCheck {
 public:
   UseEqualsDeleteCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
-        IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", 1) != 0) {}
+        IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const bool IgnoreMacros;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EQUALS_DELETE_H

clang-tools-extra/clang-tidy/modernize/UseTransparentFunctorsCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 UseTransparentFunctorsCheck::UseTransparentFunctorsCheck(
     StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context), SafeMode(Options.get("SafeMode", 0)) {}
+    : ClangTidyCheck(Name, Context), SafeMode(Options.get("SafeMode", false)) {}
 
 void UseTransparentFunctorsCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "SafeMode", SafeMode ? 1 : 0);
 }
 
 void UseTransparentFunctorsCheck::registerMatchers(MatchFinder *Finder) {
   const auto TransparentFunctors =

clang-tools-extra/clang-tidy/performance/ForRangeCopyCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 ForRangeCopyCheck::ForRangeCopyCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      WarnOnAllAutoCopies(Options.get("WarnOnAllAutoCopies", 0)),
+      WarnOnAllAutoCopies(Options.get("WarnOnAllAutoCopies", false)),
       AllowedTypes(
           utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
 
 void ForRangeCopyCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnAllAutoCopies", WarnOnAllAutoCopies);
   Options.store(Opts, "AllowedTypes",
                 utils::options::serializeStringList(AllowedTypes));
 }

clang-tools-extra/clang-tidy/performance/InefficientStringConcatenationCheck.cpp

 void InefficientStringConcatenationCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StrictMode", StrictMode);
 }
 
 InefficientStringConcatenationCheck::InefficientStringConcatenationCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      StrictMode(Options.getLocalOrGlobal("StrictMode", 0)) {}
+      StrictMode(Options.getLocalOrGlobal("StrictMode", false)) {}
 
 void InefficientStringConcatenationCheck::registerMatchers(
     MatchFinder *Finder) {
   const auto BasicStringType =
       hasType(qualType(hasUnqualifiedDesugaredType(recordType(
           hasDeclaration(cxxRecordDecl(hasName("::std::basic_string")))))));
 
   const auto BasicStringPlusOperator = cxxOperatorCallExpr(

clang-tools-extra/clang-tidy/portability/SIMDIntrinsicsCheck.cpp

if (Name.startswith("mul_"))
     return "operator* on $simd objects";
 
   return {};
 }
 
 SIMDIntrinsicsCheck::SIMDIntrinsicsCheck(StringRef Name,
                                          ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), Std(Options.get("Std", "")),
-      Suggest(Options.get("Suggest", 0) != 0) {}
+      Suggest(Options.get("Suggest", false)) {}
 
 void SIMDIntrinsicsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "Std", "");
   Options.store(Opts, "Suggest", 0);
 }
 
 void SIMDIntrinsicsCheck::registerMatchers(MatchFinder *Finder) {
   // If Std is not specified, infer it from the language options.

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

private:
   Preprocessor *PP;
   IdentifierNamingCheck *Check;
 };
 } // namespace
 
 IdentifierNamingCheck::IdentifierNamingCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : RenamerClangTidyCheck(Name, Context),
-      IgnoreFailedSplit(Options.get("IgnoreFailedSplit", 0)),
-      IgnoreMainLikeFunctions(Options.get("IgnoreMainLikeFunctions", 0)) {
+      IgnoreFailedSplit(Options.get("IgnoreFailedSplit", false)),
+      IgnoreMainLikeFunctions(Options.get("IgnoreMainLikeFunctions", false)) {
 
   for (auto const &Name : StyleNames) {
     auto CaseOptional = [&]() -> llvm::Optional<CaseType> {
       auto ValueOr = Options.get((Name + "Case").str(), makeArrayRef(Mapping));
       if (ValueOr)
         return *ValueOr;
       llvm::logAllUnhandledErrors(
           llvm::handleErrors(ValueOr.takeError(),

clang-tools-extra/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.h

 /// For detailed documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-inconsistent-declaration-parameter-name.html
 ///
 class InconsistentDeclarationParameterNameCheck : public ClangTidyCheck {
 public:
   InconsistentDeclarationParameterNameCheck(StringRef Name,
                                             ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
-        IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", 1) != 0),
-        Strict(Options.getLocalOrGlobal("Strict", 0) != 0) {}
+        IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)),
+        Strict(Options.getLocalOrGlobal("Strict", false)) {}
 
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   void markRedeclarationsAsVisited(const FunctionDecl *FunctionDeclaration);
 

clang-tools-extra/clang-tidy/readability/RedundantMemberInitCheck.h

 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-member-init.html
 class RedundantMemberInitCheck : public ClangTidyCheck {
 public:
   RedundantMemberInitCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
         IgnoreBaseInCopyConstructors(
-            Options.get("IgnoreBaseInCopyConstructors", 0)) {}
+            Options.get("IgnoreBaseInCopyConstructors", false)) {}
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   bool IgnoreBaseInCopyConstructors;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_MEMBER_INIT_H

clang-tools-extra/clang-tidy/readability/RedundantSmartptrGetCheck.h

 ///   ptr.get()->Foo()  ==>  ptr->Foo()
 ///   *ptr.get()  ==>  *ptr
 ///   *ptr->get()  ==>  **ptr
 /// \endcode
 class RedundantSmartptrGetCheck : public ClangTidyCheck {
 public:
   RedundantSmartptrGetCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
-        IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", 1) != 0) {}
+        IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const bool IgnoreMacros;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTSMARTPTRGETCHECK_H

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

bool VisitBinaryOperator(BinaryOperator *Op) {
     return true;
   }
 
  private:
   SimplifyBooleanExprCheck *Check;
   const MatchFinder::MatchResult &Result;
 };
 
-
 SimplifyBooleanExprCheck::SimplifyBooleanExprCheck(StringRef Name,
                                                    ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      ChainedConditionalReturn(Options.get("ChainedConditionalReturn", 0U)),
+      ChainedConditionalReturn(Options.get("ChainedConditionalReturn", false)),
       ChainedConditionalAssignment(
-          Options.get("ChainedConditionalAssignment", 0U)) {}
+          Options.get("ChainedConditionalAssignment", false)) {}
 
 bool containsBoolLiteral(const Expr *E) {
   if (!E)
     return false;
   E = E->IgnoreParenImpCasts();
   if (isa<CXXBoolLiteralExpr>(E))
     return true;
   if (const auto *BinOp = dyn_cast<BinaryOperator>(E))

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

 
 } // namespace
 
 UppercaseLiteralSuffixCheck::UppercaseLiteralSuffixCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       NewSuffixes(
           utils::options::parseStringList(Options.get("NewSuffixes", ""))),
-      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", 1) != 0) {}
+      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
 
 void UppercaseLiteralSuffixCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "NewSuffixes",
                 utils::options::serializeStringList(NewSuffixes));
   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
 }