[clang-tidy][docs] Update check options with boolean values instead of non-zero/0/1

[njames93]

Summary

Using bools instead of integers better conveys the expected value of the option.

[njames93]

Whoops missed one

[Eugene.Zelenko]

Looks OK for me.

[sylvestre.ledru]

Thanks for doing that :)

[aaron.ballman]

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

59–60

This edit loses information about also accepting Yes and y -- is that intentional (or were those unsupported before)?

FWIW, I'd be fine dropping support for alternate spellings of true.

129–130

"An integer true value" is a bit of a strange beast. How about "The value true specifies that the target environment..."?

clang-tools-extra/docs/clang-tidy/checks/misc-throw-by-value-catch-by-reference.rst

50

Drive-by since we're changing this line already: If option is set -> If the option is set

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

185–186

Drive-by since we're already changing the line: If option -> If the option

[njames93]

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

59–60

Having looked throughout the NotNullTerminatedResultCheck header/impl files, I can't find any reference to AreSafeFunctionsAvailable.
I can only guess this is meant to say WantToUseSafeFunctions. If that is the case, Yes and y were never supported spellings.

Should this be changed to use that option name instead? cc @Charusso

FWIW I intend (in the near future) to extend boolean parsing for check options to:
y|Y|yes|Yes|YES|true|True|TRUE|on|On|ON
n|N|no|No|NO|false|False|FALSE|off|Off|OFF.

Reason for this is we claim to use YAML for config format and according to its specification, this is what is accepted as a boolean value. Ref https://yaml.org/type/bool.html.
Still need to keep the old integer method of specifying bools for backwards compatibility reasons.

[njames93]

Address comments

[aaron.ballman]

LGTM, thank you for this cleanup!

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

59–60

Should this be changed to use that option name instead? cc @Charusso

I think so, but that can be done in an NFC followup if you'd like.

Reason for this is we claim to use YAML for config format and according to its specification, this is what is accepted as a boolean value.

Oh, that's a good reason to support those spellings, thank you for clarifying.

[Charusso]

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

59–60

Hey, nice catch and cool patch! Sorry for the extra work. WantToUseSafeFunctions is wanted to be here as a zero or non-zero value [1]. It would be great if you could rewrite this variable name because I do not write LLVM code any more. Thanks!

[1] https://clang.llvm.org/extra/clang-tidy/checks/bugprone-not-null-terminated-result.html#options

[njames93]

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

59–60

No worries, I just wanted to make sure that was your initial intention :)

[njames93]

Update bugprone-not-null-terminated-result incorrect option name

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

 
 The check tries to detect typos and suggest automated fixes for them.
 
 Options
 -------
 
 .. option:: StrictMode
 
-   When zero (default value), the check will ignore leading and trailing
+   When `false` (default value), the check will ignore leading and trailing
    underscores and case when comparing names -- otherwise they are taken into
    account.
 
 .. option:: IgnoreSingleArgument
 
-   When true, the check will ignore the single argument.
+   When `true`, the check will ignore the single argument.
 
 .. option:: CommentBoolLiterals
 
-   When true, the check will add argument comments in the format
+   When `true`, the check will add argument comments in the format
    ``/*ParameterName=*/`` right before the boolean literal argument.
 
 Before:
 
 .. code-block:: c++
 
   void foo(bool TurnKey, bool PressButton);
 

clang-tools-extra/docs/clang-tidy/checks/bugprone-misplaced-widening-cast.rst

double f(float x) {
         return (double)(x * 10.0f);
     }
 
 Options
 -------
 
 .. option:: CheckImplicitCasts
 
-   If non-zero, enables detection of implicit casts. Default is non-zero.
+   If `true`, enables detection of implicit casts. Default is `true`.

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

 
 Rewrite based on the destination array
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - If copy to the destination array cannot overflow [1] the new function should
   be the older copy function (ending with ``cpy``), because it is more
   efficient than the safe version.
 
 - If copy to the destination array can overflow [1] and
