[clang-tidy] Tidy up spelling, grammar, and inconsistencies in documentation (NFC)

Differential Revision: https://reviews.llvm.org/D112356

Author: salman-javed-nz

clang-tools-extra/docs/clang-tidy/Contributing.rst

@@ -131,8 +131,8 @@ are located in subdirectories of `clang-tidy/
 <https://github.com/llvm/llvm-project/tree/main/clang-tools-extra/clang-tidy/>`_
 and contain checks targeting a certain aspect of code quality (performance,
 readability, etc.), certain coding style or standard (Google, LLVM, CERT, etc.)
-or a widely used API (e.g. MPI). Their names are same as user-facing check
-groups names described :ref:`above <checks-groups-table>`.
+or a widely used API (e.g. MPI). Their names are the same as the user-facing
+check group names described :ref:`above <checks-groups-table>`.
 
 After choosing the module and the name for the check, run the
 ``clang-tidy/add_new_check.py`` script to create the skeleton of the check and
@@ -441,8 +441,8 @@ warnings and errors. The script provides multiple configuration flags.
 * To restrict the files examined you can provide one or more regex arguments
   that the file names are matched against.
   ``run-clang-tidy.py clang-tidy/.*Check\.cpp`` will only analyze clang-tidy
-  checks. It may also be necessary to restrict the header files warnings are
-  displayed from using the ``-header-filter`` flag. It has the same behavior
+  checks. It may also be necessary to restrict the header files that warnings
+  are displayed from using the ``-header-filter`` flag. It has the same behavior
   as the corresponding :program:`clang-tidy` flag.
 
 * To apply suggested fixes ``-fix`` can be passed as an argument. This gathers
@@ -475,7 +475,7 @@ It can also store that data as JSON files for further processing. Example output
 
 .. code-block:: console
 
-  $ clang-tidy -enable-check-profile -store-check-profile=.  -checks=-*,readability-function-size source.cpp
+  $ clang-tidy -enable-check-profile -store-check-profile=. -checks=-*,readability-function-size source.cpp
   $ # Note that there won't be timings table printed to the console.
   $ ls /tmp/out/
   20180516161318717446360-source.cpp.json

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

@@ -27,5 +27,5 @@ Examples:
 
 
 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,
+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.

clang-tools-extra/docs/clang-tidy/checks/abseil-no-internal-dependencies.rst

@@ -5,7 +5,7 @@ abseil-no-internal-dependencies
 
 Warns if code using Abseil depends on internal details. If something is in a
 namespace that includes the word "internal", code is not allowed to depend upon
-it because it’s an implementation detail. They cannot friend it, include it,
+it because it's an implementation detail. They cannot friend it, include it,
 you mention it or refer to it in any way. Doing so violates Abseil's
 compatibility guidelines and may result in breakage. See
 https://abseil.io/about/compatibility for more information.

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

@@ -10,7 +10,7 @@ This improves readability and reduces the likelihood of accidentally mixing
 ``find()`` and ``npos`` from different string-like types.
 
 By default, "string-like types" includes ``::std::basic_string``,
-``::std::basic_string_view``, and ``::absl::string_view``.  See the
+``::std::basic_string_view``, and ``::absl::string_view``. See the
 StringLikeClasses option to change this.
 
 .. code-block:: c++

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

@@ -4,7 +4,7 @@ android-cloexec-open
 ====================
 
 A common source of security bugs is code that opens a file without using the
-``O_CLOEXEC`` flag.  Without that flag, an opened sensitive file would remain
+``O_CLOEXEC`` flag. Without that flag, an opened sensitive file would remain
 open across a fork+exec to a lower-privileged SELinux domain, leaking that
 sensitive data. Open-like functions including ``open()``, ``openat()``, and
 ``open64()`` should include ``O_CLOEXEC`` in their flags argument.

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

@@ -3,7 +3,7 @@
 android-cloexec-pipe2
 =====================
 
-This checks ensures that pipe2() is called with the O_CLOEXEC flag. The check also
+This check ensures that pipe2() is called with the O_CLOEXEC flag. The check also
 adds the O_CLOEXEC flag that marks the file descriptor to be closed in child processes.
 Without this flag a sensitive file descriptor can be leaked to a child process,
 potentially into a lower-privileged SELinux domain.

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

@@ -8,7 +8,7 @@ This check finds conversion from integer type like ``int`` to ``std::string`` or
 ``std::to_string`` and ``std::to_wstring``.
 
 It doesn't replace conversion from floating points despite the ``to_string``
-overloads, because it would change the behaviour.
+overloads, because it would change the behavior.
 
 
 .. code-block:: c++

clang-tools-extra/docs/clang-tidy/checks/bugprone-branch-clone.rst

