[clang-tidy docs] Add missing option docs.

[hokein]

Fix style.

[Eugene.Zelenko]

General comments:

• I think default is XYZ is better then XYZ by default.

• There are discrepancies: option representing and option represents.

I think will be good idea to involve native English speaker in review.

docs/clang-tidy/checks/google-readability-namespace-comments.rst

11 ↗

(On Diff #69343)

This documentation is redirect, so options description should be moved to llvm-namespace-comment.rst.

14 ↗

(On Diff #69343)

Unnecessary semicolon at the end. Same below.

docs/clang-tidy/checks/google-runtime-int.rst

27 ↗

(On Diff #69343)

Will empty string displayed? May be it should be expressed in words?

docs/clang-tidy/checks/misc-move-constructor-init.rst

22 ↗

(On Diff #69343)

Unnecessary empty line.

26 ↗

(On Diff #69343)

s/checker/check/. I think will be good idea to provide link to cert-oop11-cpp.rst.

docs/clang-tidy/checks/misc-suspicious-missing-comma.rst

49 ↗

(On Diff #69343)

s/checker/check/

docs/clang-tidy/checks/misc-suspicious-string-compare.rst

55 ↗

(On Diff #69343)

Will empty string displayed? May be it should be expressed in words?

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

73 ↗

(On Diff #69343)

Unnecessary empty string.

79 ↗

(On Diff #69343)

llvm should be on this line. See other similar descriptions.

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

57 ↗

(On Diff #69343)

Please highlight 0 with `.

docs/clang-tidy/checks/readability-implicit-bool-cast.rst

106 ↗

(On Diff #69343)

Looks like 0 by should fit 80 characters. Same below.

[hokein]

Address review comments:

• Use "Default is XYZ" instead of "XYZ by default".
• Replace empty string `` with empty word, passing docs compilation.

[hokein]

Remove extra blank line.

docs/clang-tidy/checks/google-readability-namespace-comments.rst

11 ↗

(On Diff #69343)

Oh, didn't notice it. Done.

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

79 ↗

(On Diff #69343)

If we put it into one line, the line's length will exceed 80 characters.

docs/clang-tidy/checks/readability-implicit-bool-cast.rst

106 ↗

(On Diff #69343)

It exceeds 80 characters by an extra character...

[Eugene.Zelenko]

docs/clang-tidy/checks/google-runtime-int.rst

27 ↗

(On Diff #69539)

I think empty string will be better. Same for other occurrences.

[hokein]

• Use empty string words.
• rebase to master.

[Eugene.Zelenko]

I don't have further comments, but as non-English speaker and mediocre writer, I would like see other people comments. May be @aaron.ballman could help if Alexander is busy?

[aaron.ballman]

Thank you for working on this!

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

24 ↗

(On Diff #69679)

s/represents/specifying

docs/clang-tidy/checks/google-build-namespaces.rst

20 ↗

(On Diff #69679)

s/not contain/not include the

21 ↗

(On Diff #69679)

How about:

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).

(assuming my example actually works.)

docs/clang-tidy/checks/google-runtime-int.rst

19 ↗

(On Diff #69679)

A string specifying the unsigned type prefix.

23 ↗

(On Diff #69679)

A string specifying the signed type prefix.

27 ↗

(On Diff #69679)

A string specifying the type suffix.

docs/clang-tidy/checks/llvm-namespace-comment.rst

20 ↗

(On Diff #69679)

How about:

Requires the closing brace of the namespace definition to be followed by a closing comment if the body of the namespace has more than `ShortNamespaceLines` lines of code. The value is an unsigned integer that defaults to `1U`.

25 ↗

(On Diff #69679)

How about:

An unsigned integer specifying the number of spaces before the comment closing a namespace definition.

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

83 ↗

(On Diff #69679)

Same suggestion here as above.

89 ↗

(On Diff #69679)

s/use use/use the

docs/clang-tidy/checks/misc-move-constructor-init.rst

20 ↗

(On Diff #69679)

s/represents/specifying

25–26 ↗

(On Diff #69679)

cert-oop11-cpp redirects to this file, so the link is a bit circular. Perhaps a better link is:

How about:

When non-zero, the check conforms to the behavior expected by the CERT secure coding recommendation `OOP11-CPP <https://www.securecoding.cert.org/confluence/display/cplusplus/OOP11-CPP.+Do+not+copy-initialize+members+or+base+classes+from+a+move+constructor>`_. Default is `0` for misc-move-constructor-init and `1` for cert-oop11-cpp

docs/clang-tidy/checks/misc-sizeof-expression.rst

142 ↗

(On Diff #69679)

s/on/on an

147 ↗

(On Diff #69679)

s/on/on an

152 ↗

(On Diff #69679)

s/on/on an

153 ↗

(On Diff #69679)

It would be good to describe what a suspicious constant actually is.

docs/clang-tidy/checks/misc-string-constructor.rst

39 ↗

(On Diff #69679)

How about:

.. warn on a string with a length greater than `LargeLengthThreshold`.

44 ↗

(On Diff #69679)

s/represents/specifying

Also, the value is wrong, the default is 0x800000 not 0x8000000.

docs/clang-tidy/checks/misc-suspicious-missing-comma.rst

48 ↗

(On Diff #69679)

s/represents minimal/specifying the minimum
s/literals array/literal

53 ↗

(On Diff #69679)

represents->specifying
maximal->maximum

Should actually state that the string represents a floating-point value between 0 and 1 (inclusive? exclusive?). Also, is it really a string? aka, does it need quotes, or is it okay to not use quotes (as the default suggests)?

58 ↗

(On Diff #69679)

s/represents maximal/specifying the maximum

docs/clang-tidy/checks/misc-suspicious-string-compare.rst

53 ↗

(On Diff #69679)

How about:

A string specifying the comma-separated names of string comparison functions.

We should also list the default string comparison functions.

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

160 ↗

(On Diff #69679)

s/represents/specifying

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

78 ↗

(On Diff #69679)

s/represents/specifying

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

26 ↗

(On Diff #69679)

What is an "auto copy"? I think this option just warns if auto is used as the type specifier in a range-based for loop, so perhaps this should just say "When non-zero, warns on any use of auto as the type of the range-based for loop variable."

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

62 ↗

(On Diff #69679)

s/represents/specifying

[hokein]

Address aaron's comments.

[hokein]

wow, thanks for many detailed comments.

docs/clang-tidy/checks/google-build-namespaces.rst

21 ↗

(On Diff #69679)

The trailing comma in h,hh,hpp,hxx, is not required here.

docs/clang-tidy/checks/misc-suspicious-missing-comma.rst

53 ↗

(On Diff #69679)

Yeah, this is a string in the check's implementation.

[aaron.ballman]

docs/clang-tidy/checks/google-build-namespaces.rst

21 ↗

(On Diff #69812)

I may be confused then -- does the string "h,hh,hpp,hxx" (no trailing comma) also wind up including header files without extensions? If so, we should document that. If not, would adding a trailing comma cause it to include header files without an extension? If so, that's what my example was trying to point out, but perhaps my phrasing needs clarifying.

docs/clang-tidy/checks/misc-sizeof-expression.rst

154 ↗

(On Diff #69812)

s/bigger than/greater than

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

26 ↗

(On Diff #69812)

Should quote auto with backtics, I suppose.

[hokein]

Fix more comments.

docs/clang-tidy/checks/google-build-namespaces.rst

21 ↗

(On Diff #69812)

Aha, sorry, I misunderstood your words here. Yeah, we should add trailing , for the non-extension headers.

[aaron.ballman]

docs/clang-tidy/checks/google-build-namespaces.rst

21 ↗

(On Diff #69838)

Okay, that make sense to me then. This change should also be applied to other places that have the extension list.

[hokein]

Update HeaderFileExtensions doc for all documents.

[hokein]

docs/clang-tidy/checks/google-build-namespaces.rst

21 ↗

(On Diff #69839)

All related documents have been updated now.

[aaron.ballman]

LGTM, thank you for the updated documentation!

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

 
 Options
 -------
 
 .. 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`.

clang-tools-extra/trunk/docs/clang-tidy/checks/google-build-namespaces.rst

 .. title:: clang-tidy - google-build-namespaces
 
 google-build-namespaces
 =======================
 
 `cert-dcl59-cpp` redirects here as an alias for this check.
 
 Finds anonymous namespaces in headers.
 
 https://google.github.io/styleguide/cppguide.html#Namespaces
 
 Corresponding cpplint.py check name: `build/namespaces`.
+
+Options
+-------
+
+.. 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).

clang-tools-extra/trunk/docs/clang-tidy/checks/google-global-names-in-headers.rst

 https://google.github.io/styleguide/cppguide.html#Namespaces.
 
 Options
 -------
 
 .. option:: HeaderFileExtensions
 
    A comma-separated list of filename extensions of header files (the filename
-   extensions should not contain "." prefix). "h" by default. For extension-less
-   header files, using an empty string or leaving an empty string between ","
-   if there are other filename extensions.
+   extensions should not contain "." prefix). Default is "h".
+   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).

clang-tools-extra/trunk/docs/clang-tidy/checks/google-runtime-int.rst

 .. title:: clang-tidy - google-runtime-int
 
 google-runtime-int
 ==================
 
 Finds uses of ``short``, ``long`` and ``long long`` and suggest replacing them
 with ``u?intXX(_t)?``.
 
 The corresponding style guide rule:
 https://google.github.io/styleguide/cppguide.html#Integer_Types.
 
 Correspondig cpplint.py check: `runtime/int`.
+
+Options
+-------
+
+.. option:: UnsignedTypePrefix
+
+   A string specifying the unsigned type prefix. Default is `uint`.
+
+.. option:: SignedTypePrefix
+
+   A string specifying the signed type prefix. Default is `int`.
+
+.. option:: TypeSuffix
+
+   A string specifying the type suffix. Default is an empty string.

clang-tools-extra/trunk/docs/clang-tidy/checks/list.rst

 .. title:: clang-tidy - Clang-Tidy Checks
 
 Clang-Tidy Checks
-=========================
+=================
 
 .. toctree::
    boost-use-to-string
    cert-dcl03-c (redirects to misc-static-assert) <cert-dcl03-c>
    cert-dcl50-cpp
    cert-dcl54-cpp (redirects to misc-new-delete-overloads) <cert-dcl54-cpp>
    cert-dcl59-cpp (redirects to google-build-namespaces) <cert-dcl59-cpp>
    cert-env33-c

clang-tools-extra/trunk/docs/clang-tidy/checks/llvm-header-guard.rst

 .. title:: clang-tidy - llvm-header-guard
 
 llvm-header-guard
 =================
 
 Finds and fixes header guards that do not adhere to LLVM style.
 
 Options
 -------
 
 .. option:: HeaderFileExtensions
 
-   A comma-separated list of filename extensions of header files (The filename
-   extension should not contain "." prefix). Default value is ",h,hh,hpp,hxx".
-   For extension-less header files, using an empty string or leaving an empty
-   string between "," if there are other filename extensions.
+   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).

clang-tools-extra/trunk/docs/clang-tidy/checks/llvm-namespace-comment.rst

 .. title:: clang-tidy - llvm-namespace-comment
 
 llvm-namespace-comment
 ======================
 
 `google-readability-namespace-comments` redirects here as an alias for this
 check.
 
 Checks that long namespaces have a closing comment.
 
 http://llvm.org/docs/CodingStandards.html#namespace-indentation
 
 https://google.github.io/styleguide/cppguide.html#Namespaces
+
+Options
+-------
+
+.. option:: ShortNamespaceLines
+
+   Requires the closing brace of the namespace definition to be followed by a
+   closing comment if the body of the namespace has more than
+   `ShortNamespaceLines` lines of code. The value is an unsigned integer that
+   defaults to `1U`.
+
+.. option:: SpacesBeforeComments
+
+   An unsigned integer specifying the number of spaces before the comment
+   closing a namespace definition. Default is `1U`.

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

.. code-block:: c++
    template <typename T>
    struct B {
      void f1();
    };
 
    // OK: member function definition of a class template is allowed.
    template <typename T>
    void B<T>::f1() {}
+
+Options
+-------
+
+.. 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`.

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

 .. title:: clang-tidy - misc-move-constructor-init
 
 misc-move-constructor-init
 ==========================
 
 "cert-oop11-cpp" redirects here as an alias for this check.
 
 The check flags user-defined move constructors that have a ctor-initializer
 initializing a member or base class through a copy constructor instead of a
 move constructor.
 
 It also flags constructor arguments that are passed by value, have a non-deleted
 move-constructor and are assigned to a class field by copy construction.
+
+Options
+-------
+
+.. option:: IncludeStyle
+
+   A string specifying which include-style is used, `llvm` or `google`. Default
+   is `llvm`.
+
+.. option:: UseCERTSemantics
+
+   When non-zero, the check conforms to the behavior expected by the CERT secure
+   coding recommendation
+   `OOP11-CPP <https://www.securecoding.cert.org/confluence/display/cplusplus/OOP11-CPP.+Do+not+copy-initialize+members+or+base+classes+from+a+move+constructor>`_.
+   Default is `0` for misc-move-constructor-init and `1` for cert-oop11-cpp.

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

 
 .. code-block:: c++
 
   #define INT_SZ sizeof(int)
   int buf[] = { 42 };
   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`.
+
+.. option:: WarnOnSizeOfThis
+
+   When non-zero, the check will warn on an expression like ``sizeof(this)``.
+   Default is `1`.
+
+.. option:: WarnOnSizeOfCompareToConstant
+
+   When non-zero, 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`.

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

 .. title:: clang-tidy - misc-string-constructor
 
 misc-string-constructor
 =======================
 
 Finds string constructors that are suspicious and probably errors.
 
 A common mistake is to swap parameters to the 'fill' string-constructor.
 
 Examples:
 
 .. code-block:: c++
 
-  std::string('x', 50) str; // should be std::string(50, 'x') 
+  std::string('x', 50) str; // should be std::string(50, 'x')
 
 Calling the string-literal constructor with a length bigger than the literal is
 suspicious and adds extra random characters to the string.
 
 Examples:
 
 .. code-block:: c++
 
   std::string("test", 200);   // Will include random characters after "test".
 
 Creating an empty string from constructors with parameters is considered
 suspicious. The programmer should use the empty constructor instead.
 
 Examples:
 
 .. code-block:: c++
 
   std::string("test", 0);   // Creation of an empty string.
+
+Options
+-------
+
+.. 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`.

clang-tools-extra/trunk/docs/clang-tidy/checks/misc-suspicious-missing-comma.rst

 
 .. code-block:: c++
 
   const char* SupportedFormat[] = {
     "Error %s",
     "Code " PRIu64,   // May warn here.
     "Warning %s",
   };
+
+Options
+-------
+
+.. option::  SizeThreshold
+
+   An unsigned integer specifying the minimum size of a string literal to be
+   considered by the check. Default is `5U`.
+
+.. option::  RatioThreshold
+
+   A string specifying the maximum threshold ratio [0, 1.0] of suspicious string
+   literals to be considered. Default is `".2"`.
+
+.. option::  MaxConcatenatedTokens
+
+   An unsigned integer specifying the maximum number of concatenated tokens.
+   Default is `5U`.

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

 
 Additionally, the check warns if the results value is implicitly cast to a
 *suspicious* non-integer type. It's happening when the returned value is used in
 a wrong context.
 
 .. 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.
+
+.. option:: WarnOnLogicalNotComparison
+
+   When non-zero, the check will warn on logical not comparison. `0` 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/trunk/docs/clang-tidy/checks/modernize-pass-by-value.rst

 
 .. _Clang Compiler User’s Manual - Microsoft extensions: http://clang.llvm.org/docs/UsersManual.html#microsoft-extensions
 
 .. seealso::
 
   For more information about the pass-by-value idiom, read: `Want Speed? Pass by Value`_.
 
   .. _Want Speed? Pass by Value: http://cpp-next.com/archive/2009/08/want-speed-pass-by-value/
+
+Options
+-------
+
+.. option:: IncludeStyle
+
+   A string specifying which include-style is used, `llvm` or `google`. Default
+   is `llvm`.

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

.. code-block:: c++
 
      template <typename X>
      void f() {
          std::auto_ptr<X> p;
      }
 
      // only 'f<int>()' (or similar) will trigger the replacement.
 
+Options
+-------
+
+.. option:: IncludeStyle
+
+   A string specifying which include-style is used, `llvm` or `google`. Default
+   is `llvm`.

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

 
 To ensure that it is safe to replace the copy with a const reference the
 following heuristic is employed:
 
 1. The loop variable is const qualified.
 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`.

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

 .. title:: clang-tidy - performance-inefficient-string-concatenation
 
 performance-inefficient-string-concatenation
 ============================================
 
 This check warns about the performance overhead arising from concatenating
 strings using the ``operator+``, for instance:
-    
 .. code-block:: c++
 
     std::string a("Foo"), b("Bar");
     a = a + b;
 
 Instead of this structure you should use ``operator+=`` or ``std::string``'s
 (``std::basic_string``) class member function ``append()``. For instance:
-   
 .. code-block:: c++
 
    std::string a("Foo"), b("Baz");
    for (int i = 0; i < 20000; ++i) {
        a = a + "Bar" + b;
    }
 
 Could be rewritten in a greatly more efficient way like:
 
 .. code-block:: c++
 
    std::string a("Foo"), b("Baz");
    for (int i = 0; i < 20000; ++i) {
        a.append("Bar").append(b);
-   } 
+   }
 
 And this can be rewritten too:
 
 .. code-block:: c++
 
    void f(const std::string&) {}
    std::string a("Foo"), b("Baz");
    void g() {
        f(a + "Bar" + b);
    }
 
 In a slightly more efficient way like:
 
 .. code-block:: c++
 
    void f(const std::string&) {}
    std::string a("Foo"), b("Baz");
    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`.

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

 
 .. code-block:: c++
 
   #include <utility>
 
   void setValue(string Value) {
     Field = std::move(Value);
   }
+
+Options
+-------
+
+.. option:: IncludeStyle
+
+   A string specifying which include-style is used, `llvm` or `google`. Default
+   is `llvm`.

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

 Some additional accommodations are made for pre-C++11 dialects:
 
 - ``false`` literal cast to pointer is detected,
 
 - instead of ``nullptr`` literal, ``0`` is proposed as replacement.
 
 Occurrences of implicit casts inside macros and template instantiations are
 deliberately ignored, as it is not clear how to deal with such cases.
+
+Options
+-------
+
+.. option::  AllowConditionalIntegerCasts
+
+   When non-zero, the check will allow conditional integer casts. Default is
+   `0`.
+
+.. option::  AllowConditionalPointerCasts
+
+   When non-zero, the check will allow conditional pointer casts. Default is `0`.