# Policy for .clang-tidy file maintenance:
#  - all checks from https://releases.llvm.org/22.1.0/tools/clang/tools/extra/docs/clang-tidy/checks/list.html should be listed here
#  - no regex usage, only explicit enable/disable
#  - if a check is disabled an explicit reason should be specified
Checks:                                                      #(status)(offer_fixes)(description)
  - 'bugprone-argument-comment'                              #(ENABLED)(Yes)(Bugprone,Checks that argument comments at call sites match the parameter names in the declaration.)
  - 'bugprone-assert-side-effect'                            #(ENABLED)(No)(Bugprone,Flags expressions with side effects inside assert() macros that disappear in release builds.)
  - 'bugprone-assignment-in-if-condition'                    #(ENABLED)(No)(Bugprone,Warns on assignments (=) inside if conditions where equality (==) was likely intended.)
  - 'bugprone-bad-signal-to-kill-thread'                     #(ENABLED)(No)(Bugprone,Flags invalid or dangerous signal numbers passed to thread termination functions.)
  - 'bugprone-bitwise-pointer-cast'                          #(ENABLED)(No)(Bugprone,Detects unsafe pointer casting performed via bitwise operations.)
  - 'bugprone-bool-pointer-implicit-conversion'              #(ENABLED)(Yes)(Bugprone,Flags implicit conversions from boolean pointers to boolean values in conditions.)
  - 'bugprone-capturing-this-in-member-variable'             #(ENABLED)(No)(Bugprone,Warns when a lambda captures this by value inside a member variable initializer.)
  - 'bugprone-casting-through-void'                          #(ENABLED)(No)(Bugprone,Flags dangerous double-casting through void* that bypasses type checking.)
  - 'bugprone-chained-comparison'                            #(ENABLED)(No)(Bugprone,Flags chained comparisons like a < b < c which evaluate unexpectedly in C++.)
  - 'bugprone-command-processor'                             #(ENABLED)(No)(Bugprone,Warns on usage of system() due to vulnerability to command injection bugs.)
  - 'bugprone-compare-pointer-to-member-virtual-function'    #(ENABLED)(No)(Bugprone,Warns against comparing pointers to virtual member functions.)
  - 'bugprone-copy-constructor-init'                         #(ENABLED)(Yes)(Bugprone,Detects copy constructors that fail to initialize base classes or member fields.)
  - 'bugprone-copy-constructor-mutates-argument'             #(ENABLED)(No)(Bugprone,Flags copy constructors that accept non-const references and modify their argument.)
  - 'bugprone-dangling-handle'                               #(ENABLED)(No)(Bugprone,Warns on dangling handles (like std::string_view) constructed from temporary objects.)
  - 'bugprone-default-operator-new-on-overaligned-type'      #(ENABLED)(No)(Bugprone,Warns when standard operator new is called on over-aligned types.)
  - 'bugprone-dynamic-static-initializers'                   #(ENABLED)(No)(Bugprone,Detects dynamic initialization of static variables across translation units.)
  - 'bugprone-empty-catch'                                   #(ENABLED)(No)(Bugprone,Flags empty catch blocks that swallow exceptions without handling them.)
  - 'bugprone-exception-copy-constructor-throws'             #(ENABLED)(No)(Bugprone,Flags exception class copy constructors that can throw exception types.)
  - 'bugprone-exception-escape'                              #(ENABLED)(No)(Bugprone,"Detects exceptions escaping from noexcept functions, destructors, or main().")
  - 'bugprone-float-loop-counter'                            #(ENABLED)(No)(Bugprone,Warns on floating-point variables used as loop counters due to accumulation errors.)
  - 'bugprone-fold-init-type'                                #(ENABLED)(No)(Bugprone,Warns when the initial value type in std::accumulate or std::reduce causes truncation or precision loss.)
  - 'bugprone-forward-declaration-namespace'                 #(ENABLED)(No)(Bugprone,Detects forward declarations located in mismatched or incorrect namespaces.)
  - 'bugprone-forwarding-reference-overload'                 #(ENABLED)(No)(Bugprone,Warns on constructors taking universal forwarding references that shadow copy/move constructors.)
  - 'bugprone-inaccurate-erase'                              #(ENABLED)(Yes)(Bugprone,Flags calls to std::remove or std::remove_if whose return values are not passed to erase().)
  - 'bugprone-inc-dec-in-conditions'                         #(ENABLED)(No)(Bugprone,Warns on increment or decrement operations inside loop or conditional expressions.)
  - 'bugprone-incorrect-enable-if'                           #(ENABLED)(Yes)(Bugprone,Detects incorrect usages of std::enable_if (such as missing ::type).)
  - 'bugprone-incorrect-enable-shared-from-this'             #(ENABLED)(Yes)(Bugprone,Flags classes that inherit from std::enable_shared_from_this with wrong template types or non-public inheritance.)
  - 'bugprone-incorrect-roundings'                           #(ENABLED)(No)(Bugprone,Warns on bad floating-point rounding patterns like (int)(x + 0.5) for negative numbers.)
  - 'bugprone-infinite-loop'                                 #(ENABLED)(No)(Bugprone,Finds loops whose exit conditions can never be reached or modified.)
  - 'bugprone-integer-division'                              #(ENABLED)(No)(Bugprone,Detects integer division operations where floating-point results were likely expected.)
  - 'bugprone-invalid-enum-default-initialization'           #(ENABLED)(No)(Bugprone,Warns on uninitialized enum variables or invalid default enum values.)
  - 'bugprone-macro-parentheses'                             #(ENABLED)(Yes)(Bugprone,Warns when macro parameters or entire macro expressions are missing enclosing parentheses.)
  - 'bugprone-macro-repeated-side-effects'                   #(ENABLED)(No)(Bugprone,Detects macro parameters with side effects that are evaluated multiple times.)
  - 'bugprone-misleading-setter-of-reference'                #(ENABLED)(No)(Bugprone,Warns on setter methods taking references that bind to temporary objects instead of storing the reference.)
  - 'bugprone-misplaced-operator-in-strlen-in-alloc'         #(ENABLED)(Yes)(Bugprone,"Detects addition operators misplaced inside strlen() during memory allocation calls (e.g., malloc(strlen(s + 1))).")
  - 'bugprone-misplaced-pointer-arithmetic-in-alloc'         #(ENABLED)(Yes)(Bugprone,Warns on pointer arithmetic incorrectly applied inside allocation size arguments.)
  - 'bugprone-misplaced-widening-cast'                       #(ENABLED)(No)(Bugprone,"Finds widening casts placed inside expressions rather than outside, leading to truncation before casting.")
  - 'bugprone-move-forwarding-reference'                     #(ENABLED)(Yes)(Bugprone,Detects std::move used on forwarding references instead of std::forward.)
  - 'bugprone-multi-level-implicit-pointer-conversion'       #(ENABLED)(No)(Bugprone,Detects dangerous implicit multi-level pointer-to-pointer conversions.)
  - 'bugprone-multiple-new-in-one-expression'                #(ENABLED)(No)(Bugprone,Flags multiple new allocations in a single statement that risk memory leaks on exception throwing.)
  - 'bugprone-multiple-statement-macro'                      #(ENABLED)(No)(Bugprone,Flags multi-statement macros that are not enclosed in a do { ... } while(0) block.)
  - 'bugprone-no-escape'                                     #(ENABLED)(No)(Bugprone,Ensures parameters marked __attribute__((noescape)) do not escape the function scope.)
  - 'bugprone-non-zero-enum-to-bool-conversion'              #(ENABLED)(No)(Bugprone,Warns when converting enums without a zero value directly to bool.)
  - 'bugprone-nondeterministic-pointer-iteration-order'      #(ENABLED)(No)(Bugprone,"Warns on iteration over pointer containers with non-deterministic ordering (e.g., std::unordered_set<T*>).")
  - 'bugprone-not-null-terminated-result'                    #(ENABLED)(Yes)(Bugprone,Warns when string operations like memcpy or strncpy do not guarantee null termination.)
  - 'bugprone-optional-value-conversion'                     #(ENABLED)(Yes)(Bugprone,Detects unsafe or redundant value conversions on std::optional objects.)
  - 'bugprone-parent-virtual-call'                           #(ENABLED)(Yes)(Bugprone,Finds qualified virtual function calls using explicit parent class names that bypass virtual dispatch.)
  - 'bugprone-pointer-arithmetic-on-polymorphic-object'      #(ENABLED)(No)(Bugprone,Warns on pointer arithmetic performed on pointers to polymorphic classes.)
  - 'bugprone-posix-return'                                  #(ENABLED)(Yes)(Bugprone,Detects incorrect checks on POSIX function returns that compare directly against negative values instead of -1.)
  - 'bugprone-random-generator-seed'                         #(ENABLED)(No)(Bugprone,Flags pseudo-random number generators seeded with predictable or default values.)
  - 'bugprone-raw-memory-call-on-non-trivial-type'           #(ENABLED)(No)(Bugprone,"Flags raw memory operations (memset, memcpy) applied to non-trivially copyable types.")
  - 'bugprone-redundant-branch-condition'                    #(ENABLED)(Yes)(Bugprone,Warns on branch conditions that are redundant due to enclosing conditional statements.)
  - 'bugprone-reserved-identifier'                           #(ENABLED)(Yes)(Bugprone,"Flags usage of reserved language identifiers (e.g., starting with double underscores).")
  - 'bugprone-return-const-ref-from-parameter'               #(ENABLED)(No)(Bugprone,Finds functions returning const references to local temporaries or parameters passed by value.)
  - 'bugprone-shared-ptr-array-mismatch'                     #(ENABLED)(Yes)(Bugprone,Warns when std::shared_ptr manages array objects without using the array delete/type specifier.)
  - 'bugprone-signal-handler'                                #(ENABLED)(No)(Bugprone,Flags calls to non-async-signal-safe functions inside signal handling routines.)
  - 'bugprone-signed-char-misuse'                            #(ENABLED)(No)(Bugprone,Detects signed char used in arithmetic operations or array indexing where signedness causes issues.)
  - 'bugprone-sizeof-container'                              #(ENABLED)(No)(Bugprone,Warns when sizeof() is applied to standard container objects instead of element types.)
  - 'bugprone-sizeof-expression'                             #(ENABLED)(No)(Bugprone,Detects suspicious or incorrect usage patterns of the sizeof operator.)
  - 'bugprone-spuriously-wake-up-functions'                  #(ENABLED)(No)(Bugprone,Warns when condition variable wait() operations are called outside of condition loops.)
  - 'bugprone-standalone-empty'                              #(ENABLED)(Yes)(Bugprone,Detects calls to .empty() on containers where the returned boolean is ignored.)
  - 'bugprone-std-namespace-modification'                    #(ENABLED)(No)(Bugprone,Warns when adding custom declarations or definitions directly into the std namespace.)
  - 'bugprone-string-constructor'                            #(ENABLED)(Yes)(Bugprone,Detects suspicious std::string constructor arguments (such as swapping length and character arguments).)
  - 'bugprone-string-integer-assignment'                     #(ENABLED)(Yes)(Bugprone,Warns when assigning an integer to std::string where character conversion was likely intended.)
  - 'bugprone-string-literal-with-embedded-nul'              #(ENABLED)(No)(Bugprone,Flags string literals containing embedded NUL characters (\0).)
  - 'bugprone-stringview-nullptr'                            #(ENABLED)(Yes)(Bugprone,Detects construction of std::string_view from a nullptr.)
  - 'bugprone-suspicious-enum-usage'                         #(ENABLED)(No)(Bugprone,Flags suspicious bitwise and arithmetic operations on enum values.)
  - 'bugprone-suspicious-include'                            #(ENABLED)(No)(Bugprone,Warns when #include directives include .c or .cpp implementation files instead of headers.)
  - 'bugprone-suspicious-memset-usage'                       #(ENABLED)(Yes)(Bugprone,Flags memset calls with swapped parameters or zero size arguments.)
  - 'bugprone-suspicious-missing-comma'                      #(ENABLED)(No)(Bugprone,Detects missing commas between elements in string arrays that cause unintended string concatenation.)
  - 'bugprone-suspicious-realloc-usage'                      #(ENABLED)(No)(Bugprone,"Warns when realloc returns directly to the original pointer, risking memory leaks on failure.")
  - 'bugprone-suspicious-semicolon'                          #(ENABLED)(Yes)(Bugprone,"Detects misplaced semicolons immediately following if, for, or while conditions.")
  - 'bugprone-suspicious-stringview-data-usage'              #(ENABLED)(No)(Bugprone,Warns when passing .data() of std::string_view to APIs expecting null-terminated strings.)
  - 'bugprone-swapped-arguments'                             #(ENABLED)(Yes)(Bugprone,Identifies function calls where argument positions appear accidentally swapped relative to parameter types.)
  - 'bugprone-tagged-union-member-count'                     #(ENABLED)(No)(Bugprone,Flags discrepancies between tag enum member count and union field count in tagged unions.)
  - 'bugprone-terminating-continue'                          #(ENABLED)(Yes)(Bugprone,Warns on continue statements in single-iteration loops that prematurely terminate execution.)
  - 'bugprone-throw-keyword-missing'                         #(ENABLED)(No)(Bugprone,Warns when creating an exception object without executing the throw keyword.)
  - 'bugprone-too-small-loop-variable'                       #(ENABLED)(No)(Bugprone,Warns when loop counter types are too narrow to reach the upper bound loop limit.)
  - 'bugprone-unchecked-optional-access'                     #(ENABLED)(No)(Bugprone,Detects dereferences of std::optional without prior has_value() checks.)
  - 'bugprone-unchecked-string-to-number-conversion'         #(ENABLED)(No)(Bugprone,Detects unchecked string-to-number parsing functions (like atoi) lacking error handling.)
  - 'bugprone-undefined-memory-manipulation'                 #(ENABLED)(No)(Bugprone,Warns on raw memory operations on types that are not trivially copyable or setup.)
  - 'bugprone-undelegated-constructor'                       #(ENABLED)(No)(Bugprone,Detects constructors that instantiate temporary instances of their own class instead of delegating.)
  - 'bugprone-unhandled-exception-at-new'                    #(ENABLED)(No)(Bugprone,Warns on raw new operations where std::bad_alloc is not caught or handled.)
  - 'bugprone-unintended-char-ostream-output'                #(ENABLED)(Yes)(Bugprone,Flags unintended character integer values output to stream operators as characters instead of numbers.)
  - 'bugprone-unique-ptr-array-mismatch'                     #(ENABLED)(Yes)(Bugprone,Warns when std::unique_ptr manages array allocations using non-array delete/type.)
  - 'bugprone-unsafe-functions'                              #(ENABLED)(No)(Bugprone,"Flags usage of functions declared unsafe (e.g., strcpy, gets) and suggests safe alternatives.")
  - 'bugprone-unused-raii'                                   #(ENABLED)(Yes)(Bugprone,Warns on anonymous temporary RAII objects that are destroyed immediately upon creation.)
  - 'bugprone-use-after-move'                                #(ENABLED)(No)(Bugprone,Warns on reading or accessing objects whose values have already been moved away.)
  - 'bugprone-virtual-near-miss'                             #(ENABLED)(Yes)(Bugprone,Detects derived class virtual methods that almost—but do not strictly—match base class signatures.)
  - 'cert-err33-c'                                           #(ENABLED)(No)(CERT,Checks that return values of error-prone standard C functions are checked.)
  - 'cert-err60-cpp'                                         #(ENABLED)(No)(CERT,Ensures exception objects thrown are throw-copy-constructible.)
  - 'cert-flp30-c'                                           #(ENABLED)(No)(CERT,Warns against using floating-point variables as loop counters.)
  - 'cert-msc50-cpp'                                         #(ENABLED)(No)(CERT,Warns against pseudo-random number generators seeded with weak or predictable values.)
  - 'cert-oop58-cpp'                                         #(ENABLED)(No)(CERT,Ensures copy assignment and copy constructors do not mutate the source object being copied.)
  - 'concurrency-thread-canceltype-asynchronous'             #(ENABLED)(No)(Concurrency,Warns against setting thread cancellation type to PTHREAD_CANCEL_ASYNCHRONOUS.)
  - 'cppcoreguidelines-avoid-capturing-lambda-coroutines'    #(ENABLED)(No)(CppCoreGuidelines,Warns against capturing variables by reference inside coroutine lambdas.)
  - 'cppcoreguidelines-avoid-goto'                           #(ENABLED)(No)(CppCoreGuidelines,Discourages the use of goto statements.)
  - 'cppcoreguidelines-avoid-reference-coroutine-parameters' #(ENABLED)(No)(CppCoreGuidelines,Flags reference parameters passed to coroutines that risk dangling after suspension.)
  - 'cppcoreguidelines-init-variables'                       #(ENABLED)(Yes)(CppCoreGuidelines,Ensures all local variables are explicitly initialized at declaration.)
  - 'cppcoreguidelines-interfaces-global-init'               #(ENABLED)(No)(CppCoreGuidelines,Prevents global variable initializations from depending on uninitialized static state in other units.)
  - 'cppcoreguidelines-misleading-capture-default-by-value'  #(ENABLED)(Yes)(CppCoreGuidelines,Warns on default-by-value captures [=] in lambdas when this is implicitly captured by reference.)
  - 'cppcoreguidelines-no-suspend-with-lock'                 #(ENABLED)(No)(CppCoreGuidelines,Warns when suspending a coroutine while holding a lock.)
  - 'cppcoreguidelines-prefer-member-initializer'            #(ENABLED)(Yes)(CppCoreGuidelines,Prefers member initializers in constructor init-lists over assignment in constructor bodies.)
  - 'cppcoreguidelines-pro-type-cstyle-cast'                 #(ENABLED)(Yes)(CppCoreGuidelines,Flags C-style casts in favor of modern C++ casts.)
  - 'cppcoreguidelines-pro-type-static-cast-downcast'        #(ENABLED)(Yes)(CppCoreGuidelines,Warns against using static_cast for downcasting polymorphic types.)
  - 'cppcoreguidelines-rvalue-reference-param-not-moved'     #(ENABLED)(No)(CppCoreGuidelines,Flags rvalue reference parameters that are never moved or forwarded inside function bodies.)
  - 'cppcoreguidelines-slicing'                              #(ENABLED)(No)(CppCoreGuidelines,Detects object slicing when assigning or passing derived instances as base objects.)
  - 'hicpp-exception-baseclass'                              #(ENABLED)(No)(HICPP,Ensures custom exception classes inherit publicly from std::exception.)
  - 'hicpp-ignored-remove-result'                            #(ENABLED)(No)(HICPP,"Flags ignored return values of std::remove, std::remove_if, and std::unique.")
  - 'hicpp-no-assembler'                                     #(ENABLED)(No)(HICPP,Warns on inline assembly usage (__asm__ or asm).)
  - 'linuxkernel-must-check-errs'                            #(ENABLED)(No)(LinuxKernel,Checks that Linux kernel error-returning functions have their return values handled using IS_ERR() or similar macros.)
  - 'misc-anonymous-namespace-in-header'                     #(ENABLED)(No)(Misc,Warns when anonymous namespaces appear inside header files.)
  - 'misc-confusable-identifiers'                            #(ENABLED)(No)(Misc,Detects identifiers containing visually similar or confusable Unicode characters.)
  - 'misc-coroutine-hostile-raii'                            #(ENABLED)(No)(Misc,Flags RAII objects spanning coroutine suspension points that risk locks or deadlocks.)
  - 'misc-definitions-in-headers'                            #(ENABLED)(Yes)(Misc,Detects non-inline function or variable definitions placed inside header files.)
  - 'misc-header-include-cycle'                              #(ENABLED)(No)(Misc,Flags circular #include dependency loops between header files.)
  - 'misc-misleading-bidirectional'                          #(ENABLED)(No)(Misc,Warns on bidirectional Unicode control characters that alter visual code execution order.)
  - 'misc-misleading-identifier'                             #(ENABLED)(No)(Misc,Warns on identifiers using confusing combinations of lookalike characters.)
  - 'misc-misplaced-const'                                   #(ENABLED)(No)(Misc,Detects const applied to typedefs/aliases in ways that modify pointer constness unexpectedly.)
  - 'misc-new-delete-overloads'                              #(ENABLED)(No)(Misc,Ensures custom operator new overloads have corresponding operator delete overloads.)
  - 'misc-non-copyable-objects'                              #(ENABLED)(No)(Misc,Detects instances of non-copyable objects passed or returned by value.)
  - 'misc-predictable-rand'                                  #(ENABLED)(No)(Misc,Warns on calls to rand() or pseudo-random functions lacking secure seeding.)
  - 'misc-redundant-expression'                              #(ENABLED)(Yes)(Misc,"Detects redundant or tautological expressions (e.g., x == x, x | 0).")
  - 'misc-static-assert'                                     #(ENABLED)(Yes)(Misc,Replaces runtime assertions evaluated with compile-time constant expressions with static_assert.)
  - 'misc-throw-by-value-catch-by-reference'                 #(ENABLED)(No)(Misc,Ensures exceptions are thrown by value and caught by reference.)
  - 'misc-uniqueptr-reset-release'                           #(ENABLED)(Yes)(Misc,Replaces x.reset(y.release()) with x = std::move(y).)
  - 'misc-unused-alias-decls'                                #(ENABLED)(Yes)(Misc,Detects unused type aliases (using or typedef declarations).)
  - 'misc-unused-using-decls'                                #(ENABLED)(Yes)(Misc,Flags unused using declarations in source files.)
  - 'modernize-avoid-bind'                                   #(ENABLED)(Yes)(Modernize,Replaces std::bind calls with standard C++ lambdas.)
  - 'modernize-avoid-setjmp-longjmp'                         #(ENABLED)(No)(Modernize,Discourages using setjmp and longjmp in C++ code.)
  - 'modernize-deprecated-ios-base-aliases'                  #(ENABLED)(Yes)(Modernize,Replaces deprecated std::ios_base stream aliases with modern equivalents.)
  - 'modernize-loop-convert'                                 #(ENABLED)(Yes)(Modernize,Converts index- or iterator-based loops into C++11 range-based for loops.)
  - 'modernize-macro-to-enum'                                #(ENABLED)(Yes)(Modernize,Replaces #define constants with enum or enum class.)
  - 'modernize-make-shared'                                  #(ENABLED)(Yes)(Modernize,Replaces raw new operations inside std::shared_ptr constructions with std::make_shared.)
  - 'modernize-make-unique'                                  #(ENABLED)(Yes)(Modernize,Replaces raw new operations inside std::unique_ptr constructions with std::make_unique.)
  - 'modernize-min-max-use-initializer-list'                 #(ENABLED)(Yes)(Modernize,Replaces nested std::min/std::max calls with initializer list overloads.)
  - 'modernize-raw-string-literal'                           #(ENABLED)(Yes)(Modernize,"Converts escaped string literals into C++11 raw string literals (R""(...)"").")
  - 'modernize-replace-auto-ptr'                             #(ENABLED)(Yes)(Modernize,Replaces deprecated std::auto_ptr with std::unique_ptr.)
  - 'modernize-replace-disallow-copy-and-assign-macro'       #(ENABLED)(Yes)(Modernize,Replaces DISALLOW_COPY_AND_ASSIGN macros with deleted special member functions (= delete).)
  - 'modernize-replace-random-shuffle'                       #(ENABLED)(Yes)(Modernize,Replaces deprecated std::random_shuffle with std::shuffle.)
  - 'modernize-shrink-to-fit'                                #(ENABLED)(Yes)(Modernize,Replaces the vector(...).swap(...) idiom with standard .shrink_to_fit().)
  - 'modernize-unary-static-assert'                          #(ENABLED)(Yes)(Modernize,Replaces redundant two-argument static_assert calls with C++17 single-argument static_assert.)
  - 'modernize-use-auto'                                     #(ENABLED)(Yes)(Modernize,Replaces explicit type declarations with auto where types are redundant or verbose.)
  - 'modernize-use-bool-literals'                            #(ENABLED)(Yes)(Modernize,"Replaces integer literals (0, 1) in boolean contexts with true or false.")
  - 'modernize-use-constraints'                              #(ENABLED)(Yes)(Modernize,Replaces SFINAE / std::enable_if constructs with C++20 requires clauses and concepts.)
  - 'modernize-use-designated-initializers'                  #(ENABLED)(Yes)(Modernize,Suggests using C++20 designated initializers for struct construction.)
  - 'modernize-use-emplace'                                  #(ENABLED)(Yes)(Modernize,Replaces push_back/insert calls with emplace_back/emplace to avoid temporary object creation.)
  - 'modernize-use-equals-delete'                            #(ENABLED)(Yes)(Modernize,Replaces un-implemented private special member functions with = delete.)
  - 'modernize-use-integer-sign-comparison'                  #(ENABLED)(Yes)(Modernize,Replaces signed/unsigned comparison logic with C++20 std::cmp_* utilities.)
  - 'modernize-use-noexcept'                                 #(ENABLED)(Yes)(Modernize,Adds explicit noexcept specifiers to functions that do not throw exceptions.)
  - 'modernize-use-ranges'                                   #(ENABLED)(Yes)(Modernize,Replaces standard algorithm calls with C++20 std::ranges equivalents.)
  - 'modernize-use-scoped-lock'                              #(ENABLED)(Yes)(Modernize,Replaces std::lock_guard with C++17 std::scoped_lock.)
  - 'modernize-use-starts-ends-with'                         #(ENABLED)(Yes)(Modernize,Replaces find or substr comparisons with C++20 std::string::starts_with and ends_with.)
  - 'modernize-use-std-format'                               #(ENABLED)(Yes)(Modernize,"Replaces sprintf, ostringstream, or absl::StrFormat with C++20 std::format.")
  - 'modernize-use-std-numbers'                              #(ENABLED)(Yes)(Modernize,Replaces hardcoded mathematical constants with standard C++20 <numbers> constants.)
  - 'modernize-use-std-print'                                #(ENABLED)(Yes)(Modernize,Replaces printf or std::cout stream calls with C++23 std::print or std::println.)
  - 'modernize-use-transparent-functors'                     #(ENABLED)(Yes)(Modernize,"Replaces standard comparator functors with transparent versions (e.g., std::less<>()).")
  - 'modernize-use-uncaught-exceptions'                      #(ENABLED)(Yes)(Modernize,Replaces deprecated std::uncaught_exception with C++17 std::uncaught_exceptions.)
  - 'modernize-use-using'                                    #(ENABLED)(Yes)(Modernize,Replaces legacy typedef declarations with modern C++ using type aliases.)
  - 'mpi-buffer-deref'                                       #(ENABLED)(Yes)(MPI,Ensures buffer pointers passed to MPI functions are correctly passed and dereferenced.)
  - 'mpi-type-mismatch'                                      #(ENABLED)(Yes)(MPI,Flags type mismatches between underlying buffer types and MPI_Datatype arguments.)
  - 'performance-faster-string-find'                         #(ENABLED)(Yes)(Performance,Replaces single-character string literal arguments in find calls with character literals.)
  - 'performance-for-range-copy'                             #(ENABLED)(Yes)(Performance,Detects range-based for loop variables initialized by value causing accidental copies.)
  - 'performance-implicit-conversion-in-loop'                #(ENABLED)(No)(Performance,Warns on implicit type conversions of range-loop variables in each iteration.)
  - 'performance-inefficient-algorithm'                      #(ENABLED)(Yes)(Performance,Replaces generic STL algorithms on associative containers with faster container member functions.)
  - 'performance-inefficient-string-concatenation'           #(ENABLED)(No)(Performance,Flags repeated string concatenation in loops using the + operator.)
  - 'performance-inefficient-vector-operation'               #(ENABLED)(Yes)(Performance,Detects vector allocations or push_back calls in loops that should reserve space upfront.)
  - 'performance-move-constructor-init'                      #(ENABLED)(No)(Performance,Ensures move constructors initialize base classes and members using move semantics rather than copy.)
  - 'performance-no-automatic-move'                          #(ENABLED)(No)(Performance,Identifies return statements where automatic move construction is prevented (e.g. returning const locals).)
  - 'performance-noexcept-destructor'                        #(ENABLED)(Yes)(Performance,Recommends marking destructors as noexcept to avoid runtime performance overhead.)
  - 'performance-noexcept-swap'                              #(ENABLED)(Yes)(Performance,Ensures custom swap functions are explicitly marked noexcept.)
  - 'performance-trivially-destructible'                     #(ENABLED)(Yes)(Performance,Warns when user-defined destructors prevent classes with trivial members from being trivially destructible.)
  - 'performance-type-promotion-in-math-fn'                  #(ENABLED)(Yes)(Performance,Detects float parameters implicitly promoted to double when calling standard math functions.)
  - 'portability-restrict-system-includes'                   #(ENABLED)(Yes)(Portability,Restricts inclusion of system headers that vary across target platforms.)
  - 'portability-simd-intrinsics'                            #(ENABLED)(No)(Portability,Flags architecture-specific SIMD intrinsic calls that limit portability.)
  - 'portability-std-allocator-const'                        #(ENABLED)(No)(Portability,Flags deprecated std::allocator<const T> instantiations.)
  - 'portability-template-virtual-member-function'           #(ENABLED)(No)(Portability,Warns against virtual member functions in class templates that impair cross-compiler ABI compatibility.)
  - 'readability-ambiguous-smartptr-reset-call'              #(ENABLED)(Yes)(Readability,Clarifies ambiguous smart pointer .reset() calls where passing nullptr clarifies intent.)
  - 'readability-avoid-nested-conditional-operator'          #(ENABLED)(No)(Readability,Flags nested ternary operators (? :) to improve code legibility.)
  - 'readability-avoid-return-with-void-value'               #(ENABLED)(Yes)(Readability,Discourages returning expressions of type void inside void functions.)
  - 'readability-avoid-unconditional-preprocessor-if'        #(ENABLED)(No)(Readability,Flags preprocessor #if 1 or #if 0 blocks.)
  - 'readability-braces-around-statements'                   #(ENABLED)(Yes)(Readability,"Ensures statement bodies (if, for, while) are enclosed in curly braces {}.")
  - 'readability-container-contains'                         #(ENABLED)(Yes)(Readability,Replaces .find(...) != .end() with .contains(...) for C++20 associative containers.)
  - 'readability-delete-null-pointer'                        #(ENABLED)(Yes)(Readability,Removes unnecessary nullptr checks before calling delete.)
  - 'readability-duplicate-include'                          #(ENABLED)(Yes)(Readability,Warns on duplicate #include directives within the same source file.)
  - 'readability-enum-initial-value'                         #(ENABLED)(Yes)(Readability,Enforces explicit or consistent initial value assignments across enum members.)
  - 'readability-function-size'                              #(ENABLED)(No)(Readability,"Flags functions exceeding configured line count, parameter count, or complexity thresholds.")
  - 'readability-identifier-naming'                          #(ENABLED)(Yes)(Readability,"Enforces configured identifier naming conventions (camelCase, PascalCase, snake_case, etc.).")
  - 'readability-inconsistent-declaration-parameter-name'    #(ENABLED)(Yes)(Readability,Warns when parameter names in function declarations differ from definitions.)
  - 'readability-inconsistent-ifelse-braces'                 #(ENABLED)(Yes)(Readability,Ensures all branches in an if-else chain consistently use or omit braces.)
  - 'readability-isolate-declaration'                        #(ENABLED)(Yes)(Readability,Splits multi-variable declarations onto separate lines for readability.)
  - 'readability-misleading-indentation'                     #(ENABLED)(No)(Readability,Warns on misleading code indentation that does not match actual control flow logic.)
  - 'readability-misplaced-array-index'                      #(ENABLED)(Yes)(Readability,Warns on array indexing written as index[array] instead of array[index].)
  - 'readability-operators-representation'                   #(ENABLED)(Yes)(Readability,"Prefers standard token representations over alternative operator keywords (e.g., && instead of and).")
  - 'readability-redundant-control-flow'                     #(ENABLED)(Yes)(Readability,Removes redundant return; or continue; statements at the end of functions or loops.)
  - 'readability-redundant-declaration'                      #(ENABLED)(Yes)(Readability,Removes redundant repeated forward declarations of functions or variables.)
  - 'readability-redundant-function-ptr-dereference'         #(ENABLED)(Yes)(Readability,Removes unnecessary dereferences or address-of operators applied to function pointers.)
  - 'readability-redundant-inline-specifier'                 #(ENABLED)(Yes)(Readability,"Removes redundant inline specifiers (e.g., on class-internal member functions or constexpr functions).")
  - 'readability-redundant-parentheses'                      #(ENABLED)(Yes)(Readability,Removes redundant parentheses around expressions.)
  - 'readability-redundant-preprocessor'                     #(ENABLED)(No)(Readability,"Detects redundant preprocessor directives (e.g., duplicate identical #ifdef blocks).")
  - 'readability-redundant-smartptr-get'                     #(ENABLED)(Yes)(Readability,Removes unnecessary .get() calls on smart pointers when implicit conversion or operator context exists.)
  - 'readability-redundant-string-init'                      #(ENABLED)(Yes)(Readability,"Removes redundant empty string literal initializations (std::string s = """").")
  - 'readability-redundant-typename'                         #(ENABLED)(Yes)(Readability,Removes redundant typename keywords in non-dependent template contexts.)
  - 'readability-reference-to-constructed-temporary'         #(ENABLED)(No)(Readability,Detects binding local const references to newly constructed temporary objects.)
  - 'readability-simplify-subscript-expr'                    #(ENABLED)(Yes)(Readability,Replaces .data()[i] or &[i] with standard subscript operator usage ([i]).)
  - 'readability-string-compare'                             #(ENABLED)(Yes)(Readability,Replaces .compare(...) == 0 calls with standard equality operators (== or !=).)
  - 'readability-suspicious-call-argument'                   #(ENABLED)(No)(Readability,Flags function calls where argument names closely match parameter names in different positions.)
  - 'readability-uniqueptr-delete-release'                   #(ENABLED)(Yes)(Readability,Replaces delete ptr.release() with ptr.reset().)
  - 'readability-uppercase-literal-suffix'                   #(ENABLED)(Yes)(Readability,"Enforces uppercase literal suffixes (e.g., 100U, 1.0F) for consistency and clarity.")
  - 'readability-use-anyofallof'                             #(ENABLED)(No)(Readability,"Replaces manual checking loops with std::any_of, std::all_of, or std::none_of.")
  - 'readability-use-std-min-max'                            #(ENABLED)(Yes)(Readability,Replaces ternary or conditional expressions calculating minimum/maximum values with std::min or std::max.)

