clang-tidy doc: add a note for every checker with an autofix

[sylvestre.ledru]

Summary

Currently, when looking at a checker documentation, we have to go back
to the whole list or look at the sources to figure out if an autofix
is available or not.

Feel free to propose a better wording

Here is the ugly way I used:
LIST=$(grep Yes list.rst|awk '{print $1}'|cut -d\` -f2)
or f in $LIST; do cat /tmp/a.txt >> $f.rst; done

with /tmp/a.txt containing the text

[Eugene.Zelenko]

It'll be reasonable to use two spaces indent. At least this is what mostly used for code blocks. Options are exceptions, but will be good idea to reformat them eventually.

[sylvestre.ledru]

2 spaces instead of 4

[alexfh]

clang-tools-extra/docs/clang-tidy/checks/abseil-duration-conversion-cast.rst

29–35

A few problems with this approach:

1. Some checkers' docs already have more specific wording about the fix. Adding a generic phase doesn't make the documentation look neat.
2. The "callable with --fix" part isn't relevant to all clang-tidy frontends. Even for the CLI a reference to the documentation would be more helpful than a mention of this command-line option (there are other relevant options and ways to apply a fix - --fix-errors, -export-fixes + the clang-apply-fixes tool, etc.).

My proposal is to add a mandatory Automatic fixes or Suggested fixes section to all checker documentation files, require the authors to describe the nature of the fix more thoroughly, and use consistent wording when there is no fix. E.g.

Automatic Fixes
^^^^^^^^^^^^^

The check doesn't provide an automatic fix.

or

Automatic Fixes
^^^^^^^^^^^^^

The check provides suggested fixes. See the documentation above for the details.

or

Automatic Fixes
^^^^^^^^^^^^^

The check provides suggested fixes in the following cases:
1.
2.
3.

WDYT?

[sylvestre.ledru]

Makes sense.
I will give it a try :)
thanks

[sylvestre.ledru]

Doing it by hand. @alexfh please let me know if you would be ok with it
(I will do it by hand)

[sylvestre.ledru]

@alexfh ping

[sylvestre.ledru]

@alexfh ping

[sylvestre.ledru]

has been reverted

clang-tools-extra/docs/clang-tidy/checks/abseil-duration-addition.rst

.. code-block:: c++
 
   // Original - Addition in the integer domain
   int x;
   absl::Time t;
   int result = absl::ToUnixSeconds(t) + x;
 
   // Suggestion - Addition in the absl::Time domain
   int result = absl::ToUnixSeconds(t + absl::Seconds(x));
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-duration-comparison.rst

.. code-block:: c++
 
   // Original - Comparison in the integer domain
   int x;
   absl::Duration d;
   if (x < absl::ToInt64Microseconds(d)) ...
 
   // Suggested - Compare in the absl::Duration domain instead
   if (absl::Microseconds(x) < d) ...
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-duration-conversion-cast.rst

.. code-block:: c++
   // Original - Cast from a double to an integer
   absl::Duration d;
   double x = static_cast<double>(absl::ToInt64Seconds(d));
 
   // Suggested - Use the integer conversion function directly.
   double x = absl::ToDoubleSeconds(d);
 
 
 Note: In the second example, the suggested fix could yield a different result,
 as the conversion to integer could truncate.  In practice, this is very rare,
 and you should use ``absl::Trunc`` to perform this operation explicitly instead.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-duration-division.rst

  double dsec1 = absl::FDivDuration(d, absl::Seconds(1));  // GOOD: No truncation.
  double dsec2 = absl::ToDoubleSeconds(d);                 // GOOD: No truncation.
  assert(dsec1 == 3.5 && dsec2 == 3.5);
 
 
 This check looks for uses of ``absl::Duration`` division that is done in a
 floating-point context, and recommends the use of a function that returns a
 floating-point value.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-duration-factory-float.rst

.. code-block:: c++
   absl::Duration d = absl::Seconds(10);
 
 
   // Original - Explicitly casting to a floating-point type.
   absl::Duration d = absl::Seconds(static_cast<double>(10));
 
   // Suggested - Remove the explicit cast
   absl::Duration d = absl::Seconds(10);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-duration-factory-scale.rst

.. code-block:: c++
   absl::Duration d = absl::Seconds(y);
 
 
   // Original - Zero-value argument.
   absl::Duration d = absl::Hours(0);
 
   // Suggested = Use absl::ZeroDuration instead
   absl::Duration d = absl::ZeroDuration();
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-duration-subtraction.rst

.. code-block:: c++
   double result = absl::ToDoubleSeconds(d1 - d2);
 
 
 Note: As with other ``clang-tidy`` checks, it is possible that multiple fixes
 may overlap (as in the case of nested expressions), so not all occurrences can
 be transformed in one run. In particular, this may occur for nested subtraction
 expressions. Running ``clang-tidy`` multiple times will find and fix these
 overlaps.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-duration-unnecessary-conversion.rst

.. code-block:: c++
 
   // Suggestion - Remove unnecessary conversion
   absl::Duration d2 = d1 * 2;
 
 Note: Converting to an integer and back to an ``absl::Duration`` might be a
 truncating operation if the value is not aligned to the scale of conversion.
 In the rare case where this is the intended result, callers should use
 ``absl::Trunc`` to truncate explicitly.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-faster-strsplit-delimiter.rst

.. code-block:: c++
 
 
   // Original - the argument is a string literal inside absl::MaxSplits call.
   for (auto piece : absl::StrSplit(str, absl::MaxSplits("B", 1))) {
 
   // Suggested - the argument is a character, which causes the more efficient
   // overload of absl::StrSplit() to be used.
   for (auto piece : absl::StrSplit(str, absl::MaxSplits('B', 1))) {
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-redundant-strcat-calls.rst

.. code-block:: c++
   std::string s = absl::StrCat("A", "B", "C", "D");
   //after
 
   absl::StrAppend(&s, absl::StrCat("E", "F", "G"));
   //before
   
   absl::StrAppend(&s, "E", "F", "G");
   //after
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-str-cat-append.rst

 them makes the code smaller and faster.
 
 .. code-block:: c++
 
   a = absl::StrCat(a, b); // Use absl::StrAppend(&a, b) instead.
 
 Does not diagnose cases where ``absl::StrCat()`` is used as a template
 argument for a functor.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-string-find-startswith.rst

.. option:: IncludeStyle
 
    A string specifying which include-style is used, `llvm` or `google`. Default
    is `llvm`.
 
 .. option:: AbseilStringsMatchHeader
 
    The location of Abseil's ``strings/match.h``. Defaults to
    ``absl/strings/match.h``.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-time-comparison.rst

.. code-block:: c++
 
   // Original - Comparison in the integer domain
   int x;
   absl::Time t;
   if (x < absl::ToUnixSeconds(t)) ...
 
   // Suggested - Compare in the absl::Time domain instead
   if (absl::FromUnixSeconds(x) < t) ...
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-time-subtraction.rst

.. code-block:: c++
   absl::Duration d = t - absl::FromUnixSeconds(x);
 
 
   // Original - Second operand is an absl::Time.
   int i = x - absl::ToUnixSeconds(t);
 
   // Suggestion - Perform subtraction in the Time domain instead.
   int i = absl::ToInt64Seconds(absl::FromUnixSeconds(x) - t);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/abseil-upgrade-duration-conversions.rst

.. code-block:: c++
 
   std::atomic<int> a;
   absl::Duration d = absl::Milliseconds(static_cast<int64_t>(a));
   d *= static_cast<int64_t>(a);
 
 Note that this check always adds a cast to ``int64_t`` in order to preserve the
 current behavior of user code. It is possible that this uncovers unintended
 behavior due to types implicitly convertible to a floating-point type.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/android-cloexec-accept.rst

 
 .. code-block:: c++
 
   accept(sockfd, addr, addrlen);
 
   // becomes
 
   accept4(sockfd, addr, addrlen, SOCK_CLOEXEC);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/android-cloexec-creat.rst

 .. title:: clang-tidy - android-cloexec-creat
 
 android-cloexec-creat
 =====================
 
 The usage of ``creat()`` is not recommended, it's better to use ``open()``.
 
 Examples:
 
 .. code-block:: c++
 
   int fd = creat(path, mode);
 
   // becomes
 
   int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, mode);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/android-cloexec-dup.rst

 
 .. code-block:: c++
 
   int fd = dup(oldfd);
 
   // becomes
 
   int fd = fcntl(oldfd, F_DUPFD_CLOEXEC);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/android-cloexec-pipe.rst

.. code-block:: c++
 
   pipe(pipefd);
 
 Suggested replacement:
 
 .. code-block:: c++
 
   pipe2(pipefd, O_CLOEXEC);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/boost-use-to-string.rst

.. code-block:: c++
 
     auto str = boost::lexical_cast<std::string>(42);
     auto wstr = boost::lexical_cast<std::wstring>(2137LL);
 
     // Will be changed to
     auto str = std::to_string(42);
     auto wstr = std::to_wstring(2137LL);
 
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-argument-comment.rst

 
 After:
 
 .. code-block:: c++
 
   void foo(A* Value);
 
   foo(/*Value=*/nullptr);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-bool-pointer-implicit-conversion.rst

 .. title:: clang-tidy - bugprone-bool-pointer-implicit-conversion
 
 bugprone-bool-pointer-implicit-conversion
 =========================================
 
 Checks for conditions based on implicit conversion from a ``bool`` pointer to
 ``bool``.
 
 Example:
 
 .. code-block:: c++
 
   bool *p;
   if (p) {
     // Never used in a pointer-specific way.
   }
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-copy-constructor-init.rst

 
 .. code-block:: c++
 
     class X4 : public Copyable {
       X4(const X4 &other) : Copyable() {} // other is missing
     };
 
 The check also suggests a fix-its in some cases.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-inaccurate-erase.rst

 
 Call the two-argument overload of ``erase()`` to remove the subrange:
 
 .. code-block:: c++
 
   std::vector<int> xs;
   ...
   xs.erase(std::remove(xs.begin(), xs.end(), 10), xs.end());
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-macro-parentheses.rst

 
 When the replacement list has an expression, it is recommended to surround
 it with parentheses. This ensures that the macro result is evaluated
 completely before it is used.
 
 It is also recommended to surround macro arguments in the replacement list
 with parentheses. This ensures that the argument value is calculated
 properly.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-misplaced-operator-in-strlen-in-alloc.rst

 
 Example for silencing the diagnostic:
 
 .. code-block:: c
 
     void bad_malloc(char *str) {
       char *c = (char*) malloc(strlen((str + 1)));
     }
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-misplaced-pointer-arithmetic-in-alloc.rst

 
 
 The suggested fix is to add the integer expression to the argument of
 ``malloc`` and not to its result. In the example above the fix would be
 
 .. code-block:: c
 
   char *p = (char*) malloc(n + 10);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-move-forwarding-reference.rst

 deduced to be an lvalue reference. In the example, ``T`` is deduced to be
 ``std::string &``. The type of the argument ``t`` therefore becomes
 ``std::string& &&``; by the reference collapsing rules, this collapses to
 ``std::string&``.
 
 This means that the ``foo(s)`` call passes ``s`` as an lvalue reference, and
 ``foo()`` ends up moving ``s`` and thereby placing it into an indeterminate
 state.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-not-null-terminated-result.rst

 Options
 -------
 
 .. option::  WantToUseSafeFunctions
 
    An integer non-zero value specifying if the target environment is considered
    to implement '_s' suffixed memory and string handler functions which are
    safer than older versions (e.g. 'memcpy_s()'). The default value is ``1``.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-parent-virtual-call.rst

struct B: public A {
     int foo() override {...}
   };
 
   struct C: public B {
     int foo() override { A::foo(); }
   //                     ^^^^^^^^
   // warning: qualified name A::foo refers to a member overridden in subclass; did you mean 'B'?  [bugprone-parent-virtual-call]
   };
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-posix-return.rst

.. code-block:: c
 
   if (posix_fadvise(...) < 0) {
 
 This will never happen as the return value is always non-negative. A simple fix could be:
 
 .. code-block:: c
 
   if (posix_fadvise(...) > 0) {
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-reserved-identifier.rst

.. option:: Invert
 
    If non-zero, inverts the check, i.e. flags names that are not reserved. 
    Default is `0`.
 
 .. option:: AllowedIdentifiers
 
    Semicolon-separated list of names that the check ignores. Default is an 
    empty list.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-string-constructor.rst

 .. option::  WarnOnLargeLength
 
    When non-zero, the check will warn on a string with a length greater than
    `LargeLengthThreshold`. Default is `1`.
 
 .. option::  LargeLengthThreshold
 
    An integer specifying the large length threshold. Default is `0x800000`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-string-integer-assignment.rst

.. code-block:: c++
   s = std::to_string(x);
 
 In order to suppress false positives, use an explicit cast.
 
 .. code-block:: c++
 
   std::string s;
   s = static_cast<char>(6);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-suspicious-memset-usage.rst

void foo() {
     // Case 2
     memset(ip, 0xabcd, 1); // fill value gets truncated
     memset(ip, 0x00, 1);   // OK
 
     // Case 3
     memset(ip, sizeof(int), v); // zero length, potentially swapped
     memset(ip, 0, 1);           // OK
   }
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-suspicious-semicolon.rst

.. code-block:: c++
 
     while (readWhitespace())
       ;
 
       Token t = readNextToken();
 
 In this case the check will assume that you know what you are doing, and will
 not raise a warning.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-suspicious-string-compare.rst

.. option:: StringCompareLikeFunctions
    `__builtin_strncasecmp`, `__builtin_strncmp`, `_mbscmp`, `_mbscmp_l`,
    `_mbsicmp`, `_mbsicmp_l`, `_mbsnbcmp`, `_mbsnbcmp_l`, `_mbsnbicmp`,
    `_mbsnbicmp_l`, `_mbsncmp`, `_mbsncmp_l`, `_mbsnicmp`, `_mbsnicmp_l`,
    `_memicmp`, `_memicmp_l`, `_stricmp`, `_stricmp_l`, `_strnicmp`,
    `_strnicmp_l`, `_wcsicmp`, `_wcsicmp_l`, `_wcsnicmp`, `_wcsnicmp_l`,
    `lstrcmp`, `lstrcmpi`, `memcmp`, `memicmp`, `strcasecmp`, `strcmp`,
    `strcmpi`, `stricmp`, `strncasecmp`, `strncmp`, `strnicmp`, `wcscasecmp`,
    `wcscmp`, `wcsicmp`, `wcsncmp`, `wcsnicmp`, `wmemcmp`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-swapped-arguments.rst

 .. title:: clang-tidy - bugprone-swapped-arguments
 
 bugprone-swapped-arguments
 ==========================
 
 Finds potentially swapped arguments by looking at implicit conversions.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-terminating-continue.rst

 .. code-block:: c++
 
   void f() {
   do {
     // some code
     continue; // terminating continue
     // some other code
   } while(false);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-unused-raii.rst

 - Ignore code expanded from macros. Testing frameworks make heavy use of this.
 
 - Ignore types with trivial destructors. They are very unlikely to be RAII
   objects and there's no difference when they are deleted.
 
 - Ignore objects at the end of a compound statement (doesn't change behavior).
 
 - Ignore objects returned from a call.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/bugprone-virtual-near-miss.rst

.. code-block:: c++
   struct Base {
     virtual void func();
   };
 
   struct Derived : Base {
     virtual funk();
     // warning: 'Derived::funk' has a similar name and the same signature as virtual method 'Base::func'; did you mean to override it?
   };
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/cert-dcl03-c.rst

 .. title:: clang-tidy - cert-dcl03-c
 .. meta::
    :http-equiv=refresh: 5;URL=misc-static-assert.html
 
 cert-dcl03-c
 ============
 
 The cert-dcl03-c check is an alias, please see
 `misc-static-assert <misc-static-assert.html>`_ for more information.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/cert-dcl16-c.rst

 .. title:: clang-tidy - cert-dcl16-c
 .. meta::
    :http-equiv=refresh: 5;URL=readability-uppercase-literal-suffix.html
 
 cert-dcl16-c
 ============
 
 The cert-dcl16-c check is an alias, please see
 `readability-uppercase-literal-suffix <readability-uppercase-literal-suffix.html>`_ for more information.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/cert-dcl37-c.rst

 .. title:: clang-tidy - cert-dcl37-c
 .. meta::
    :http-equiv=refresh: 5;URL=bugprone-reserved-identifier.html
 
 cert-dcl37-c
 ============
 
 The cert-dcl37-c check is an alias, please see
 `bugprone-reserved-identifier <bugprone-reserved-identifier.html>`_ for more 
 information.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/cert-dcl51-cpp.rst

 .. title:: clang-tidy - cert-dcl51-cpp
 .. meta::
    :http-equiv=refresh: 5;URL=bugprone-reserved-identifier.html
 
 cert-dcl51-cpp
 ==============
 
 The cert-dcl51-cpp check is an alias, please see
 `bugprone-reserved-identifier <bugprone-reserved-identifier.html>`_ for more 
 information.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/cert-oop11-cpp.rst

 .. title:: clang-tidy - cert-oop11-cpp
 .. meta::
    :http-equiv=refresh: 5;URL=performance-move-constructor-init.html
 
 cert-oop11-cpp
 ==============
 
 The cert-oop11-cpp check is an alias, please see
 `performance-move-constructor-init <performance-move-constructor-init.html>`_
 for more information.
 
 This check corresponds to the CERT C++ Coding Standard recommendation
 OOP11-CPP. Do not copy-initialize members or base classes from a move
 constructor. However, all of the CERT recommendations have been removed from
 public view, and so their justification for the behavior of this check requires
-an account on their wiki to view.
+an account on their wiki to view.
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-explicit-virtual-functions.rst

 .. title:: clang-tidy - cppcoreguidelines-explicit-virtual-functions
 .. meta::
    :http-equiv=refresh: 5;URL=modernize-use-override.html
 
 cppcoreguidelines-explicit-virtual-functions
 ============================================
 
 The cppcoreguidelines-explicit-virtual-functions check is an alias, please see
 `modernize-use-override <modernize-use-override.html>`_
 for more information.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-init-variables.rst

.. option:: IncludeStyle
 
    A string specifying which include-style is used, `llvm` or
    `google`. Default is `llvm`.
 
 .. option:: MathHeader
 
    A string specifying the header to include to get the definition of
    `NAN`. Default is `math.h`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-pro-bounds-constant-array-index.rst

.. option:: GslHeader
 
    The check can generate fixes after this option has been set to the name of
    the include file that contains ``gsl::at()``, e.g. `"gsl/gsl.h"`.
 
 .. option:: IncludeStyle
 
    A string specifying which include-style is used, `llvm` or `google`. Default
    is `llvm`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-pro-type-cstyle-cast.rst

 type Z. Note that a C-style ``(T)expression`` cast means to perform the first of
 the following that is possible: a ``const_cast``, a ``static_cast``, a
 ``static_cast`` followed by a ``const_cast``, a ``reinterpret_cast``, or a
 ``reinterpret_cast`` followed by a ``const_cast``. This rule bans
 ``(T)expression`` only when used to perform an unsafe cast.
 
 This rule is part of the "Type safety" profile of the C++ Core Guidelines, see
 https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Pro-type-cstylecast.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-pro-type-member-init.rst

 .. option:: UseAssignment
 
    If set to non-zero, the check will provide fix-its with literal initializers
    \( ``int i = 0;`` \) instead of curly braces \( ``int i{};`` \).
 
 This rule is part of the "Type safety" profile of the C++ Core
 Guidelines, corresponding to rule Type.6. See
 https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Pro-type-memberinit.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-pro-type-static-cast-downcast.rst

 .. title:: clang-tidy - cppcoreguidelines-pro-type-static-cast-downcast
 
 cppcoreguidelines-pro-type-static-cast-downcast
 ===============================================
 
 This check flags all usages of ``static_cast``, where a base class is casted to
 a derived class. In those cases, a fix-it is provided to convert the cast to a
 ``dynamic_cast``.
 
 Use of these casts can violate type safety and cause the program to access a
 variable that is actually of type ``X`` to be accessed as if it were of an
 unrelated type ``Z``.
 
 This rule is part of the "Type safety" profile of the C++ Core Guidelines, see
 https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Pro-type-downcast.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/darwin-dispatch-once-nonstatic.rst

 Programmers have also been known to make ``dispatch_once_t`` variables be
 members of structs or classes, with the intent to lazily perform some expensive
 struct or class member initialization only once; however, this violates the
 libdispatch requirements.
 
 See the discussion section of
 `Apple's dispatch_once documentation <https://developer.apple.com/documentation/dispatch/1447169-dispatch_once>`_
 for more information.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/fuchsia-default-arguments-declarations.rst

 .. title:: clang-tidy - fuchsia-default-arguments-declarations
 
 fuchsia-default-arguments-declarations
 ======================================
 
 Warns if a function or method is declared with default parameters.
 
 For example, the declaration:
 
 .. code-block:: c++
 
   int foo(int value = 5) { return value; }
 
 will cause a warning.
 
 See the features disallowed in Fuchsia at https://fuchsia.googlesource.com/zircon/+/master/docs/cxx.md
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/google-explicit-constructor.rst

struct S {
     explicit S(int a);
     S(const S&);
     explicit operator bool() const;
     ...
 
 
 
 See https://google.github.io/styleguide/cppguide.html#Explicit_Constructors
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/google-readability-braces-around-statements.rst

 .. title:: clang-tidy - google-readability-braces-around-statements
 .. meta::
    :http-equiv=refresh: 5;URL=readability-braces-around-statements.html
 
 google-readability-braces-around-statements
 ===========================================
 
 The google-readability-braces-around-statements check is an alias, please see
 `readability-braces-around-statements <readability-braces-around-statements.html>`_
 for more information.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/google-upgrade-googletest-case.rst

.. code-block:: c++
   };
 
   TYPED_TEST_SUITE(BarTest, BarTypes);
 
 For better consistency of user code, the check renames both virtual and
 non-virtual member functions with matching names in derived types. The check
 tries to provide a only warning when a fix cannot be made safely, as is the case
 with some template and macro uses.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-braces-around-statements.rst

 .. title:: clang-tidy - hicpp-braces-around-statements
 .. meta::
    :http-equiv=refresh: 5;URL=readability-braces-around-statements.html
 
 hicpp-braces-around-statements
 ==============================
 
 The `hicpp-braces-around-statements` check is an alias, please see
 `readability-braces-around-statements <readability-braces-around-statements.html>`_
 for more information.
 It enforces the `rule 6.1.1 <http://www.codingstandard.com/rule/6-1-1-enclose-the-body-of-a-selection-or-an-iteration-statement-in-a-compound-statement/>`_.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-deprecated-headers.rst

 .. title:: clang-tidy - hicpp-deprecated-headers
 .. meta::
    :http-equiv=refresh: 5;URL=modernize-deprecated-headers.html
 
 hicpp-deprecated-headers
 ========================
 
 The `hicpp-deprecated-headers` check is an alias, please see
 `modernize-deprecated-headers <modernize-deprecated-headers.html>`_
 for more information.
 It enforces the `rule 1.3.3 <http://www.codingstandard.com/rule/1-3-3-do-not-use-the-c-standard-library-h-headers/>`_.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-explicit-conversions.rst

 This check will enforce that constructors and conversion operators are marked `explicit`.
 Other forms of casting checks are implemented in other places.
 The following checks can be used to check for more forms of casting:
 
 - `cppcoreguidelines-pro-type-static-cast-downcast <cppcoreguidelines-pro-type-static-cast-downcast.html>`_
 - `cppcoreguidelines-pro-type-reinterpret-cast <cppcoreguidelines-pro-type-reinterpret-cast.html>`_
 - `cppcoreguidelines-pro-type-const-cast <cppcoreguidelines-pro-type-const-cast.html>`_ 
 - `cppcoreguidelines-pro-type-cstyle-cast <cppcoreguidelines-pro-type-cstyle-cast.html>`_
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-member-init.rst

 .. title:: clang-tidy - hicpp-member-init
 .. meta::
    :http-equiv=refresh: 5;URL=cppcoreguidelines-pro-type-member-init.html
 
 hicpp-member-init
 =================
 
 This check is an alias for `cppcoreguidelines-pro-type-member-init <cppcoreguidelines-pro-type-member-init.html>`_.
 Implements the check for 
 `rule 12.4.2 <http://www.codingstandard.com/rule/12-4-2-ensure-that-a-constructor-initializes-explicitly-all-base-classes-and-non-static-data-members/>`_ 
 to initialize class members in the right order.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-move-const-arg.rst

 .. title:: clang-tidy - hicpp-move-const-arg
 .. meta::
    :http-equiv=refresh: 5;URL=performance-move-const-arg.html
 
 hicpp-move-const-arg
 ====================
 
 The `hicpp-move-const-arg` check is an alias, please see
 `performance-move-const-arg <performance-move-const-arg.html>`_ for more information.
 It enforces the `rule 17.3.1 <http://www.codingstandard.com/rule/17-3-1-do-not-use-stdmove-on-objects-declared-with-const-or-const-type/>`_.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-named-parameter.rst

 .. title:: clang-tidy - hicpp-named-parameter
 .. meta::
    :http-equiv=refresh: 5;URL=readability-named-parameter.html
 
 hicpp-named-parameter
 =====================
 
 This check is an alias for `readability-named-parameter <readability-named-parameter.html>`_.
 
 Implements `rule 8.2.1 <http://www.codingstandard.com/rule/8-2-1-make-parameter-names-absent-or-identical-in-all-declarations/>`_.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-static-assert.rst

 .. title:: clang-tidy - hicpp-static-assert
 .. meta::
    :http-equiv=refresh: 5;URL=misc-static-assert.html
 
 hicpp-static-assert
 ===================
 
 The `hicpp-static-assert` check is an alias, please see
 `misc-static-assert <misc-static-assert.html>`_ for more information.
 It enforces the `rule 7.1.10 <http://www.codingstandard.com/rule/6-1-1-enclose-the-body-of-a-selection-or-an-iteration-statement-in-a-compound-statement/>`_.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-uppercase-literal-suffix.rst

 .. title:: clang-tidy - hicpp-uppercase-literal-suffix
 .. meta::
    :http-equiv=refresh: 5;URL=readability-uppercase-literal-suffix.html
 
 hicpp-uppercase-literal-suffix
 ==============================
 
 The hicpp-uppercase-literal-suffix check is an alias, please see
 `readability-uppercase-literal-suffix <readability-uppercase-literal-suffix.html>`_ for more information.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-use-auto.rst

 .. title:: clang-tidy - hicpp-use-auto
 .. meta::
    :http-equiv=refresh: 5;URL=modernize-use-auto.html
 
 hicpp-use-auto
 ==============
 
 The `hicpp-use-auto` check is an alias, please see
 `modernize-use-auto <modernize-use-auto.html>`_ for more information.
 It enforces the `rule 7.1.8 <http://www.codingstandard.com/rule/7-1-8-use-auto-id-expr-when-declaring-a-variable-to-have-the-same-type-as-its-initializer-function-call/>`_.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-use-emplace.rst

 .. title:: clang-tidy - hicpp-use-emplace
 .. meta::
    :http-equiv=refresh: 5;URL=modernize-use-emplace.html
 
 hicpp-use-emplace
 =================
 
 The `hicpp-use-emplace` check is an alias, please see
 `modernize-use-emplace <modernize-use-emplace.html>`_ for more information.
 It enforces the `rule 17.4.2 <http://www.codingstandard.com/rule/17-4-2-use-api-calls-that-construct-objects-in-place/>`_.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-use-equals-default.rst

 .. title:: clang-tidy - hicpp-use-equals-defaults
 .. meta::
    :http-equiv=refresh: 5;URL=modernize-use-equals-default.html
 
 hicpp-use-equals-default
 ========================
 
 This check is an alias for `modernize-use-equals-default <modernize-use-equals-default.html>`_.
 Implements `rule 12.5.1 <http://www.codingstandard.com/rule/12-5-1-define-explicitly-default-or-delete-implicit-special-member-functions-of-concrete-classes/>`_ to explicitly default special member functions.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-use-equals-delete.rst

 .. title:: clang-tidy - hicpp-use-equals-delete
 .. meta::
    :http-equiv=refresh: 5;URL=modernize-use-equals-delete.html
 
 hicpp-use-equals-delete
 =======================
 
 This check is an alias for `modernize-use-equals-delete <modernize-use-equals-delete.html>`_.
 Implements `rule 12.5.1 <http://www.codingstandard.com/rule/12-5-1-define-explicitly-default-or-delete-implicit-special-member-functions-of-concrete-classes/>`_ 
 to explicitly default or delete special member functions.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-use-noexcept.rst

 .. title:: clang-tidy - hicpp-use-noexcept
 .. meta::
    :http-equiv=refresh: 5;URL=modernize-use-noexcept.html
 
 hicpp-use-noexcept
 ==================
 
 The `hicpp-use-noexcept` check is an alias, please see
 `modernize-use-noexcept <modernize-use-noexcept.html>`_ for more information.
 It enforces the `rule 1.3.5 <http://www.codingstandard.com/rule/1-3-5-do-not-use-throw-exception-specifications/>`_.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-use-nullptr.rst

 .. title:: clang-tidy - hicpp-use-nullptr
 .. meta::
    :http-equiv=refresh: 5;URL=modernize-use-nullptr.html
 
 hicpp-use-nullptr
 =================
 
 The `hicpp-use-nullptr` check is an alias, please see
 `modernize-use-nullptr <modernize-use-nullptr.html>`_ for more information.
 It enforces the `rule 2.5.3 <http://www.codingstandard.com/rule/2-5-3-use-nullptr-for-the-null-pointer-constant/>`_.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/hicpp-use-override.rst

 .. title:: clang-tidy - hicpp-use-override
 .. meta::
    :http-equiv=refresh: 5;URL=modernize-use-override.html
 
 hicpp-use-override
 ==================
 
 This check is an alias for `modernize-use-override <modernize-use-override.html>`_.
 Implements `rule 10.2.1 <http://www.codingstandard.com/section/10-2-virtual-functions/>`_ to 
 declare a virtual function `override` when overriding.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/llvm-include-order.rst

 .. title:: clang-tidy - llvm-include-order
 
 llvm-include-order
 ==================
 
 
 Checks the correct order of ``#includes``.
 
 See https://llvm.org/docs/CodingStandards.html#include-style
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/llvm-prefer-isa-or-dyn-cast-in-conditionals.rst

.. code-block:: c++
   if (var && isa<T>(var)) {}
   // is replaced by:
   if (isa_and_nonnull<T>(var.foo())) {}
 
   // Other cases are ignored, e.g.:
   if (auto f = cast<Z>(y)->foo()) {}
   if (cast<Z>(y)->foo()) {}
   if (X.cast(y)) {}
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/llvm-prefer-register-over-unsigned.rst

 
 .. code-block:: c++
 
   void example(MachineOperand &MO) {
     Register Reg = MO.getReg();
     ...
   }
 
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/llvm-qualified-auto.rst

 .. title:: clang-tidy - llvm-qualified-auto
 .. meta::
    :http-equiv=refresh: 5;URL=readability-qualified-auto.html
 
 llvm-qualified-auto
 ===================
 
 The llvm-qualified-auto check is an alias, please see
 `readability-qualified-auto <readability-qualified-auto.html>`_
 for more information.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/llvm-twine-local.rst

 .. title:: clang-tidy - llvm-twine-local
 
 llvm-twine-local
 ================
 
 
 Looks for local ``Twine`` variables which are prone to use after frees and
 should be generally avoided.
 
 .. code-block:: c++
 
   static Twine Moo = Twine("bark") + "bah";
 
   // becomes
 
   static std::string Moo = (Twine("bark") + "bah").str();
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/llvmlibc-restrict-system-libc-headers.rst

.. option:: Includes
    filenames. Similar to the -checks glob list for running clang-tidy itself,
    the two wildcard characters are `*` and `-`, to include and exclude globs,
    respectively. The default is `-*`, which disallows all includes.
 
    This can be used to allow known safe includes such as Linux development
    headers. See :doc:`portability-restrict-system-includes
    <portability-restrict-system-includes>` for more
    details.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/misc-definitions-in-headers.rst

.. option:: HeaderFileExtensions
    For header files without an extension, use an empty string (if there are no
    other desired extensions) or leave an empty element in the list. e.g.,
    "h,hh,hpp,hxx," (note the trailing comma).
 
 .. option:: UseHeaderFileExtension
 
    When non-zero, the check will use the file extension to distinguish header
    files. Default is `1`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/misc-redundant-expression.rst

 Examples:
 
 .. code-block:: c++
 
   ((x+1) | (x+1))             // (x+1) is redundant
   (p->x == p->x)              // always true
   (p->x < p->x)               // always false
   (speed - speed + 1 == 12)   // speed - speed is always zero
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/misc-static-assert.rst

 .. title:: clang-tidy - misc-static-assert
 
 misc-static-assert
 ==================
 
 `cert-dcl03-c` redirects here as an alias for this check.
 
 Replaces ``assert()`` with ``static_assert()`` if the condition is evaluatable
 at compile time.
 
 The condition of ``static_assert()`` is evaluated at compile time which is
 safer and more efficient.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/misc-uniqueptr-reset-release.rst

 .. title:: clang-tidy - misc-uniqueptr-reset-release
 
 misc-uniqueptr-reset-release
 ============================
 
 Find and replace ``unique_ptr::reset(release())`` with ``std::move()``.
 
 Example:
 
 .. code-block:: c++
 
   std::unique_ptr<Foo> x, y;
   x.reset(y.release()); -> x = std::move(y);
 
 If ``y`` is already rvalue, ``std::move()`` is not added. ``x`` and ``y`` can
 also be ``std::unique_ptr<Foo>*``.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/misc-unused-alias-decls.rst

 .. title:: clang-tidy - misc-unused-alias-decls
 
 misc-unused-alias-decls
 =======================
 
 
 Finds unused namespace alias declarations.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/misc-unused-parameters.rst

 
 .. option:: StrictMode
 
    When zero (default value), the check will ignore trivially unused parameters,
    i.e. when the corresponding function has an empty body (and in case of
    constructors - no constructor initializers). When the function body is empty,
    an unused parameter is unlikely to be unnoticed by a human reader, and
    there's basically no place for a bug to hide.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/misc-unused-using-decls.rst

 .. title:: clang-tidy - misc-unused-using-decls
 
 misc-unused-using-decls
 =======================
 
 Finds unused ``using`` declarations.
 
 Example:
 
 .. code-block:: c++
 
   namespace n { class C; }
   using n::C;  // Never actually used.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-avoid-bind.rst

.. code-block:: c++
   int foo() {
     std::function<int(int,int)> ignore_args = [](auto&&...) { return add(2, 2); }
     return ignore_args(3, 3);
   }
 
 which is correct.
   
 This check requires using C++14 or higher to run.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-concat-nested-namespaces.rst

.. code-block:: c++
   namespace n4::n5 {
   void t();
   }
   namespace n6::n7 {
   void t();
   }
   }
 
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-deprecated-headers.rst

 headers deprecated before C++11, otherwise -- every header that appeared in
 the previous list.
 
 These headers don't have effect in C++:
 
 * `<iso646.h>`
 * `<stdalign.h>`
 * `<stdbool.h>`
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-deprecated-ios-base-aliases.rst

 Deprecated member type               Replacement
 ===================================  ===========================
 ``std::ios_base::io_state``          ``std::ios_base::iostate``
 ``std::ios_base::open_mode``         ``std::ios_base::openmode``
 ``std::ios_base::seek_dir``          ``std::ios_base::seekdir``
 ``std::ios_base::streamoff``          
 ``std::ios_base::streampos``         
 ===================================  ===========================
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-loop-convert.rst

 As range-based for loops are only available since OpenMP 5, this check should
 not been used on code with a compatibility requirements of OpenMP prior to
 version 5. It is **intentional** that this check does not make any attempts to
 exclude incorrect diagnostics on OpenMP for loops prior to OpenMP 5.
 
 To prevent this check to be applied (and to break) OpenMP for loops but still be
 applied to non-OpenMP for loops the usage of ``NOLINT`` (see
 :ref:`clang-tidy-nolint`) on the specific for loops is recommended.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-make-shared.rst

