reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

   28           Options.get("StringLikeClasses", "::std::basic_string"))),
   30           Options.getLocalOrGlobal("IncludeStyle", "llvm"))),
   32           Options.get("AbseilStringsMatchHeader", "absl/strings/match.h")) {}
  125   Options.store(Opts, "StringLikeClasses",
  127   Options.store(Opts, "IncludeStyle",
  129   Options.store(Opts, "AbseilStringsMatchHeader", AbseilStringsMatchHeader);

   26       StrictMode(Options.getLocalOrGlobal("StrictMode", 0) != 0),
   27       IgnoreSingleArgument(Options.get("IgnoreSingleArgument", 0) != 0),
   28       CommentBoolLiterals(Options.get("CommentBoolLiterals", 0) != 0),
   29       CommentIntegerLiterals(Options.get("CommentIntegerLiterals", 0) != 0),
   30       CommentFloatLiterals(Options.get("CommentFloatLiterals", 0) != 0),
   31       CommentStringLiterals(Options.get("CommentStringLiterals", 0) != 0),
   32       CommentUserDefinedLiterals(Options.get("CommentUserDefinedLiterals", 0) !=
   34       CommentCharacterLiterals(Options.get("CommentCharacterLiterals", 0) != 0),
   35       CommentNullPtrs(Options.get("CommentNullPtrs", 0) != 0),
   39   Options.store(Opts, "StrictMode", StrictMode);
   40   Options.store(Opts, "IgnoreSingleArgument", IgnoreSingleArgument);
   41   Options.store(Opts, "CommentBoolLiterals", CommentBoolLiterals);
   42   Options.store(Opts, "CommentIntegerLiterals", CommentIntegerLiterals);
   43   Options.store(Opts, "CommentFloatLiterals", CommentFloatLiterals);
   44   Options.store(Opts, "CommentStringLiterals", CommentStringLiterals);
   45   Options.store(Opts, "CommentUserDefinedLiterals", CommentUserDefinedLiterals);
   46   Options.store(Opts, "CommentCharacterLiterals", CommentCharacterLiterals);
   47   Options.store(Opts, "CommentNullPtrs", CommentNullPtrs);

   74       CheckFunctionCalls(Options.get("CheckFunctionCalls", false)),
   75       RawAssertList(Options.get("AssertMacros", "assert")) {
   81   Options.store(Opts, "CheckFunctionCalls", CheckFunctionCalls);
   82   Options.store(Opts, "AssertMacros", RawAssertList);

   94       HandleClasses(utils::options::parseStringList(Options.get(
  102   Options.store(Opts, "HandleClasses",

   32       RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
   43   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);

   30     : ClangTidyCheck(Name, Context), RawFunctionsThatShouldNotThrow(Options.get(
   32       RawIgnoredExceptions(Options.get("IgnoredExceptions", "")) {
   49   Options.store(Opts, "FunctionsThatShouldNotThrow",
   51   Options.store(Opts, "IgnoredExceptions", RawIgnoredExceptions);

   23       CheckImplicitCasts(Options.get("CheckImplicitCasts", false)) {}
   27   Options.store(Opts, "CheckImplicitCasts", CheckImplicitCasts);

  502       WantToUseSafeFunctions(Options.get("WantToUseSafeFunctions", 1)) {}
  506   Options.store(Opts, "WantToUseSafeFunctions", WantToUseSafeFunctions);

   63       WarnOnSizeOfConstant(Options.get("WarnOnSizeOfConstant", 1) != 0),
   65           Options.get("WarnOnSizeOfIntegerExpression", 0) != 0),
   66       WarnOnSizeOfThis(Options.get("WarnOnSizeOfThis", 1) != 0),
   68           Options.get("WarnOnSizeOfCompareToConstant", 1) != 0) {}
   71   Options.store(Opts, "WarnOnSizeOfConstant", WarnOnSizeOfConstant);
   72   Options.store(Opts, "WarnOnSizeOfIntegerExpression",
   74   Options.store(Opts, "WarnOnSizeOfThis", WarnOnSizeOfThis);
   75   Options.store(Opts, "WarnOnSizeOfCompareToConstant",

   29       WarnOnLargeLength(Options.get("WarnOnLargeLength", 1) != 0),
   30       LargeLengthThreshold(Options.get("LargeLengthThreshold", 0x800000)) {}
   33   Options.store(Opts, "WarnOnLargeLength", WarnOnLargeLength);
   34   Options.store(Opts, "LargeLengthThreshold", LargeLengthThreshold);

  113       StrictMode(Options.getLocalOrGlobal("StrictMode", 0)) {}
  116   Options.store(Opts, "StrictMode", StrictMode);

   73       SizeThreshold(Options.get("SizeThreshold", 5U)),
   74       RatioThreshold(std::stod(Options.get("RatioThreshold", ".2"))),
   75       MaxConcatenatedTokens(Options.get("MaxConcatenatedTokens", 5U)) {}
   79   Options.store(Opts, "SizeThreshold", SizeThreshold);
   80   Options.store(Opts, "RatioThreshold", std::to_string(RatioThreshold));
   81   Options.store(Opts, "MaxConcatenatedTokens", MaxConcatenatedTokens);

   72       WarnOnImplicitComparison(Options.get("WarnOnImplicitComparison", 1)),
   73       WarnOnLogicalNotComparison(Options.get("WarnOnLogicalNotComparison", 0)),
   75           Options.get("StringCompareLikeFunctions", "")) {}
   79   Options.store(Opts, "WarnOnImplicitComparison", WarnOnImplicitComparison);
   80   Options.store(Opts, "WarnOnLogicalNotComparison", WarnOnLogicalNotComparison);
   81   Options.store(Opts, "StringCompareLikeFunctions", StringCompareLikeFunctions);

   33       MagnitudeBitsUpperLimit(Options.get<unsigned>(
   38   Options.store(Opts, "MagnitudeBitsUpperLimit", MagnitudeBitsUpperLimit);

   23           Options.get("WarnOnlyIfThisHasSuspiciousField", true)) {}
   27   Options.store(Opts, "WarnOnlyIfThisHasSuspiciousField",

   38       CheckedFunctions(Options.get("CheckedFunctions",
   49   Options.store(Opts, "CheckedFunctions", CheckedFunctions);

   24           Options.get("DisallowedSeedTypes", "time_t,std::time_t")) {
   30   Options.store(Opts, "DisallowedSeedTypes", RawDisallowedSeedTypes);

   28           Options.getLocalOrGlobal("IncludeStyle", "llvm"))),
   29       MathHeader(Options.get("MathHeader", "math.h")) {}

   66   Options.store(Opts, "AllowedRegexp", AllowedRegexp);
   67   Options.store(Opts, "CheckCapsOnly", CheckCapsOnly);
   68   Options.store(Opts, "IgnoreCommandLineMacros", IgnoreCommandLineMacros);

   29         AllowedRegexp(Options.get("AllowedRegexp", "^DEBUG_*")),
   30         CheckCapsOnly(Options.get("CheckCapsOnly", 0)),
   31         IgnoreCommandLineMacros(Options.get("IgnoreCommandLineMacros", 1)) {}

   29           Options.get("WarnOnFloatingPointNarrowingConversion", 1)),
   30       PedanticMode(Options.get("PedanticMode", 0)) {}

   34   Options.store(Opts, "Allocations", AllocList);
   35   Options.store(Opts, "Reallocations", ReallocList);
   36   Options.store(Opts, "Deallocations", DeallocList);

   32         AllocList(Options.get("Allocations", "::malloc;::calloc")),
   33         ReallocList(Options.get("Reallocations", "::realloc")),
   34         DeallocList(Options.get("Deallocations", "::free")) {}

   35   Options.store(Opts, "LegacyResourceProducers", LegacyResourceProducers);
   36   Options.store(Opts, "LegacyResourceConsumers", LegacyResourceConsumers);

   27         LegacyResourceProducers(Options.get(
   30         LegacyResourceConsumers(Options.get(

   23     : ClangTidyCheck(Name, Context), GslHeader(Options.get("GslHeader", "")),
   25           Options.getLocalOrGlobal("IncludeStyle", "llvm"))) {}
   29   Options.store(Opts, "GslHeader", GslHeader);
   30   Options.store(Opts, "IncludeStyle", IncludeStyle);

  253       IgnoreArrays(Options.get("IgnoreArrays", false)),
  254       UseAssignment(Options.getLocalOrGlobal("UseAssignment", false)) {}
  317   Options.store(Opts, "IgnoreArrays", IgnoreArrays);
  318   Options.store(Opts, "UseAssignment", UseAssignment);

   27       AllowMissingMoveFunctions(Options.get("AllowMissingMoveFunctions", 0)),
   28       AllowSoleDefaultDtor(Options.get("AllowSoleDefaultDtor", 0)) {}
   32   Options.store(Opts, "AllowMissingMoveFunctions", AllowMissingMoveFunctions);
   33   Options.store(Opts, "AllowSoleDefaultDtor", AllowSoleDefaultDtor);

  111   Options.store(Opts, "Includes", AllowedIncludes);

   28         AllowedIncludes(Options.get("Includes", "*")),

   25       RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
   36   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);

   45       UnsignedTypePrefix(Options.get("UnsignedTypePrefix", "uint")),
   46       SignedTypePrefix(Options.get("SignedTypePrefix", "int")),
   47       TypeSuffix(Options.get("TypeSuffix", "")) {}
   50   Options.store(Opts, "UnsignedTypePrefix", UnsignedTypePrefix);
   51   Options.store(Opts, "SignedTypePrefix", SignedTypePrefix);
   52   Options.store(Opts, "TypeSuffix", TypeSuffix);

   26           utils::options::parseStringList(Options.get("WhiteListTypes", ""))) {}
   29   Options.store(Opts, "WhiteListTypes",

   24       RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
   35   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);

   22   Options.store(Opts, "WarnOnMissingElse", WarnOnMissingElse);

   30         WarnOnMissingElse(Options.get("WarnOnMissingElse", 0)) {}

   33       UseHeaderFileExtension(Options.get("UseHeaderFileExtension", true)),
   34       RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
   47   Options.store(Opts, "UseHeaderFileExtension", UseHeaderFileExtension);
   48   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);

   47           Options.get("IgnoreClassesWithAllMemberVariablesBeingPublic", false)),
   49           Options.get("IgnorePublicMemberVariables", false)) {}

   23       CheckAnonymousTemporaries(Options.get("CheckThrowTemporaries", true)),
   24       WarnOnLargeObject(Options.get("WarnOnLargeObject", false)),
   26       MaxSize(Options.get("MaxSize", std::numeric_limits<uint64_t>::max())) {}
   39   Options.store(Opts, "CheckThrowTemporaries", true);

  125       StrictMode(Options.getLocalOrGlobal("StrictMode", 0) != 0) {}
  128   Options.store(Opts, "StrictMode", StrictMode);

  459       MaxCopySize(std::stoull(Options.get("MaxCopySize", "16"))),
  461                         Options.get("MinConfidence", "reasonable"))
  466                       Options.get("NamingStyle", "CamelCase"))
  473   Options.store(Opts, "MaxCopySize", std::to_string(MaxCopySize));
  475   Options.store(Opts, "MinConfidence", Confs[static_cast<int>(MinConfidence)]);
  479   Options.store(Opts, "NamingStyle", Styles[static_cast<int>(NamingStyle)]);

   49           Options.getLocalOrGlobal("IncludeStyle", "llvm"))),
   51           Options.get("MakeSmartPtrFunctionHeader", StdMemoryHeader)),
   53           Options.get("MakeSmartPtrFunction", MakeSmartPtrFunctionName)),
   54       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
   57   Options.store(Opts, "IncludeStyle", IncludeStyle);
   58   Options.store(Opts, "MakeSmartPtrFunctionHeader", MakeSmartPtrFunctionHeader);
   59   Options.store(Opts, "MakeSmartPtrFunction", MakeSmartPtrFunctionName);
   60   Options.store(Opts, "IgnoreMacros", IgnoreMacros);

   20       RequireCPlusPlus14(Options.get("MakeSmartPtrFunction", "").empty()) {}

  123           Options.getLocalOrGlobal("IncludeStyle", "llvm"))),
  124       ValuesOnly(Options.get("ValuesOnly", 0) != 0) {}
  127   Options.store(Opts, "IncludeStyle",
  129   Options.store(Opts, "ValuesOnly", ValuesOnly);

   90       DelimiterStem(Options.get("DelimiterStem", "lit")),
   91       ReplaceShorterLiterals(Options.get("ReplaceShorterLiterals", false)) {
  116   this->Options.store(Options, "ReplaceShorterLiterals",

   78           Options.getLocalOrGlobal("IncludeStyle", "llvm"))) {}
   81   Options.store(Opts, "IncludeStyle",

   27           Options.getLocalOrGlobal("IncludeStyle", "llvm"))) {}
   54   Options.store(Opts, "IncludeStyle",

  319       MinTypeNameLength(Options.get("MinTypeNameLength", 5)),
  320       RemoveStars(Options.get("RemoveStars", 0)) {}
  323   Options.store(Opts, "MinTypeNameLength", MinTypeNameLength);
  324   Options.store(Opts, "RemoveStars", RemoveStars ? 1 : 0);

   23       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}

  183       UseAssignment(Options.get("UseAssignment", 0) != 0),
  184       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true) != 0) {}
  188   Options.store(Opts, "UseAssignment", UseAssignment);
  189   Options.store(Opts, "IgnoreMacros", IgnoreMacros);

   32       IgnoreImplicitConstructors(Options.get("IgnoreImplicitConstructors", 0)),
   33       ContainersWithPushBack(utils::options::parseStringList(Options.get(
   36           Options.get("SmartPointers", DefaultSmartPointers))),
   38           Options.get("TupleTypes", DefaultTupleTypes))),
   40           Options.get("TupleMakeFunctions", DefaultTupleMakeFunctions))) {}
  164   Options.store(Opts, "ContainersWithPushBack",
  166   Options.store(Opts, "SmartPointers",
  168   Options.store(Opts, "TupleTypes",
  170   Options.store(Opts, "TupleMakeFunctions",

  203       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true) != 0) {}
  206   Options.store(Opts, "IgnoreMacros", IgnoreMacros);

   24   Options.store(Opts, "IgnoreMacros", IgnoreMacros);

   41         IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", 1) != 0) {}

   80       NoDiscardMacro(Options.get("ReplacementString", "[[nodiscard]]")) {}
   83   Options.store(Opts, "ReplacementString", NoDiscardMacro);

   21       NoexceptMacro(Options.get("ReplacementString", "")),
   22       UseNoexceptFalse(Options.get("UseNoexceptFalse", true)) {}
   25   Options.store(Opts, "ReplacementString", NoexceptMacro);
   26   Options.store(Opts, "UseNoexceptFalse", UseNoexceptFalse);

  467       NullMacrosStr(Options.get("NullMacros", "")) {
  472   Options.store(Opts, "NullMacros", NullMacrosStr);

   22       IgnoreDestructors(Options.get("IgnoreDestructors", false)),
   23       OverrideSpelling(Options.get("OverrideSpelling", "override")),
   24       FinalSpelling(Options.get("FinalSpelling", "final")) {}
   27   Options.store(Opts, "IgnoreDestructors", IgnoreDestructors);
   28   Options.store(Opts, "OverrideSpelling", OverrideSpelling);
   29   Options.store(Opts, "FinalSpelling", FinalSpelling);

   21     : ClangTidyCheck(Name, Context), SafeMode(Options.get("SafeMode", 0)) {}
   25   Options.store(Opts, "SafeMode", SafeMode ? 1 : 0);

   21       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}

   29     Options.store(Opts, "IgnoreMacros", IgnoreMacros);

   48               Options.get("ClassNames", DefaultForbiddenSuperClassNames))) {
   86   Options.store(

   27       RawIgnoredExceptions(Options.get("IgnoredExceptions", "")) {
   42   Options.store(Opts, "IgnoredExceptions", RawIgnoredExceptions);

   54           Options.get("StringLikeClasses", "std::basic_string"))) {}
   57   Options.store(Opts, "StringLikeClasses",

   25       WarnOnAllAutoCopies(Options.get("WarnOnAllAutoCopies", 0)),
   27           utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
   30   Options.store(Opts, "WarnOnAllAutoCopies", WarnOnAllAutoCopies);
   31   Options.store(Opts, "AllowedTypes",

   21   Options.store(Opts, "StrictMode", StrictMode);
   27       StrictMode(Options.getLocalOrGlobal("StrictMode", 0)) {}

   77           Options.get("VectorLikeClasses", "::std::vector"))),
   78       EnableProto(Options.getLocalOrGlobal("EnableProto", false)) {}
   82   Options.store(Opts, "VectorLikeClasses",
   84   Options.store(Opts, "EnableProto", EnableProto);

   39   Options.store(Opts, "CheckTriviallyCopyableMove", CheckTriviallyCopyableMove);

   29             Options.get("CheckTriviallyCopyableMove", true)) {}

   27           Options.getLocalOrGlobal("IncludeStyle", "llvm"))) {}
  102   Options.store(Opts, "IncludeStyle",

   35           Options.getLocalOrGlobal("IncludeStyle", "llvm"))) {}
   46   Options.store(Opts, "IncludeStyle",

   37           utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
  157   Options.store(Opts, "AllowedTypes",

   71           Options.getLocalOrGlobal("IncludeStyle", "llvm"))),
   73           utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
  179   Options.store(Opts, "IncludeStyle",
  181   Options.store(Opts, "AllowedTypes",

   86     : ClangTidyCheck(Name, Context), Std(Options.get("Std", "")),
   87       Suggest(Options.get("Suggest", 0) != 0) {}
   90   Options.store(Opts, "Std", "");
   91   Options.store(Opts, "Suggest", 0);

  118       ShortStatementLines(Options.get("ShortStatementLines", 0U)) {}
  122   Options.store(Opts, "ShortStatementLines", ShortStatementLines);

  130       LineThreshold(Options.get("LineThreshold", -1U)),
  131       StatementThreshold(Options.get("StatementThreshold", 800U)),
  132       BranchThreshold(Options.get("BranchThreshold", -1U)),
  133       ParameterThreshold(Options.get("ParameterThreshold", -1U)),
  134       NestingThreshold(Options.get("NestingThreshold", -1U)),
  135       VariableThreshold(Options.get("VariableThreshold", -1U)) {}
  138   Options.store(Opts, "LineThreshold", LineThreshold);
  139   Options.store(Opts, "StatementThreshold", StatementThreshold);
  140   Options.store(Opts, "BranchThreshold", BranchThreshold);
  141   Options.store(Opts, "ParameterThreshold", ParameterThreshold);
  142   Options.store(Opts, "NestingThreshold", NestingThreshold);
  143   Options.store(Opts, "VariableThreshold", VariableThreshold);

  182         fromString(Options.get((Name + "Case").str(), ""));
  183     auto prefix = Options.get((Name + "Prefix").str(), "");
  184     auto postfix = Options.get((Name + "Suffix").str(), "");
  193   IgnoreFailedSplit = Options.get("IgnoreFailedSplit", 0);
  223         Options.store(Opts, (StyleNames[i] + "Case").str(),
  226       Options.store(Opts, (StyleNames[i] + "Prefix").str(),
  228       Options.store(Opts, (StyleNames[i] + "Suffix").str(),
  233   Options.store(Opts, "IgnoreFailedSplit", IgnoreFailedSplit);

  250       AllowIntegerConditions(Options.get("AllowIntegerConditions", false)),
  251       AllowPointerConditions(Options.get("AllowPointerConditions", false)) {}
  255   Options.store(Opts, "AllowIntegerConditions", AllowIntegerConditions);
  256   Options.store(Opts, "AllowPointerConditions", AllowPointerConditions);

  294   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
  295   Options.store(Opts, "Strict", Strict);

   30         IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", 1) != 0),
   31         Strict(Options.getLocalOrGlobal("Strict", 0) != 0) {}

   58           Options.get("IgnoreAllFloatingPointValues", false)),
   60           Options.get("IgnorePowersOf2IntegerValues", false)) {
   64           Options.get("IgnoredIntegerValues", DefaultIgnoredIntegerValues));
   73         utils::options::parseStringList(Options.get(
   94   Options.store(Opts, "IgnoredIntegerValues", DefaultIgnoredIntegerValues);
   95   Options.store(Opts, "IgnoredFloatingPointValues",

   28       ShortNamespaceLines(Options.get("ShortNamespaceLines", 1u)),
   29       SpacesBeforeComments(Options.get("SpacesBeforeComments", 1u)) {}
   32   Options.store(Opts, "ShortNamespaceLines", ShortNamespaceLines);
   33   Options.store(Opts, "SpacesBeforeComments", SpacesBeforeComments);

   27       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}

   98   Options.store(Opts, "IgnoreMacros", IgnoreMacros);

   31         IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", 1) != 0) {}

  340       ChainedConditionalReturn(Options.get("ChainedConditionalReturn", 0U)),
  342           Options.get("ChainedConditionalAssignment", 0U)) {}
  501   Options.store(Opts, "ChainedConditionalReturn", ChainedConditionalReturn);
  502   Options.store(Opts, "ChainedConditionalAssignment",

   26                                          Options.get("Types", kDefaultTypes))) {
   70   Options.store(Opts, "Types", utils::options::serializeStringList(Types));

   35   Options.store(Opts, "NameSpecifierNestingThreshold",

   28             Options.get("NameSpecifierNestingThreshold", 3)) {}

  185           utils::options::parseStringList(Options.get("NewSuffixes", ""))),
  186       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", 1) != 0) {}
  190   Options.store(Opts, "NewSuffixes",
  192   Options.store(Opts, "IgnoreMacros", IgnoreMacros);

   30         RawStringHeaderFileExtensions(Options.getLocalOrGlobal(

   33     : ClangTidyCheck(Name, Context), Rule(MakeRule(getLangOpts(), Options)) {

   54   Options.store(Opts, "Names", utils::options::serializeStringList(Names));

   28         Names(utils::options::parseStringList(Options.get("Names", ""))) {}