[clang-tidy] Implement storeOptions for checks missing it.

[njames93]

Summary

Just adds the storeOptions for Checks that weren't already storing their options.

[Eugene.Zelenko]

Looks OK for me, but Aaron is proper person to approve patch.

[aaron.ballman]

LGTM!

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

 static constexpr llvm::StringLiteral LoopUpperBoundName =
     llvm::StringLiteral("loopUpperBound");
 static constexpr llvm::StringLiteral LoopIncrementName =
     llvm::StringLiteral("loopIncrement");
 
 TooSmallLoopVariableCheck::TooSmallLoopVariableCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      MagnitudeBitsUpperLimit(Options.get<unsigned>(
-          "MagnitudeBitsUpperLimit", 16)) {}
+      MagnitudeBitsUpperLimit(Options.get("MagnitudeBitsUpperLimit", 16U)) {}
 
 void TooSmallLoopVariableCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "MagnitudeBitsUpperLimit", MagnitudeBitsUpperLimit);
 }
 
 /// The matcher for loops with suspicious integer loop variable.
 ///

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

 
 /// Find uninitialized local variables.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-init-variables.html
 class InitVariablesCheck : public ClangTidyCheck {
 public:
   InitVariablesCheck(StringRef Name, ClangTidyContext *Context);
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   std::unique_ptr<clang::tidy::utils::IncludeInserter> IncludeInserter;
   const utils::IncludeSorter::IncludeStyle IncludeStyle;
   const std::string MathHeader;
 };
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_INITVARIABLESCHECK_H

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

 InitVariablesCheck::InitVariablesCheck(StringRef Name,
                                        ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IncludeStyle(Options.getLocalOrGlobal("IncludeStyle",
                                             utils::IncludeSorter::getMapping(),
                                             utils::IncludeSorter::IS_LLVM)),
       MathHeader(Options.get("MathHeader", "math.h")) {}
 
+void InitVariablesCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IncludeStyle", IncludeStyle,
+                utils::IncludeSorter::getMapping());
+  Options.store(Opts, "MathHeader", MathHeader);
+}
+
 void InitVariablesCheck::registerMatchers(MatchFinder *Finder) {
   std::string BadDecl = "badDecl";
   Finder->addMatcher(
       varDecl(unless(hasInitializer(anything())), unless(isInstantiated()),
               isLocalVarDecl(), unless(isStaticLocal()), isDefinition(),
               optionally(hasParent(declStmt(hasParent(
                   cxxForRangeStmt(hasLoopVariable(varDecl().bind(BadDecl))))))),
               unless(equalsBoundNode(BadDecl)))
auto Diagnostic =
                    MatchedDecl->getName().size()),
                InitializationString);
     if (AddMathInclude) {
       Diagnostic << IncludeInserter->CreateIncludeInsertion(
           Source.getFileID(MatchedDecl->getBeginLoc()), MathHeader, false);
     }
   }
 }
-
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

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

 ///   i += 0.1;
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-narrowing-conversions.html
 class NarrowingConversionsCheck : public ClangTidyCheck {
 public:
   NarrowingConversionsCheck(StringRef Name, ClangTidyContext *Context);
 
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   void diagNarrowType(SourceLocation SourceLoc, const Expr &Lhs,
                       const Expr &Rhs);
 
   void diagNarrowTypeToSignedInt(SourceLocation SourceLoc, const Expr &Lhs,

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

 
 NarrowingConversionsCheck::NarrowingConversionsCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       WarnOnFloatingPointNarrowingConversion(
           Options.get("WarnOnFloatingPointNarrowingConversion", true)),
       PedanticMode(Options.get("PedanticMode", false)) {}
 
+void NarrowingConversionsCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "WarnOnFloatingPointNarrowingConversion",
+                WarnOnFloatingPointNarrowingConversion);
+  Options.store(Opts, "PedanticMode", PedanticMode);
+}
+
 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:
   //   i = 0.5;

 
 void NarrowingConversionsCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Op = Result.Nodes.getNodeAs<BinaryOperator>("binary_op"))
     return handleBinaryOperator(*Result.Context, *Op);
   if (const auto *Cast = Result.Nodes.getNodeAs<ImplicitCastExpr>("cast"))
     return handleImplicitCast(*Result.Context, *Cast);
   llvm_unreachable("must be binary operator or cast expression");
 }