.. option:: IncludeStyle
 
    A string specifying which include-style is used, `llvm` or `google`. Default
    is `llvm`.
 
 .. option:: IgnoreMacros
 
    If set to non-zero, the check will not give warnings inside macros. Default
    is `1`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-make-unique.rst

.. option:: IncludeStyle
 
    A string specifying which include-style is used, `llvm` or `google`. Default
    is `llvm`.
 
 .. option:: IgnoreMacros
 
    If set to non-zero, the check will not give warnings inside macros. Default
    is `1`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-pass-by-value.rst

.. option:: IncludeStyle
 
    A string specifying which include-style is used, `llvm` or `google`. Default
    is `llvm`.
 
 .. option:: ValuesOnly
 
    When non-zero, the check only warns about copied parameters that are already
    passed by value. Default is `0`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-raw-string-literal.rst

 A string literal containing only escaped newlines is a common way of
 writing lines of text output. Introducing physical newlines with raw
 string literals in this case is likely to impede readability. These
 string literals are left unchanged.
 
 An escaped horizontal tab, form feed, or vertical tab prevents the string
 literal from being converted. The presence of a horizontal tab, form feed or
 vertical tab in source code is not visually obvious.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-redundant-void-arg.rst

Examples:
   ===================================  ===========================
   ``int f(void);``                     ``int f();``
   ``int (*f(void))(void);``            ``int (*f())();``
   ``typedef int (*f_t(void))(void);``  ``typedef int (*f_t())();``
   ``void (C::*p)(void);``              ``void (C::*p)();``
   ``C::C(void) {}``                    ``C::C() {}``
   ``C::~C(void) {}``                   ``C::~C() {}``
   ===================================  ===========================
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-replace-auto-ptr.rst

 
 Options
 -------
 
 .. option:: IncludeStyle
 
    A string specifying which include-style is used, `llvm` or `google`. Default
    is `llvm`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-replace-random-shuffle.rst