@@ -87,4 +87,4 @@ Unlike if statements, the check does not detect chains of conditional
 operators.
 
 Note: This check also reports situations where branches become identical only
-after preprocession.
+after preprocessing.

clang-tools-extra/docs/clang-tidy/checks/bugprone-easily-swappable-parameters.rst

@@ -116,7 +116,7 @@ noisiness.
     The value is a `;`-separated list of names.
     To ignore unnamed parameters, add `""` to the list verbatim (not the
     empty string, but the two quotes, potentially escaped!).
-    **This options is case-sensitive!**
+    **This option is case-sensitive!**
 
     By default, the following parameter names, and their Uppercase-initial
     variants are ignored:
@@ -154,7 +154,7 @@ noisiness.
       ``a < b``.
     * The parameters are further passed to the same function to the same
       parameter of that function, of the same overload.
-      E.g. ``f(a, 1)`` and ``f(b, 2)`` to some ``f(T, int)``.
+      e.g. ``f(a, 1)`` and ``f(b, 2)`` to some ``f(T, int)``.
 
       .. note::
 
@@ -202,7 +202,7 @@ an argument list, and C++ template instantiations.
 Most of these cases, which are otherwise swappable from a caller's standpoint,
 have no way of getting "fixed" at the definition point.
 In the case of C++ templates, only primary template definitions and explicit
-specialisations are matched and analysed.
+specializations are matched and analyzed.
 
 None of the following cases produce a diagnostic:
 
@@ -241,7 +241,7 @@ not diagnosed.
     void exact(typename Vector<T>::element_type A,
                typename Vector<T>::element_type B) { /* ... */ }
 
-    // Skipped: The two parameters are both 'T' but we can not prove this
+    // Skipped: The two parameters are both 'T' but we cannot prove this
     // without actually instantiating.
     template <typename T>
     void falseNegative(T A, typename Vector<T>::element_type B) { /* ... */ }

clang-tools-extra/docs/clang-tidy/checks/bugprone-implicit-widening-of-multiplication-result.rst

@@ -8,7 +8,7 @@ widened, and suggests (with fix-it) to either silence the code by making
 widening explicit, or to perform the multiplication in a wider type,
 to avoid the widening afterwards.
 
-This is mainly useful when operating on a very large buffers.
+This is mainly useful when operating on very large buffers.
 For example, consider:
 
 .. code-block:: c++
@@ -22,7 +22,7 @@ For example, consider:
     }
   }
 
-This is fine in general, but iff ``width * height`` overflows,
+This is fine in general, but if ``width * height`` overflows,
 you end up wrapping back to the beginning of ``base``
 instead of processing the entire requested buffer.
 

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

@@ -4,10 +4,10 @@ bugprone-macro-parentheses
 ==========================
 
 
-Finds macros that can have unexpected behaviour due to missing parentheses.
+Finds macros that can have unexpected behavior due to missing parentheses.
 
 Macros are expanded by the preprocessor as-is. As a result, there can be
-unexpected behaviour; operators may be evaluated in unexpected order and
+unexpected behavior; operators may be evaluated in unexpected order and
 unary operators may become binary operators, etc.
 
 When the replacement list has an expression, it is recommended to surround

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

@@ -9,7 +9,7 @@ instead of the result and the value is used as an argument to a memory
 allocation function (``malloc()``, ``calloc()``, ``realloc()``, ``alloca()``) or
 the ``new[]`` operator in `C++`. The check detects error cases even if one of
 these functions (except the ``new[]`` operator) is called by a constant function
-pointer.  Cases where ``1`` is added both to the parameter and the result of the
+pointer. Cases where ``1`` is added both to the parameter and the result of the
 ``strlen()``-like function are ignored, as are cases where the whole addition is
 surrounded by extra parentheses.
 

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

@@ -6,7 +6,7 @@ bugprone-not-null-terminated-result
 Finds function calls where it is possible to cause a not null-terminated result.
 Usually the proper length of a string is ``strlen(src) + 1`` or equal length of
 this expression, because the null terminator needs an extra space. Without the
-null terminator it can result in undefined behaviour when the string is read.
+null terminator it can result in undefined behavior when the string is read.
 
 The following and their respective ``wchar_t`` based functions are checked:
 
@@ -61,7 +61,7 @@ Rewrite based on the destination array
   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
+- If the new function is could be safe version and C++ files are analyzed and
   the destination array is plain ``char``/``wchar_t`` without ``un/signed`` then
   the length of the destination array can be omitted.
 

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

@@ -185,5 +185,5 @@ Options
 .. option:: WarnOnSizeOfCompareToConstant
 
    When `true`, the check will warn on an expression like