-
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/misc/NonPrivateMemberVariablesInClassesCheck.h

 /// http://clang.llvm.org/extra/clang-tidy/checks/misc-non-private-member-variables-in-classes.html
 class NonPrivateMemberVariablesInClassesCheck : public ClangTidyCheck {
 public:
   NonPrivateMemberVariablesInClassesCheck(StringRef Name,
                                           ClangTidyContext *Context);
   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 IgnoreClassesWithAllMemberVariablesBeingPublic;
   const bool IgnorePublicMemberVariables;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NONPRIVATEMEMBERVARIABLESINCLASSESCHECK_H

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

NonPrivateMemberVariablesInClassesCheck::
     NonPrivateMemberVariablesInClassesCheck(StringRef Name,
                                             ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IgnoreClassesWithAllMemberVariablesBeingPublic(
           Options.get("IgnoreClassesWithAllMemberVariablesBeingPublic", false)),
       IgnorePublicMemberVariables(
           Options.get("IgnorePublicMemberVariables", false)) {}
 
+void NonPrivateMemberVariablesInClassesCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IgnoreClassesWithAllMemberVariablesBeingPublic",
+                IgnoreClassesWithAllMemberVariablesBeingPublic);
+  Options.store(Opts, "IgnorePublicMemberVariables",
+                IgnorePublicMemberVariables);
+}
+
 void NonPrivateMemberVariablesInClassesCheck::registerMatchers(
     MatchFinder *Finder) {
   // We can ignore structs/classes with all member variables being public.
   auto ShouldIgnoreRecord =
       allOf(boolean(IgnoreClassesWithAllMemberVariablesBeingPublic),
             unless(hasNonPublicMemberVariable()));
 
   // There are three visibility types: public, protected, private.

clang-tools-extra/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.h

private:
   void diagnoseThrowLocations(const CXXThrowExpr *throwExpr);
   void diagnoseCatchLocations(const CXXCatchStmt *catchStmt,
                               ASTContext &context);
   bool isFunctionParameter(const DeclRefExpr *declRefExpr);
   bool isCatchVariable(const DeclRefExpr *declRefExpr);
   bool isFunctionOrCatchVar(const DeclRefExpr *declRefExpr);
   const bool CheckAnonymousTemporaries;
   const bool WarnOnLargeObject;
+  const uint64_t MaxSizeOptions; // The raw value read from the options.
   uint64_t MaxSize; // No `const` because we have to set it in two steps.
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROW_BY_VALUE_CATCH_BY_REFERENCE_H

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

 namespace misc {
 
 ThrowByValueCatchByReferenceCheck::ThrowByValueCatchByReferenceCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       CheckAnonymousTemporaries(Options.get("CheckThrowTemporaries", true)),
       WarnOnLargeObject(Options.get("WarnOnLargeObject", false)),
       // Cannot access `ASTContext` from here so set it to an extremal value.
-      MaxSize(Options.get("MaxSize", std::numeric_limits<uint64_t>::max())) {}
+      MaxSizeOptions(
+          Options.get("MaxSize", std::numeric_limits<uint64_t>::max())),
+      MaxSize(MaxSizeOptions) {}
 
 void ThrowByValueCatchByReferenceCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(cxxThrowExpr().bind("throw"), this);
   Finder->addMatcher(cxxCatchStmt().bind("catch"), this);
 }
 
 void ThrowByValueCatchByReferenceCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "CheckThrowTemporaries", true);