.. code-block:: c++
   std::shuffle(v.begin(), v.end(), []() {
     std::mt19937::result_type seeds[std::mt19937::state_size];
     std::random_device device;
     std::uniform_int_distribution<typename std::mt19937::result_type> dist;
     std::generate(std::begin(seeds), std::end(seeds), [&] { return dist(device); });
     std::seed_seq seq(std::begin(seeds), std::end(seeds));
     return std::mt19937(seq);
   }());
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-return-braced-init-list.rst

.. code:: c++
   }
 
   // transforms to:
 
   Foo bar() {
     Baz baz;
     return {baz};
   }
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-shrink-to-fit.rst

 .. title:: clang-tidy - modernize-shrink-to-fit
 
 modernize-shrink-to-fit
 =======================
 
 
 Replace copy and swap tricks on shrinkable containers with the
 ``shrink_to_fit()`` method call.
 
 The ``shrink_to_fit()`` method is more readable and more effective than
 the copy and swap trick to reduce the capacity of a shrinkable container.
 Note that, the ``shrink_to_fit()`` method is only available in C++11 and up.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-unary-static-assert.rst

 
 is replaced by:
 
 .. code-block:: c++
 
   void f_textless(int a) {
     static_assert(sizeof(a) <= 10);
   }
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-auto.rst