-  ``AreSafeFunctionsAvailable`` is set to ``Yes``, ``y`` or non-zero and it is
-  possible to obtain the capacity of the destination array then the new function
-  could be the safe version (ending with ``cpy_s``).
+  :option:`WantToUseSafeFunctions` is set to `true` and it is possible to
+  obtain the capacity of the destination array then the new function could be
+  the safe version (ending with ``cpy_s``).
 
 - If the new function is could be safe version and C++ files are analysed and
   the destination array is plain ``char``/``wchar_t`` without ``un/signed`` then
   the length of the destination array can be omitted.
 
 - If the new function is could be safe version and the destination array is
   ``un/signed`` it needs to be casted to plain ``char *``/``wchar_t *``.
 

 
 ``strxfrm``
 The given length is incremented by one.
 
 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``.
+   The value `true` specifies that 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 `true`.

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

 identifier 
 <https://wiki.sei.cmu.edu/confluence/display/cplusplus/DCL51-CPP.+Do+not+declare+or+define+a+reserved+identifier>`_.
 
 Options
 -------
 
 .. option:: Invert
 
-   If non-zero, inverts the check, i.e. flags names that are not reserved. 
-   Default is `0`.
+   If `true`, inverts the check, i.e. flags names that are not reserved. 
+   Default is `false`.
 
 .. option:: AllowedIdentifiers
 
    Semicolon-separated list of names that the check ignores. Default is an 
    empty list.

clang-tools-extra/docs/clang-tidy/checks/bugprone-signed-char-misuse.rst

 .. title:: clang-tidy - bugprone-signed-char-misuse
 
 bugprone-signed-char-misuse
 ===========================
 
 `cert-str34-c` redirects here as an alias for this check. For the CERT alias,
-the `DiagnoseSignedUnsignedCharComparisons` option is set to `0`.
+the `DiagnoseSignedUnsignedCharComparisons` option is set to `false`.
 
 Finds those ``signed char`` -> integer conversions which might indicate a
 programming error. The basic problem with the ``signed char``, that it might
 store the non-ASCII characters as negative values. This behavior can cause a
 misunderstanding of the written code both when an explicit and when an
 implicit conversion happens.
 
 When the code contains an explicit ``signed char`` -> integer conversion, the
.. option:: CharTypdefsToIgnore
   A semicolon-separated list of typedef names. In this list, we can list
   typedefs for ``char`` or ``signed char``, which will be ignored by the
   check. This is useful when a typedef introduces an integer alias like
   ``sal_Int8`` or ``int8_t``. In this case, human misinterpretation is not
   an issue.
 
 .. option:: DiagnoseSignedUnsignedCharComparisons
 
-  When nonzero, the check will warn on ``signed char``/``unsigned char`` comparisons,
-  otherwise these comparisons are ignored. By default, this option is set to ``1``.
+  When `true`, the check will warn on ``signed char``/``unsigned char`` comparisons,
+  otherwise these comparisons are ignored. By default, this option is set to `true`.

clang-tools-extra/docs/clang-tidy/checks/bugprone-sizeof-expression.rst

void getInt(int* dst) {
     memcpy(dst, buf, sizeof(INT_SZ));  // sizeof(sizeof(int)) is suspicious.
   }
 
 Options
 -------
 
 .. option:: WarnOnSizeOfConstant
 
-   When non-zero, the check will warn on an expression like
-   ``sizeof(CONSTANT)``. Default is `1`.
+   When `true`, the check will warn on an expression like
+   ``sizeof(CONSTANT)``. Default is `true`.
 
 .. option:: WarnOnSizeOfIntegerExpression
 
-   When non-zero, the check will warn on an expression like ``sizeof(expr)``
-   where the expression results in an integer. Default is `0`.
+   When `true`, the check will warn on an expression like ``sizeof(expr)``
+   where the expression results in an integer. Default is `false`.
 
 .. option:: WarnOnSizeOfThis
 
-   When non-zero, the check will warn on an expression like ``sizeof(this)``.
-   Default is `1`.
+   When `true`, the check will warn on an expression like ``sizeof(this)``.
+   Default is `true`.
 
 .. option:: WarnOnSizeOfCompareToConstant
 
-   When non-zero, the check will warn on an expression like
+   When `true`, the check will warn on an expression like
    ``sizeof(epxr) <= k`` for a suspicious constant `k` while `k` is `0` or
-   greater than `0x8000`. Default is `1`.
+   greater than `0x8000`. Default is `true`.

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

.. code-block:: c++
   std::string("test", 0);   // Creation of an empty string.
   std::string_view("test", 0);
 
 Options
 -------
 
 .. option::  WarnOnLargeLength
 
