1 //===--- BugproneTidyModule.cpp - clang-tidy ------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "../ClangTidy.h" 10 #include "../ClangTidyModule.h" 11 #include "../ClangTidyModuleRegistry.h" 12 #include "ArgumentCommentCheck.h" 13 #include "AssertSideEffectCheck.h" 14 #include "AssignmentInIfConditionCheck.h" 15 #include "BadSignalToKillThreadCheck.h" 16 #include "BitwisePointerCastCheck.h" 17 #include "BoolPointerImplicitConversionCheck.h" 18 #include "BranchCloneCheck.h" 19 #include "CastingThroughVoidCheck.h" 20 #include "ChainedComparisonCheck.h" 21 #include "ComparePointerToMemberVirtualFunctionCheck.h" 22 #include "CopyConstructorInitCheck.h" 23 #include "CrtpConstructorAccessibilityCheck.h" 24 #include "DanglingHandleCheck.h" 25 #include "DynamicStaticInitializersCheck.h" 26 #include "EasilySwappableParametersCheck.h" 27 #include "EmptyCatchCheck.h" 28 #include "ExceptionEscapeCheck.h" 29 #include "FoldInitTypeCheck.h" 30 #include "ForwardDeclarationNamespaceCheck.h" 31 #include "ForwardingReferenceOverloadCheck.h" 32 #include "ImplicitWideningOfMultiplicationResultCheck.h" 33 #include "InaccurateEraseCheck.h" 34 #include "IncDecInConditionsCheck.h" 35 #include "IncorrectEnableIfCheck.h" 36 #include "IncorrectEnableSharedFromThisCheck.h" 37 #include "IncorrectRoundingsCheck.h" 38 #include "InfiniteLoopCheck.h" 39 #include "IntegerDivisionCheck.h" 40 #include "LambdaFunctionNameCheck.h" 41 #include "MacroParenthesesCheck.h" 42 #include "MacroRepeatedSideEffectsCheck.h" 43 #include "MisplacedOperatorInStrlenInAllocCheck.h" 44 #include "MisplacedPointerArithmeticInAllocCheck.h" 45 #include "MisplacedWideningCastCheck.h" 46 #include "MoveForwardingReferenceCheck.h" 47 #include "MultiLevelImplicitPointerConversionCheck.h" 48 #include "MultipleNewInOneExpressionCheck.h" 49 #include "MultipleStatementMacroCheck.h" 50 #include "NarrowingConversionsCheck.h" 51 #include "NoEscapeCheck.h" 52 #include "NonZeroEnumToBoolConversionCheck.h" 53 #include "NondeterministicPointerIterationOrderCheck.h" 54 #include "NotNullTerminatedResultCheck.h" 55 #include "OptionalValueConversionCheck.h" 56 #include "ParentVirtualCallCheck.h" 57 #include "PointerArithmeticOnPolymorphicObjectCheck.h" 58 #include "PosixReturnCheck.h" 59 #include "RedundantBranchConditionCheck.h" 60 #include "ReservedIdentifierCheck.h" 61 #include "ReturnConstRefFromParameterCheck.h" 62 #include "SharedPtrArrayMismatchCheck.h" 63 #include "SignalHandlerCheck.h" 64 #include "SignedCharMisuseCheck.h" 65 #include "SizeofContainerCheck.h" 66 #include "SizeofExpressionCheck.h" 67 #include "SpuriouslyWakeUpFunctionsCheck.h" 68 #include "StandaloneEmptyCheck.h" 69 #include "StringConstructorCheck.h" 70 #include "StringIntegerAssignmentCheck.h" 71 #include "StringLiteralWithEmbeddedNulCheck.h" 72 #include "StringviewNullptrCheck.h" 73 #include "SuspiciousEnumUsageCheck.h" 74 #include "SuspiciousIncludeCheck.h" 75 #include "SuspiciousMemoryComparisonCheck.h" 76 #include "SuspiciousMemsetUsageCheck.h" 77 #include "SuspiciousMissingCommaCheck.h" 78 #include "SuspiciousReallocUsageCheck.h" 79 #include "SuspiciousSemicolonCheck.h" 80 #include "SuspiciousStringCompareCheck.h" 81 #include "SuspiciousStringviewDataUsageCheck.h" 82 #include "SwappedArgumentsCheck.h" 83 #include "SwitchMissingDefaultCaseCheck.h" 84 #include "TaggedUnionMemberCountCheck.h" 85 #include "TerminatingContinueCheck.h" 86 #include "ThrowKeywordMissingCheck.h" 87 #include "TooSmallLoopVariableCheck.h" 88 #include "UncheckedOptionalAccessCheck.h" 89 #include "UndefinedMemoryManipulationCheck.h" 90 #include "UndelegatedConstructorCheck.h" 91 #include "UnhandledExceptionAtNewCheck.h" 92 #include "UnhandledSelfAssignmentCheck.h" 93 #include "UniquePtrArrayMismatchCheck.h" 94 #include "UnsafeFunctionsCheck.h" 95 #include "UnusedLocalNonTrivialVariableCheck.h" 96 #include "UnusedRaiiCheck.h" 97 #include "UnusedReturnValueCheck.h" 98 #include "UseAfterMoveCheck.h" 99 #include "VirtualNearMissCheck.h" 100 101 namespace clang::tidy { 102 namespace bugprone { 103 104 class BugproneModule : public ClangTidyModule { 105 public: 106 void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { 107 CheckFactories.registerCheck<ArgumentCommentCheck>( 108 "bugprone-argument-comment"); 109 CheckFactories.registerCheck<AssertSideEffectCheck>( 110 "bugprone-assert-side-effect"); 111 CheckFactories.registerCheck<AssignmentInIfConditionCheck>( 112 "bugprone-assignment-in-if-condition"); 113 CheckFactories.registerCheck<BadSignalToKillThreadCheck>( 114 "bugprone-bad-signal-to-kill-thread"); 115 CheckFactories.registerCheck<BitwisePointerCastCheck>( 116 "bugprone-bitwise-pointer-cast"); 117 CheckFactories.registerCheck<BoolPointerImplicitConversionCheck>( 118 "bugprone-bool-pointer-implicit-conversion"); 119 CheckFactories.registerCheck<BranchCloneCheck>("bugprone-branch-clone"); 120 CheckFactories.registerCheck<CastingThroughVoidCheck>( 121 "bugprone-casting-through-void"); 122 CheckFactories.registerCheck<ChainedComparisonCheck>( 123 "bugprone-chained-comparison"); 124 CheckFactories.registerCheck<ComparePointerToMemberVirtualFunctionCheck>( 125 "bugprone-compare-pointer-to-member-virtual-function"); 126 CheckFactories.registerCheck<CopyConstructorInitCheck>( 127 "bugprone-copy-constructor-init"); 128 CheckFactories.registerCheck<DanglingHandleCheck>( 129 "bugprone-dangling-handle"); 130 CheckFactories.registerCheck<DynamicStaticInitializersCheck>( 131 "bugprone-dynamic-static-initializers"); 132 CheckFactories.registerCheck<EasilySwappableParametersCheck>( 133 "bugprone-easily-swappable-parameters"); 134 CheckFactories.registerCheck<EmptyCatchCheck>("bugprone-empty-catch"); 135 CheckFactories.registerCheck<ExceptionEscapeCheck>( 136 "bugprone-exception-escape"); 137 CheckFactories.registerCheck<FoldInitTypeCheck>("bugprone-fold-init-type"); 138 CheckFactories.registerCheck<ForwardDeclarationNamespaceCheck>( 139 "bugprone-forward-declaration-namespace"); 140 CheckFactories.registerCheck<ForwardingReferenceOverloadCheck>( 141 "bugprone-forwarding-reference-overload"); 142 CheckFactories.registerCheck<ImplicitWideningOfMultiplicationResultCheck>( 143 "bugprone-implicit-widening-of-multiplication-result"); 144 CheckFactories.registerCheck<InaccurateEraseCheck>( 145 "bugprone-inaccurate-erase"); 146 CheckFactories.registerCheck<IncorrectEnableIfCheck>( 147 "bugprone-incorrect-enable-if"); 148 CheckFactories.registerCheck<IncorrectEnableSharedFromThisCheck>( 149 "bugprone-incorrect-enable-shared-from-this"); 150 CheckFactories.registerCheck<ReturnConstRefFromParameterCheck>( 151 "bugprone-return-const-ref-from-parameter"); 152 CheckFactories.registerCheck<SwitchMissingDefaultCaseCheck>( 153 "bugprone-switch-missing-default-case"); 154 CheckFactories.registerCheck<IncDecInConditionsCheck>( 155 "bugprone-inc-dec-in-conditions"); 156 CheckFactories.registerCheck<IncorrectRoundingsCheck>( 157 "bugprone-incorrect-roundings"); 158 CheckFactories.registerCheck<InfiniteLoopCheck>("bugprone-infinite-loop"); 159 CheckFactories.registerCheck<IntegerDivisionCheck>( 160 "bugprone-integer-division"); 161 CheckFactories.registerCheck<LambdaFunctionNameCheck>( 162 "bugprone-lambda-function-name"); 163 CheckFactories.registerCheck<MacroParenthesesCheck>( 164 "bugprone-macro-parentheses"); 165 CheckFactories.registerCheck<MacroRepeatedSideEffectsCheck>( 166 "bugprone-macro-repeated-side-effects"); 167 CheckFactories.registerCheck<MisplacedOperatorInStrlenInAllocCheck>( 168 "bugprone-misplaced-operator-in-strlen-in-alloc"); 169 CheckFactories.registerCheck<MisplacedPointerArithmeticInAllocCheck>( 170 "bugprone-misplaced-pointer-arithmetic-in-alloc"); 171 CheckFactories.registerCheck<MisplacedWideningCastCheck>( 172 "bugprone-misplaced-widening-cast"); 173 CheckFactories.registerCheck<MoveForwardingReferenceCheck>( 174 "bugprone-move-forwarding-reference"); 175 CheckFactories.registerCheck<MultiLevelImplicitPointerConversionCheck>( 176 "bugprone-multi-level-implicit-pointer-conversion"); 177 CheckFactories.registerCheck<MultipleNewInOneExpressionCheck>( 178 "bugprone-multiple-new-in-one-expression"); 179 CheckFactories.registerCheck<MultipleStatementMacroCheck>( 180 "bugprone-multiple-statement-macro"); 181 CheckFactories.registerCheck<NondeterministicPointerIterationOrderCheck>( 182 "bugprone-nondeterministic-pointer-iteration-order"); 183 CheckFactories.registerCheck<OptionalValueConversionCheck>( 184 "bugprone-optional-value-conversion"); 185 CheckFactories.registerCheck<PointerArithmeticOnPolymorphicObjectCheck>( 186 "bugprone-pointer-arithmetic-on-polymorphic-object"); 187 CheckFactories.registerCheck<RedundantBranchConditionCheck>( 188 "bugprone-redundant-branch-condition"); 189 CheckFactories.registerCheck<NarrowingConversionsCheck>( 190 "bugprone-narrowing-conversions"); 191 CheckFactories.registerCheck<NoEscapeCheck>("bugprone-no-escape"); 192 CheckFactories.registerCheck<NonZeroEnumToBoolConversionCheck>( 193 "bugprone-non-zero-enum-to-bool-conversion"); 194 CheckFactories.registerCheck<NotNullTerminatedResultCheck>( 195 "bugprone-not-null-terminated-result"); 196 CheckFactories.registerCheck<ParentVirtualCallCheck>( 197 "bugprone-parent-virtual-call"); 198 CheckFactories.registerCheck<PosixReturnCheck>("bugprone-posix-return"); 199 CheckFactories.registerCheck<ReservedIdentifierCheck>( 200 "bugprone-reserved-identifier"); 201 CheckFactories.registerCheck<SharedPtrArrayMismatchCheck>( 202 "bugprone-shared-ptr-array-mismatch"); 203 CheckFactories.registerCheck<SignalHandlerCheck>("bugprone-signal-handler"); 204 CheckFactories.registerCheck<SignedCharMisuseCheck>( 205 "bugprone-signed-char-misuse"); 206 CheckFactories.registerCheck<SizeofContainerCheck>( 207 "bugprone-sizeof-container"); 208 CheckFactories.registerCheck<SizeofExpressionCheck>( 209 "bugprone-sizeof-expression"); 210 CheckFactories.registerCheck<SpuriouslyWakeUpFunctionsCheck>( 211 "bugprone-spuriously-wake-up-functions"); 212 CheckFactories.registerCheck<StandaloneEmptyCheck>( 213 "bugprone-standalone-empty"); 214 CheckFactories.registerCheck<StringConstructorCheck>( 215 "bugprone-string-constructor"); 216 CheckFactories.registerCheck<StringIntegerAssignmentCheck>( 217 "bugprone-string-integer-assignment"); 218 CheckFactories.registerCheck<StringLiteralWithEmbeddedNulCheck>( 219 "bugprone-string-literal-with-embedded-nul"); 220 CheckFactories.registerCheck<StringviewNullptrCheck>( 221 "bugprone-stringview-nullptr"); 222 CheckFactories.registerCheck<SuspiciousEnumUsageCheck>( 223 "bugprone-suspicious-enum-usage"); 224 CheckFactories.registerCheck<SuspiciousIncludeCheck>( 225 "bugprone-suspicious-include"); 226 CheckFactories.registerCheck<SuspiciousMemoryComparisonCheck>( 227 "bugprone-suspicious-memory-comparison"); 228 CheckFactories.registerCheck<SuspiciousMemsetUsageCheck>( 229 "bugprone-suspicious-memset-usage"); 230 CheckFactories.registerCheck<SuspiciousMissingCommaCheck>( 231 "bugprone-suspicious-missing-comma"); 232 CheckFactories.registerCheck<SuspiciousReallocUsageCheck>( 233 "bugprone-suspicious-realloc-usage"); 234 CheckFactories.registerCheck<SuspiciousSemicolonCheck>( 235 "bugprone-suspicious-semicolon"); 236 CheckFactories.registerCheck<SuspiciousStringCompareCheck>( 237 "bugprone-suspicious-string-compare"); 238 CheckFactories.registerCheck<SuspiciousStringviewDataUsageCheck>( 239 "bugprone-suspicious-stringview-data-usage"); 240 CheckFactories.registerCheck<SwappedArgumentsCheck>( 241 "bugprone-swapped-arguments"); 242 CheckFactories.registerCheck<TaggedUnionMemberCountCheck>( 243 "bugprone-tagged-union-member-count"); 244 CheckFactories.registerCheck<TerminatingContinueCheck>( 245 "bugprone-terminating-continue"); 246 CheckFactories.registerCheck<ThrowKeywordMissingCheck>( 247 "bugprone-throw-keyword-missing"); 248 CheckFactories.registerCheck<TooSmallLoopVariableCheck>( 249 "bugprone-too-small-loop-variable"); 250 CheckFactories.registerCheck<UncheckedOptionalAccessCheck>( 251 "bugprone-unchecked-optional-access"); 252 CheckFactories.registerCheck<UndefinedMemoryManipulationCheck>( 253 "bugprone-undefined-memory-manipulation"); 254 CheckFactories.registerCheck<UndelegatedConstructorCheck>( 255 "bugprone-undelegated-constructor"); 256 CheckFactories.registerCheck<UnhandledSelfAssignmentCheck>( 257 "bugprone-unhandled-self-assignment"); 258 CheckFactories.registerCheck<UnhandledExceptionAtNewCheck>( 259 "bugprone-unhandled-exception-at-new"); 260 CheckFactories.registerCheck<UniquePtrArrayMismatchCheck>( 261 "bugprone-unique-ptr-array-mismatch"); 262 CheckFactories.registerCheck<CrtpConstructorAccessibilityCheck>( 263 "bugprone-crtp-constructor-accessibility"); 264 CheckFactories.registerCheck<UnsafeFunctionsCheck>( 265 "bugprone-unsafe-functions"); 266 CheckFactories.registerCheck<UnusedLocalNonTrivialVariableCheck>( 267 "bugprone-unused-local-non-trivial-variable"); 268 CheckFactories.registerCheck<UnusedRaiiCheck>("bugprone-unused-raii"); 269 CheckFactories.registerCheck<UnusedReturnValueCheck>( 270 "bugprone-unused-return-value"); 271 CheckFactories.registerCheck<UseAfterMoveCheck>("bugprone-use-after-move"); 272 CheckFactories.registerCheck<VirtualNearMissCheck>( 273 "bugprone-virtual-near-miss"); 274 } 275 }; 276 277 } // namespace bugprone 278 279 // Register the BugproneTidyModule using this statically initialized variable. 280 static ClangTidyModuleRegistry::Add<bugprone::BugproneModule> 281 X("bugprone-module", "Adds checks for bugprone code constructs."); 282 283 // This anchor is used to force the linker to link in the generated object file 284 // and thus register the BugproneModule. 285 volatile int BugproneModuleAnchorSource = 0; 286 287 } // namespace clang::tidy 288