# Disabled checks:
  - '-abseil-cleanup-ctad'                                   #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Replaces explicit template arguments with Class Template Argument Deduction (CTAD) for absl::Cleanup.)
  - '-abseil-duration-addition'                              #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Replaces factory function additions of absl::Duration with direct arithmetic operations.)
  - '-abseil-duration-comparison'                            #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Replaces raw numeric comparisons with absl::Duration objects with explicit duration factory calls.)
  - '-abseil-duration-conversion-cast'                       #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Detects and replaces explicit type casts when converting absl::Duration objects.)
  - '-abseil-duration-division'                              #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Simplifies division operations involving absl::Duration and absl::Time.)
  - '-abseil-duration-factory-float'                         #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Warns when floating-point literals are passed to integer-expecting absl::Duration factory functions.)
  - '-abseil-duration-factory-scale'                         #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Replaces scale-multiplied duration factories with larger unit factories.)
  - '-abseil-duration-subtraction'                           #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Replaces explicit arithmetic calls in absl::Duration and absl::Time subtraction with direct subtraction.)
  - '-abseil-duration-unnecessary-conversion'                #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Removes redundant explicit conversions to and from absl::Duration.)
  - '-abseil-faster-strsplit-delimiter'                      #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Replaces single-character string delimiters in absl::StrSplit with character or absl::ByChar literals.)
  - '-abseil-no-internal-dependencies'                       #(DISABLED:tool-or-lib-specific-check)(No)(Abseil,Warns against direct usage of internal Abseil namespaces (absl::internal::*).)
  - '-abseil-no-namespace'                                   #(DISABLED:tool-or-lib-specific-check)(No)(Abseil,Warns against using directives or declarations that bring the absl namespace into global scope.)
  - '-abseil-redundant-strcat-calls'                         #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Consolidates nested or sequential absl::StrCat calls into a single variadic call.)
  - '-abseil-str-cat-append'                                 #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,"Replaces x = absl::StrCat(x, ...) with absl::StrAppend(&x, ...).")
  - '-abseil-string-find-startswith'                         #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,"Replaces s.find(...) == 0 with absl::StartsWith(s, ...).")
  - '-abseil-string-find-str-contains'                       #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Replaces s.find(...) != std::string::npos with absl::StrContains(...).)
  - '-abseil-time-comparison'                                #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Warns on invalid comparison of absl::Time values against raw numbers.)
  - '-abseil-time-subtraction'                               #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Replaces arithmetic subtraction of absl::Time instances with proper duration calculations.)
  - '-abseil-unchecked-statusor-access'                      #(DISABLED:tool-or-lib-specific-check)(No)(Abseil,Detects unchecked access to absl::StatusOr values without prior checking of .ok().)
  - '-abseil-upgrade-duration-conversions'                   #(DISABLED:tool-or-lib-specific-check)(Yes)(Abseil,Finds deprecated absl::Duration conversions and updates them to modern Abseil APIs.)
  - '-altera-id-dependent-backward-branch'                   #(DISABLED:vendor-specific-check)(No)(Altera,Flags work-item ID-dependent backward branches in OpenCL kernels that prevent loop unrolling.)
  - '-altera-kernel-name-restriction'                        #(DISABLED:vendor-specific-check)(No)(Altera,Enforces naming rules for Altera OpenCL kernels to avoid invalid characters and duplicate names.)
  - '-altera-single-work-item-barrier'                       #(DISABLED:vendor-specific-check)(No)(Altera,Flags barriers inside single work-item OpenCL kernels where synchronization is unnecessary.)
  - '-altera-struct-pack-align'                              #(DISABLED:vendor-specific-check)(Yes)(Altera,Checks for structs in Altera OpenCL code that lack explicit packing or alignment attributes.)
  - '-altera-unroll-loops'                                   #(DISABLED:vendor-specific-check)(No)(Altera,Finds loops in Altera OpenCL kernels that do not specify unrolling pragmas.)
  - '-android-cloexec-accept'                                #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,Replaces accept() calls with accept4() using SOCK_CLOEXEC to prevent file descriptor leaks.)
  - '-android-cloexec-accept4'                               #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,Ensures accept4() calls include the SOCK_CLOEXEC flag.)
  - '-android-cloexec-creat'                                 #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,"Warns on creat() calls, suggesting open() with O_CLOEXEC instead.")
  - '-android-cloexec-dup'                                   #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,Suggests replacing dup() with fcntl() using F_DUPFD_CLOEXEC.)
  - '-android-cloexec-epoll-create'                          #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,Suggests replacing epoll_create() with epoll_create1(EPOLL_CLOEXEC).)
  - '-android-cloexec-epoll-create1'                         #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,Ensures epoll_create1() calls set the EPOLL_CLOEXEC flag.)
  - '-android-cloexec-fopen'                                 #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,Ensures fopen() file mode strings include the 'e' flag for O_CLOEXEC.)
  - '-android-cloexec-inotify-init'                          #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,Suggests replacing inotify_init() with inotify_init1(IN_CLOEXEC).)
  - '-android-cloexec-inotify-init1'                         #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,Ensures inotify_init1() calls set the IN_CLOEXEC flag.)
  - '-android-cloexec-memfd-create'                          #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,Ensures memfd_create() calls include the MFD_CLOEXEC flag.)
  - '-android-cloexec-open'                                  #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,Ensures open() and openat() calls include the O_CLOEXEC flag.)
  - '-android-cloexec-pipe'                                  #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,"Warns on pipe() calls, suggesting pipe2() with O_CLOEXEC.")
  - '-android-cloexec-pipe2'                                 #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,Ensures pipe2() calls include the O_CLOEXEC flag.)
  - '-android-cloexec-socket'                                #(DISABLED:tool-or-lib-specific-check)(Yes)(Android,Ensures socket() calls include the SOCK_CLOEXEC flag.)
  - '-android-comparison-in-temp-failure-retry'              #(DISABLED:tool-or-lib-specific-check)(No)(Android,Flags assignment or comparison operations inside TEMP_FAILURE_RETRY macro invocations.)
  - '-boost-use-ranges'                                      #(DISABLED:tool-or-lib-specific-check)(Yes)(Boost,Replaces standard algorithm calls with boost::range algorithms for cleaner range operations.)
  - '-boost-use-to-string'                                   #(DISABLED:tool-or-lib-specific-check)(Yes)(Boost,Replaces boost::lexical_cast<std::string> with std::to_string or boost::to_string.)
  - '-darwin-avoid-spinlock'                                 #(DISABLED:tool-or-lib-specific-check)(No)(Darwin,Flags usage of deprecated OSSpinLock on Apple platforms.)
  - '-darwin-dispatch-once-nonstatic'                        #(DISABLED:tool-or-lib-specific-check)(Yes)(Darwin,Ensures dispatch_once_t tokens have static or global storage duration.)
  - '-fuchsia-default-arguments-calls'                       #(DISABLED:tool-or-lib-specific-check)(No)(Fuchsia,Flags calls to functions that rely on default arguments.)
  - '-fuchsia-default-arguments-declarations'                #(DISABLED:tool-or-lib-specific-check)(Yes)(Fuchsia,Flags function declarations that define default parameter values.)
  - '-fuchsia-overloaded-operator'                           #(DISABLED:tool-or-lib-specific-check)(No)(Fuchsia,Discourages operator overloading per Fuchsia guidelines.)
  - '-fuchsia-statically-constructed-objects'                #(DISABLED:tool-or-lib-specific-check)(No)(Fuchsia,Flags static or global objects requiring dynamic runtime constructors.)
  - '-fuchsia-temporary-objects'                             #(DISABLED:tool-or-lib-specific-check)(No)(Fuchsia,Discourages the creation of temporary objects.)
  - '-fuchsia-trailing-return'                               #(DISABLED:tool-or-lib-specific-check)(No)(Fuchsia,Discourages trailing return type syntax except where required by templates.)
  - '-fuchsia-virtual-inheritance'                           #(DISABLED:tool-or-lib-specific-check)(No)(Fuchsia,Discourages virtual inheritance in C++ classes.)
  - '-google-build-explicit-make-pair'                       #(DISABLED:vendor-specific-check)(No)(Google,Flags explicit type parameters supplied to std::make_pair.)
  - '-google-build-using-namespace'                          #(DISABLED:vendor-specific-check)(No)(Google,Forbids using namespace directives in global or namespace scopes.)
  - '-google-default-arguments'                              #(DISABLED:vendor-specific-check)(No)(Google,Forbids default arguments on virtual functions.)
  - '-google-explicit-constructor'                           #(DISABLED:vendor-specific-check)(Yes)(Google,Requires single-argument constructors and conversion operators to be explicitly marked explicit.)
  - '-google-global-names-in-headers'                        #(DISABLED:vendor-specific-check)(No)(Google,Flags using declarations in header files at global scope.)
  - '-google-objc-avoid-nsobject-new'                        #(DISABLED:vendor-specific-check)(No)(Google,Discourages calling +[NSObject new] in favor of alloc/init.)
  - '-google-objc-avoid-throwing-exception'                  #(DISABLED:vendor-specific-check)(No)(Google,Flags throwing Objective-C exceptions.)
  - '-google-objc-function-naming'                           #(DISABLED:vendor-specific-check)(No)(Google,Enforces standard Google naming conventions for C-style functions in Objective-C.)
  - '-google-objc-global-variable-declaration'               #(DISABLED:vendor-specific-check)(No)(Google,Enforces Google naming rules for Objective-C global variables.)
  - '-google-readability-avoid-underscore-in-googletest-name' #(DISABLED:vendor-specific-check)(No)(Google,"Discourages underscores in GoogleTest macro, test suite, and test case names.")
  - '-google-readability-todo'                               #(DISABLED:vendor-specific-check)(No)(Google,Enforces standard formatting for TODO comments.)
  - '-google-runtime-float'                                  #(DISABLED:vendor-specific-check)(No)(Google,Suggests double over float unless memory or speed explicitly requires float.)
  - '-google-runtime-int'                                    #(DISABLED:vendor-specific-check)(No)(Google,"Discourages built-in long or short types in favor of fixed-width integer types (int32_t, int64_t).")
  - '-google-runtime-operator'                               #(DISABLED:vendor-specific-check)(No)(Google,Flags usage of overloaded operator &.)
  - '-google-upgrade-googletest-case'                        #(DISABLED:vendor-specific-check)(Yes)(Google,Updates deprecated GoogleTest TYPED_TEST_CASE macros to TYPED_TEST_SUITE.)
  - '-llvm-header-guard'                                     #(DISABLED:vendor-specific-check)(No)(LLVM,Enforces LLVM header guard naming conventions.)
  - '-llvm-include-order'                                    #(DISABLED:vendor-specific-check)(Yes)(LLVM,Enforces LLVM #include directive ordering rules.)
  - '-llvm-namespace-comment'                                #(DISABLED:vendor-specific-check)(No)(LLVM,Ensures namespace closing braces carry identifying comments (e.g. // namespace llvm).)
  - '-llvm-prefer-isa-or-dyn-cast-in-conditionals'           #(DISABLED:vendor-specific-check)(Yes)(LLVM,Replaces isa<X>(Y) && cast<X>(Y) with dyn_cast<X>(Y) in condition checks.)
  - '-llvm-prefer-register-over-unsigned'                    #(DISABLED:vendor-specific-check)(Yes)(LLVM,Replaces unsigned with Register for LLVM virtual/physical register variables.)
  - '-llvm-prefer-static-over-anonymous-namespace'           #(DISABLED:vendor-specific-check)(No)(LLVM,Prefers static for function/variable internal linkage over anonymous namespaces in LLVM source.)
  - '-llvm-twine-local'                                      #(DISABLED:vendor-specific-check)(Yes)(LLVM,Warns against storing LLVM Twine objects in local variables due to dangling reference risks.)
  - '-llvm-use-new-mlir-op-builder'                          #(DISABLED:vendor-specific-check)(Yes)(LLVM,Updates deprecated MLIR OpBuilder::create usage patterns.)
  - '-llvm-use-ranges'                                       #(DISABLED:vendor-specific-check)(Yes)(LLVM,Replaces standard algorithms taking iterator pairs with C++20 range-based equivalents in LLVM code.)
  - '-llvmlibc-callee-namespace'                             #(DISABLED:vendor-specific-check)(No)(LLVM Libc,Ensures standard library functions called by llvm-libc reside in the internal namespace.)
  - '-llvmlibc-implementation-in-namespace'                  #(DISABLED:vendor-specific-check)(No)(LLVM Libc,Checks that llvm-libc implementations are defined within the __llvm_libc namespace.)
  - '-llvmlibc-inline-function-decl'                         #(DISABLED:vendor-specific-check)(Yes)(LLVM Libc,Checks that functions declared in llvm-libc headers are properly marked LIBC_INLINE.)
  - '-llvmlibc-restrict-system-libc-headers'                 #(DISABLED:vendor-specific-check)(Yes)(LLVM Libc,Prevents inclusion of external system C library headers in llvm-libc source files.)
  - '-objc-assert-equals'                                    #(DISABLED:tool-or-lib-specific-check)(Yes)(Objective-C,Replaces complex macro comparisons with standard XCTAssertEqual or XCTAssertEqualObjects.)
  - '-objc-avoid-nserror-init'                               #(DISABLED:tool-or-lib-specific-check)(No)(Objective-C,Discourages calling [[NSError alloc] init] directly without specifying domain and code.)
  - '-objc-dealloc-in-category'                              #(DISABLED:tool-or-lib-specific-check)(No)(Objective-C,Warns when -dealloc is implemented inside an Objective-C category.)
  - '-objc-forbidden-subclassing'                            #(DISABLED:tool-or-lib-specific-check)(No)(Objective-C,Flags subclassing of classes marked with objc_subclassing_restricted.)
  - '-objc-missing-hash'                                     #(DISABLED:tool-or-lib-specific-check)(No)(Objective-C,Ensures Objective-C classes overriding -isEqual: also implement -hash.)
  - '-objc-nsdate-formatter'                                 #(DISABLED:tool-or-lib-specific-check)(No)(Objective-C,Flags expensive re-creation of NSDateFormatter instances in hot execution paths.)
  - '-objc-nsinvocation-argument-lifetime'                   #(DISABLED:tool-or-lib-specific-check)(Yes)(Objective-C,Ensures argument pointers passed into NSInvocation match ownership lifetime semantics.)
  - '-objc-property-declaration'                             #(DISABLED:tool-or-lib-specific-check)(Yes)(Objective-C,Enforces naming and attribute conventions for Objective-C @property declarations.)
  - '-objc-super-self'                                       #(DISABLED:tool-or-lib-specific-check)(Yes)(Objective-C,Flags comparisons of self against super inside Objective-C methods.)
  - '-openmp-exception-escape'                               #(DISABLED:tool-or-lib-specific-check)(No)(OpenMP,Warns when exceptions escape from OpenMP structured parallel blocks.)
  - '-openmp-use-default-none'                               #(DISABLED:tool-or-lib-specific-check)(No)(OpenMP,Enforces explicit default(none) clauses on OpenMP directives.)
  - '-zircon-temporary-objects'                              #(DISABLED:vendor-specific-check)(No)(Zircon,Enforces temporary object creation and construction rules specific to the Zircon kernel codebase.)