-   When non-zero, the check will warn on a string with a length greater than
-   `LargeLengthThreshold`. Default is `1`.
+   When `true`, the check will warn on a string with a length greater than
+   :option:`LargeLengthThreshold`. Default is `true`.
 
 .. option::  LargeLengthThreshold
 
    An integer specifying the large length threshold. Default is `0x800000`.
 
 .. option:: StringNames
 
     Default is `::std::basic_string;::std::basic_string_view`.
 
     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.

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

.. code-block:: c++
 
     if (strcmp(...) < 0.)  // Incorrect usage of the returned value.
 
 Options
 -------
 
 .. option:: WarnOnImplicitComparison
 
-   When non-zero, the check will warn on implicit comparison. `1` by default.
+   When `true`, the check will warn on implicit comparison. `true` by default.
 
 .. option:: WarnOnLogicalNotComparison
 
-   When non-zero, the check will warn on logical not comparison. `0` by default.
+   When `true`, the check will warn on logical not comparison. `false` by default.
 
 .. option:: StringCompareLikeFunctions
 
    A string specifying the comma-separated names of the extra string comparison
    functions. Default is an empty string.
    The check will detect the following string comparison functions:
    `__builtin_memcmp`, `__builtin_strcasecmp`, `__builtin_strcmp`,
    `__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`.

clang-tools-extra/docs/clang-tidy/checks/bugprone-unhandled-self-assignment.rst

 .. title:: clang-tidy - bugprone-unhandled-self-assignment
 
 bugprone-unhandled-self-assignment
 ==================================
 
 `cert-oop54-cpp` redirects here as an alias for this check. For the CERT alias,
-the `WarnOnlyIfThisHasSuspiciousField` option is set to `0`.
+the `WarnOnlyIfThisHasSuspiciousField` option is set to `false`.
 
 Finds user-defined copy assignment operators which do not protect the code
 against self-assignment either by checking self-assignment explicitly or
 using the copy-and-swap or the copy-and-move method.
 
 By default, this check searches only those classes which have any pointer or C array field
 to avoid false positives. In case of a pointer or a C array, it's likely that self-copy
 assignment breaks the object if the copy assignment operator was not written with care.
T& operator=(T &&rhs) {
       p = rhs.p;
       rhs.p = nullptr;
       return *this;
     }
   };
 
 .. option:: WarnOnlyIfThisHasSuspiciousField
 
-  When non-zero, the check will warn only if the container class of the copy assignment operator
-  has any suspicious fields (pointer or C array). This option is set to `1` by default.
+  When `true`, the check will warn only if the container class of the copy assignment operator
+  has any suspicious fields (pointer or C array). This option is set to `true` by default.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-macro-usage.rst

.. option:: AllowedRegexp
     A regular expression to filter allowed macros. For example 
     `DEBUG*|LIBTORRENT*|TORRENT*|UNI*` could be applied to filter `libtorrent`.
     Default value is `^DEBUG_*`.
 
 .. option:: CheckCapsOnly
 
     Boolean flag to warn on all macros except those with CAPS_ONLY names.
     This option is intended to ease introduction of this check into older
-    code bases. Default value is `0`/`false`.
+    code bases. Default value is `false`.
 
 .. option:: IgnoreCommandLineMacros
 
     Boolean flag to toggle ignoring command-line-defined macros.
-    Default value is `1`/`true`.
+    Default value is `true`.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-narrowing-conversions.rst

- All applications of binary operators with a narrowing conversions.
    For example: ``int i; i+= 0.1;``.
 
 
 Options
 -------
 
 .. option:: WarnOnFloatingPointNarrowingConversion
 
-    When non-zero, the check will warn on narrowing floating point conversion
-    (e.g. ``double`` to ``float``). `1` by default.
+    When `true`, the check will warn on narrowing floating point conversion
+    (e.g. ``double`` to ``float``). `true` by default.
 
 .. option:: PedanticMode
 
-    When non-zero, the check will warn on assigning a floating point constant
+    When `true`, the check will warn on assigning a floating point constant
     to an integer value even if the floating point value is exactly
     representable in the destination type (e.g. ``int i = 1.0;``).