+  Options.store(Opts, "WarnOnLargeObjects", WarnOnLargeObject);
+  Options.store(Opts, "MaxSize", MaxSizeOptions);
 }
 
 void ThrowByValueCatchByReferenceCheck::check(
     const MatchFinder::MatchResult &Result) {
   diagnoseThrowLocations(Result.Nodes.getNodeAs<CXXThrowExpr>("throw"));
   diagnoseCatchLocations(Result.Nodes.getNodeAs<CXXCatchStmt>("catch"),
                          *Result.Context);
 }

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

 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/modernize-avoid-std-bind.html
 class AvoidBindCheck : public ClangTidyCheck {
 public:
   AvoidBindCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus14;
   }
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   bool PermissiveParameterList = false;
 };
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOID_BIND_H

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

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", false)) {}
 
+void AvoidBindCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "PermissiveParameterList", PermissiveParameterList);
+}
+
 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"),
                        expr(hasParent(materializeTemporaryExpr().bind("ref"))),

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

 }
 
 LoopConvertCheck::RangeDescriptor::RangeDescriptor()
     : ContainerNeedsDereference(false), DerefByConstRef(false),
       DerefByValue(false) {}
 
 LoopConvertCheck::LoopConvertCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), TUInfo(new TUTrackingInfo),
-      MaxCopySize(std::stoull(Options.get("MaxCopySize", "16"))),
+      MaxCopySize(Options.get("MaxCopySize", 16ULL)),
       MinConfidence(Options.get("MinConfidence", getConfidenceMapping(),
                                 Confidence::CL_Reasonable)),
       NamingStyle(Options.get("NamingStyle", getStyleMapping(),
                               VariableNamer::NS_CamelCase)) {}
 
 void LoopConvertCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "MaxCopySize", std::to_string(MaxCopySize));
   Options.store(Opts, "MinConfidence", MinConfidence, getConfidenceMapping());

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

for (const unsigned char C : StringRef("\000\001\002\003\004\005\006\a"
                                          33))
     DisallowedChars.set(C);
 
   // Non-ASCII are disallowed too.
   for (unsigned int C = 0x80u; C <= 0xFFu; ++C)
     DisallowedChars.set(static_cast<unsigned char>(C));
 }
 
-void RawStringLiteralCheck::storeOptions(ClangTidyOptions::OptionMap &Options) {
-  ClangTidyCheck::storeOptions(Options);
-  this->Options.store(Options, "ReplaceShorterLiterals",
-                      ReplaceShorterLiterals);
+void RawStringLiteralCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "DelimiterStem", DelimiterStem);
+  Options.store(Opts, "ReplaceShorterLiterals", ReplaceShorterLiterals);
 }
 
 void RawStringLiteralCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       stringLiteral(unless(hasParent(predefinedExpr()))).bind("lit"), this);
 }
 
 void RawStringLiteralCheck::check(const MatchFinder::MatchResult &Result) {

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

 
 UseAutoCheck::UseAutoCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       MinTypeNameLength(Options.get("MinTypeNameLength", 5)),
       RemoveStars(Options.get("RemoveStars", false)) {}
 
 void UseAutoCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "MinTypeNameLength", MinTypeNameLength);
