From 30bef63dd8ca418a6160afccd5c0935b2d7d47ff Mon Sep 17 00:00:00 2001 From: light7734 Date: Tue, 9 Jul 2024 15:34:22 +0330 Subject: [PATCH] chore: add .clang-tidy checklist --- .clang-tidy | 250 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 250 insertions(+) create mode 100644 .clang-tidy diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 0000000..b5ca783 --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,250 @@ +--- +Checks: "-*, + +performance-unnecessary-value-param, +performance-unnecessary-copy-initialization, +performance-type-promotion-in-math-fn, +performance-trivially-destructible, +performance-noexcept-swap, +performance-noexcept-move-constructor, +performance-noexcept-destructor, +performance-no-int-to-ptr, +performance-no-automatic-move, +performance-move-constructor-init, +performance-move-const-arg, +performance-inefficient-vector-operation, +performance-inefficient-string-concatenation, +performance-inefficient-algorithm, +performance-implicit-conversion-in-loop, +performance-for-range-copy, +performance-faster-string-find, +performance-enum-size, +performance-avoid-endl, + +readability-avoid-const-params-in-decls, +readability-avoid-nested-conditional-operator, +readability-avoid-return-with-void-value, +readability-avoid-unconditional-preprocessor-if, +readability-const-return-type, +readability-container-contains, +readability-container-data-pointdr, +readability-container-size-empty, +readability-delete-null-pointer, +readability-duplicate-include, +readability-else-after-return, +readability-inconsistent-declaration-parameter-name, +readability-isolate-declaration, +readability-make-member-function-const, +readability-misleading-indentation, +readability-misplaced-array-index, +readability-named-parameter, +readability-non-const-parameter, +readability-qualified-auto, +readability-redundant-access-specifiers, +readability-redundant-casting, +readability-redundant-control-flow, +readability-redundant-declaration, +readability-redundant-function-ptr-dereference, +readability-redundant-inline-specifier, +readability-redundant-member-init, +readability-redundant-preprocessor, +readability-redundant-smartptr-get, +readability-redundant-string-cstr, +readability-reference-to-constructed-temporary, +readability-simplify-boolean-expr, +readability-simplify-subscript-expr, +readability-static-accessed-through-instance, +readability-static-definition-in-anonymous-namespace, +readability-string-compare, +readability-suspicious-call-argument, +readability-uniqueptr-delete-release, +readability-use-anyofallof +readability-use-std-min-max, +readability-function-cognitive-complexity +readability-function-size +readability-identifier-naming +readability-identifier-length +readability-magic-numbers + +modernize-avoid-bind, +modernize-avoid-c-arrays, +modernize-concat-nested-namespaces, +modernize-deprecated-headers, +modernize-deprecated-ios-base-aliases, +modernize-loop-convert, +modernize-macro-to-enum, +modernize-make-shared, +modernize-make-unique, +modernize-pass-by-value, +modernize-raw-string-literal, +modernize-redundant-void-arg, +modernize-replace-auto-ptr, +modernize-replace-disallow-copy-and-assign-macro, +modernize-replace-random-shuffle, +modernize-return-braced-init-list, +modernize-shrink-to-fit, +modernize-type-traits, +modernize-unary-static-assert, +modernize-use-auto, +modernize-use-bool-literals, +modernize-use-constraints, +modernize-use-default-member-init, +modernize-use-designated-initializers, +modernize-use-emplace, +modernize-use-equals-default, +modernize-use-equals-delete, +modernize-use-nodiscard, +modernize-use-noexcept, +modernize-use-nullptr, +modernize-use-override, +modernize-use-starts-ends-with, +modernize-use-std-numbers, +modernize-use-std-print, +modernize-use-transparent-functors, +modernize-use-uncaught-exceptions, +modernize-use-using +modernize-min-max-use-initializer-list, + +cppcoreguidelines-avoid-capturing-lambda-coroutines, +cppcoreguidelines-avoid-const-or-ref-data-members, +cppcoreguidelines-avoid-do-while, +cppcoreguidelines-avoid-goto, +cppcoreguidelines-avoid-non-const-global-variables, +cppcoreguidelines-avoid-reference-coroutine-parameters, +cppcoreguidelines-init-variables, +cppcoreguidelines-interfaces-global-init, +cppcoreguidelines-macro-usage, +cppcoreguidelines-misleading-capture-default-by-value, +cppcoreguidelines-missing-std-forward, +cppcoreguidelines-narrowing-conversions, +cppcoreguidelines-no-malloc, +cppcoreguidelines-no-suspend-with-lock, +cppcoreguidelines-owning-memory, +cppcoreguidelines-prefer-member-initializer, +cppcoreguidelines-pro-bounds-array-to-pointer-decay, +cppcoreguidelines-pro-bounds-pointer-arithmetic, +cppcoreguidelines-pro-type-const-cast, +cppcoreguidelines-pro-type-cstyle-cast, +cppcoreguidelines-pro-type-member-init, +cppcoreguidelines-pro-type-reinterpret-cast, +cppcoreguidelines-pro-type-static-cast-downcast, +cppcoreguidelines-pro-type-union-access, +cppcoreguidelines-pro-type-vararg, +cppcoreguidelines-rvalue-reference-param-not-moved, +cppcoreguidelines-slicing, +cppcoreguidelines-special-member-functions, +cppcoreguidelines-virtual-class-destructor, + +bugprone-argument-comment, +bugprone-assert-side-effect, +bugprone-assignment-in-if-condition, +bugprone-bad-signal-to-kill-thread, +bugprone-bool-pointer-implicit-conversion, +bugprone-branch-clone, +bugprone-casting-through-void, +bugprone-chained-comparison, +bugprone-compare-pointer-to-member-virtual-function, +bugprone-copy-constructor-init, +bugprone-crtp-constructor-accessibility, +bugprone-dangling-handle, +bugprone-empty-catch, +bugprone-exception-escape, +bugprone-fold-init-type, +bugprone-forward-declaration-namespace, +bugprone-forwarding-reference-overload, +bugprone-implicit-widening-of-multiplication-result, +bugprone-inaccurate-erase, +bugprone-inc-dec-in-conditions, +bugprone-incorrect-enable-if, +bugprone-incorrect-roundings, +bugprone-infinite-loop, +bugprone-integer-division, +bugprone-lambda-function-name, +bugprone-macro-parentheses, +bugprone-macro-repeated-side-effects, +bugprone-misplaced-operator-in-strlen-in-alloc, +bugprone-misplaced-pointer-arithmetic-in-alloc, +bugprone-misplaced-widening-cast, +bugprone-move-forwarding-reference, +bugprone-multi-level-implicit-pointer-conversion, +bugprone-multiple-new-in-one-expression, +bugprone-multiple-statement-macro, +bugprone-no-escape, +bugprone-non-zero-enum-to-bool-conversion, +bugprone-not-null-terminated-result, +bugprone-optional-value-conversion, +bugprone-parent-virtual-call, +bugprone-posix-return, +bugprone-redundant-branch-condition, +bugprone-reserved-identifier, +bugprone-return-const-ref-from-parameter, +bugprone-shared-ptr-array-mismatch, +bugprone-signal-handler, +bugprone-signed-char-misuse, +bugprone-sizeof-container, +bugprone-sizeof-expression, +bugprone-spuriously-wake-up-functions, +bugprone-standalone-empty, +bugprone-string-constructor, +bugprone-string-integer-assignment, +bugprone-string-literal-with-embedded-nul, +bugprone-stringview-nullptr, +bugprone-suspicious-enum-usage, +bugprone-suspicious-include, +bugprone-suspicious-memory-comparison, +bugprone-suspicious-memset-usage, +bugprone-suspicious-missing-comma, +bugprone-suspicious-realloc-usage, +bugprone-suspicious-semicolon, +bugprone-suspicious-string-compare, +bugprone-suspicious-stringview-data-usage, +bugprone-swapped-arguments, +bugprone-switch-missing-default-case, +bugprone-terminating-continue, +bugprone-throw-keyword-missing, +bugprone-too-small-loop-variable, +bugprone-unchecked-optional-access, +bugprone-undefined-memory-manipulation, +bugprone-undelegated-constructor, +bugprone-unhandled-exception-at-new, +bugprone-unhandled-self-assignment, +bugprone-unique-ptr-array-mismatch, +bugprone-unsafe-functions, +bugprone-unused-local-non-trivial-variable, +bugprone-unused-raii, +bugprone-unused-return-value, +bugprone-use-after-move, +bugprone-virtual-near-miss, + +concurrency-mt-unsafe, +concurrency-thread-canceltype-asynchronous, + +misc-use-anonymous-namespace, +misc-unused-using-decls, +misc-unused-parameters, +misc-unused-alias-decls, +misc-uniqueptr-reset-release, +misc-unconventional-assign-operator, +misc-throw-by-value-catch-by-reference, +misc-static-assert, +misc-redundant-expression, +misc-non-private-member-variables-in-classes, +misc-non-copyable-objects, +misc-no-recursion, +misc-new-delete-overloads, +misc-misplaced-const, +misc-misleading-identifier, +misc-misleading-bidirectional, +misc-include-cleaner, +misc-header-include-cycle, +misc-definitions-in-headers, +misc-coroutine-hostile-raii, +misc-const-correctness, +misc-confusable-identifiers, + +hicpp-signed-bitwise, +hicpp-no-assembler, +hicpp-multiway-paths-covered, +hicpp-ignored-remove-result, +hicpp-exception-baseclass, +"