-    `0` by default.
+    `false` by default.
 
 FAQ
 ---
 
  - What does "narrowing conversion from 'int' to 'float'" mean?
 
 An IEEE754 Floating Point number can represent all integer values in the range
 [-2^PrecisionBits, 2^PrecisionBits] where PrecisionBits is the number of bits in

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-prefer-member-initializer.rst

.. code-block:: c++
   C(int nn, int mm) : n(nn) {
     if (dice())
       return;
     m = mm;
   }
 
 .. option:: UseAssignment
 
-   If this option is set to non-zero (default is `0`), the check will initialize
+   If this option is set to `true` (default is `false`), the check will initialize
    members with an assignment. In this case the fix of the first example looks
    like this:
 
 .. code-block:: c++
 
   class C {
     int n = 1;
     int m;
   public:
     C() {
       if (dice())
         return;
       m = 1;
     }
   };

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

 fix is to zero initialize the variable via ``{}`` for C++11 and beyond or ``=
 {}`` for older language versions.
 
 Options
 -------
 
 .. option:: IgnoreArrays
 
-   If set to non-zero, the check will not warn about array members that are not
+   If set to `true`, the check will not warn about array members that are not
    zero-initialized during construction. For performance critical code, it may
-   be important to not initialize fixed-size array members. Default is `0`.
+   be important to not initialize fixed-size array members. Default is `false`.
 
 .. option:: UseAssignment
 
-   If set to non-zero, the check will provide fix-its with literal initializers
+   If set to `true`, 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.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-special-member-functions.rst

 
 https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c21-if-you-define-or-delete-any-default-operation-define-or-delete-them-all.
 
 Options
 -------
 
 .. option:: AllowSoleDefaultDtor
 
-   When set to `1` (default is `0`), this check doesn't flag classes with a sole, explicitly
+   When set to `true` (default is `false`), this check doesn't flag classes with a sole, explicitly
    defaulted destructor. An example for such a class is:
    
    .. code-block:: c++
    
      struct A {
        virtual ~A() = default;
      };
    
 .. option:: AllowMissingMoveFunctions
 
-   When set to `1` (default is `0`), this check doesn't flag classes which define no move
+   When set to `true` (default is `false`), this check doesn't flag classes which define no move
    operations at all. It still flags classes which define only one of either
    move constructor or move assignment operator. With this option enabled, the following class won't be flagged:
    
    .. code-block:: c++
    
      struct A {
        A(const A&);
        A& operator=(const A&);
        ~A();
      };
 
 .. option:: AllowMissingMoveFunctionsWhenCopyIsDeleted
 
-   When set to `1` (default is `0`), this check doesn't flag classes which define deleted copy
+   When set to `true` (default is `false`), this check doesn't flag classes which define deleted copy
    operations but don't define move operations. This flags is related to Google C++ Style Guide
    https://google.github.io/styleguide/cppguide.html#Copyable_Movable_Types. With this option enabled, the 
    following class won't be flagged:
    
    .. code-block:: c++
    
      struct A {
        A(const A&) = delete;
        A& operator=(const A&) = delete;
        ~A();
      };

clang-tools-extra/docs/clang-tidy/checks/hicpp-multiway-paths-covered.rst

 
 
 Options
 -------
 
 .. option:: WarnOnMissingElse
 
   Boolean flag that activates a warning for missing ``else`` branches.
-  Default is `0`.
+  Default is `false`.

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