-   ``sizeof(epxr) <= k`` for a suspicious constant `k` while `k` is `0` or
+   ``sizeof(expr) <= k`` for a suspicious constant `k` while `k` is `0` or
    greater than `0x8000`. Default is `true`.

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

@@ -14,7 +14,7 @@ Checks for calls with implicit comparator and proposed to explicitly add it.
     if (!strcmp(...))      // Won't warn
     if (strcmp(...) != 0)  // Won't warn
 
-Checks that compare function results (i,e, ``strcmp``) are compared to valid
+Checks that compare function results (i.e., ``strcmp``) are compared to valid
 constant. The resulting value is
 
 .. code::

clang-tools-extra/docs/clang-tidy/checks/bugprone-too-small-loop-variable.rst

@@ -25,7 +25,7 @@ In a real use case size means a container's size which depends on the user input
     for (short i = 0; i < items.size(); ++i) {}
   }
 
-This algorithm works for small amount of objects, but will lead to freeze for a
+This algorithm works for a small amount of objects, but will lead to freeze for
 a larger user input.
 
 .. option:: MagnitudeBitsUpperLimit

clang-tools-extra/docs/clang-tidy/checks/bugprone-unhandled-exception-at-new.rst

@@ -21,5 +21,5 @@ is allowed to propagate out of the function (exception handler is checked for
 types ``std::bad_alloc``, ``std::exception``, and catch-all handler).
 The check assumes that any user-defined ``operator new`` is either
 ``noexcept`` or may throw an exception of type ``std::bad_alloc`` (or derived
-from it). Other exception types or exceptions occurring in the objects's
+from it). Other exception types or exceptions occurring in the object's
 constructor are not taken into account.

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

@@ -3,7 +3,7 @@
 bugprone-virtual-near-miss
 ==========================
 