.. code-block:: c++
 
   // RemoveStars = 0
 
   auto *my_first_pointer = new TypeName, *my_second_pointer = new TypeName;
 
   // RemoveStars = 1
 
   auto my_first_pointer = new TypeName, my_second_pointer = new TypeName;
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-bool-literals.rst

 
 Options
 -------
 
 .. option:: IgnoreMacros
 
    If set to non-zero, the check will not give warnings inside macros. Default
    is `1`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-default-member-init.rst

struct A {
     int i = 5;
     double j = 10.0;
   };
 
 .. option:: IgnoreMacros
 
    If this option is set to non-zero (default is `1`), the check will not warn
    about members declared inside macros.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-emplace.rst

 
 .. code-block:: c++
 
   std::vector<MyTuple<int, bool, char>> x;
   x.emplace_back(1, false, 'x');
 
 when :option:`TupleTypes` is set to ``MyTuple`` and :option:`TupleMakeFunctions`
 is set to ``MakeMyTuple``.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-equals-default.rst

 
 Options
 -------
 
 .. option:: IgnoreMacros
 
    If set to non-zero, the check will not give warnings inside macros. Default
    is `1`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-equals-delete.rst

private:
     A& operator=(const A&) = delete;
   };
 
 
 .. option:: IgnoreMacros
 
    If this option is set to non-zero (default is `1`), the check will not warn
    about functions declared inside macros.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-nodiscard.rst