.. option:: HeaderFileExtensions
    A comma-separated list of filename extensions of header files (the filename
    extensions should not include "." prefix). Default is "h,hh,hpp,hxx".
    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`.
+   When `true`, the check will use the file extension to distinguish header
+   files. Default is `true`.

clang-tools-extra/docs/clang-tidy/checks/misc-throw-by-value-catch-by-reference.rst

 
 Options
 -------
 
 .. option:: CheckThrowTemporaries
 
    Triggers detection of violations of the CERT recommendation ERR09-CPP. Throw
    anonymous temporaries.
-   Default is `1`.
+   Default is `true`.
 
 .. option:: WarnOnLargeObject
 
    Also warns for any large, trivial object caught by value. Catching a large
    object by value is not dangerous but affects the performance negatively. The
    maximum size of an object allowed to be caught without warning can be set
    using the `MaxSize` option.
-   Default is `0`.
+   Default is `false`.
 
 .. option:: MaxSize
 
    Determines the maximum size of an object allowed to be caught without
-   warning. Only applicable if `WarnOnLargeObject` is set to `1`. If option is
-   set by the user to `std::numeric_limits<uint64_t>::max()` then it reverts to
-   the default value.
+   warning. Only applicable if :option:`WarnOnLargeObject` is set to `true`. If 
+   the option is set by the user to `std::numeric_limits<uint64_t>::max()` then
+   it reverts to the default value.
    Default is the size of `size_t`.

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

.. code-block:: c++
   static void staticFunctionA()
   static void staticFunctionA() { /*some code that doesn't use `i`*/ }
 
 Options
 -------
 
 .. option:: StrictMode
 
-   When zero (default value), the check will ignore trivially unused parameters,
+   When `false` (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.

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

 binaries due to type information that will not be produced by equivalent
 lambdas.
 
 Options
 -------
 
 .. option:: PermissiveParameterList
 
-  If the option is set to non-zero, the check will append ``auto&&...`` to the end
+  If the option is set to `true`, the check will append ``auto&&...`` to the end
   of every placeholder parameter list. Without this, it is possible for a fix-it
   to perform an incorrect transformation in the case where the result of the ``bind``
   is used in the context of a type erased functor such as ``std::function`` which
   allows mismatched arguments. For example:
   
 
 .. code-block:: c++
 

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`.
+   If set to `true`, the check will not give warnings inside macros. Default
+   is `true`.

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`.
+   If set to `true`, the check will not give warnings inside macros. Default
+   is `true`.

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`.
+   When `true`, the check only warns about copied parameters that are already
+   passed by value. Default is `false`.

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

 Options
 -------
 
 .. option:: MinTypeNameLength
 
    If the option is set to non-zero (default `5`), the check will ignore type
    names having a length less than the option value. The option affects
    expressions only, not iterators.
    Spaces between multi-lexeme type names (``long int``) are considered as one.
-   If ``RemoveStars`` option (see below) is set to non-zero, then ``*s`` in
-   the type are also counted as a part of the type name.
+   If the :option:`RemoveStars` option (see below) is set to `true`, then ``*s``
+   in the type are also counted as a part of the type name.
 
 .. code-block:: c++
 
   // MinTypeNameLength = 0, RemoveStars=0
 
   int a = static_cast<int>(foo());            // ---> auto a = ...
   // length(bool *) = 4
   bool *b = new bool;                         // ---> auto *b = ...
.. code-block:: c++
   int **pa = static_cast<int**>(foo());            // ---> auto pa = ...
   bool b = static_cast<bool>(foo());               // ---> bool b = ...
   bool *pb = static_cast<bool*>(foo());            // ---> auto pb = ...
   unsigned c = static_cast<unsigned>(foo());       // ---> auto c = ...
   long int d = static_cast<long int>(foo());       // ---> auto d = ...
 
 .. option:: RemoveStars
 
-   If the option is set to non-zero (default is `0`), the check will remove
+   If the option is set to `true` (default is `false`), the check will remove
    stars from the non-typedef pointer types when replacing type names with
    ``auto``. Otherwise, the check will leave stars. For example:
 
 .. code-block:: c++
 
   TypeName *my_first_pointer = new TypeName, *my_second_pointer = new TypeName;
 
   // 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;

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

.. code-block:: c++
   std::ios_base::sync_with_stdio(false);
   bool x = p ? true : false;
 
 Options
 -------
 
 .. option:: IgnoreMacros
 
-   If set to non-zero, the check will not give warnings inside macros. Default
-   is `1`.
+   If set to `true`, the check will not give warnings inside macros. Default
+   is `true`.

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

.. note::
   The `readability-redundant-member-init` check will remove redundant member
   initializers for classes.
 
 Options
 -------
 
 .. option:: UseAssignment
 