-Warn if a function is a near miss (ie. the name is very similar and the function
+Warn if a function is a near miss (i.e. the name is very similar and the function
 signature is the same) to a virtual function from a base class.
 
 Example:

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

@@ -21,4 +21,4 @@ This check corresponds to the CERT C++ Coding Standard recommendation
 DCL21-CPP. Overloaded postfix increment and decrement operators should return a
 const object. 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.

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

@@ -12,4 +12,4 @@ for more information.
 This check corresponds to the CERT C++ Coding Standard recommendation
 ERR09-CPP. Throw anonymous temporaries. 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.
+of this check requires an account on their wiki to view.

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

@@ -13,4 +13,4 @@ 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.

clang-tools-extra/docs/clang-tidy/checks/concurrency-mt-unsafe.rst

@@ -12,7 +12,7 @@ Note that using some thread-unsafe functions may be still valid in
 concurrent programming if only a single thread is used (e.g. setenv(3)),
 however, some functions may track a state in global variables which
 would be clobbered by subsequent (non-parallel, but concurrent) calls to
-a related function. E.g. the following code suffers from unprotected
+a related function. e.g. the following code suffers from unprotected
 accesses to a global state:
 
 .. code-block:: c++

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

@@ -4,7 +4,7 @@ cppcoreguidelines-init-variables
 ================================
 
 Checks whether there are local variables that are declared without an initial
-value. These may lead to unexpected behaviour if there is a code path that reads
+value. These may lead to unexpected behavior if there is a code path that reads
 the variable before assigning to it.
 
 Only integers, booleans, floats, doubles and pointers are checked. The fix

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

@@ -84,7 +84,7 @@ the range [-2^31, 2^31-1].
 
 You may have encountered messages like "narrowing conversion from 'unsigned int'
 to signed type 'int' is implementation-defined".
-The C/C++ standard does not mandate two’s complement for signed integers, and so
+The C/C++ standard does not mandate two's complement for signed integers, and so
 the compiler is free to define what the semantics are for converting an unsigned
-integer to signed integer. Clang's implementation uses the two’s complement
+integer to signed integer. Clang's implementation uses the two's complement
 format.

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

@@ -51,7 +51,7 @@ Options
 .. option:: AllowMissingMoveFunctionsWhenCopyIsDeleted
 
    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
+   operations but don't define move operations. This flag 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:
 

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-virtual-class-destructor.rst

@@ -5,7 +5,7 @@ cppcoreguidelines-virtual-class-destructor
 
 Finds virtual classes whose destructor is neither public and virtual
 nor protected and non-virtual. A virtual class's destructor should be specified
-in one of these ways to prevent undefined behaviour.
+in one of these ways to prevent undefined behavior.
 
 This check implements
 `C.35 <http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rc-dtor-virtual>`_

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

@@ -68,7 +68,7 @@ Degenerated ``switch`` statements without any labels are caught as well.
   int i = 42;
   switch(i) {
     case 1: // do something here
-    default: // do somethe else here
+    default: // do something else here
   }
 
   // Should rather be the following:

clang-tools-extra/docs/clang-tidy/checks/hicpp-signed-bitwise.rst

@@ -4,7 +4,7 @@ hicpp-signed-bitwise
 ====================
 
 Finds uses of bitwise operations on signed integer types, which may lead to 
-undefined or implementation defined behaviour.
+undefined or implementation defined behavior.
 
 The according rule is defined in the `High Integrity C++ Standard, Section 5.6.1 <http://www.codingstandard.com/section/5-6-shift-operators/>`_.
 

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

@@ -5,7 +5,7 @@ misc-static-assert
 
 `cert-dcl03-c` redirects here as an alias for this check.
 
-Replaces ``assert()`` with ``static_assert()`` if the condition is evaluatable
+Replaces ``assert()`` with ``static_assert()`` if the condition is evaluable
 at compile time.
 
 The condition of ``static_assert()`` is evaluated at compile time which is

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

@@ -14,15 +14,16 @@ the CERT C++ Coding Standard rule `ERR61-CPP. Catch exceptions by lvalue referen
 
 Exceptions:
   * Throwing string literals will not be flagged despite being a pointer. They
-    are not susceptible to slicing and the usage of string literals is idomatic.
+    are not susceptible to slicing and the usage of string literals is
+    idiomatic.
   * Catching character pointers (``char``, ``wchar_t``, unicode character types)
     will not be flagged to allow catching sting literals.
   * Moved named values will not be flagged as not throwing an anonymous
     temporary. In this case we can be sure that the user knows that the object
     can't be accessed outside catch blocks handling the error.
   * Throwing function parameters will not be flagged as not throwing an
     anonymous temporary. This allows helper functions for throwing.
-  * Re-throwing caught exception variables will not be flragged as not throwing
+  * Re-throwing caught exception variables will not be flagged as not throwing
     an anonymous temporary. Although this can usually be done by just writing
     ``throw;`` it happens often enough in real code.
 

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

@@ -72,7 +72,7 @@ simply ignored. Without ``PermissiveParameterList``, this would be transformed i
     return ignore_args(3, 3);
   }
 
-which will *not* compile, since the lambda does not contain an ``operator()`` that
+which will *not* compile, since the lambda does not contain an ``operator()``
 that accepts 2 arguments. With permissive parameter list, it instead generates
 
 .. code-block:: c++

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

@@ -56,5 +56,5 @@ such headers between C code, and C++ code.
   }
 
 Similarly, the ``main()`` function is ignored. Its second and third parameters
-can be either ``char* argv[]`` or ``char** argv``, but can not be
+can be either ``char* argv[]`` or ``char** argv``, but cannot be
 ``std::array<>``.

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

@@ -138,7 +138,7 @@ lives.
 
    Specify the function used to reverse an iterator pair, the function should 
    accept a class with ``rbegin`` and ``rend`` methods and return a 
-   class with ``begin`` and ``end`` methods methods that call the ``rbegin`` and
+   class with ``begin`` and ``end`` methods that call the ``rbegin`` and
    ``rend`` methods respectively. Common examples are ``ranges::reverse_view``
    and ``llvm::reverse``.
    Default value is an empty string.
@@ -165,7 +165,7 @@ Limitations
 
 There are certain situations where the tool may erroneously perform
 transformations that remove information and change semantics. Users of the tool
-should be aware of the behaviour and limitations of the check outlined by
+should be aware of the behavior and limitations of the check outlined by
 the cases below.
 
 Comments inside loop headers
@@ -300,7 +300,7 @@ OpenMP
 ^^^^^^
 
 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
+not be used on code with a compatibility requirement 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.
 

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

@@ -124,7 +124,7 @@ When delayed template parsing is enabled, constructors part of templated
 contexts; templated constructors, constructors in class templates, constructors
 of inner classes of template classes, etc., are not transformed. Delayed
 template parsing is enabled by default on Windows as a Microsoft extension:
-`Clang Compiler User’s Manual - Microsoft extensions`_.
+`Clang Compiler User's Manual - Microsoft extensions`_.
 
 Delayed template parsing can be enabled using the `-fdelayed-template-parsing`
 flag and disabled using `-fno-delayed-template-parsing`.
@@ -144,7 +144,7 @@ Example:
  +  C(std::string S) : S(std::move(S)) {}
    };
 
-.. _Clang Compiler User’s Manual - Microsoft extensions: https://clang.llvm.org/docs/UsersManual.html#microsoft-extensions
+.. _Clang Compiler User's Manual - Microsoft extensions: https://clang.llvm.org/docs/UsersManual.html#microsoft-extensions
 
 .. seealso::