# Checks to review (with auto-fix, sorted in hits order):
  - '-modernize-use-trailing-return-type'                    #(TO_REVIEW:hits-in-clang-tidy-logs=2600)(Yes)(Modernize,Converts function declarations to use C++11 trailing return type syntax (auto f() -> int).)
  - '-modernize-use-nodiscard'                               #(TO_REVIEW:hits-in-clang-tidy-logs=782)(Yes)(Modernize,Replaces custom or vendor unused-result attributes with standard C++17 [[nodiscard]].)
  - '-misc-include-cleaner'                                  #(TO_REVIEW:hits-in-clang-tidy-logs=535)(Yes)(Misc,Identifies unused #include directives and missing directly-used headers.)
  - '-cppcoreguidelines-pro-bounds-avoid-unchecked-container-access' #(TO_REVIEW:hits-in-clang-tidy-logs=216)(Yes)(CppCoreGuidelines,Warns against using operator[] on containers without bounds checking.)
  - '-readability-qualified-auto'                            #(TO_REVIEW:hits-in-clang-tidy-logs=211)(Yes)(Readability,Ensures explicit const and pointer/reference qualifiers are preserved when using auto.)
  - '-readability-implicit-bool-conversion'                  #(TO_REVIEW:hits-in-clang-tidy-logs=190)(Yes)(Readability,Enforces explicit boolean conversions in conditions rather than implicit pointer/numeric checks.)
  - '-modernize-use-override'                                #(TO_REVIEW:hits-in-clang-tidy-logs=123)(Yes)(Modernize,Adds override keywords to virtual member function overrides and drops redundant virtual keywords.)
  - '-cppcoreguidelines-virtual-class-destructor'            #(TO_REVIEW:hits-in-clang-tidy-logs=98)(Yes)(CppCoreGuidelines,Ensures base classes with virtual methods define virtual or protected destructors.)
  - '-performance-noexcept-move-constructor'                 #(TO_REVIEW:hits-in-clang-tidy-logs=97)(Yes)(Performance,Enforces marking move constructors and move assignment operators as noexcept for container optimization.)
  - '-modernize-concat-nested-namespaces'                    #(TO_REVIEW:hits-in-clang-tidy-logs=62)(Yes)(Modernize,Replaces nested namespace blocks with C++17 nested namespace syntax (namespace A::B).)
  - '-readability-redundant-access-specifiers'               #(TO_REVIEW:hits-in-clang-tidy-logs=62)(Yes)(Readability,"Removes redundant class access specifiers (e.g., repeated public: labels).")
  - '-readability-redundant-member-init'                     #(TO_REVIEW:hits-in-clang-tidy-logs=59)(Yes)(Readability,Removes explicit default initializations in member initializer lists for types that are default-constructed anyway.)
  - '-readability-named-parameter'                           #(TO_REVIEW:hits-in-clang-tidy-logs=53)(Yes)(Readability,Replaces unnamed parameters in function declarations/definitions with named parameters.)
  - '-modernize-use-equals-default'                          #(TO_REVIEW:hits-in-clang-tidy-logs=52)(Yes)(Modernize,Replaces empty constructor or destructor bodies with = default.)
  - '-misc-const-correctness'                                #(TO_REVIEW:hits-in-clang-tidy-logs=51)(Yes)(Misc,Identifies local variables that are never modified after initialization and marks them const.)
  - '-cppcoreguidelines-pro-bounds-constant-array-index'     #(TO_REVIEW:hits-in-clang-tidy-logs=48)(Yes)(CppCoreGuidelines,Enforces bounds checking when indexing constant-size C-arrays.)
  - '-bugprone-suspicious-string-compare'                    #(TO_REVIEW:hits-in-clang-tidy-logs=46)(Yes)(Bugprone,Flags suspicious logic in strcmp or memcmp equality checks.)
  - '-readability-convert-member-functions-to-static'        #(TO_REVIEW:hits-in-clang-tidy-logs=45)(Yes)(Readability,Identifies non-static member functions that do not access instance state and converts them to static.)
  - '-cppcoreguidelines-pro-type-member-init'                #(TO_REVIEW:hits-in-clang-tidy-logs=36)(Yes)(CppCoreGuidelines,Ensures all struct/class members are initialized during construction.)
  - '-readability-avoid-const-params-in-decls'               #(TO_REVIEW:hits-in-clang-tidy-logs=34)(Yes)(Readability,Removes const value qualifiers from parameter declarations in function prototypes.)
  - '-readability-static-accessed-through-instance'          #(TO_REVIEW:hits-in-clang-tidy-logs=32)(Yes)(Readability,Prefers accessing static class members using scope resolution (Class::member) over instance objects.)
  - '-readability-math-missing-parentheses'                  #(TO_REVIEW:hits-in-clang-tidy-logs=28)(Yes)(Readability,Suggests adding explicit parentheses around complex mathematical operator expressions.)
  - '-readability-container-data-pointer'                    #(TO_REVIEW:hits-in-clang-tidy-logs=26)(Yes)(Readability,Replaces &c[0] or &c.front() with c.data() for contiguous containers.)
  - '-readability-else-after-return'                         #(TO_REVIEW:hits-in-clang-tidy-logs=25)(Yes)(Readability,"Removes redundant else branches following control flow exit statements (return, break, continue, throw).")
  - '-performance-avoid-endl'                                #(TO_REVIEW:hits-in-clang-tidy-logs=21)(Yes)(Performance,Replaces std::endl with '\n' to avoid unnecessary stream flushes.)
  - '-modernize-return-braced-init-list'                     #(TO_REVIEW:hits-in-clang-tidy-logs=19)(Yes)(Modernize,Replaces explicit return type declarations with braced initializer lists in return statements.)
  - '-readability-make-member-function-const'                #(TO_REVIEW:hits-in-clang-tidy-logs=17)(Yes)(Readability,Identifies member functions that do not modify class state and marks them const.)
  - '-modernize-redundant-void-arg'                          #(TO_REVIEW:hits-in-clang-tidy-logs=15)(Yes)(Modernize,"Removes redundant void parameter lists in C++ functions (e.g., void f(void) -> void f()).")
  - '-performance-unnecessary-value-param'                   #(TO_REVIEW:hits-in-clang-tidy-logs=15)(Yes)(Performance,Flags read-only parameters passed by value that should be passed by const reference.)
  - '-readability-static-definition-in-anonymous-namespace'  #(TO_REVIEW:hits-in-clang-tidy-logs=15)(Yes)(Readability,Removes redundant static keywords from definitions placed inside anonymous namespaces.)
  - '-misc-use-internal-linkage'                             #(TO_REVIEW:hits-in-clang-tidy-logs=14)(Yes)(Misc,Suggests marking functions/variables used only in one translation unit with internal linkage (static).)
  - '-modernize-use-default-member-init'                     #(TO_REVIEW:hits-in-clang-tidy-logs=12)(Yes)(Modernize,Converts constructor member initialization lists into default in-class member initializers.)
  - '-readability-non-const-parameter'                       #(TO_REVIEW:hits-in-clang-tidy-logs=11)(Yes)(Readability,Marks function reference/pointer parameters as const when the function does not modify them.)
  - '-bugprone-crtp-constructor-accessibility'               #(TO_REVIEW:hits-in-clang-tidy-logs=10)(Yes)(Bugprone,Ensures CRTP base class constructors are marked private or protected.)
  - '-modernize-type-traits'                                 #(TO_REVIEW:hits-in-clang-tidy-logs=10)(Yes)(Modernize,"Replaces C++11 type traits syntax (e.g., typename std::enable_if<...>::type) with C++14 _t and _v aliases.")
  - '-readability-use-concise-preprocessor-directives'       #(TO_REVIEW:hits-in-clang-tidy-logs=10)(Yes)(Readability,Replaces #elif defined(...) with #elifdef and #elifndef directives.)
  - '-readability-simplify-boolean-expr'                     #(TO_REVIEW:hits-in-clang-tidy-logs=9)(Yes)(Readability,"Simplifies complex or redundant boolean logic (e.g., if (x == true) -> if (x)).")
  - '-modernize-pass-by-value'                               #(TO_REVIEW:hits-in-clang-tidy-logs=8)(Yes)(Modernize,Replaces const-reference parameters moved into class constructors with pass-by-value parameters.)
  - '-misc-unused-parameters'                                #(TO_REVIEW:hits-in-clang-tidy-logs=7)(Yes)(Misc,Detects unused function parameters and suggests removing or commenting them.)
  - '-modernize-deprecated-headers'                          #(TO_REVIEW:hits-in-clang-tidy-logs=7)(Yes)(Modernize,"Replaces C-style headers (e.g., <stdlib.h>) with C++ standard headers (e.g., <cstdlib>).")
  - '-modernize-use-nullptr'                                 #(TO_REVIEW:hits-in-clang-tidy-logs=7)(Yes)(Modernize,Replaces 0 and NULL macros with C++11 nullptr.)
  - '-readability-container-size-empty'                      #(TO_REVIEW:hits-in-clang-tidy-logs=7)(Yes)(Readability,Replaces .size() == 0 or .size() > 0 checks with .empty().)
  - '-bugprone-implicit-widening-of-multiplication-result'   #(TO_REVIEW:hits-in-clang-tidy-logs=6)(Yes)(Bugprone,"Detects integer multiplications whose results are implicitly widened, masking integer overflows.")
  - '-performance-move-const-arg'                            #(TO_REVIEW:hits-in-clang-tidy-logs=6)(Yes)(Performance,Flags std::move calls on const arguments or scalar types where moving has no effect.)
  - '-performance-unnecessary-copy-initialization'           #(TO_REVIEW:hits-in-clang-tidy-logs=6)(Yes)(Performance,Flags unnecessary copy initialization of local variables from const references or function returns.)
  - '-readability-const-return-type'                         #(TO_REVIEW:hits-in-clang-tidy-logs=6)(Yes)(Readability,Discourages returning const value types from functions.)
  - '-readability-redundant-casting'                         #(TO_REVIEW:hits-in-clang-tidy-logs=5)(Yes)(Readability,Warns on redundant type casts to identical types or redundant base/derived casts.)
  - '-readability-redundant-string-cstr'                     #(TO_REVIEW:hits-in-clang-tidy-logs=3)(Yes)(Readability,Removes redundant .c_str() calls passed to functions taking std::string or std::string_view.)