.. note::
     macro, then that macro must be defined in scope or the fix-it will not be 
     applied.
 
 .. note::
 
     For alternative ``__attribute__`` syntax options to mark functions as
     ``[[nodiscard]]`` in non-c++17 source code.
     See https://clang.llvm.org/docs/AttributeReference.html#nodiscard-warn-unused-result
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-noexcept.rst

.. code-block:: c++
   struct bar {
     void foobar();
     void operator delete(void *ptr) noexcept(false);
     void operator delete[](void *ptr) noexcept(false);
     ~bar() noexcept(false);
   }
 
 if the :option:`UseNoexceptFalse` option is set to `0`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-nullptr.rst

 .. code-block:: c++
 
   #define MY_NULL NULL
   void assignment() {
     int *p = nullptr;
   }
 
 if the :option:`NullMacros` option is set to ``MY_NULL``.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-override.rst

.. option:: FinalSpelling
 
    Specifies a macro to use instead of ``final``. This is useful when
    maintaining source code that also needs to compile with a pre-C++11
    compiler.
 
 .. note::
 
    For more information on the use of ``override`` see https://en.cppreference.com/w/cpp/language/override
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-trailing-return-type.rst

class CC {
     int Object;
     auto m() -> struct Object;
   };
   auto CC::m() -> Object { return {0}; } // error
 
 This code fails to compile because the Object in the context of f refers to the equally named function parameter.
 Similarly, the Object in the context of m refers to the equally named class member.
 The check can currently only detect a clash with a function parameter name.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-transparent-functors.rst

 
 .. option:: SafeMode
 
   If the option is set to non-zero, the check will not diagnose cases where
   using a transparent functor cannot be guaranteed to produce identical results
   as the original code. The default value for this option is `0`.
 
 This check requires using C++14 or higher to run.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-uncaught-exceptions.rst