-   If this option is set to non-zero (default is `0`), the check will initialise
+   If this option is set to `true` (default is `false`), the check will initialise
    members with an assignment. For example:
 
 .. code-block:: c++
 
   struct A {
     A() {}
     A(int i) : i(i) {}
     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
+   If this option is set to `true` (default is `true`), the check will not warn
    about members declared inside macros.

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

 
 .. option:: ContainersWithPushBack
 
    Semicolon-separated list of class names of custom containers that support
    ``push_back``.
 
 .. option:: IgnoreImplicitConstructors
 
-    When non-zero, the check will ignore implicitly constructed arguments of
+    When `true`, the check will ignore implicitly constructed arguments of
     ``push_back``, e.g.
 
     .. code-block:: c++
 
         std::vector<std::string> v;
-        v.push_back("a"); // Ignored when IgnoreImplicitConstructors is ``1``.
+        v.push_back("a"); // Ignored when IgnoreImplicitConstructors is `true`.
 
-    Default is ``0``.
+    Default is `false`.
 
 .. option:: SmartPointers
 
    Semicolon-separated list of class names of custom smart pointers.
 
 .. option:: TupleTypes
 
     Semicolon-separated list of ``std::tuple``-like class names.

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

 .. note::
   Move-constructor and move-assignment operator are not supported yet.
 
 Options
 -------
 
 .. option:: IgnoreMacros
 
-   If set to non-zero, the check will not give warnings inside macros. Default
-   is `1`.
+   If set to `true`, the check will not give warnings inside macros. Default
+   is `true`.

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

.. code-block:: c++
   private:
     A(const A&) = delete;
     A& operator=(const A&) = delete;
   };
 
 
 .. option:: IgnoreMacros
 
-   If this option is set to non-zero (default is `1`), the check will not warn
+   If this option is set to `true` (default is `true`), the check will not warn
    about functions declared inside macros.

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`.
+if the :option:`UseNoexceptFalse` option is set to `false`.

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

  - The base class implementation function signature changes.
  - The user has not created the override with the correct signature.
 
 Options
 -------
 
 .. option:: IgnoreDestructors
 
-   If set to non-zero, this check will not diagnose destructors. Default is `0`.
+   If set to `true`, this check will not diagnose destructors. Default is `false`.
 
 .. option:: AllowOverrideAndFinal
 
-   If set to non-zero, this check will not diagnose ``override`` as redundant
+   If set to `true`, this check will not diagnose ``override`` as redundant
    with ``final``. This is useful when code will be compiled by a compiler with
    warning/error checking flags requiring ``override`` explicitly on overridden
    members, such as ``gcc -Wsuggest-override``/``gcc -Werror=suggest-override``.
-   Default is `0`.
+   Default is `false`.
 
 .. option:: OverrideSpelling
 
    Specifies a macro to use instead of ``override``. This is useful when
    maintaining source code that also needs to compile with a pre-C++11
    compiler.
 
 .. 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

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

.. code-block:: c++
     // Non-transparent functor
     std::map<const char *, std::string, std::greater<std::string>> s;
 
 Options
 -------
 
 .. option:: SafeMode
 
-  If the option is set to non-zero, the check will not diagnose cases where
+  If the option is set to `true`, 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`.
+  as the original code. The default value for this option is `false`.
 
 This check requires using C++14 or higher to run.

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

 
 This check requires using C++11 or higher to run.
 
 Options
 -------
 
 .. option:: IgnoreMacros
 
-   If set to non-zero, the check will not give warnings inside macros. Default
-   is `1`.
+   If set to `true`, the check will not give warnings inside macros. Default
+   is `true`.

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

2. The loop variable is not const, but only const methods or operators are
    invoked on it, or it is used as const reference or value argument in
    constructors or function calls.
 
 Options
 -------
 
 .. option:: WarnOnAllAutoCopies
 
-   When non-zero, warns on any use of `auto` as the type of the range-based for
-   loop variable. Default is `0`.
+   When `true`, warns on any use of `auto` as the type of the range-based for
+   loop variable. Default is `false`.
 
 .. 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.

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

void g() {
        f(std::string(a).append("Bar").append(b));
    }
 
 Options
 -------
 
 .. option:: StrictMode
 
-   When zero, the check will only check the string usage in ``while``, ``for``
-   and ``for-range`` statements. Default is `0`.
+   When `false`, the check will only check the string usage in ``while``, ``for``
+   and ``for-range`` statements. Default is `false`.

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
+   When `true`, the check will also warn on inefficient operations for proto
    repeated fields. Otherwise, the check only warns on inefficient vector
-   operations. Default is `0`.
+   operations. Default is `false`.

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

