[llvm-branch-commits] [clang-tools-extra] [clang-tidy][docs] Rewrite readability check docs to Markdown [4/5] (PR #221641)

[Baranov Victor via llvm-branch-commits]

================
@@ -1,125 +1,119 @@
-.. title:: clang-tidy - readability-simplify-boolean-expr
+```{title} clang-tidy - readability-simplify-boolean-expr
+```
 
-readability-simplify-boolean-expr
-=================================
+# readability-simplify-boolean-expr
 
 Looks for boolean expressions involving boolean constants and simplifies
-them to use the appropriate boolean expression directly.  Simplifies
+them to use the appropriate boolean expression directly. Simplifies
 boolean expressions by application of DeMorgan's Theorem.
 
 Examples:
 
-===========================================  ================
-Initial expression                           Result
--------------------------------------------  ----------------
-``if (b == true)``                             ``if (b)``
-``if (b == false)``                            ``if (!b)``
-``if (b && true)``                             ``if (b)``
-``if (b && false)``                            ``if (false)``
-``if (b || true)``                             ``if (true)``
-``if (b || false)``                            ``if (b)``
-``e ? true : false``                           ``e``
-``e ? false : true``                           ``!e``
-``if (true) t(); else f();``                   ``t();``
-``if (false) t(); else f();``                  ``f();``
-``if (e) return true; else return false;``     ``return e;``
-``if (e) return false; else return true;``     ``return !e;``
-``if (e) b = true; else b = false;``           ``b = e;``
-``if (e) b = false; else b = true;``           ``b = !e;``
-``if (e) return true; return false;``          ``return e;``
-``if (e) return false; return true;``          ``return !e;``
-``!(!a || b)``                                 ``a && !b``
-``!(a || !b)``                                 ``!a && b``
-``!(!a || !b)``                                ``a && b``
-``!(!a && b)``                                 ``a || !b``
-``!(a && !b)``                                 ``!a || b``
-``!(!a && !b)``                                ``a || b``
-===========================================  ================
-
-The resulting expression ``e`` is modified as follows:
-  1. Unnecessary parentheses around the expression are removed.
-  2. Negated applications of ``!`` are eliminated.
-  3. Negated applications of comparison operators are changed to use the
-     opposite condition.
-  4. Implicit conversions of pointers, including pointers to members, to
-     ``bool`` are replaced with explicit comparisons to ``nullptr`` in C++11
-     or ``NULL`` in C++98/03.
-  5. Implicit casts to ``bool`` are replaced with explicit casts to ``bool``.
-  6. Object expressions with ``explicit operator bool`` conversion operators
-     are replaced with explicit casts to ``bool``.
-  7. Implicit conversions of integral types to ``bool`` are replaced with
-     explicit comparisons to ``0``.
+| Initial expression                         | Result        |
+| ------------------------------------------ | ------------- |
+| `if (b == true)`                           | `if (b)`      |
+| `if (b == false)`                          | `if (!b)`     |
+| `if (b && true)`                           | `if (b)`      |
+| `if (b && false)`                          | `if (false)`  |
+| `if (b \|\| true)`                         | `if (true)`   |
+| `if (b \|\| false)`                        | `if (b)`      |
+| `e ? true : false`                         | `e`           |
+| `e ? false : true`                         | `!e`          |
+| `if (true) t(); else f();`                 | `t();`        |
+| `if (false) t(); else f();`                | `f();`        |
+| `if (e) return true; else return false;`   | `return e;`   |
+| `if (e) return false; else return true;`   | `return !e;`  |
+| `if (e) b = true; else b = false;`         | `b = e;`      |
+| `if (e) b = false; else b = true;`         | `b = !e;`     |
+| `if (e) return true; return false;`        | `return e;`   |
+| `if (e) return false; return true;`        | `return !e;`  |
+| `!(!a \|\| b)`                             | `a && !b`     |
+| `!(a \|\| !b)`                             | `!a && b`     |
+| `!(!a \|\| !b)`                            | `a && b`      |
+| `!(!a && b)`                               | `a \|\| !b`  |
+| `!(a && !b)`                               | `!a \|\| b`  |
+| `!(!a && !b)`                              | `a \|\| b`   |
+
+The resulting expression `e` is modified as follows:
+
+1. Unnecessary parentheses around the expression are removed.
+2. Negated applications of `!` are eliminated.
+3. Negated applications of comparison operators are changed to use the
+   opposite condition.
+4. Implicit conversions of pointers, including pointers to members, to
+   `bool` are replaced with explicit comparisons to `nullptr` in C++11
+   or `NULL` in C++98/03.
+5. Implicit casts to `bool` are replaced with explicit casts to `bool`.
+6. Object expressions with `explicit operator bool` conversion operators
+   are replaced with explicit casts to `bool`.
+7. Implicit conversions of integral types to `bool` are replaced with
+   explicit comparisons to `0`.
 
 Examples:
-  1. The ternary assignment ``bool b = (i < 0) ? true : false;`` has redundant
-     parentheses and becomes ``bool b = i < 0;``.
 
-  2. The conditional return ``if (!b) return false; return true;`` has an
-     implied double negation and becomes ``return b;``.
-
-  3. The conditional return ``if (i < 0) return false; return true;`` becomes
-     ``return i >= 0;``.
-
-     The conditional return ``if (i != 0) return false; return true;`` becomes
-     ``return i == 0;``.
-
-  4. The conditional return ``if (p) return true; return false;`` has an
-     implicit conversion of a pointer to ``bool`` and becomes
-     ``return p != nullptr;``.
-
-     The ternary assignment ``bool b = (i & 1) ? true : false;`` has an
-     implicit conversion of ``i & 1`` to ``bool`` and becomes
-     ``bool b = (i & 1) != 0;``.
-
-  5. The conditional return ``if (i & 1) return true; else return false;`` has
-     an implicit conversion of an integer quantity ``i & 1`` to ``bool`` and
-     becomes ``return (i & 1) != 0;``
-
-  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:: IgnoreMacros
-
-   If `true`, ignore boolean expressions originating from expanded macros.
-   Default is `false`.
-
-.. option:: ChainedConditionalReturn
-
-   If `true`, conditional boolean return statements at the end of an
-   ``if/else if`` chain will be transformed. Default is `false`.
-
-.. option:: ChainedConditionalAssignment
-
-   If `true`, conditional boolean assignments at the end of an ``if/else
-   if`` chain will be transformed. Default is `false`.
-
-.. option:: SimplifyDeMorgan
-
-   If `true`, DeMorgan's Theorem will be applied to simplify negated
-   conjunctions and disjunctions.  Default is `true`.
-
-.. option:: SimplifyDeMorganRelaxed
-
-   If `true`, :option:`SimplifyDeMorgan` will also transform negated
-   conjunctions and disjunctions where there is no negation on either operand.
-   This option has no effect if :option:`SimplifyDeMorgan` is `false`.
-   Default is `false`.
-
-   When Enabled:
-
-   .. code-block::
-
-      bool X = !(A && B)
-      bool Y = !(A || B)
-
-   Would be transformed to:
-
-   .. code-block::
-
-      bool X = !A || !B
-      bool Y = !A && !B
+1. The ternary assignment `bool b = (i < 0) ? true : false;` has redundant
+   parentheses and becomes `bool b = i < 0;`.
+2. The conditional return `if (!b) return false; return true;` has an
+   implied double negation and becomes `return b;`.
+3. The conditional return `if (i < 0) return false; return true;` becomes
+   `return i >= 0;`.
+
+   The conditional return `if (i != 0) return false; return true;` becomes
+   `return i == 0;`.
+4. The conditional return `if (p) return true; return false;` has an
+   implicit conversion of a pointer to `bool` and becomes
+   `return p != nullptr;`.
+
+   The ternary assignment `bool b = (i & 1) ? true : false;` has an
+   implicit conversion of `i & 1` to `bool` and becomes
+   `bool b = (i & 1) != 0;`.
+5. The conditional return `if (i & 1) return true; else return false;` has
+   an implicit conversion of an integer quantity `i & 1` to `bool` and
+   becomes `return (i & 1) != 0;`
+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} IgnoreMacros
+If `true`, ignore boolean expressions originating from expanded macros.
+Default is `false`.
+```
+
+```{option} ChainedConditionalReturn
+If `true`, conditional boolean return statements at the end of an
+`if/else if` chain will be transformed. Default is `false`.
+```
+
+```{option} ChainedConditionalAssignment
+If `true`, conditional boolean assignments at the end of an `if/else
+if` chain will be transformed. Default is `false`.
+```
+
+```{option} SimplifyDeMorgan
+If `true`, DeMorgan's Theorem will be applied to simplify negated
+conjunctions and disjunctions. Default is `true`.
+```
+
+````{option} SimplifyDeMorganRelaxed
+If `true`, {option}`SimplifyDeMorgan` will also transform negated
+conjunctions and disjunctions where there is no negation on either operand.
+This option has no effect if {option}`SimplifyDeMorgan` is `false`.
+Default is `false`.
+
+When enabled:
+
+```
----------------
vbvictor wrote:

Can we add C++ tag here

https://github.com/llvm/llvm-project/pull/221641