int main() {
     res = MACRO2();
     
     res = std::uncaught_exceptions();
     
     using std::uncaught_exceptions;
     
     res = uncaught_exceptions();
   }
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-using.rst

 
 Options
 -------
 
 .. option:: IgnoreMacros
 
    If set to non-zero, the check will not give warnings inside macros. Default
    is `1`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/mpi-buffer-deref.rst

.. code-block:: c++
 
    // A multidimensional array is passed to the MPI function.
    short buf[1][1];
    MPI_Send(buf, 1, MPI_SHORT, 0, 0, MPI_COMM_WORLD);
 
    // A pointer to an array is passed to the MPI function.
    short *buf[1];
    MPI_Send(buf, 1, MPI_SHORT, 0, 0, MPI_COMM_WORLD);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/mpi-type-mismatch.rst

.. code-block:: c++
 
   // In this case, the buffer type matches MPI datatype.
   char buf;
   MPI_Send(&buf, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
 
   // In the following case, the buffer type does not match MPI datatype.
   int buf;
   MPI_Send(&buf, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/objc-nsinvocation-argument-lifetime.rst

 
 The check will warn on being passed instance variable references that have
 lifetimes other than ``__unsafe_unretained``, but does not propose a fix:
 
 .. code-block:: objc
 
     // "id _returnValue" is declaration of instance variable of class.
     [invocation getReturnValue:&self->_returnValue];
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/objc-property-declaration.rst

 The check will also accept property declared in category with a prefix of
 lowercase letters followed by a '_' to avoid naming conflict. For example:
 
 .. code-block:: objc
 
    @property(nonatomic, assign) int abc_lowerCamelCase;
 
 The corresponding style rule: https://developer.apple.com/library/content/qa/qa1908/_index.html
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/objc-super-self.rst

 .. title:: clang-tidy - objc-super-self
 
 objc-super-self
 ===============
 
 Finds invocations of ``-self`` on super instances in initializers of subclasses
 of ``NSObject`` and recommends calling a superclass initializer instead.
 
 Invoking ``-self`` on super instances in initializers is a common programmer
 error when the programmer's original intent is to call a superclass
 initializer. Failing to call a superclass initializer breaks initializer
 chaining and can result in invalid object initialization.
 
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/performance-faster-string-find.rst

 -------
 
 .. option:: StringLikeClasses
 
    Semicolon-separated list of names of string-like classes. By default only
    ``std::basic_string`` is considered. The list of methods to consired is
    fixed.
 
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/performance-for-range-copy.rst

.. option:: WarnOnAllAutoCopies
    loop variable. Default is `0`.
 
 .. option:: AllowedTypes
 
    A semicolon-separated list of names of types allowed to be copied in each
    iteration. Regular expressions are accepted, e.g. `[Rr]ef(erence)?$` matches
    every type with suffix `Ref`, `ref`, `Reference` and `reference`. The default
    is empty.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/performance-inefficient-algorithm.rst

 .. code-block:: c++
 
   std::set<int> s;
   auto c = std::count(s.begin(), s.end(), 43);
 
   // becomes
 
   auto c = s.count(43);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/performance-inefficient-vector-operation.rst

.. option:: VectorLikeClasses
    Semicolon-separated list of names of vector-like classes. By default only
    ``::std::vector`` is considered.
 
 .. option:: EnableProto
 
    When non-zero, the check will also warn on inefficient operations for proto
    repeated fields. Otherwise, the check only warns on inefficient vector
    operations. Default is `0`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/performance-move-const-arg.rst

 
 Options
 -------
 
 .. option:: CheckTriviallyCopyableMove
 
    If non-zero, enables detection of trivially copyable types that do not
    have a move constructor. Default is non-zero.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/performance-move-constructor-init.rst

 
 Options
 -------
 
 .. option:: IncludeStyle
 
    A string specifying which include-style is used, `llvm` or `google`. Default
    is `llvm`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/performance-noexcept-move-constructor.rst

 .. title:: clang-tidy - performance-noexcept-move-constructor
 
 performance-noexcept-move-constructor
 =====================================
 
 
 The check flags user-defined move constructors and assignment operators not
 marked with ``noexcept`` or marked with ``noexcept(expr)`` where ``expr``
 evaluates to ``false`` (but is not a ``false`` literal itself).
 
 Move constructors of all the types used with STL containers, for example,
 need to be declared ``noexcept``. Otherwise STL will choose copy constructors
 instead. The same is valid for move assignment operations.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/performance-trivially-destructible.rst

 .. title:: clang-tidy - performance-trivially-destructible
 
 performance-trivially-destructible
 ==================================
 
 Finds types that could be made trivially-destructible by removing out-of-line
 defaulted destructor declarations.
 
 .. code-block:: c++
 
    struct A: TrivialType {
      ~A(); // Makes A non-trivially-destructible.
      TrivialType trivial_fields;
    };
    A::~A() = default;
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/performance-type-promotion-in-math-fn.rst

.. code-block:: c++
 
   float a;
   asin(a);
 
   // becomes
 
   float a;
   std::asin(a);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/performance-unnecessary-value-param.rst

.. option:: IncludeStyle
    A string specifying which include-style is used, `llvm` or `google`. Default
    is `llvm`.
 
 .. option:: AllowedTypes
 
    A semicolon-separated list of names of types allowed to be passed by value.
    Regular expressions are accepted, e.g. `[Rr]ef(erence)?$` matches every type
    with suffix `Ref`, `ref`, `Reference` and `reference`. The default is empty.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/portability-restrict-system-includes.rst

 -------
 
 .. option:: Includes
 
    A string containing a comma separated glob list of allowed include
    filenames. Similar to the -checks glob list for running clang-tidy itself,
    the two wildcard characters are `*` and `-`, to include and exclude globs,
    respectively. The default is `*`, which allows all includes.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-braces-around-statements.rst

.. option:: ShortStatementLines
 
    Defines the minimal number of lines that the statement should have in order
    to trigger this check.
 
    The number of lines is counted from the end of condition or initial keyword
    (``do``/``else``) until the last line of the inner statement. Default value
    `0` means that braces will be added to all statements (not having them
    already).
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-const-return-type.rst

 Note that this applies strictly to top-level qualification, which excludes
 pointers or references to const values. For example, these are fine:
 
 .. code-block:: c++
 
    const int* foo();
    const int& foo();
    const Clazz* foo();
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-container-size-empty.rst

 matching following signatures:
 
 .. code-block:: c++
 
   size_type size() const;
   bool empty() const;
 
 `size_type` can be any kind of integer type.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-delete-null-pointer.rst

 .. title:: clang-tidy - readability-delete-null-pointer
 
 readability-delete-null-pointer
 ===============================
 
 Checks the ``if`` statements where a pointer's existence is checked and then deletes the pointer.
 The check is unnecessary as deleting a null pointer has no effect.
 
 .. code:: c++
 
   int *p;
   if (p)
     delete p;
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-else-after-return.rst

void foo(int Value) {
         }
         Local++;
       }
     }
 
 
 This check helps to enforce this `LLVM Coding Standards recommendation
 <https://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return>`_.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-identifier-naming.rst

 After:
 
 .. code-block:: c++
 
     class Foo {
     public:
       virtual int pre_member_function_post();
     }
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-implicit-bool-conversion.rst