-  Options.store(Opts, "RemoveStars", RemoveStars ? 1 : 0);
+  Options.store(Opts, "RemoveStars", RemoveStars);
 }
 
 void UseAutoCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(traverse(ast_type_traits::TK_AsIs, makeCombinedMatcher()),
                      this);
 }
 
 void UseAutoCheck::replaceIterators(const DeclStmt *D, ASTContext *Context) {

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

 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-bool-literals.html
 class UseBoolLiteralsCheck : public ClangTidyCheck {
 public:
   UseBoolLiteralsCheck(StringRef Name, ClangTidyContext *Context);
   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_BOOL_LITERALS_H

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

 namespace tidy {
 namespace modernize {
 
 UseBoolLiteralsCheck::UseBoolLiteralsCheck(StringRef Name,
                                            ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
 
+void UseBoolLiteralsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IgnoreMacros", IgnoreMacros);
+}
+
 void UseBoolLiteralsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       traverse(
           ast_type_traits::TK_AsIs,
           implicitCastExpr(
               has(ignoringParenImpCasts(integerLiteral().bind("literal"))),
               hasImplicitDestinationType(qualType(booleanType())),
               unless(isInTemplateInstantiation()),

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

const auto ParamCallSourceRange =
       CharSourceRange::getTokenRange(ExprBegin, CallParensRange.getBegin());
 
   Diag << FixItHint::CreateRemoval(ParamCallSourceRange)
        << FixItHint::CreateRemoval(CharSourceRange::getTokenRange(
            CallParensRange.getEnd(), CallParensRange.getEnd()));
 }
 
 void UseEmplaceCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IgnoreImplicitConstructors", IgnoreImplicitConstructors);
   Options.store(Opts, "ContainersWithPushBack",
                 utils::options::serializeStringList(ContainersWithPushBack));
   Options.store(Opts, "SmartPointers",
                 utils::options::serializeStringList(SmartPointers));
   Options.store(Opts, "TupleTypes",
                 utils::options::serializeStringList(TupleTypes));
   Options.store(Opts, "TupleMakeFunctions",
                 utils::options::serializeStringList(TupleMakeFunctions));
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

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

 namespace modernize {
 
 UseTransparentFunctorsCheck::UseTransparentFunctorsCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), SafeMode(Options.get("SafeMode", false)) {}
 
 void UseTransparentFunctorsCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "SafeMode", SafeMode ? 1 : 0);
+  Options.store(Opts, "SafeMode", SafeMode);
 }
 
 void UseTransparentFunctorsCheck::registerMatchers(MatchFinder *Finder) {
   const auto TransparentFunctors =
       classTemplateSpecializationDecl(
           unless(hasAnyTemplateArgument(refersToType(voidType()))),
           hasAnyName("::std::plus", "::std::minus", "::std::multiplies",
                      "::std::divides", "::std::modulus", "::std::negate",

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

class UseUsingCheck : public ClangTidyCheck {
   std::string FirstTypedefType;
   std::string FirstTypedefName;
 
 public:
   UseUsingCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11;
   }
-  void storeOptions(ClangTidyOptions::OptionMap &Opts) override {
-    Options.store(Opts, "IgnoreMacros", IgnoreMacros);
-  }
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_USING_H

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

 namespace clang {
 namespace tidy {
 namespace modernize {
 
 UseUsingCheck::UseUsingCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
 
+void UseUsingCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IgnoreMacros", IgnoreMacros);
+}
+
 void UseUsingCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(typedefDecl(unless(isInstantiated())).bind("typedef"),
                      this);
   // This matcher used to find tag declarations in source code within typedefs.
   // They appear in the AST just *prior* to the typedefs.
   Finder->addMatcher(tagDecl(unless(isImplicit())).bind("tagdecl"), this);
 }
 
Type = std::string(
                              *Result.SourceManager, getLangOpts(), &Invalid));
     if (Invalid)
       return;
   }
 
   std::string Replacement = Using + Name + " = " + Type;
   Diag << FixItHint::CreateReplacement(ReplaceRange, Replacement);
 }
-
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

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

void checkBoundMatch(const ast_matchers::MatchFinder::MatchResult &Result,
     diag(MatchedLiteral->getLocation(),
          "%0 is a magic number; consider replacing it with a named constant")
         << LiteralSourceText;
   }
 
   const bool IgnoreAllFloatingPointValues;
   const bool IgnoreBitFieldsWidths;
   const bool IgnorePowersOf2IntegerValues;
+  const std::string RawIgnoredIntegerValues;
+  const std::string RawIgnoredFloatingPointValues;
 
   constexpr static unsigned SensibleNumberOfMagicValueExceptions = 16;
 
   constexpr static llvm::APFloat::roundingMode DefaultRoundingMode =
       llvm::APFloat::rmNearestTiesToEven;
 
   llvm::SmallVector<int64_t, SensibleNumberOfMagicValueExceptions>
       IgnoredIntegerValues;

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

 const char DefaultIgnoredFloatingPointValues[] = "1.0;100.0;";
 
 MagicNumbersCheck::MagicNumbersCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IgnoreAllFloatingPointValues(
           Options.get("IgnoreAllFloatingPointValues", false)),
       IgnoreBitFieldsWidths(Options.get("IgnoreBitFieldsWidths", true)),
       IgnorePowersOf2IntegerValues(
-          Options.get("IgnorePowersOf2IntegerValues", false)) {
+          Options.get("IgnorePowersOf2IntegerValues", false)),
+      RawIgnoredIntegerValues(
+          Options.get("IgnoredIntegerValues", DefaultIgnoredIntegerValues)),
+      RawIgnoredFloatingPointValues(Options.get(
+          "IgnoredFloatingPointValues", DefaultIgnoredFloatingPointValues)) {
   // Process the set of ignored integer values.
   const std::vector<std::string> IgnoredIntegerValuesInput =
-      utils::options::parseStringList(
-          Options.get("IgnoredIntegerValues", DefaultIgnoredIntegerValues));
+      utils::options::parseStringList(RawIgnoredIntegerValues);
   IgnoredIntegerValues.resize(IgnoredIntegerValuesInput.size());
   llvm::transform(IgnoredIntegerValuesInput, IgnoredIntegerValues.begin(),
                   [](const std::string &Value) { return std::stoll(Value); });
   llvm::sort(IgnoredIntegerValues);
 
   if (!IgnoreAllFloatingPointValues) {
     // Process the set of ignored floating point values.
     const std::vector<std::string> IgnoredFloatingPointValuesInput =
-        utils::options::parseStringList(Options.get(
-            "IgnoredFloatingPointValues", DefaultIgnoredFloatingPointValues));
+        utils::options::parseStringList(RawIgnoredFloatingPointValues);
     IgnoredFloatingPointValues.reserve(IgnoredFloatingPointValuesInput.size());
     IgnoredDoublePointValues.reserve(IgnoredFloatingPointValuesInput.size());
     for (const auto &InputValue : IgnoredFloatingPointValuesInput) {
       llvm::APFloat FloatValue(llvm::APFloat::IEEEsingle());
       auto StatusOrErr =
           FloatValue.convertFromString(InputValue, DefaultRoundingMode);
       assert(StatusOrErr && "Invalid floating point representation");
       consumeError(StatusOrErr.takeError());
if (!IgnoreAllFloatingPointValues) {
     llvm::sort(IgnoredFloatingPointValues.begin(),
                IgnoredFloatingPointValues.end());
     llvm::sort(IgnoredDoublePointValues.begin(),
                IgnoredDoublePointValues.end());
   }
 }
 
 void MagicNumbersCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IgnoredIntegerValues", DefaultIgnoredIntegerValues);
+  Options.store(Opts, "IgnoreAllFloatingPointValues",
+                IgnoreAllFloatingPointValues);
+  Options.store(Opts, "IgnoreBitFieldsWidths", IgnoreBitFieldsWidths);
+  Options.store(Opts, "IgnorePowersOf2IntegerValues",
+                IgnorePowersOf2IntegerValues);
+  Options.store(Opts, "IgnoredIntegerValues", RawIgnoredIntegerValues);
   Options.store(Opts, "IgnoredFloatingPointValues",
-                DefaultIgnoredFloatingPointValues);
+                RawIgnoredFloatingPointValues);
 }
 
 void MagicNumbersCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(integerLiteral().bind("integer"), this);
   if (!IgnoreAllFloatingPointValues)
     Finder->addMatcher(floatLiteral().bind("float"), this);
 }
 

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

 
 /// Find redundant variable declarations.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-declaration.html
 class RedundantDeclarationCheck : public ClangTidyCheck {
 public:
   RedundantDeclarationCheck(StringRef Name, ClangTidyContext *Context);
+  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_REDUNDANT_DECLARATION_H

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

AST_MATCHER(FunctionDecl, doesDeclarationForceExternallyVisibleDefinition) {
   return Node.doesDeclarationForceExternallyVisibleDefinition();
 }
 
 RedundantDeclarationCheck::RedundantDeclarationCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
 
+void RedundantDeclarationCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IgnoreMacros", IgnoreMacros);
+}
+
 void RedundantDeclarationCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       namedDecl(anyOf(varDecl(unless(isDefinition())),
                       functionDecl(unless(anyOf(
                           isDefinition(), isDefaulted(),
                           doesDeclarationForceExternallyVisibleDefinition(),
                           hasParent(friendDecl()))))))
           .bind("Decl"),
void RedundantDeclarationCheck::check(const MatchFinder::MatchResult &Result) {
   {
     auto Diag = diag(D->getLocation(), "redundant %0 declaration") << D;
     if (!MultiVar && !DifferentHeaders)
       Diag << FixItHint::CreateRemoval(
           SourceRange(D->getSourceRange().getBegin(), EndLoc));
   }
   diag(Prev->getLocation(), "previously declared here", DiagnosticIDs::Note);
 }
-
 } // namespace readability
 } // namespace tidy
 } // namespace clang

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

 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-static-accessed-through-instance.html
 class StaticAccessedThroughInstanceCheck : public ClangTidyCheck {
 public:
   StaticAccessedThroughInstanceCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
         NameSpecifierNestingThreshold(
-            Options.get("NameSpecifierNestingThreshold", 3)) {}
+            Options.get("NameSpecifierNestingThreshold", 3U)) {}
 
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const unsigned NameSpecifierNestingThreshold;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_STATIC_ACCESSED_THROUGH_INSTANCE_H