.. code-block:: c++
   string s;
   f(std::move(s));  // Warning: passing result of std::move as a const reference argument; no move will actually happen
 
 Options
 -------
 
 .. option:: CheckTriviallyCopyableMove
 
-   If non-zero, enables detection of trivially copyable types that do not
-   have a move constructor. Default is non-zero.
+   If `true`, enables detection of trivially copyable types that do not
+   have a move constructor. Default is `true`.

clang-tools-extra/docs/clang-tidy/checks/portability-simd-intrinsics.rst

 .. title:: clang-tidy - portability-simd-intrinsics
 
 portability-simd-intrinsics
 ===========================
 
 Finds SIMD intrinsics calls and suggests ``std::experimental::simd`` (`P0214`_)
 alternatives.
 
-If the option ``Suggest`` is set to non-zero, for
+If the option :option:`Suggest` is set to `true`, for
 
 .. code-block:: c++
 
   _mm_add_epi32(a, b); // x86
   vec_add(a, b);       // Power
 
 the check suggests an alternative: ``operator+`` on ``std::experimental::simd``
 objects.

 Refer to `P0214`_ for introduction and motivation for the data-parallel standard
 library.
 
 Options
 -------
 
 .. option:: Suggest
 
-   If this option is set to non-zero (default is `0`), the check will suggest
+   If this option is set to `true` (default is `false`), the check will suggest
    `P0214`_ alternatives, otherwise it only points out the intrinsic function is
    non-portable.
 
 .. option:: Std
 
    The namespace used to suggest `P0214`_ alternatives. If not specified, `std::`
    for `-std=c++20` and `std::experimental::` for `-std=c++11`.
 
 .. _P0214: https://wg21.link/p0214

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

.. code-block:: c++
 
     class pre_abstract_class_post {
     public:
       pre_abstract_class_post();
     };
 
 .. option:: AggressiveDependentMemberLookup
 
-    When set to `1` the check will look in dependent base classes for dependent
+    When set to `true` the check will look in dependent base classes for dependent
     member references that need changing. This can lead to errors with template
-    specializations so the default value is `0`.
+    specializations so the default value is `false`.
 
 For example using values of:
 
    - ClassMemberCase of ``lower_case``
 
 Before:
 
 .. code-block:: c++
 
     template <typename T>
     struct Base {
       T BadNamedMember;
     };
 
     template <typename T>
     struct Derived : Base<T> {
       void reset() {
         this->BadNamedMember = 0;
       }
     };
 
-After if AggressiveDependentMemberLookup is ``0``:
+After if AggressiveDependentMemberLookup is `false`:
 
 .. code-block:: c++
 
     template <typename T>
     struct Base {
       T bad_named_member;
     };
 
     template <typename T>
     struct Derived : Base<T> {
       void reset() {
         this->BadNamedMember = 0;
       }
     };
 
-After if AggressiveDependentMemberLookup is ``1``:
+After if AggressiveDependentMemberLookup is `true`:
 
 .. code-block:: c++
 
     template <typename T>
     struct Base {
       T bad_named_member;
     };
 

 After:
 
 .. code-block:: c++
 
     int pre_global3_post;
 
 .. option:: IgnoreMainLikeFunctions
 
-    When set to `1` functions that have a similar signature to ``main`` or 
+    When set to `true` functions that have a similar signature to ``main`` or 
     ``wmain`` won't enforce checks on the names of their parameters.
-    Default value is `0`.
+    Default value is `false`.
 
 .. option:: InlineNamespaceCase
 
     When defined, the check will ensure inline namespaces names conform to the
     selected casing.
 
 .. option:: InlineNamespacePrefix
 

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

 Occurrences of implicit conversions inside macros and template instantiations
 are deliberately ignored, as it is not clear how to deal with such cases.
 
 Options
 -------
 
 .. option::  AllowIntegerConditions
 
-   When non-zero, the check will allow conditional integer conversions. Default
-   is `0`.
+   When `true`, the check will allow conditional integer conversions. Default
+   is `false`.
 
 .. option::  AllowPointerConditions
 
-   When non-zero, the check will allow conditional pointer conversions. Default
-   is `0`.
+   When `true`, the check will allow conditional pointer conversions. Default
+   is `false`.

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

.. code-block:: c++
   int foo(int b) { return b + 2; } // definition with use of "b"
 
 In the case of multiple redeclarations or function template specializations,
 a warning is issued for every redeclaration or specialization inconsistent with
 the definition or the first declaration seen in a translation unit.
 
 .. option:: IgnoreMacros
 