.. option::  AllowIntegerConditions
 
    When non-zero, the check will allow conditional integer conversions. Default
    is `0`.
 
 .. option::  AllowPointerConditions
 
    When non-zero, the check will allow conditional pointer conversions. Default
    is `0`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-inconsistent-declaration-parameter-name.rst

.. option:: IgnoreMacros
 
    If this option is set to non-zero (default is `1`), the check will not warn
    about names declared inside macros.
 
 .. option:: Strict
 
    If this option is set to non-zero (default is `0`), then names must match
    exactly (or be absent).
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-isolate-declaration.rst

void macros() {
     int Unconditional,
   #if CONFIGURATION
         IfConfigured = 42,
   #else
         IfConfigured = 0;
   #endif
     // Won't be transformed, but a diagnostic is emitted.
   }
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-make-member-function-const.rst

public:
     S *get() {
       return const_cast<int*>(const_cast<const C*>(this)->get());
     }
     ...
   };
 
 After applying modifications as suggested by the check, running the check again
 might find more opportunities to mark member functions ``const``.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-misplaced-array-index.rst

.. code-block:: c++
   void f(int *X, int Y) {
     X[Y] = 0;
   }
 
 The check warns about such unusual syntax for readability reasons:
  * There are programmers that are not familiar with this unusual syntax.
  * It is possible that variables are mixed up.
 
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-named-parameter.rst

 .. title:: clang-tidy - readability-named-parameter
 
 readability-named-parameter
 ===========================
 
 Find functions with unnamed arguments.
 
 The check implements the following rule originating in the Google C++ Style
 Guide:
 
 https://google.github.io/styleguide/cppguide.html#Function_Declarations_and_Definitions
 
 All parameters should be named, with identical names in the declaration and
 implementation.
 
 Corresponding cpplint.py check name: `readability/function`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-non-const-parameter.rst