clang-tools-extra/clang-tidy/utils/HeaderGuard.h

public:
   HeaderGuardCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
         RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
             "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
     utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                HeaderFileExtensions,
                                utils::defaultFileExtensionDelimiters());
   }
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
 
   /// Returns ``true`` if the check should suggest inserting a trailing comment
   /// on the ``#endif`` of the header guard. It will use the same name as
   /// returned by ``HeaderGuardCheck::getHeaderGuard``.
   virtual bool shouldSuggestEndifComment(StringRef Filename);
   /// Returns ``true`` if the check should suggest changing an existing header

clang-tools-extra/clang-tidy/utils/HeaderGuard.cpp

std::map<const IdentifierInfo *, std::pair<SourceLocation, SourceLocation>>
       Ifndefs;
   std::map<SourceLocation, SourceLocation> EndIfs;
 
   Preprocessor *PP;
   HeaderGuardCheck *Check;
 };
 } // namespace
 
+void HeaderGuardCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);
+}
+
 void HeaderGuardCheck::registerPPCallbacks(const SourceManager &SM,
                                            Preprocessor *PP,
                                            Preprocessor *ModuleExpanderPP) {
   PP->addPPCallbacks(std::make_unique<HeaderGuardPPCallbacks>(PP, this));
 }
 
 bool HeaderGuardCheck::shouldSuggestEndifComment(StringRef FileName) {
   return utils::isFileExtension(FileName, HeaderFileExtensions);
 }
 
 bool HeaderGuardCheck::shouldFixHeaderGuard(StringRef FileName) { return true; }
 
 bool HeaderGuardCheck::shouldSuggestToAddHeaderGuard(StringRef FileName) {
   return utils::isFileExtension(FileName, HeaderFileExtensions);
 }
 
 std::string HeaderGuardCheck::formatEndIf(StringRef HeaderGuard) {
   return "endif // " + HeaderGuard.str();
 }
-
 } // namespace utils
 } // namespace tidy
 } // namespace clang