# Checks to review (no auto-fix, sorted in hits order):
  - '-misc-non-private-member-variables-in-classes'          #(TO_REVIEW:hits-in-clang-tidy-logs=836)(No)(Misc,Warns when class member variables are declared non-private.)
  - '-cppcoreguidelines-avoid-do-while'                      #(TO_REVIEW:hits-in-clang-tidy-logs=769)(No)(CppCoreGuidelines,Recommends replacing do-while loops with standard while or for loops.)
  - '-portability-avoid-pragma-once'                         #(TO_REVIEW:hits-in-clang-tidy-logs=585)(No)(Portability,Discourages using #pragma once in favor of standard header guards for cross-compiler portability.)
  - '-modernize-avoid-c-arrays'                              #(TO_REVIEW:hits-in-clang-tidy-logs=312)(No)(Modernize,Replaces C-style arrays with std::array or std::vector.)
  - '-readability-magic-numbers'                             #(TO_REVIEW:hits-in-clang-tidy-logs=271)(No)(Readability,Replaces hardcoded numeric literals (magic numbers) with named constants.)
  - '-cppcoreguidelines-pro-type-reinterpret-cast'           #(TO_REVIEW:hits-in-clang-tidy-logs=270)(No)(CppCoreGuidelines,Flags usage of reinterpret_cast.)
  - '-cppcoreguidelines-pro-bounds-pointer-arithmetic'       #(TO_REVIEW:hits-in-clang-tidy-logs=168)(No)(CppCoreGuidelines,Flags pointer arithmetic operations in favor of array/span abstractions.)
  - '-cppcoreguidelines-special-member-functions'            #(TO_REVIEW:hits-in-clang-tidy-logs=117)(No)(CppCoreGuidelines,Enforces the Rule of Zero / Rule of Five for special class member functions.)
  - '-readability-identifier-length'                         #(TO_REVIEW:hits-in-clang-tidy-logs=111)(No)(Readability,Flags variable or parameter names that are excessively short or long.)
  - '-performance-enum-size'                                 #(TO_REVIEW:hits-in-clang-tidy-logs=99)(No)(Performance,Recommends explicit underlying integer types for enums to optimize memory footprint.)
  - '-cppcoreguidelines-pro-type-vararg'                     #(TO_REVIEW:hits-in-clang-tidy-logs=92)(No)(CppCoreGuidelines,Flags C-style variadic arguments (...) in favor of variadic templates or std::initializer_list.)
  - '-bugprone-easily-swappable-parameters'                  #(TO_REVIEW:hits-in-clang-tidy-logs=90)(No)(Bugprone,Warns on adjacent function parameters of identical types that can be easily swapped by mistake.)
  - '-misc-override-with-different-visibility'               #(TO_REVIEW:hits-in-clang-tidy-logs=77)(No)(Misc,Flags virtual method overrides that alter base method access specifier visibility.)
  - '-cppcoreguidelines-avoid-const-or-ref-data-members'     #(TO_REVIEW:hits-in-clang-tidy-logs=67)(No)(CppCoreGuidelines,Flags const or reference struct members that inhibit copy/move assignment.)
  - '-cppcoreguidelines-use-enum-class'                      #(TO_REVIEW:hits-in-clang-tidy-logs=64)(No)(CppCoreGuidelines,Recommends enum class over unscoped enum.)
  - '-readability-function-cognitive-complexity'             #(TO_REVIEW:hits-in-clang-tidy-logs=59)(No)(Readability,Flags functions exceeding a configured cognitive complexity threshold.)
  - '-hicpp-signed-bitwise'                                  #(TO_REVIEW:hits-in-clang-tidy-logs=53)(No)(HICPP,Warns on bitwise operations applied to signed integer operands.)
  - '-cppcoreguidelines-pro-bounds-array-to-pointer-decay'   #(TO_REVIEW:hits-in-clang-tidy-logs=48)(No)(CppCoreGuidelines,Flags implicit array-to-pointer decay.)
  - '-bugprone-narrowing-conversions'                        #(TO_REVIEW:hits-in-clang-tidy-logs=36)(No)(Bugprone,Warns on implicit conversions that narrow type size or precision.)
  - '-bugprone-throwing-static-initialization'               #(TO_REVIEW:hits-in-clang-tidy-logs=33)(No)(Bugprone,Flags static or global variable initializers that may throw exceptions during startup.)
  - '-bugprone-lambda-function-name'                         #(TO_REVIEW:hits-in-clang-tidy-logs=29)(No)(Bugprone,Flags __func__ or __FUNCTION__ used inside lambdas where it evaluates to operator().)
  - '-cppcoreguidelines-macro-usage'                         #(TO_REVIEW:hits-in-clang-tidy-logs=28)(No)(CppCoreGuidelines,"Replaces preprocessor macros with const, constexpr, inline functions, or templates.")
  - '-cppcoreguidelines-pro-type-const-cast'                 #(TO_REVIEW:hits-in-clang-tidy-logs=21)(No)(CppCoreGuidelines,Flags usage of const_cast.)
  - '-bugprone-unhandled-self-assignment'                    #(TO_REVIEW:hits-in-clang-tidy-logs=20)(No)(Bugprone,Warns when custom copy/move assignment operators lack self-assignment protection.)
  - '-misc-unconventional-assign-operator'                   #(TO_REVIEW:hits-in-clang-tidy-logs=20)(No)(Misc,Ensures assignment operators follow standard idiomatic signatures (returning non-const *this reference).)
  - '-misc-multiple-inheritance'                             #(TO_REVIEW:hits-in-clang-tidy-logs=19)(No)(Misc,Flags classes using multiple inheritance (excluding pure interface classes).)
  - '-cppcoreguidelines-avoid-non-const-global-variables'    #(TO_REVIEW:hits-in-clang-tidy-logs=17)(No)(CppCoreGuidelines,Flags non-const global or namespace-scoped variables.)
  - '-bugprone-derived-method-shadowing-base-method'         #(TO_REVIEW:hits-in-clang-tidy-logs=15)(No)(Bugprone,Detects non-virtual derived class methods that shadow base class methods.)
  - '-cppcoreguidelines-missing-std-forward'                 #(TO_REVIEW:hits-in-clang-tidy-logs=12)(No)(CppCoreGuidelines,Flags forwarding references that fail to be passed through std::forward.)
  - '-cppcoreguidelines-pro-type-union-access'               #(TO_REVIEW:hits-in-clang-tidy-logs=11)(No)(CppCoreGuidelines,Discourages direct reads and writes to union fields.)
  - '-modernize-avoid-c-style-cast'                          #(TO_REVIEW:hits-in-clang-tidy-logs=9)(No)(Modernize,"Replaces C-style type casts with modern C++ casts (static_cast, const_cast, reinterpret_cast).")
  - '-cppcoreguidelines-no-malloc'                           #(TO_REVIEW:hits-in-clang-tidy-logs=5)(No)(CppCoreGuidelines,"Discourages C-style memory management (malloc, free) in favor of C++ abstractions.")
  - '-misc-no-recursion'                                     #(TO_REVIEW:hits-in-clang-tidy-logs=5)(No)(Misc,Warns on recursive function calls.)
  - '-cppcoreguidelines-owning-memory'                       #(TO_REVIEW:hits-in-clang-tidy-logs=4)(No)(CppCoreGuidelines,Enforces resource ownership semantics using gsl::owner.)
  - '-bugprone-branch-clone'                                 #(TO_REVIEW:hits-in-clang-tidy-logs=2)(No)(Bugprone,Identifies duplicate branch bodies in if/else or switch statements.)
  - '-bugprone-suspicious-memory-comparison'                 #(TO_REVIEW:hits-in-clang-tidy-logs=2)(No)(Bugprone,Flags memcmp used on non-trivially copyable objects or padding-containing structs.)
  - '-bugprone-switch-missing-default-case'                  #(TO_REVIEW:hits-in-clang-tidy-logs=2)(No)(Bugprone,Warns on non-enum switch statements that lack a default case.)
  - '-bugprone-unused-local-non-trivial-variable'            #(TO_REVIEW:hits-in-clang-tidy-logs=2)(No)(Bugprone,Flags unused local variables even when they have non-trivial constructors/destructors.)
  - '-bugprone-unused-return-value'                          #(TO_REVIEW:hits-in-clang-tidy-logs=2)(No)(Bugprone,Warns when return values from functions marked [[nodiscard]] are ignored.)
  - '-concurrency-mt-unsafe'                                 #(TO_REVIEW:hits-in-clang-tidy-logs=2)(No)(Concurrency,Flags calls to thread-unsafe functions in multi-threaded programs.)
  - '-hicpp-multiway-paths-covered'                          #(TO_REVIEW:hits-in-clang-tidy-logs=2)(No)(HICPP,Ensures all possible execution paths in switch statements or if-else chains are explicitly handled.)
  - '-misc-use-anonymous-namespace'                          #(TO_REVIEW:hits-in-clang-tidy-logs=2)(No)(Misc,Replaces static function/variable declarations with anonymous namespaces in C++ files.)
  - '-modernize-avoid-variadic-functions'                    #(TO_REVIEW:hits-in-clang-tidy-logs=2)(No)(Modernize,Discourages C-style variadic functions in favor of variadic templates or std::initializer_list.)
  - '-performance-no-int-to-ptr'                             #(TO_REVIEW:hits-in-clang-tidy-logs=2)(No)(Performance,Discourages integer-to-pointer conversions in performance-critical code sections.)

# Treat all enabled warnings as errors
WarningsAsErrors: '*'

# Controls how clang-tidy formats code when applying automatic fixes ('clang-tidy -fix').
# 'file' forces clang-tidy to read and respect project '.clang-format' file.
FormatStyle: 'file'

# Files to exclude from header filter
ExcludeHeaderFilterRegex: '3rdparty/.*'