.. code-block:: c++
 
   // no warning; Technically, *p can be const ("const struct S *p"). But making
   // *p const could be misleading. People might think that it's safe to pass
   // const data to this function.
   struct S { int *a; int *b; };
   int f3(struct S *p) {
     *(p->a) = 0;
   }
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-qualified-auto.rst

 
 .. code-block:: c++
 
    const auto *Foo1 = cast<const int *>(Bar1);
    const auto *Foo2 = cast<const int *>(Bar2);
    const auto &Foo3 = cast<const int &>(Bar3);
 
 Note in the LLVM alias, the default value is `0`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-redundant-access-specifiers.rst

.. code-block:: c++
   struct Bar {
   public:
     int x;
   }
 
 If `CheckFirstDeclaration` option is enabled, a warning about redundant
 access specifier will be emitted, because ``public`` is the default member access
 for structs.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-redundant-control-flow.rst

 becomes
 
 .. code-block:: c++
 
   void k() {
     for (int i = 0; i < 10; ++i) {
     }
   }
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-redundant-declaration.rst

 
 Options
 -------
 
 .. option:: IgnoreMacros
 
    If set to non-zero, the check will not give warnings inside macros. Default
    is `1`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-redundant-function-ptr-dereference.rst

 After:
 
 .. code-block:: c++
 
   int f(int,int);
   int (*p)(int, int) = &f;
 
   int i = (*p)(10, 50);
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-redundant-member-init.rst

.. code-block:: c++
 
   // Explicitly initializing member s and base class Bar is unnecessary.
   struct Foo : public Bar {
     // Remove s() below. If IgnoreBaseInCopyConstructors!=0, keep Bar().
     Foo(const Foo& foo) : Bar(), s() {}
     std::string s;
   };
 
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-redundant-smartptr-get.rst

.. code-block:: c++
   *ptr->get()  ==>  **ptr
   if (ptr.get() == nullptr) ... => if (ptr == nullptr) ...
 
 
 .. option:: IgnoreMacros
 
    If this option is set to non-zero (default is `1`), the check will not warn
    about calls inside macros.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-redundant-string-init.rst

 .. option:: StringNames
 
     Default is `::std::basic_string`.
 
     Semicolon-delimited list of class names to apply this check to.
     By default `::std::basic_string` applies to ``std::string`` and
     ``std::wstring``. Set to e.g. `::std::basic_string;llvm::StringRef;QString`
     to perform this check on custom classes.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-simplify-boolean-expr.rst

.. option:: ChainedConditionalReturn
 
    If non-zero, conditional boolean return statements at the end of an
    ``if/else if`` chain will be transformed. Default is `0`.
 
 .. option:: ChainedConditionalAssignment
 
    If non-zero, conditional boolean assignments at the end of an ``if/else
    if`` chain will be transformed. Default is `0`.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-simplify-subscript-expr.rst

 
 Options
 -------
 
 .. option:: Types
 
    The list of type(s) that triggers this check. Default is
    `::std::basic_string;::std::basic_string_view;::std::vector;::std::array`
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-static-accessed-through-instance.rst

 is changed to:
 
 .. code-block:: c++
 
   C *c1 = new C();
   C::foo();
   C::x;
 
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-static-definition-in-anonymous-namespace.rst

 .. code-block:: c++
 
   namespace {
     static int a = 1; // Warning.
     static const b = 1; // Warning.
   }
 
 The check will apply a fix by removing the redundant ``static`` qualifier.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-string-compare.rst

.. code-block:: c++
 
   // Use str1 == "foo" instead.
   if (str1.compare("foo") == 0) {
   }
 
 The above code examples shows the list of if-statements that this check will
 give a warning for. All of them uses ``compare`` to check if equality or 
 inequality of two strings instead of using the correct operators.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-uniqueptr-delete-release.rst

.. code-block:: c++
 
   std::unique_ptr<int> P;
   delete P.release();
 
   // becomes
 
   std::unique_ptr<int> P;
   P = nullptr;
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.

clang-tools-extra/docs/clang-tidy/checks/readability-uppercase-literal-suffix.rst

 * ``uL`` will be kept as is.
 * ``ull`` will be kept as is, since it is not in the list
 * and so on.
 
 .. option:: IgnoreMacros
 
    If this option is set to non-zero (default is `1`), the check will not warn
    about literal suffixes inside macros.
+
+.. note::
+
+    This checker provides an automatic fix callable with ``--fix``.