-   If this option is set to non-zero (default is `1`), the check will not warn
+   If this option is set to `true` (default is `true`), 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
+   If this option is set to `true` (default is `false`), then names must match
    exactly (or be absent).

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

.. code-block:: c++
   auto *volatile FooBar = cast<int *>(Baz3);
   auto *BarFoo = cast<int **>(Baz4);
 
 Options
 -------
 
 .. option:: AddConstToQualified
    
-   When set to `1` the check will add const qualifiers variables defined as
+   When set to `true` the check will add const qualifiers variables defined as
    ``auto *`` or ``auto &`` when applicable.
-   Default value is '1'.
+   Default value is `true`.
 
 .. code-block:: c++
 
    auto Foo1 = cast<const int *>(Bar1);
    auto *Foo2 = cast<const int *>(Bar2);
    auto &Foo3 = cast<const int &>(Bar3);
 
-If AddConstToQualified is set to `0`,  it will be transformed into:
+If AddConstToQualified is set to `false`,  it will be transformed into:
 
 .. code-block:: c++
 
    const auto *Foo1 = cast<const int *>(Bar1);
    auto *Foo2 = cast<const int *>(Bar2);
    auto &Foo3 = cast<const int &>(Bar3);
 
 Otherwise it will be transformed into:
 
 .. 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 in the LLVM alias, the default value is `false`.

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

 In the example above, the second ``public`` declaration can be removed without
 any changes of behavior.
 
 Options
 -------
 
 .. option:: CheckFirstDeclaration
 
-   If set to non-zero, the check will also diagnose if the first access
+   If set to `true`, the check will also diagnose if the first access
    specifier declaration is redundant (e.g. ``private`` inside ``class``,
    or ``public`` inside ``struct`` or ``union``).
-   Default is `0`.
+   Default is `false`.
 
 Example
 ^^^^^^^
 
 .. 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.

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

 * When the declarations are in different header files;
 * When multiple variables are declared together.
 
 Options
 -------
 
 .. option:: IgnoreMacros
 
-   If set to non-zero, the check will not give warnings inside macros. Default
-   is `1`.
+   If set to `true`, the check will not give warnings inside macros. Default
+   is `true`.

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

private:
     std::string s;
   };
 
 Options
 -------
 
 .. option:: IgnoreBaseInCopyConstructors
 
-    Default is ``0``.
+    Default is `false`.
 
-    When non-zero, the check will ignore unnecessary base class initializations
+    When `true`, the check will ignore unnecessary base class initializations
     within copy constructors, since some compilers issue warnings/errors when
     base classes are not explicitly intialized in copy constructors. For example,
     ``gcc`` with ``-Wextra`` or ``-Werror=extra`` issues warning or error
     ``base class 'Bar' should be explicitly initialized in the copy constructor``
     if ``Bar()`` were removed in the following example:
 
 .. 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;
   };
 

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

.. code-block:: c++
   ptr.get()->Foo()  ==>  ptr->Foo()
   *ptr.get()  ==>  *ptr
   *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
+   If this option is set to `true` (default is `true`), the check will not warn
    about calls inside macros.

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

6. Given ``struct X { explicit operator bool(); };``, and an instance ``x`` of
      ``struct X``, the conditional return ``if (x) return true; return false;``
      becomes ``return static_cast<bool>(x);``
 
 Options
 -------
 
 .. option:: ChainedConditionalReturn
 
-   If non-zero, conditional boolean return statements at the end of an
-   ``if/else if`` chain will be transformed. Default is `0`.
+   If `true`, conditional boolean return statements at the end of an
+   ``if/else if`` chain will be transformed. Default is `false`.
 
 .. option:: ChainedConditionalAssignment
 
-   If non-zero, conditional boolean assignments at the end of an ``if/else
-   if`` chain will be transformed. Default is `0`.
+   If `true`, conditional boolean assignments at the end of an ``if/else
+   if`` chain will be transformed. Default is `false`.

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

 * ``Ul`` -> ``uL``
 * ``UL`` -> ``uL``
 * ``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
+   If this option is set to `true` (default is `true`), the check will not warn
    about literal suffixes inside macros.