[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

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

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

22

Unnecessary empty line.

26

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

s/checker/check/

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

53

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

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

73

Unnecessary empty string.

79

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

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

59

Please highlight 0 with `.

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

125

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

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

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

125

It exceeds 80 characters by an extra character...

[Eugene.Zelenko]

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

27

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

s/represents/specifying

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

20

s/not contain/not include the

21

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

A string specifying the unsigned type prefix.

23

A string specifying the signed type prefix.

27

A string specifying the type suffix.

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

20

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

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

Same suggestion here as above.

89

s/use use/use the

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

20

s/represents/specifying

25–26

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

s/on/on an

147

s/on/on an

152

s/on/on an

153

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

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

39

How about:

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

44

s/represents/specifying

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

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

48

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

53

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

s/represents maximal/specifying the maximum

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

53

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

s/represents/specifying

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

78

s/represents/specifying

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

26

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

s/represents/specifying

[hokein]

Address aaron's comments.

[hokein]

wow, thanks for many detailed comments.

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

21

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

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

53

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

[aaron.ballman]

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

21

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

s/bigger than/greater than

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

26

Should quote auto with backtics, I suppose.

[hokein]

Fix more comments.

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

21

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

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

All related documents have been updated now.

[aaron.ballman]

LGTM, thank you for the updated documentation!

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 represents which include-style is used, `llvm` or `google`. Default
+   is `llvm`.

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 contain "." prefix). "h,hh,hpp,hxx" by default. For
+   extension-less header files, using an empty string or leaving an empty string
+   between "," if there are other filename extensions.

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 represents unsigned type prefix. Default is `uint`.
+
+.. option:: SignedTypePrefix
+
+   A string represents singed type prefix. Default is `int`.
+
+.. option:: TypeSuffix
+
+   A string represents type suffix. Default is an empty string.

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

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
+
+   An unsigned integer represents the maximal number of lines of the namespace
+   that is not required closing commments. Default is `1U`.
+
+.. option:: SpacesBeforeComments
+
+   An unsigned integer represents spaces before comments. Default is `1U`.

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 contain "." prefix). "h,hh,hpp,hxx" by default. For
+   extension-less header files, using an empty string or leaving an empty string
+   between "," if there are other filename extensions.
+
+.. option:: UseHeaderFileExtension
+
+   When non-zero, the check will use use file extension to distinguish header
+   files. Default is `1`.

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 represents which include-style is used, `llvm` or `google`. Default
+   is `llvm`.
+
+.. option:: UseCERTSemantics
+
+   When non-zero, the check is also used to implement
+   `cert-oop11-cpp <cert-oop11-cpp.html>`_. Default is `0`.

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 expression like ``sizeof(CONSTANT)``.
+   Default is `1`.
+
+.. option:: WarnOnSizeOfThis
+
+   When non-zero, the check will warn on expression like ``sizeof(this)``.
+   Default is `1`.
+
+.. option:: WarnOnSizeOfCompareToConstant
+
+   When non-zero, the check will warn on expression like ``sizeof(epxr) <= k``
+   for a suspicious constant 'k'. Default is `1`.

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 the large length string. Default is
+   `1`.
+
+.. option::  LargeLengthThreshold
+
+   An integer represents the large length threshold. Default is `0x8000000`.

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 represents minimal size of a string literals array to be
+   considered by the check. Default is `5U`.
+
+.. option::  RatioThreshold
+
+   A string represents maximal threshold ratio of suspicious string literals to
+   be considered. Default is `.2`.
+
+.. option::  MaxConcatenatedTokens
+
+   An unsigned integer represents maximal number of concatenated tokens.
+   Default is `5U`.

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 represents the name of detecting string compare function. Default is
+   an empty string.

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 represents which include-style is used, `llvm` or `google`. Default
+   is `llvm`.

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 represents which include-style is used, `llvm` or `google`. Default
+   is `llvm`.

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, the check will warn on all auto copies. Default is `0`.

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

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 represents which include-style is used, `llvm` or `google`. Default
+   is `llvm`.

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