[llvm-branch-commits] [clang-tools-extra] [clang-tidy][docs] Rewrite readability check docs to Markdown [2/5] (PR #221529)
Zeyi Xu via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Sat Sep 5 23:20:08 PDT 2026
https://github.com/zeyi2 created https://github.com/llvm/llvm-project/pull/221529
<sub>Stack created with <a href="https://github.com/github/gh-stack">GitHub Stacks CLI</a> • <a href="https://gh.io/stacks-feedback">Give Feedback 💬</a></sub>
>From 2be71ec61bed9f7e48aadf2b8335f6be4358265f Mon Sep 17 00:00:00 2001
From: Zeyi Xu <mitchell.xu2 at gmail.com>
Date: Sun, 6 Sep 2026 14:17:16 +0800
Subject: [PATCH] [clang-tidy][docs] Rewrite readability check docs to Markdown
[2/5]
---
.../function-cognitive-complexity.md | 218 +-
.../checks/readability/function-size.md | 97 +-
.../checks/readability/identifier-length.md | 275 +-
.../checks/readability/identifier-naming.md | 5003 ++++++++---------
.../readability/implicit-bool-conversion.md | 190 +-
...inconsistent-declaration-parameter-name.md | 64 +-
.../readability/inconsistent-ifelse-braces.md | 62 +-
.../checks/readability/isolate-declaration.md | 139 +-
.../checks/readability/magic-numbers.md | 192 +-
.../readability/make-member-function-const.md | 84 +-
10 files changed, 3143 insertions(+), 3181 deletions(-)
diff --git a/clang-tools-extra/docs/clang-tidy/checks/readability/function-cognitive-complexity.md b/clang-tools-extra/docs/clang-tidy/checks/readability/function-cognitive-complexity.md
index 430006e68ceb4..9623ce977eabc 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/readability/function-cognitive-complexity.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/readability/function-cognitive-complexity.md
@@ -1,166 +1,168 @@
-.. title:: clang-tidy - readability-function-cognitive-complexity
+```{title} clang-tidy - readability-function-cognitive-complexity
+```
-readability-function-cognitive-complexity
-=========================================
+# readability-function-cognitive-complexity
Checks function Cognitive Complexity metric.
-The metric is implemented as per the `COGNITIVE COMPLEXITY by SonarSource
-<https://www.sonarsource.com/docs/CognitiveComplexity.pdf>`_ specification
+The metric is implemented as per the [COGNITIVE COMPLEXITY by SonarSource](https://www.sonarsource.com/docs/CognitiveComplexity.pdf) specification
version 1.2 (19 April 2017).
-Options
--------
+## Options
-.. option:: Threshold
+```{option} Threshold
+Flag functions with Cognitive Complexity exceeding this number.
+Default is `25`.
+```
- Flag functions with Cognitive Complexity exceeding this number.
- The default is `25`.
+```{option} DescribeBasicIncrements
+When `true`, for each function exceeding the complexity threshold
+the check will issue additional diagnostics on every piece of code (loop,
+`if` statement, etc.) which contributes to that complexity. See also the
+examples below. Default is `true`.
+```
-.. option:: DescribeBasicIncrements
+```{option} IgnoreMacros
+When `true`, the check will ignore code inside macros. Note that
+any macro arguments are ignored, even if they should count to the complexity.
+As this might change in the future, this option isn't guaranteed to be
+forward-compatible. Default is `false`.
+```
- If set to `true`, then for each function exceeding the complexity threshold
- the check will issue additional diagnostics on every piece of code (loop,
- `if` statement, etc.) which contributes to that complexity. See also the
- examples below. Default is `true`.
-
-.. option:: IgnoreMacros
-
- If set to `true`, the check will ignore code inside macros. Note, that also
- any macro arguments are ignored, even if they should count to the complexity.
- As this might change in the future, this option isn't guaranteed to be
- forward-compatible. Default is `false`.
-
-Building blocks
----------------
+## Building blocks
There are three basic building blocks of a Cognitive Complexity metric:
-Increment
-^^^^^^^^^
+### Increment
The following structures increase the function's Cognitive Complexity metric
(by `1`):
-* Conditional operators:
+- Conditional operators:
+
+ - `if()`
+ - `else if()`
+ - `else`
+ - `cond ? true : false`
+
+- `switch()`
+
+- Loops:
- - ``if()``
- - ``else if()``
- - ``else``
- - ``cond ? true : false``
+ - `for()`
+ - C++11 range-based `for()`
+ - `while()`
+ - `do while()`
-* ``switch()``
-* Loops:
+- `catch ()`
- - ``for()``
- - C++11 range-based ``for()``
- - ``while()``
- - ``do while()``
+- `goto LABEL`, `goto *(&&LABEL))`,
-* ``catch ()``
-* ``goto LABEL``, ``goto *(&&LABEL))``,
-* sequences of binary logical operators:
+- sequences of binary logical operators:
- - ``boolean1 || boolean2``
- - ``boolean1 && boolean2``
+ - `boolean1 || boolean2`
+ - `boolean1 && boolean2`
-Nesting level
-^^^^^^^^^^^^^
+### Nesting level
While by itself the nesting level does not change the function's Cognitive
Complexity metric, it is tracked, and is used by the next, third building
block. The following structures increase the nesting level (by `1`):
-* Conditional operators:
+- Conditional operators:
- - ``if()``
- - ``else if()``
- - ``else``
- - ``cond ? true : false``
+ - `if()`
+ - `else if()`
+ - `else`
+ - `cond ? true : false`
-* ``switch()``
-* Loops:
+- `switch()`
- - ``for()``
- - C++11 range-based ``for()``
- - ``while()``
- - ``do while()``
+- Loops:
-* ``catch ()``
-* Nested functions:
+ - `for()`
+ - C++11 range-based `for()`
+ - `while()`
+ - `do while()`
- - C++11 Lambda
- - Nested ``class``
- - Nested ``struct``
-* GNU statement expression
-* Apple Block Declaration
+- `catch ()`
-Nesting increment
-^^^^^^^^^^^^^^^^^
+- Nested functions:
-This is where the previous basic building block, `Nesting level`_, matters.
-The following structures increase the function's Cognitive Complexity metric by
-the current `Nesting level`_:
+ - C++11 Lambda
+ - Nested `class`
+ - Nested `struct`
-* Conditional operators:
+- GNU statement expression
- - ``if()``
- - ``cond ? true : false``
+- Apple Block Declaration
-* ``switch()``
-* Loops:
+### Nesting increment
- - ``for()``
- - C++11 range-based ``for()``
- - ``while()``
- - ``do while()``
+This is where the previous basic building block,
+[Nesting level](#nesting-level), matters.
+The following structures increase the function's Cognitive Complexity metric by
+the current [Nesting level](#nesting-level):
-* ``catch ()``
+- Conditional operators:
-Examples
---------
+ - `if()`
+ - `cond ? true : false`
-The simplest case. This function has Cognitive Complexity of `0`.
+- `switch()`
-.. code-block:: c++
+- Loops:
- void function0() {}
+ - `for()`
+ - C++11 range-based `for()`
+ - `while()`
+ - `do while()`
-Slightly better example. This function has Cognitive Complexity of `1`.
+- `catch ()`
-.. code-block:: c++
+## Examples
- int function1(bool var) {
- if(var) // +1, nesting level +1
- return 42;
- return 0;
- }
+The simplest case. This function has Cognitive Complexity of `0`.
-Full example. This function has Cognitive Complexity of `3`.
+```c++
+void function0() {}
+```
+
+Slightly better example. This function has Cognitive Complexity of `1`.
-.. code-block:: c++
+```c++
+int function1(bool var) {
+ if(var) // +1, nesting level +1
+ return 42;
+ return 0;
+}
+```
- int function3(bool var1, bool var2) {
- if(var1) { // +1, nesting level +1
- if(var2) // +2 (1 + current nesting level of 1), nesting level +1
- return 42;
- }
+Full example. This function has Cognitive Complexity of `3`.
- return 0;
+```c++
+int function3(bool var1, bool var2) {
+ if(var1) { // +1, nesting level +1
+ if(var2) // +2 (1 + current nesting level of 1), nesting level +1
+ return 42;
}
-In the last example, the check will flag `function3` if the option Threshold is
-set to `2` or smaller. If the option DescribeBasicIncrements is set to `true`,
+ return 0;
+}
+```
+
+In the last example, the check will flag `function3` if the
+{option}`Threshold` option is set to `2` or smaller. If the
+{option}`DescribeBasicIncrements` option is set to `true`,
it will additionally flag the two `if` statements with the amounts by which they
increase to the complexity of the function and the current nesting level.
-
-Limitations
------------
+## Limitations
The metric is implemented with two notable exceptions:
- * `preprocessor conditionals` (``#ifdef``, ``#if``, ``#elif``, ``#else``,
- ``#endif``) are not accounted for.
- * `each method in a recursion cycle` is not accounted for. It can't be fully
- implemented, because cross-translational-unit analysis would be needed,
- which is currently not possible in clang-tidy.
+
+- `preprocessor conditionals` (`#ifdef`, `#if`, `#elif`, `#else`,
+ `#endif`) are not accounted for.
+- `each method in a recursion cycle` is not accounted for. It can't be fully
+ implemented, because cross-translational-unit analysis would be needed,
+ which is currently not possible in clang-tidy.
diff --git a/clang-tools-extra/docs/clang-tidy/checks/readability/function-size.md b/clang-tools-extra/docs/clang-tidy/checks/readability/function-size.md
index a87862f77c366..37d96bd14e673 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/readability/function-size.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/readability/function-size.md
@@ -1,55 +1,54 @@
-.. title:: clang-tidy - readability-function-size
+```{title} clang-tidy - readability-function-size
+```
-readability-function-size
-=========================
+# readability-function-size
`google-readability-function-size` redirects here as an alias for this check.
Checks for large functions based on various metrics.
-Options
--------
-
-.. option:: LineThreshold
-
- Flag functions exceeding this number of lines. The default is `none` (ignore
- the number of lines).
-
-.. option:: StatementThreshold
-
- Flag functions exceeding this number of statements. This may differ
- significantly from the number of lines for macro-heavy code. The default is
- `800`.
-
-.. option:: BranchThreshold
-
- Flag functions exceeding this number of control statements. The default is
- `none` (ignore the number of branches).
-
-.. option:: ParameterThreshold
-
- Flag functions that exceed a specified number of parameters. The default
- is `none` (ignore the number of parameters).
-
-.. option:: NestingThreshold
-
- Flag compound statements which create next nesting level after
- `NestingThreshold`. This may differ significantly from the expected value
- for macro-heavy code. The default is `none` (ignore the nesting level).
-
-.. option:: VariableThreshold
-
- Flag functions exceeding this number of variables declared in the body.
- The default is `none` (ignore the number of variables).
- Please note that function parameters and variables declared in lambdas,
- GNU Statement Expressions, and nested class inline functions are not counted.
-
-.. option:: CountMemberInitAsStmt
-
- When `true`, count class member initializers in constructors as statements.
- Default is `true`.
-
-.. option:: IgnoreMacros
-
- If set to `true`, the check will not count statements, branches, nesting
- levels, or variable declarations inside macros. Default is `false`.
+## Options
+
+```{option} LineThreshold
+Flag functions exceeding this number of lines. Default is `none` (ignore the
+number of lines).
+```
+
+```{option} StatementThreshold
+Flag functions exceeding this number of statements. This may differ
+significantly from the number of lines for macro-heavy code. Default is
+`800`.
+```
+
+```{option} BranchThreshold
+Flag functions exceeding this number of control statements. Default is
+`none` (ignore the number of branches).
+```
+
+```{option} ParameterThreshold
+Flag functions that exceed a specified number of parameters. Default
+is `none` (ignore the number of parameters).
+```
+
+```{option} NestingThreshold
+Flag compound statements which create next nesting level after
+{option}`NestingThreshold`. This may differ significantly from the expected
+value for macro-heavy code. Default is `none` (ignore the nesting level).
+```
+
+```{option} VariableThreshold
+Flag functions exceeding this number of variables declared in the body.
+Please note that function parameters and variables declared in lambdas,
+GNU Statement Expressions, and nested class inline functions are not counted.
+Default is `none` (ignore the number of variables).
+```
+
+```{option} CountMemberInitAsStmt
+When `true`, count class member initializers in constructors as statements.
+Default is `true`.
+```
+
+```{option} IgnoreMacros
+When `true`, the check will not count statements, branches, nesting
+levels, or variable declarations inside macros. Default is `false`.
+```
diff --git a/clang-tools-extra/docs/clang-tidy/checks/readability/identifier-length.md b/clang-tools-extra/docs/clang-tidy/checks/readability/identifier-length.md
index 52910ef032f26..080b66a4dbc71 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/readability/identifier-length.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/readability/identifier-length.md
@@ -1,147 +1,148 @@
-.. title:: clang-tidy - readability-identifier-length
+```{title} clang-tidy - readability-identifier-length
+```
-readability-identifier-length
-=============================
+# readability-identifier-length
This check finds variables and function parameters whose length are too short.
The desired name length is configurable. Special short names which should be
ignored can be specified. Local variables with short names can also be ignored
if they are short-lived.
-Options
--------
+## Options
The following options are described below:
- - :option:`MinimumVariableNameLength`, :option:`IgnoredVariableNames`
- - :option:`MinimumBindingNameLength`, :option:`IgnoredBindingNames`
- - :option:`MinimumParameterNameLength`, :option:`IgnoredParameterNames`
- - :option:`MinimumLoopCounterNameLength`, :option:`IgnoredLoopCounterNames`
- - :option:`MinimumExceptionNameLength`,
- :option:`IgnoredExceptionVariableNames`
- - :option:`LineCountThreshold`
-
-.. option:: MinimumVariableNameLength
-
- All variables (other than loop counter, exception names and function
- parameters) are expected to have at least a length of
- `MinimumVariableNameLength` (default is `3`). Setting it to `0` or `1`
- disables the check entirely.
-
- .. code-block:: c++
-
- int i = 42; // warns that 'i' is too short
-
-.. option:: IgnoredVariableNames
-
- Specifies a regular expression for variable names that are
- to be ignored. The default value is empty, thus no names are ignored.
-
-.. option:: MinimumBindingNameLength
-
- All variables introduced by structured bindings are expected to have at
- least a length of `MinimumBindingNameLength` (default is `2`). Setting it
- to `0` or `1` disables the check entirely.
-
- .. code-block:: c++
-
- auto [a] = get_result(); // warns that 'a' is too short
-
-.. option:: IgnoredBindingNames
-
- Specifies a regular expression for variable names introduced by structured
- bindings that are to be ignored. The default value is `^[_]$`, to allow the
- use of the `_` idiom to specify that the value is discarded on purpose.
-
-.. option:: MinimumParameterNameLength
-
- All function parameter names are expected to have a length of at least
- `MinimumParameterNameLength` (default is `3`). Setting it to `0` or `1`
- disables the check entirely.
-
- .. code-block:: c++
-
- int doubler(int x) // warns that x is too short
- {
- return 2 * x;
- }
-
-.. option:: IgnoredParameterNames
-
- Specifies a regular expression for parameters that are to be ignored.
- The default value is `^[n]$` for historical reasons.
-
-.. option:: MinimumLoopCounterNameLength
-
- Loop counter variables are expected to have a length of at least
- `MinimumLoopCounterNameLength` characters (default is `2`). Setting it to
- `0` or `1` disables the check entirely.
-
- .. code-block:: c++
-
- // This warns that 'q' is too short.
- for (int q = 0; q < size; ++ q) {
- // ...
- }
-
-.. option:: IgnoredLoopCounterNames
-
- Specifies a regular expression for counter names that are to be ignored.
- The default value is `^[ijk_]$`; the first three symbols for historical
- reasons and the last one since it is frequently used as a "don't care"
- value, specifically in tools such as Google Benchmark.
-
- .. code-block:: c++
-
- // This does not warn by default, for historical reasons.
- for (int i = 0; i < size; ++ i) {
- // ...
- }
-
-.. option:: MinimumExceptionNameLength
-
- Exception clause variables are expected to have a length of at least
- `MinimumExceptionNameLength` (default is `2`). Setting it to `0` or `1`
- disables the check entirely.
-
- .. code-block:: c++
-
- try {
- // ...
- }
- // This warns that 'e' is too short.
- catch (const std::exception& x) {
- // ...
- }
-
-.. option:: IgnoredExceptionVariableNames
-
- Specifies a regular expression for exception variable names that are to
- be ignored. The default value is `^[e]$` mainly for historical reasons.
-
- .. code-block:: c++
-
- try {
- // ...
- }
- // This does not warn by default, for historical reasons.
- catch (const std::exception& e) {
- // ...
- }
-
-.. option:: LineCountThreshold
-
- Defines the minimum number of lines required between declaration and last
- use for a diagnostic to be issued. The default value for this option is 0,
- which corresponds to all variables being flagged. This option only affects
- the behavior regarding local variables: a warning is always issued when a
- global variable has a short name, because globals can potentially be used
- across multiple files.
-
- .. code-block:: c++
-
- // In this example, a warning will be issued if LineCountThreshold < N
- int a = 0; // First line (declaration line)
- a = 1; // Second line
- // ...
- last_use_of(a); // N-th line
+- {option}`MinimumVariableNameLength`, {option}`IgnoredVariableNames`
+- {option}`MinimumBindingNameLength`, {option}`IgnoredBindingNames`
+- {option}`MinimumParameterNameLength`,
+ [`IgnoredParameterNames`](#readability-identifier-length-ignored-parameter-names)
+- {option}`MinimumLoopCounterNameLength`, {option}`IgnoredLoopCounterNames`
+- {option}`MinimumExceptionNameLength`,
+ {option}`IgnoredExceptionVariableNames`
+- {option}`LineCountThreshold`
+
+````{option} MinimumVariableNameLength
+All variables (other than loop counter, exception names and function
+parameters) are expected to have at least a length of
+{option}`MinimumVariableNameLength`. Setting it to `0` or `1` disables the
+check entirely. Default is `3`.
+
+```c++
+int i = 42; // warns that 'i' is too short
+```
+````
+
+```{option} IgnoredVariableNames
+Specifies a regular expression for variable names that are
+to be ignored. Default is empty string, so no names are ignored.
+```
+
+````{option} MinimumBindingNameLength
+All variables introduced by structured bindings are expected to have at
+least a length of {option}`MinimumBindingNameLength`. Setting it to `0` or `1`
+disables the check entirely. Default is `2`.
+
+```c++
+auto [a] = get_result(); // warns that 'a' is too short
+```
+````
+
+```{option} IgnoredBindingNames
+Specifies a regular expression for variable names introduced by structured
+bindings that are to be ignored. The `^[_]$` value allows the `_` idiom to
+specify that the value is discarded on purpose. Default is `^[_]$`.
+```
+
+````{option} MinimumParameterNameLength
+All function parameter names are expected to have a length of at least
+{option}`MinimumParameterNameLength`. Setting it to `0` or `1` disables the
+check entirely. Default is `3`.
+
+```c++
+int doubler(int x) // warns that x is too short
+{
+ return 2 * x;
+}
+```
+````
+
+(readability-identifier-length-ignored-parameter-names)=
+
+```{option} IgnoredParameterNames
+Specifies a regular expression for parameters that are to be ignored.
+Default is `^[n]$` for historical reasons.
+```
+
+````{option} MinimumLoopCounterNameLength
+Loop counter variables are expected to have a length of at least
+{option}`MinimumLoopCounterNameLength` characters. Setting it to `0` or `1`
+disables the check entirely. Default is `2`.
+
+```c++
+// This warns that 'q' is too short.
+for (int q = 0; q < size; ++ q) {
+ // ...
+}
+```
+````
+
+````{option} IgnoredLoopCounterNames
+Specifies a regular expression for counter names that are to be ignored.
+Default is `^[ijk_]$`; the first three symbols are included for historical
+reasons and the last one since it is frequently used as a "don't care"
+value, specifically in tools such as Google Benchmark.
+
+```c++
+// This does not warn by default, for historical reasons.
+for (int i = 0; i < size; ++ i) {
+ // ...
+}
+```
+````
+
+````{option} MinimumExceptionNameLength
+Exception clause variables are expected to have a length of at least
+{option}`MinimumExceptionNameLength`. Setting it to `0` or `1` disables the
+check entirely. Default is `2`.
+
+```c++
+try {
+ // ...
+}
+// This warns that 'e' is too short.
+catch (const std::exception& x) {
+ // ...
+}
+```
+````
+
+````{option} IgnoredExceptionVariableNames
+Specifies a regular expression for exception variable names that are to
+be ignored. Default is `^[e]$` mainly for historical reasons.
+
+```c++
+try {
+ // ...
+}
+// This does not warn by default, for historical reasons.
+catch (const std::exception& e) {
+ // ...
+}
+```
+````
+
+````{option} LineCountThreshold
+Defines the minimum number of lines required between declaration and last
+use for a diagnostic to be issued. This option only affects the behavior
+regarding local variables: a warning is always issued when a global variable
+has a short name, because globals can potentially be used across multiple
+files. Default is `0`, which corresponds to all variables being flagged.
+
+```c++
+// In this example, a warning will be issued if LineCountThreshold < N
+int a = 0; // First line (declaration line)
+a = 1; // Second line
+ // ...
+last_use_of(a); // N-th line
+```
+````
diff --git a/clang-tools-extra/docs/clang-tidy/checks/readability/identifier-naming.md b/clang-tools-extra/docs/clang-tidy/checks/readability/identifier-naming.md
index b177577df311e..ddbbbf1e01271 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/readability/identifier-naming.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/readability/identifier-naming.md
@@ -1,7 +1,7 @@
-.. title:: clang-tidy - readability-identifier-naming
+```{title} clang-tidy - readability-identifier-naming
+```
-readability-identifier-naming
-=============================
+# readability-identifier-naming
Checks for identifiers naming style mismatch.
@@ -11,14 +11,14 @@ another if a mismatch is detected
Casing types include:
- - ``lower_case``
- - ``UPPER_CASE``
- - ``camelBack``
- - ``CamelCase``
- - ``camel_Snake_Back``
- - ``Camel_Snake_Case``
- - ``aNy_CasE``
- - ``Leading_upper_snake_case``
+- `lower_case`
+- `UPPER_CASE`
+- `camelBack`
+- `CamelCase`
+- `camel_Snake_Back`
+- `Camel_Snake_Case`
+- `aNy_CasE`
+- `Leading_upper_snake_case`
It also supports a fixed prefix and suffix that will be prepended or appended
to the identifiers, regardless of the casing.
@@ -31,3027 +31,3021 @@ The naming of virtual methods is reported where they occur in the base class,
but not where they are overridden, as it can't be fixed locally there.
This also applies for pseudo-override patterns like CRTP.
-``Leading_upper_snake_case`` is a naming convention where the first word is
-capitalized followed by lower case word(s) separated by underscore(s) '_'.
+`Leading_upper_snake_case` is a naming convention where the first word is
+capitalized followed by lower case word(s) separated by underscore(s) '\_'.
Examples include: `Cap_snake_case`, `Cobra_case`, `Foo_bar_baz`,
and `Master_copy_8gb`.
Hungarian notation can be customized using different *HungarianPrefix*
settings. The options and their corresponding values are:
- - ``Off`` - the default setting
- - ``On`` - example: ``int iVariable``
- - ``LowerCase`` - example: ``int i_Variable``
- - ``CamelCase`` - example: ``int IVariable``
+- `Off` - the default setting
+- `On` - example: `int iVariable`
+- `LowerCase` - example: `int i_Variable`
+- `CamelCase` - example: `int IVariable`
The check only enforces style on kinds of identifiers which have been
configured, so an empty config effectively disables it.
-The :option:`DefaultCase` option can be used to enforce style on all kinds of
+The {option}`DefaultCase` option can be used to enforce style on all kinds of
identifiers, then optionally overriden for specific kinds which are desired
with a different case.
For example using values of:
- - DefaultCase of ``lower_case``
- - MacroDefinitionCase of ``UPPER_CASE``
- - TemplateParameterCase of ``CamelCase``
+- {option}`DefaultCase` of `lower_case`
+- {option}`MacroDefinitionCase` of `UPPER_CASE`
+- {option}`TemplateParameterCase` of `CamelCase`
Identifies and transforms names as follows:
Before:
-.. code-block:: c++
-
- #define macroDefinition
- template <typename typenameParameter>
- int functionDeclaration(typenameParameter paramVal, int paramCount);
+```c++
+#define macroDefinition
+template <typename typenameParameter>
+int functionDeclaration(typenameParameter paramVal, int paramCount);
+```
After:
-.. code-block:: c++
-
- #define MACRO_DEFINITION
- template <typename TypenameParameter>
- int function_declarations(TypenameParameter param_val, int param_count);
+```c++
+#define MACRO_DEFINITION
+template <typename TypenameParameter>
+int function_declarations(TypenameParameter param_val, int param_count);
+```
-Options summary
----------------
+## Options summary
The available options are summarized below:
**General options**
- - :option:`AggressiveDependentMemberLookup`
- - :option:`CheckAnonFieldInParent`
- - :option:`GetConfigPerFile`
- - :option:`IgnoreMainLikeFunctions`
- - :option:`TypedefInheritAnonTagConfig`
+- {option}`AggressiveDependentMemberLookup`
+- {option}`CheckAnonFieldInParent`
+- {option}`GetConfigPerFile`
+- {option}`IgnoreMainLikeFunctions`
+- {option}`TypedefInheritAnonTagConfig`
**Specific options**
- - :option:`DefaultCase`, :option:`DefaultPrefix`,
- :option:`DefaultSuffix`, :option:`DefaultIgnoredRegexp`,
- :option:`DefaultHungarianPrefix`
- - :option:`AbstractClassCase`, :option:`AbstractClassPrefix`,
- :option:`AbstractClassSuffix`, :option:`AbstractClassIgnoredRegexp`,
- :option:`AbstractClassHungarianPrefix`
- - :option:`ClassCase`, :option:`ClassPrefix`, :option:`ClassSuffix`,
- :option:`ClassIgnoredRegexp`, :option:`ClassHungarianPrefix`
- - :option:`ClassConstexprCase`, :option:`ClassConstexprPrefix`,
- :option:`ClassConstexprSuffix`, :option:`ClassConstexprIgnoredRegexp`,
- :option:`ClassConstexprHungarianPrefix`
- - :option:`ClassConstantCase`, :option:`ClassConstantPrefix`,
- :option:`ClassConstantSuffix`, :option:`ClassConstantIgnoredRegexp`,
- :option:`ClassConstantHungarianPrefix`
- - :option:`ClassMemberCase`, :option:`ClassMemberPrefix`,
- :option:`ClassMemberSuffix`, :option:`ClassMemberIgnoredRegexp`,
- :option:`ClassMemberHungarianPrefix`
- - :option:`ClassMethodCase`, :option:`ClassMethodPrefix`,
- :option:`ClassMethodSuffix`, :option:`ClassMethodIgnoredRegexp`
- - :option:`ConceptCase`, :option:`ConceptPrefix`, :option:`ConceptSuffix`,
- :option:`ConceptIgnoredRegexp`
- - :option:`ConstantCase`, :option:`ConstantPrefix`, :option:`ConstantSuffix`,
- :option:`ConstantIgnoredRegexp`, :option:`ConstantHungarianPrefix`
- - :option:`ConstantMemberCase`, :option:`ConstantMemberPrefix`,
- :option:`ConstantMemberSuffix`, :option:`ConstantMemberIgnoredRegexp`,
- :option:`ConstantMemberHungarianPrefix`
- - :option:`ConstantParameterCase`, :option:`ConstantParameterPrefix`,
- :option:`ConstantParameterSuffix`, :option:`ConstantParameterIgnoredRegexp`,
- :option:`ConstantParameterHungarianPrefix`
- - :option:`ConstantPointerParameterCase`,
- :option:`ConstantPointerParameterPrefix`,
- :option:`ConstantPointerParameterSuffix`,
- :option:`ConstantPointerParameterIgnoredRegexp`,
- :option:`ConstantPointerParameterHungarianPrefix`
- - :option:`ConstexprFunctionCase`, :option:`ConstexprFunctionPrefix`,
- :option:`ConstexprFunctionSuffix`, :option:`ConstexprFunctionIgnoredRegexp`
- - :option:`ConstexprMethodCase`, :option:`ConstexprMethodPrefix`,
- :option:`ConstexprMethodSuffix`, :option:`ConstexprMethodIgnoredRegexp`
- - :option:`ConstexprVariableCase`, :option:`ConstexprVariablePrefix`,
- :option:`ConstexprVariableSuffix`, :option:`ConstexprVariableIgnoredRegexp`,
- :option:`ConstexprVariableHungarianPrefix`
- - :option:`EnumCase`, :option:`EnumPrefix`, :option:`EnumSuffix`,
- :option:`EnumIgnoredRegexp`
- - :option:`EnumConstantCase`, :option:`EnumConstantPrefix`,
- :option:`EnumConstantSuffix`, :option:`EnumConstantIgnoredRegexp`,
- :option:`EnumConstantHungarianPrefix`
- - :option:`FunctionCase`, :option:`FunctionPrefix`, :option:`FunctionSuffix`,
- :option:`FunctionIgnoredRegexp`
- - :option:`GlobalConstexprVariableCase`,
- :option:`GlobalConstexprVariablePrefix`,
- :option:`GlobalConstexprVariableSuffix`,
- :option:`GlobalConstexprVariableIgnoredRegexp`,
- :option:`GlobalConstexprVariableHungarianPrefix`
- - :option:`GlobalConstantCase`, :option:`GlobalConstantPrefix`,
- :option:`GlobalConstantSuffix`, :option:`GlobalConstantIgnoredRegexp`,
- :option:`GlobalConstantHungarianPrefix`
- - :option:`GlobalConstantPointerCase`,
- :option:`GlobalConstantPointerPrefix`,
- :option:`GlobalConstantPointerSuffix`,
- :option:`GlobalConstantPointerIgnoredRegexp`,
- :option:`GlobalConstantPointerHungarianPrefix`
- - :option:`GlobalFunctionCase`, :option:`GlobalFunctionPrefix`,
- :option:`GlobalFunctionSuffix`, :option:`GlobalFunctionIgnoredRegexp`
- - :option:`GlobalPointerCase`, :option:`GlobalPointerPrefix`,
- :option:`GlobalPointerSuffix`, :option:`GlobalPointerIgnoredRegexp`,
- :option:`GlobalPointerHungarianPrefix`
- - :option:`GlobalVariableCase`, :option:`GlobalVariablePrefix`,
- :option:`GlobalVariableSuffix`, :option:`GlobalVariableIgnoredRegexp`,
- :option:`GlobalVariableHungarianPrefix`
- - :option:`InlineNamespaceCase`, :option:`InlineNamespacePrefix`,
- :option:`InlineNamespaceSuffix`, :option:`InlineNamespaceIgnoredRegexp`
- - :option:`LambdaCaptureCase`, :option:`LambdaCapturePrefix`,
- :option:`LambdaCaptureSuffix`, :option:`LambdaCaptureIgnoredRegexp`,
- :option:`LambdaCaptureHungarianPrefix`
- - :option:`LocalConstexprVariableCase`,
- :option:`LocalConstexprVariablePrefix`,
- :option:`LocalConstexprVariableSuffix`,
- :option:`LocalConstexprVariableIgnoredRegexp`,
- :option:`LocalConstexprVariableHungarianPrefix`
- - :option:`LocalConstantCase`, :option:`LocalConstantPrefix`,
- :option:`LocalConstantSuffix`, :option:`LocalConstantIgnoredRegexp`,
- :option:`LocalConstantHungarianPrefix`
- - :option:`LocalConstantPointerCase`,
- :option:`LocalConstantPointerPrefix`,
- :option:`LocalConstantPointerSuffix`,
- :option:`LocalConstantPointerIgnoredRegexp`,
- :option:`LocalConstantPointerHungarianPrefix`
- - :option:`LocalPointerCase`, :option:`LocalPointerPrefix`,
- :option:`LocalPointerSuffix`, :option:`LocalPointerIgnoredRegexp`,
- :option:`LocalPointerHungarianPrefix`
- - :option:`LocalVariableCase`, :option:`LocalVariablePrefix`,
- :option:`LocalVariableSuffix`, :option:`LocalVariableIgnoredRegexp`,
- :option:`LocalVariableHungarianPrefix`
- - :option:`MacroDefinitionCase`, :option:`MacroDefinitionPrefix`,
- :option:`MacroDefinitionSuffix`, :option:`MacroDefinitionIgnoredRegexp`
- - :option:`MemberCase`, :option:`MemberPrefix`, :option:`MemberSuffix`,
- :option:`MemberIgnoredRegexp`, :option:`MemberHungarianPrefix`
- - :option:`MethodCase`, :option:`MethodPrefix`, :option:`MethodSuffix`,
- :option:`MethodIgnoredRegexp`
- - :option:`NamespaceCase`, :option:`NamespacePrefix`,
- :option:`NamespaceSuffix`, :option:`NamespaceIgnoredRegexp`
- - :option:`ParameterCase`, :option:`ParameterPrefix`,
- :option:`ParameterSuffix`, :option:`ParameterIgnoredRegexp`,
- :option:`ParameterHungarianPrefix`
- - :option:`ParameterPackCase`, :option:`ParameterPackPrefix`,
- :option:`ParameterPackSuffix`, :option:`ParameterPackIgnoredRegexp`
- - :option:`PointerParameterCase`, :option:`PointerParameterPrefix`,
- :option:`PointerParameterSuffix`, :option:`PointerParameterIgnoredRegexp`,
- :option:`PointerParameterHungarianPrefix`
- - :option:`PrivateMemberCase`, :option:`PrivateMemberPrefix`,
- :option:`PrivateMemberSuffix`, :option:`PrivateMemberIgnoredRegexp`,
- :option:`PrivateMemberHungarianPrefix`
- - :option:`PrivateMethodCase`, :option:`PrivateMethodPrefix`,
- :option:`PrivateMethodSuffix`, :option:`PrivateMethodIgnoredRegexp`
- - :option:`ProtectedMemberCase`, :option:`ProtectedMemberPrefix`,
- :option:`ProtectedMemberSuffix`, :option:`ProtectedMemberIgnoredRegexp`,
- :option:`ProtectedMemberHungarianPrefix`
- - :option:`ProtectedMethodCase`, :option:`ProtectedMethodPrefix`,
- :option:`ProtectedMethodSuffix`, :option:`ProtectedMethodIgnoredRegexp`
- - :option:`PublicMemberCase`, :option:`PublicMemberPrefix`,
- :option:`PublicMemberSuffix`, :option:`PublicMemberIgnoredRegexp`,
- :option:`PublicMemberHungarianPrefix`
- - :option:`PublicMethodCase`, :option:`PublicMethodPrefix`,
- :option:`PublicMethodSuffix`, :option:`PublicMethodIgnoredRegexp`
- - :option:`ScopedEnumConstantCase`, :option:`ScopedEnumConstantPrefix`,
- :option:`ScopedEnumConstantSuffix`,
- :option:`ScopedEnumConstantIgnoredRegexp`
- - :option:`StaticConstexprVariableCase`,
- :option:`StaticConstexprVariablePrefix`,
- :option:`StaticConstexprVariableSuffix`,
- :option:`StaticConstexprVariableIgnoredRegexp`,
- :option:`StaticConstexprVariableHungarianPrefix`
- - :option:`StaticConstantCase`, :option:`StaticConstantPrefix`,
- :option:`StaticConstantSuffix`, :option:`StaticConstantIgnoredRegexp`,
- :option:`StaticConstantHungarianPrefix`
- - :option:`StaticVariableCase`, :option:`StaticVariablePrefix`,
- :option:`StaticVariableSuffix`, :option:`StaticVariableIgnoredRegexp`,
- :option:`StaticVariableHungarianPrefix`
- - :option:`StructCase`, :option:`StructPrefix`, :option:`StructSuffix`,
- :option:`StructIgnoredRegexp`
- - :option:`TemplateParameterCase`, :option:`TemplateParameterPrefix`,
- :option:`TemplateParameterSuffix`, :option:`TemplateParameterIgnoredRegexp`
- - :option:`TemplateTemplateParameterCase`,
- :option:`TemplateTemplateParameterPrefix`,
- :option:`TemplateTemplateParameterSuffix`,
- :option:`TemplateTemplateParameterIgnoredRegexp`
- - :option:`TypeAliasCase`, :option:`TypeAliasPrefix`,
- :option:`TypeAliasSuffix`, :option:`TypeAliasIgnoredRegexp`
- - :option:`TypedefCase`, :option:`TypedefPrefix`, :option:`TypedefSuffix`,
- :option:`TypedefIgnoredRegexp`
- - :option:`TypeTemplateParameterCase`,
- :option:`TypeTemplateParameterPrefix`,
- :option:`TypeTemplateParameterSuffix`,
- :option:`TypeTemplateParameterIgnoredRegexp`
- - :option:`UnionCase`, :option:`UnionPrefix`, :option:`UnionSuffix`,
- :option:`UnionIgnoredRegexp`
- - :option:`ValueTemplateParameterCase`,
- :option:`ValueTemplateParameterPrefix`,
- :option:`ValueTemplateParameterSuffix`,
- :option:`ValueTemplateParameterIgnoredRegexp`
- - :option:`VariableCase`, :option:`VariablePrefix`, :option:`VariableSuffix`,
- :option:`VariableIgnoredRegexp`, :option:`VariableHungarianPrefix`
- - :option:`VirtualMethodCase`, :option:`VirtualMethodPrefix`,
- :option:`VirtualMethodSuffix`, :option:`VirtualMethodIgnoredRegexp`
-
-
-Options description
--------------------
+- {option}`DefaultCase`, {option}`DefaultPrefix`,
+ {option}`DefaultSuffix`, {option}`DefaultIgnoredRegexp`,
+ {option}`DefaultHungarianPrefix`
+- {option}`AbstractClassCase`, {option}`AbstractClassPrefix`,
+ {option}`AbstractClassSuffix`, {option}`AbstractClassIgnoredRegexp`,
+ {option}`AbstractClassHungarianPrefix`
+- {option}`ClassCase`, {option}`ClassPrefix`, {option}`ClassSuffix`,
+ {option}`ClassIgnoredRegexp`, {option}`ClassHungarianPrefix`
+- {option}`ClassConstexprCase`, {option}`ClassConstexprPrefix`,
+ {option}`ClassConstexprSuffix`, {option}`ClassConstexprIgnoredRegexp`,
+ {option}`ClassConstexprHungarianPrefix`
+- {option}`ClassConstantCase`, {option}`ClassConstantPrefix`,
+ {option}`ClassConstantSuffix`, {option}`ClassConstantIgnoredRegexp`,
+ {option}`ClassConstantHungarianPrefix`
+- {option}`ClassMemberCase`, {option}`ClassMemberPrefix`,
+ {option}`ClassMemberSuffix`, {option}`ClassMemberIgnoredRegexp`,
+ {option}`ClassMemberHungarianPrefix`
+- {option}`ClassMethodCase`, {option}`ClassMethodPrefix`,
+ {option}`ClassMethodSuffix`, {option}`ClassMethodIgnoredRegexp`
+- {option}`ConceptCase`, {option}`ConceptPrefix`, {option}`ConceptSuffix`,
+ {option}`ConceptIgnoredRegexp`
+- {option}`ConstantCase`, {option}`ConstantPrefix`, {option}`ConstantSuffix`,
+ {option}`ConstantIgnoredRegexp`, {option}`ConstantHungarianPrefix`
+- {option}`ConstantMemberCase`, {option}`ConstantMemberPrefix`,
+ {option}`ConstantMemberSuffix`, {option}`ConstantMemberIgnoredRegexp`,
+ {option}`ConstantMemberHungarianPrefix`
+- {option}`ConstantParameterCase`, {option}`ConstantParameterPrefix`,
+ {option}`ConstantParameterSuffix`, {option}`ConstantParameterIgnoredRegexp`,
+ {option}`ConstantParameterHungarianPrefix`
+- {option}`ConstantPointerParameterCase`,
+ {option}`ConstantPointerParameterPrefix`,
+ {option}`ConstantPointerParameterSuffix`,
+ {option}`ConstantPointerParameterIgnoredRegexp`,
+ {option}`ConstantPointerParameterHungarianPrefix`
+- {option}`ConstexprFunctionCase`, {option}`ConstexprFunctionPrefix`,
+ {option}`ConstexprFunctionSuffix`, {option}`ConstexprFunctionIgnoredRegexp`
+- {option}`ConstexprMethodCase`, {option}`ConstexprMethodPrefix`,
+ {option}`ConstexprMethodSuffix`, {option}`ConstexprMethodIgnoredRegexp`
+- {option}`ConstexprVariableCase`, {option}`ConstexprVariablePrefix`,
+ {option}`ConstexprVariableSuffix`, {option}`ConstexprVariableIgnoredRegexp`,
+ {option}`ConstexprVariableHungarianPrefix`
+- {option}`EnumCase`, {option}`EnumPrefix`, {option}`EnumSuffix`,
+ {option}`EnumIgnoredRegexp`
+- {option}`EnumConstantCase`, {option}`EnumConstantPrefix`,
+ {option}`EnumConstantSuffix`, {option}`EnumConstantIgnoredRegexp`,
+ {option}`EnumConstantHungarianPrefix`
+- {option}`FunctionCase`, {option}`FunctionPrefix`, {option}`FunctionSuffix`,
+ {option}`FunctionIgnoredRegexp`
+- {option}`GlobalConstexprVariableCase`,
+ {option}`GlobalConstexprVariablePrefix`,
+ {option}`GlobalConstexprVariableSuffix`,
+ {option}`GlobalConstexprVariableIgnoredRegexp`,
+ {option}`GlobalConstexprVariableHungarianPrefix`
+- {option}`GlobalConstantCase`, {option}`GlobalConstantPrefix`,
+ {option}`GlobalConstantSuffix`, {option}`GlobalConstantIgnoredRegexp`,
+ {option}`GlobalConstantHungarianPrefix`
+- {option}`GlobalConstantPointerCase`,
+ {option}`GlobalConstantPointerPrefix`,
+ {option}`GlobalConstantPointerSuffix`,
+ {option}`GlobalConstantPointerIgnoredRegexp`,
+ {option}`GlobalConstantPointerHungarianPrefix`
+- {option}`GlobalFunctionCase`, {option}`GlobalFunctionPrefix`,
+ {option}`GlobalFunctionSuffix`, {option}`GlobalFunctionIgnoredRegexp`
+- {option}`GlobalPointerCase`, {option}`GlobalPointerPrefix`,
+ {option}`GlobalPointerSuffix`, {option}`GlobalPointerIgnoredRegexp`,
+ {option}`GlobalPointerHungarianPrefix`
+- {option}`GlobalVariableCase`, {option}`GlobalVariablePrefix`,
+ {option}`GlobalVariableSuffix`, {option}`GlobalVariableIgnoredRegexp`,
+ {option}`GlobalVariableHungarianPrefix`
+- {option}`InlineNamespaceCase`, {option}`InlineNamespacePrefix`,
+ {option}`InlineNamespaceSuffix`, {option}`InlineNamespaceIgnoredRegexp`
+- {option}`LambdaCaptureCase`, {option}`LambdaCapturePrefix`,
+ {option}`LambdaCaptureSuffix`, {option}`LambdaCaptureIgnoredRegexp`,
+ {option}`LambdaCaptureHungarianPrefix`
+- {option}`LocalConstexprVariableCase`,
+ {option}`LocalConstexprVariablePrefix`,
+ {option}`LocalConstexprVariableSuffix`,
+ {option}`LocalConstexprVariableIgnoredRegexp`,
+ {option}`LocalConstexprVariableHungarianPrefix`
+- {option}`LocalConstantCase`, {option}`LocalConstantPrefix`,
+ {option}`LocalConstantSuffix`, {option}`LocalConstantIgnoredRegexp`,
+ {option}`LocalConstantHungarianPrefix`
+- {option}`LocalConstantPointerCase`,
+ {option}`LocalConstantPointerPrefix`,
+ {option}`LocalConstantPointerSuffix`,
+ {option}`LocalConstantPointerIgnoredRegexp`,
+ {option}`LocalConstantPointerHungarianPrefix`
+- {option}`LocalPointerCase`, {option}`LocalPointerPrefix`,
+ {option}`LocalPointerSuffix`, {option}`LocalPointerIgnoredRegexp`,
+ {option}`LocalPointerHungarianPrefix`
+- {option}`LocalVariableCase`, {option}`LocalVariablePrefix`,
+ {option}`LocalVariableSuffix`, {option}`LocalVariableIgnoredRegexp`,
+ {option}`LocalVariableHungarianPrefix`
+- {option}`MacroDefinitionCase`, {option}`MacroDefinitionPrefix`,
+ {option}`MacroDefinitionSuffix`, {option}`MacroDefinitionIgnoredRegexp`
+- {option}`MemberCase`, {option}`MemberPrefix`, {option}`MemberSuffix`,
+ {option}`MemberIgnoredRegexp`, {option}`MemberHungarianPrefix`
+- {option}`MethodCase`, {option}`MethodPrefix`, {option}`MethodSuffix`,
+ {option}`MethodIgnoredRegexp`
+- {option}`NamespaceCase`, {option}`NamespacePrefix`,
+ {option}`NamespaceSuffix`, {option}`NamespaceIgnoredRegexp`
+- {option}`ParameterCase`, {option}`ParameterPrefix`,
+ {option}`ParameterSuffix`, {option}`ParameterIgnoredRegexp`,
+ {option}`ParameterHungarianPrefix`
+- {option}`ParameterPackCase`, {option}`ParameterPackPrefix`,
+ {option}`ParameterPackSuffix`, {option}`ParameterPackIgnoredRegexp`
+- {option}`PointerParameterCase`, {option}`PointerParameterPrefix`,
+ {option}`PointerParameterSuffix`, {option}`PointerParameterIgnoredRegexp`,
+ {option}`PointerParameterHungarianPrefix`
+- {option}`PrivateMemberCase`, {option}`PrivateMemberPrefix`,
+ {option}`PrivateMemberSuffix`, {option}`PrivateMemberIgnoredRegexp`,
+ {option}`PrivateMemberHungarianPrefix`
+- {option}`PrivateMethodCase`, {option}`PrivateMethodPrefix`,
+ {option}`PrivateMethodSuffix`, {option}`PrivateMethodIgnoredRegexp`
+- {option}`ProtectedMemberCase`, {option}`ProtectedMemberPrefix`,
+ {option}`ProtectedMemberSuffix`, {option}`ProtectedMemberIgnoredRegexp`,
+ {option}`ProtectedMemberHungarianPrefix`
+- {option}`ProtectedMethodCase`, {option}`ProtectedMethodPrefix`,
+ {option}`ProtectedMethodSuffix`, {option}`ProtectedMethodIgnoredRegexp`
+- {option}`PublicMemberCase`, {option}`PublicMemberPrefix`,
+ {option}`PublicMemberSuffix`, {option}`PublicMemberIgnoredRegexp`,
+ {option}`PublicMemberHungarianPrefix`
+- {option}`PublicMethodCase`, {option}`PublicMethodPrefix`,
+ {option}`PublicMethodSuffix`, {option}`PublicMethodIgnoredRegexp`
+- {option}`ScopedEnumConstantCase`, {option}`ScopedEnumConstantPrefix`,
+ {option}`ScopedEnumConstantSuffix`,
+ {option}`ScopedEnumConstantIgnoredRegexp`
+- {option}`StaticConstexprVariableCase`,
+ {option}`StaticConstexprVariablePrefix`,
+ {option}`StaticConstexprVariableSuffix`,
+ {option}`StaticConstexprVariableIgnoredRegexp`,
+ {option}`StaticConstexprVariableHungarianPrefix`
+- {option}`StaticConstantCase`, {option}`StaticConstantPrefix`,
+ {option}`StaticConstantSuffix`, {option}`StaticConstantIgnoredRegexp`,
+ {option}`StaticConstantHungarianPrefix`
+- {option}`StaticVariableCase`, {option}`StaticVariablePrefix`,
+ {option}`StaticVariableSuffix`, {option}`StaticVariableIgnoredRegexp`,
+ {option}`StaticVariableHungarianPrefix`
+- {option}`StructCase`, {option}`StructPrefix`, {option}`StructSuffix`,
+ {option}`StructIgnoredRegexp`
+- {option}`TemplateParameterCase`, {option}`TemplateParameterPrefix`,
+ {option}`TemplateParameterSuffix`, {option}`TemplateParameterIgnoredRegexp`
+- {option}`TemplateTemplateParameterCase`,
+ {option}`TemplateTemplateParameterPrefix`,
+ {option}`TemplateTemplateParameterSuffix`,
+ {option}`TemplateTemplateParameterIgnoredRegexp`
+- {option}`TypeAliasCase`, {option}`TypeAliasPrefix`,
+ {option}`TypeAliasSuffix`, {option}`TypeAliasIgnoredRegexp`
+- {option}`TypedefCase`, {option}`TypedefPrefix`, {option}`TypedefSuffix`,
+ {option}`TypedefIgnoredRegexp`
+- {option}`TypeTemplateParameterCase`,
+ {option}`TypeTemplateParameterPrefix`,
+ {option}`TypeTemplateParameterSuffix`,
+ {option}`TypeTemplateParameterIgnoredRegexp`
+- {option}`UnionCase`, {option}`UnionPrefix`, {option}`UnionSuffix`,
+ {option}`UnionIgnoredRegexp`
+- {option}`ValueTemplateParameterCase`,
+ {option}`ValueTemplateParameterPrefix`,
+ {option}`ValueTemplateParameterSuffix`,
+ {option}`ValueTemplateParameterIgnoredRegexp`
+- {option}`VariableCase`, {option}`VariablePrefix`, {option}`VariableSuffix`,
+ {option}`VariableIgnoredRegexp`, {option}`VariableHungarianPrefix`
+- {option}`VirtualMethodCase`, {option}`VirtualMethodPrefix`,
+ {option}`VirtualMethodSuffix`, {option}`VirtualMethodIgnoredRegexp`
+
+## Options description
A detailed description of each option is presented below:
-.. option:: DefaultCase
+```{option} DefaultCase
+When defined, the check will ensure all names by default conform to the
+selected casing.
+```
+
+```{option} DefaultPrefix
+When defined, the check will ensure all names by default will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} DefaultIgnoredRegexp
+Identifier naming checks won't be enforced for all names by default
+matching this regular expression.
+```
+
+```{option} DefaultSuffix
+When defined, the check will ensure all names by default will add the
+suffix with the given value (regardless of casing).
+```
+
+```{option} DefaultHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
+
+```{option} AbstractClassCase
+When defined, the check will ensure abstract class names conform to the
+selected casing.
+```
+
+```{option} AbstractClassPrefix
+When defined, the check will ensure abstract class names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} AbstractClassIgnoredRegexp
+Identifier naming checks won't be enforced for abstract class names
+matching this regular expression.
+```
+
+```{option} AbstractClassSuffix
+When defined, the check will ensure abstract class names will add the
+suffix with the given value (regardless of casing).
+```
+
+```{option} AbstractClassHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
- When defined, the check will ensure all names by default conform to the
- selected casing.
+For example using values of:
-.. option:: DefaultPrefix
+- {option}`AbstractClassCase` of `lower_case`
+- {option}`AbstractClassPrefix` of `pre_`
+- {option}`AbstractClassSuffix` of `_post`
+- {option}`AbstractClassHungarianPrefix` of `On`
- When defined, the check will ensure all names by default will add the
- prefix with the given value (regardless of casing).
+Identifies and/or transforms abstract class names as follows:
-.. option:: DefaultIgnoredRegexp
+Before:
- Identifier naming checks won't be enforced for all names by default
- matching this regular expression.
+```c++
+class ABSTRACT_CLASS {
+public:
+ ABSTRACT_CLASS();
+};
+```
-.. option:: DefaultSuffix
+After:
- When defined, the check will ensure all names by default will add the
- suffix with the given value (regardless of casing).
+```c++
+class pre_abstract_class_post {
+public:
+ pre_abstract_class_post();
+};
+```
-.. option:: DefaultHungarianPrefix
+```{option} AggressiveDependentMemberLookup
+When `true`, the check will look in dependent base classes for dependent
+member references that need changing. This can lead to errors with template
+specializations. Default is `false`.
+```
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+For example using values of:
-.. option:: AbstractClassCase
+- {option}`ClassMemberCase` of `lower_case`
- When defined, the check will ensure abstract class names conform to the
- selected casing.
+Before:
-.. option:: AbstractClassPrefix
+```c++
+template <typename T>
+struct Base {
+ T BadNamedMember;
+};
+
+template <typename T>
+struct Derived : Base<T> {
+ void reset() {
+ this->BadNamedMember = 0;
+ }
+};
+```
+
+After if {option}`AggressiveDependentMemberLookup` is `false`:
+
+```c++
+template <typename T>
+struct Base {
+ T bad_named_member;
+};
+
+template <typename T>
+struct Derived : Base<T> {
+ void reset() {
+ this->BadNamedMember = 0;
+ }
+};
+```
+
+After if {option}`AggressiveDependentMemberLookup` is `true`:
+
+```c++
+template <typename T>
+struct Base {
+ T bad_named_member;
+};
+
+template <typename T>
+struct Derived : Base<T> {
+ void reset() {
+ this->bad_named_member = 0;
+ }
+};
+```
+
+```{option} CheckAnonFieldInParent
+When `true`, fields in anonymous records (i.e. anonymous
+unions and structs) will be treated as names in the enclosing scope
+rather than public members of the anonymous record for the purpose
+of name checking.
+```
- When defined, the check will ensure abstract class names will add the
- prefix with the given value (regardless of casing).
+For example:
-.. option:: AbstractClassIgnoredRegexp
+```c++
+class Foo {
+private:
+ union {
+ int iv_;
+ float fv_;
+ };
+};
+```
+
+If {option}`CheckAnonFieldInParent` is `false`, you may get warnings
+that `iv_` and `fv_` are not coherent to public member names, because
+`iv_` and `fv_` are public members of the anonymous union. When
+{option}`CheckAnonFieldInParent` is `true`, `iv_` and `fv_` will be
+treated as private data members of `Foo` for the purpose of name checking
+and thus no warnings will be emitted.
- Identifier naming checks won't be enforced for abstract class names
- matching this regular expression.
+```{option} ClassCase
+When defined, the check will ensure class names conform to the
+selected casing.
+```
-.. option:: AbstractClassSuffix
+```{option} ClassPrefix
+When defined, the check will ensure class names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure abstract class names will add the
- suffix with the given value (regardless of casing).
+```{option} ClassIgnoredRegexp
+Identifier naming checks won't be enforced for class names matching
+this regular expression.
+```
-.. option:: AbstractClassHungarianPrefix
+```{option} ClassSuffix
+When defined, the check will ensure class names will add the
+suffix with the given value (regardless of casing).
+```
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```{option} ClassHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - AbstractClassCase of ``lower_case``
- - AbstractClassPrefix of ``pre_``
- - AbstractClassSuffix of ``_post``
- - AbstractClassHungarianPrefix of ``On``
+- {option}`ClassCase` of `lower_case`
+- {option}`ClassPrefix` of `pre_`
+- {option}`ClassSuffix` of `_post`
+- {option}`ClassHungarianPrefix` of `On`
-
-Identifies and/or transforms abstract class names as follows:
+Identifies and/or transforms class names as follows:
Before:
-.. code-block:: c++
-
- class ABSTRACT_CLASS {
- public:
- ABSTRACT_CLASS();
- };
+```c++
+class FOO {
+public:
+ FOO();
+ ~FOO();
+};
+```
After:
-.. code-block:: c++
+```c++
+class pre_foo_post {
+public:
+ pre_foo_post();
+ ~pre_foo_post();
+};
+```
+
+```{option} ClassConstexprCase
+When defined, the check will ensure class `constexpr` names conform to
+the selected casing.
+```
+
+```{option} ClassConstexprPrefix
+When defined, the check will ensure class `constexpr` names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ClassConstexprIgnoredRegexp
+Identifier naming checks won't be enforced for class `constexpr` names
+matching this regular expression.
+```
+
+```{option} ClassConstexprSuffix
+When defined, the check will ensure class `constexpr` names will add the
+suffix with the given value (regardless of casing).
+```
+
+```{option} ClassConstexprHungarianPrefix
+When enabled, the check ensures that the declared identifier will have a
+Hungarian notation prefix based on the declared type.
+```
+
+For example using values of:
+
+- {option}`ClassConstexprCase` of `lower_case`
+- {option}`ClassConstexprPrefix` of `pre_`
+- {option}`ClassConstexprSuffix` of `_post`
+- {option}`ClassConstexprHungarianPrefix` of `On`
+
+Identifies and/or transforms class `constexpr` variable names as follows:
+
+Before:
- class pre_abstract_class_post {
- public:
- pre_abstract_class_post();
- };
+```c++
+class FOO {
+public:
+ static constexpr int CLASS_CONSTEXPR;
+};
+```
-.. option:: AggressiveDependentMemberLookup
+After:
- 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 `false`.
+```c++
+class FOO {
+public:
+ static const int pre_class_constexpr_post;
+};
+```
+
+```{option} ClassConstantCase
+When defined, the check will ensure class constant names conform to the
+selected casing.
+```
+
+```{option} ClassConstantPrefix
+When defined, the check will ensure class constant names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ClassConstantIgnoredRegexp
+Identifier naming checks won't be enforced for class constant names
+matching this regular expression.
+```
+
+```{option} ClassConstantSuffix
+When defined, the check will ensure class constant names will add the
+suffix with the given value (regardless of casing).
+```
+
+```{option} ClassConstantHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - ClassMemberCase of ``lower_case``
+- {option}`ClassConstantCase` of `lower_case`
+- {option}`ClassConstantPrefix` of `pre_`
+- {option}`ClassConstantSuffix` of `_post`
+- {option}`ClassConstantHungarianPrefix` of `On`
+
+Identifies and/or transforms class constant names as follows:
Before:
-.. code-block:: c++
+```c++
+class FOO {
+public:
+ static const int CLASS_CONSTANT;
+};
+```
- template <typename T>
- struct Base {
- T BadNamedMember;
- };
+After:
- template <typename T>
- struct Derived : Base<T> {
- void reset() {
- this->BadNamedMember = 0;
- }
- };
+```c++
+class FOO {
+public:
+ static const int pre_class_constant_post;
+};
+```
+
+```{option} ClassMemberCase
+When defined, the check will ensure class member names conform to the
+selected casing.
+```
+
+```{option} ClassMemberPrefix
+When defined, the check will ensure class member names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ClassMemberIgnoredRegexp
+Identifier naming checks won't be enforced for class member names
+matching this regular expression.
+```
+
+```{option} ClassMemberSuffix
+When defined, the check will ensure class member names will add the
+suffix with the given value (regardless of casing).
+```
+
+```{option} ClassMemberHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
-After if AggressiveDependentMemberLookup is `false`:
+For example using values of:
-.. code-block:: c++
+- {option}`ClassMemberCase` of `lower_case`
+- {option}`ClassMemberPrefix` of `pre_`
+- {option}`ClassMemberSuffix` of `_post`
+- {option}`ClassMemberHungarianPrefix` of `On`
- template <typename T>
- struct Base {
- T bad_named_member;
- };
+Identifies and/or transforms class member names as follows:
- template <typename T>
- struct Derived : Base<T> {
- void reset() {
- this->BadNamedMember = 0;
- }
- };
+Before:
-After if AggressiveDependentMemberLookup is `true`:
+```c++
+class FOO {
+public:
+ static int CLASS_CONSTANT;
+};
+```
-.. code-block:: c++
+After:
- template <typename T>
- struct Base {
- T bad_named_member;
- };
+```c++
+class FOO {
+public:
+ static int pre_class_constant_post;
+};
+```
+
+```{option} ClassMethodCase
+When defined, the check will ensure class method names conform to the
+selected casing.
+```
+
+```{option} ClassMethodPrefix
+When defined, the check will ensure class method names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ClassMethodIgnoredRegexp
+Identifier naming checks won't be enforced for class method names
+matching this regular expression.
+```
+
+```{option} ClassMethodSuffix
+When defined, the check will ensure class method names will add the
+suffix with the given value (regardless of casing).
+```
- template <typename T>
- struct Derived : Base<T> {
- void reset() {
- this->bad_named_member = 0;
- }
- };
+For example using values of:
-.. option:: CheckAnonFieldInParent
+- {option}`ClassMethodCase` of `lower_case`
+- {option}`ClassMethodPrefix` of `pre_`
+- {option}`ClassMethodSuffix` of `_post`
- When set to `true`, fields in anonymous records (i.e. anonymous
- unions and structs) will be treated as names in the enclosing scope
- rather than public members of the anonymous record for the purpose
- of name checking.
+Identifies and/or transforms class method names as follows:
-For example:
+Before:
-.. code-block:: c++
-
- class Foo {
- private:
- union {
- int iv_;
- float fv_;
- };
- };
-
-If :option:`CheckAnonFieldInParent` is `false`, you may get warnings
-that ``iv_`` and ``fv_`` are not coherent to public member names, because
-``iv_`` and ``fv_`` are public members of the anonymous union. When
-:option:`CheckAnonFieldInParent` is `true`, ``iv_`` and ``fv_`` will be
-treated as private data members of ``Foo`` for the purpose of name checking
-and thus no warnings will be emitted.
+```c++
+class FOO {
+public:
+ int CLASS_MEMBER();
+};
+```
+
+After:
+
+```c++
+class FOO {
+public:
+ int pre_class_member_post();
+};
+```
+
+```{option} ConceptCase
+When defined, the check will ensure concept names conform to the
+selected casing.
+```
+
+```{option} ConceptPrefix
+When defined, the check will ensure concept names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ConceptIgnoredRegexp
+Identifier naming checks won't be enforced for concept names
+matching this regular expression.
+```
+
+```{option} ConceptSuffix
+When defined, the check will ensure concept names will add the
+suffix with the given value (regardless of casing).
+```
-.. option:: ClassCase
+For example using values of:
+
+- {option}`ConceptCase` of `CamelCase`
+- {option}`ConceptPrefix` of `Pre`
+- {option}`ConceptSuffix` of `Post`
+
+Identifies and/or transforms concept names as follows:
- When defined, the check will ensure class names conform to the
- selected casing.
+Before:
-.. option:: ClassPrefix
+```c++
+template<typename T> concept my_concept = requires (T t) { {t++}; };
+```
- When defined, the check will ensure class names will add the
- prefix with the given value (regardless of casing).
+After:
-.. option:: ClassIgnoredRegexp
+```c++
+template<typename T> concept PreMyConceptPost = requires (T t) { {t++}; };
+```
- Identifier naming checks won't be enforced for class names matching
- this regular expression.
+```{option} ConstantCase
+When defined, the check will ensure constant names conform to the
+selected casing.
+```
-.. option:: ClassSuffix
+```{option} ConstantPrefix
+When defined, the check will ensure constant names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure class names will add the
- suffix with the given value (regardless of casing).
+```{option} ConstantIgnoredRegexp
+Identifier naming checks won't be enforced for constant names
+matching this regular expression.
+```
-.. option:: ClassHungarianPrefix
+```{option} ConstantSuffix
+When defined, the check will ensure constant names will add the
+suffix with the given value (regardless of casing).
+```
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```{option} ConstantHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - ClassCase of ``lower_case``
- - ClassPrefix of ``pre_``
- - ClassSuffix of ``_post``
- - ClassHungarianPrefix of ``On``
+- {option}`ConstantCase` of `lower_case`
+- {option}`ConstantPrefix` of `pre_`
+- {option}`ConstantSuffix` of `_post`
+- {option}`ConstantHungarianPrefix` of `On`
-Identifies and/or transforms class names as follows:
+Identifies and/or transforms constant names as follows:
Before:
-.. code-block:: c++
-
- class FOO {
- public:
- FOO();
- ~FOO();
- };
+```c++
+void function() { unsigned const MyConst_array[] = {1, 2, 3}; }
+```
After:
-.. code-block:: c++
+```c++
+void function() { unsigned const pre_myconst_array_post[] = {1, 2, 3}; }
+```
+
+```{option} ConstantMemberCase
+When defined, the check will ensure constant member names conform to the
+selected casing.
+```
- class pre_foo_post {
- public:
- pre_foo_post();
- ~pre_foo_post();
- };
+```{option} ConstantMemberPrefix
+When defined, the check will ensure constant member names will add the
+prefix with the given value (regardless of casing).
+```
-.. option:: ClassConstexprCase
+```{option} ConstantMemberIgnoredRegexp
+Identifier naming checks won't be enforced for constant member names
+matching this regular expression.
+```
- When defined, the check will ensure class ``constexpr`` names conform to
- the selected casing.
+```{option} ConstantMemberSuffix
+When defined, the check will ensure constant member names will add the
+suffix with the given value (regardless of casing).
+```
-.. option:: ClassConstexprPrefix
+```{option} ConstantMemberHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
- When defined, the check will ensure class ``constexpr`` names will add the
- prefix with the given value (regardless of casing).
+For example using values of:
-.. option:: ClassConstexprIgnoredRegexp
+- {option}`ConstantMemberCase` of `lower_case`
+- {option}`ConstantMemberPrefix` of `pre_`
+- {option}`ConstantMemberSuffix` of `_post`
+- {option}`ConstantMemberHungarianPrefix` of `On`
- Identifier naming checks won't be enforced for class ``constexpr`` names
- matching this regular expression.
+Identifies and/or transforms constant member names as follows:
-.. option:: ClassConstexprSuffix
+Before:
- When defined, the check will ensure class ``constexpr`` names will add the
- suffix with the given value (regardless of casing).
+```c++
+class Foo {
+ char const MY_ConstMember_string[4] = "123";
+}
+```
-.. option:: ClassConstexprHungarianPrefix
+After:
- When enabled, the check ensures that the declared identifier will have a
- Hungarian notation prefix based on the declared type.
+```c++
+class Foo {
+ char const pre_my_constmember_string_post[4] = "123";
+}
+```
+
+```{option} ConstantParameterCase
+When defined, the check will ensure constant parameter names conform to the
+selected casing.
+```
+
+```{option} ConstantParameterPrefix
+When defined, the check will ensure constant parameter names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ConstantParameterIgnoredRegexp
+Identifier naming checks won't be enforced for constant parameter names
+matching this regular expression.
+```
+
+```{option} ConstantParameterSuffix
+When defined, the check will ensure constant parameter names will add the
+suffix with the given value (regardless of casing).
+```
+
+```{option} ConstantParameterHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - ClassConstexprCase of ``lower_case``
- - ClassConstexprPrefix of ``pre_``
- - ClassConstexprSuffix of ``_post``
- - ClassConstexprHungarianPrefix of ``On``
+- {option}`ConstantParameterCase` of `lower_case`
+- {option}`ConstantParameterPrefix` of `pre_`
+- {option}`ConstantParameterSuffix` of `_post`
+- {option}`ConstantParameterHungarianPrefix` of `On`
-Identifies and/or transforms class ``constexpr`` variable names as follows:
+Identifies and/or transforms constant parameter names as follows:
Before:
-.. code-block:: c++
-
- class FOO {
- public:
- static constexpr int CLASS_CONSTEXPR;
- };
+```c++
+void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
+```
After:
-.. code-block:: c++
+```c++
+void GLOBAL_FUNCTION(int PARAMETER_1, int const pre_const_parameter_post);
+```
+
+```{option} ConstantPointerParameterCase
+When defined, the check will ensure constant pointer parameter names conform to the
+selected casing.
+```
+
+```{option} ConstantPointerParameterPrefix
+When defined, the check will ensure constant pointer parameter names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ConstantPointerParameterIgnoredRegexp
+Identifier naming checks won't be enforced for constant pointer parameter
+names matching this regular expression.
+```
+
+```{option} ConstantPointerParameterSuffix
+When defined, the check will ensure constant pointer parameter names will add the
+suffix with the given value (regardless of casing).
+```
- class FOO {
- public:
- static const int pre_class_constexpr_post;
- };
+```{option} ConstantPointerParameterHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
-.. option:: ClassConstantCase
+For example using values of:
+
+- {option}`ConstantPointerParameterCase` of `lower_case`
+- {option}`ConstantPointerParameterPrefix` of `pre_`
+- {option}`ConstantPointerParameterSuffix` of `_post`
+- {option}`ConstantPointerParameterHungarianPrefix` of `On`
- When defined, the check will ensure class constant names conform to the
- selected casing.
+Identifies and/or transforms constant pointer parameter names as follows:
-.. option:: ClassConstantPrefix
+Before:
- When defined, the check will ensure class constant names will add the
- prefix with the given value (regardless of casing).
+```c++
+void GLOBAL_FUNCTION(int const *CONST_parameter);
+```
-.. option:: ClassConstantIgnoredRegexp
+After:
- Identifier naming checks won't be enforced for class constant names
- matching this regular expression.
+```c++
+void GLOBAL_FUNCTION(int const *pre_const_parameter_post);
+```
-.. option:: ClassConstantSuffix
+```{option} ConstexprFunctionCase
+When defined, the check will ensure constexpr function names conform to the
+selected casing.
+```
- When defined, the check will ensure class constant names will add the
- suffix with the given value (regardless of casing).
+```{option} ConstexprFunctionPrefix
+When defined, the check will ensure constexpr function names will add the
+prefix with the given value (regardless of casing).
+```
-.. option:: ClassConstantHungarianPrefix
+```{option} ConstexprFunctionIgnoredRegexp
+Identifier naming checks won't be enforced for constexpr function names
+matching this regular expression.
+```
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```{option} ConstexprFunctionSuffix
+When defined, the check will ensure constexpr function names will add the
+suffix with the given value (regardless of casing).
+```
For example using values of:
- - ClassConstantCase of ``lower_case``
- - ClassConstantPrefix of ``pre_``
- - ClassConstantSuffix of ``_post``
- - ClassConstantHungarianPrefix of ``On``
+- {option}`ConstexprFunctionCase` of `lower_case`
+- {option}`ConstexprFunctionPrefix` of `pre_`
+- {option}`ConstexprFunctionSuffix` of `_post`
-Identifies and/or transforms class constant names as follows:
+Identifies and/or transforms constexpr function names as follows:
Before:
-.. code-block:: c++
-
- class FOO {
- public:
- static const int CLASS_CONSTANT;
- };
+```c++
+constexpr int CE_function() { return 3; }
+```
After:
-.. code-block:: c++
+```c++
+constexpr int pre_ce_function_post() { return 3; }
+```
- class FOO {
- public:
- static const int pre_class_constant_post;
- };
+```{option} ConstexprMethodCase
+When defined, the check will ensure constexpr method names conform to the
+selected casing.
+```
-.. option:: ClassMemberCase
+```{option} ConstexprMethodPrefix
+When defined, the check will ensure constexpr method names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure class member names conform to the
- selected casing.
+```{option} ConstexprMethodIgnoredRegexp
+Identifier naming checks won't be enforced for constexpr method names
+matching this regular expression.
+```
-.. option:: ClassMemberPrefix
+```{option} ConstexprMethodSuffix
+When defined, the check will ensure constexpr method names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure class member names will add the
- prefix with the given value (regardless of casing).
+For example using values of:
-.. option:: ClassMemberIgnoredRegexp
+- {option}`ConstexprMethodCase` of `lower_case`
+- {option}`ConstexprMethodPrefix` of `pre_`
+- {option}`ConstexprMethodSuffix` of `_post`
- Identifier naming checks won't be enforced for class member names
- matching this regular expression.
+Identifies and/or transforms constexpr method names as follows:
-.. option:: ClassMemberSuffix
+Before:
- When defined, the check will ensure class member names will add the
- suffix with the given value (regardless of casing).
+```c++
+class Foo {
+public:
+ constexpr int CST_expr_Method() { return 2; }
+}
+```
-.. option:: ClassMemberHungarianPrefix
+After:
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```c++
+class Foo {
+public:
+ constexpr int pre_cst_expr_method_post() { return 2; }
+}
+```
+
+```{option} ConstexprVariableCase
+When defined, the check will ensure constexpr variable names conform to the
+selected casing.
+```
+
+```{option} ConstexprVariablePrefix
+When defined, the check will ensure constexpr variable names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ConstexprVariableIgnoredRegexp
+Identifier naming checks won't be enforced for constexpr variable names
+matching this regular expression.
+```
+
+```{option} ConstexprVariableSuffix
+When defined, the check will ensure constexpr variable names will add the
+suffix with the given value (regardless of casing).
+```
+
+```{option} ConstexprVariableHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - ClassMemberCase of ``lower_case``
- - ClassMemberPrefix of ``pre_``
- - ClassMemberSuffix of ``_post``
- - ClassMemberHungarianPrefix of ``On``
+- {option}`ConstexprVariableCase` of `lower_case`
+- {option}`ConstexprVariablePrefix` of `pre_`
+- {option}`ConstexprVariableSuffix` of `_post`
+- {option}`ConstexprVariableHungarianPrefix` of `On`
-Identifies and/or transforms class member names as follows:
+Identifies and/or transforms constexpr variable names as follows:
Before:
-.. code-block:: c++
-
- class FOO {
- public:
- static int CLASS_CONSTANT;
- };
+```c++
+constexpr int ConstExpr_variable = MyConstant;
+```
After:
-.. code-block:: c++
+```c++
+constexpr int pre_constexpr_variable_post = MyConstant;
+```
+
+```{option} EnumCase
+When defined, the check will ensure enumeration names conform to the
+selected casing.
+```
- class FOO {
- public:
- static int pre_class_constant_post;
- };
+```{option} EnumPrefix
+When defined, the check will ensure enumeration names will add the
+prefix with the given value (regardless of casing).
+```
-.. option:: ClassMethodCase
+```{option} EnumIgnoredRegexp
+Identifier naming checks won't be enforced for enumeration names
+matching this regular expression.
+```
- When defined, the check will ensure class method names conform to the
- selected casing.
+```{option} EnumSuffix
+When defined, the check will ensure enumeration names will add the
+suffix with the given value (regardless of casing).
+```
-.. option:: ClassMethodPrefix
+For example using values of:
- When defined, the check will ensure class method names will add the
- prefix with the given value (regardless of casing).
+- {option}`EnumCase` of `lower_case`
+- {option}`EnumPrefix` of `pre_`
+- {option}`EnumSuffix` of `_post`
-.. option:: ClassMethodIgnoredRegexp
+Identifies and/or transforms enumeration names as follows:
- Identifier naming checks won't be enforced for class method names
- matching this regular expression.
+Before:
-.. option:: ClassMethodSuffix
+```c++
+enum FOO { One, Two, Three };
+```
- When defined, the check will ensure class method names will add the
- suffix with the given value (regardless of casing).
+After:
-For example using values of:
+```c++
+enum pre_foo_post { One, Two, Three };
+```
- - ClassMethodCase of ``lower_case``
- - ClassMethodPrefix of ``pre_``
- - ClassMethodSuffix of ``_post``
+```{option} EnumConstantCase
+When defined, the check will ensure enumeration constant names conform to the
+selected casing.
+```
-Identifies and/or transforms class method names as follows:
+```{option} EnumConstantPrefix
+When defined, the check will ensure enumeration constant names will add the
+prefix with the given value (regardless of casing).
+```
-Before:
+```{option} EnumConstantIgnoredRegexp
+Identifier naming checks won't be enforced for enumeration constant names
+matching this regular expression.
+```
-.. code-block:: c++
+```{option} EnumConstantSuffix
+When defined, the check will ensure enumeration constant names will add the
+suffix with the given value (regardless of casing).
+```
- class FOO {
- public:
- int CLASS_MEMBER();
- };
+```{option} EnumConstantHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
-After:
+For example using values of:
-.. code-block:: c++
+- {option}`EnumConstantCase` of `lower_case`
+- {option}`EnumConstantPrefix` of `pre_`
+- {option}`EnumConstantSuffix` of `_post`
+- {option}`EnumConstantHungarianPrefix` of `On`
- class FOO {
- public:
- int pre_class_member_post();
- };
+Identifies and/or transforms enumeration constant names as follows:
-.. option:: ConceptCase
+Before:
- When defined, the check will ensure concept names conform to the
- selected casing.
+```c++
+enum FOO { One, Two, Three };
+```
-.. option:: ConceptPrefix
+After:
- When defined, the check will ensure concept names will add the
- prefix with the given value (regardless of casing).
+```c++
+enum FOO { pre_One_post, pre_Two_post, pre_Three_post };
+```
-.. option:: ConceptIgnoredRegexp
+```{option} FunctionCase
+When defined, the check will ensure function names conform to the
+selected casing.
+```
- Identifier naming checks won't be enforced for concept names
- matching this regular expression.
+```{option} FunctionPrefix
+When defined, the check will ensure function names will add the
+prefix with the given value (regardless of casing).
+```
-.. option:: ConceptSuffix
+```{option} FunctionIgnoredRegexp
+Identifier naming checks won't be enforced for function names
+matching this regular expression.
+```
- When defined, the check will ensure concept names will add the
- suffix with the given value (regardless of casing).
+```{option} FunctionSuffix
+When defined, the check will ensure function names will add the
+suffix with the given value (regardless of casing).
+```
For example using values of:
- - ConceptCase of ``CamelCase``
- - ConceptPrefix of ``Pre``
- - ConceptSuffix of ``Post``
+- {option}`FunctionCase` of `lower_case`
+- {option}`FunctionPrefix` of `pre_`
+- {option}`FunctionSuffix` of `_post`
-Identifies and/or transforms concept names as follows:
+Identifies and/or transforms function names as follows:
Before:
-.. code-block:: c++
-
- template<typename T> concept my_concept = requires (T t) { {t++}; };
+```c++
+char MY_Function_string();
+```
After:
-.. code-block:: c++
+```c++
+char pre_my_function_string_post();
+```
+
+```{option} GetConfigPerFile
+When `true`, the check will look for the configuration for where an
+identifier is declared. Useful for when included header files use a
+different style.
+Default is `true`.
+```
+
+```{option} GlobalConstexprVariableCase
+When defined, the check will ensure global `constexpr` variable names
+conform to the selected casing.
+```
+
+```{option} GlobalConstexprVariablePrefix
+When defined, the check will ensure global `constexpr` variable names
+will add the prefixed with the given value (regardless of casing).
+```
+
+```{option} GlobalConstexprVariableIgnoredRegexp
+Identifier naming checks won't be enforced for global `constexpr`
+variable names matching this regular expression.
+```
+
+```{option} GlobalConstexprVariableSuffix
+When defined, the check will ensure global `constexpr` variable names
+will add the suffix with the given value (regardless of casing).
+```
+
+```{option} GlobalConstexprVariableHungarianPrefix
+When enabled, the check ensures that the declared identifier will have a
+Hungarian notation prefix based on the declared type.
+```
+
+For example using values of:
- template<typename T> concept PreMyConceptPost = requires (T t) { {t++}; };
+- {option}`GlobalConstexprVariableCase` of `lower_case`
+- {option}`GlobalConstexprVariablePrefix` of `pre_`
+- {option}`GlobalConstexprVariableSuffix` of `_post`
+- {option}`GlobalConstexprVariableHungarianPrefix` of `On`
-.. option:: ConstantCase
+Identifies and/or transforms global `constexpr` variable names as follows:
- When defined, the check will ensure constant names conform to the
- selected casing.
+Before:
-.. option:: ConstantPrefix
+```c++
+constexpr unsigned ImportantValue = 69;
+```
- When defined, the check will ensure constant names will add the
- prefix with the given value (regardless of casing).
+After:
-.. option:: ConstantIgnoredRegexp
+```c++
+constexpr unsigned pre_important_value_post = 69;
+```
- Identifier naming checks won't be enforced for constant names
- matching this regular expression.
+```{option} GlobalConstantCase
+When defined, the check will ensure global constant names conform to the
+selected casing.
+```
-.. option:: ConstantSuffix
+```{option} GlobalConstantPrefix
+When defined, the check will ensure global constant names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure constant names will add the
- suffix with the given value (regardless of casing).
+```{option} GlobalConstantIgnoredRegexp
+Identifier naming checks won't be enforced for global constant names
+matching this regular expression.
+```
-.. option:: ConstantHungarianPrefix
+```{option} GlobalConstantSuffix
+When defined, the check will ensure global constant names will add the
+suffix with the given value (regardless of casing).
+```
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```{option} GlobalConstantHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - ConstantCase of ``lower_case``
- - ConstantPrefix of ``pre_``
- - ConstantSuffix of ``_post``
- - ConstantHungarianPrefix of ``On``
+- {option}`GlobalConstantCase` of `lower_case`
+- {option}`GlobalConstantPrefix` of `pre_`
+- {option}`GlobalConstantSuffix` of `_post`
+- {option}`GlobalConstantHungarianPrefix` of `On`
-Identifies and/or transforms constant names as follows:
+Identifies and/or transforms global constant names as follows:
Before:
-.. code-block:: c++
-
- void function() { unsigned const MyConst_array[] = {1, 2, 3}; }
+```c++
+unsigned const MyConstGlobal_array[] = {1, 2, 3};
+```
After:
-.. code-block:: c++
+```c++
+unsigned const pre_myconstglobal_array_post[] = {1, 2, 3};
+```
+
+```{option} GlobalConstantPointerCase
+When defined, the check will ensure global constant pointer names conform to the
+selected casing.
+```
+
+```{option} GlobalConstantPointerPrefix
+When defined, the check will ensure global constant pointer names will add the
+prefix with the given value (regardless of casing).
+```
- void function() { unsigned const pre_myconst_array_post[] = {1, 2, 3}; }
+```{option} GlobalConstantPointerIgnoredRegexp
+Identifier naming checks won't be enforced for global constant pointer
+names matching this regular expression.
+```
-.. option:: ConstantMemberCase
+```{option} GlobalConstantPointerSuffix
+When defined, the check will ensure global constant pointer names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure constant member names conform to the
- selected casing.
+```{option} GlobalConstantPointerHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
-.. option:: ConstantMemberPrefix
+For example using values of:
+
+- {option}`GlobalConstantPointerCase` of `lower_case`
+- {option}`GlobalConstantPointerPrefix` of `pre_`
+- {option}`GlobalConstantPointerSuffix` of `_post`
+- {option}`GlobalConstantPointerHungarianPrefix` of `On`
+
+Identifies and/or transforms global constant pointer names as follows:
- When defined, the check will ensure constant member names will add the
- prefix with the given value (regardless of casing).
+Before:
+
+```c++
+int *const MyConstantGlobalPointer = nullptr;
+```
-.. option:: ConstantMemberIgnoredRegexp
+After:
- Identifier naming checks won't be enforced for constant member names
- matching this regular expression.
+```c++
+int *const pre_myconstantglobalpointer_post = nullptr;
+```
-.. option:: ConstantMemberSuffix
+```{option} GlobalFunctionCase
+When defined, the check will ensure global function names conform to the
+selected casing.
+```
- When defined, the check will ensure constant member names will add the
- suffix with the given value (regardless of casing).
+```{option} GlobalFunctionPrefix
+When defined, the check will ensure global function names will add the
+prefix with the given value (regardless of casing).
+```
-.. option:: ConstantMemberHungarianPrefix
+```{option} GlobalFunctionIgnoredRegexp
+Identifier naming checks won't be enforced for global function names
+matching this regular expression.
+```
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```{option} GlobalFunctionSuffix
+When defined, the check will ensure global function names will add the
+suffix with the given value (regardless of casing).
+```
For example using values of:
- - ConstantMemberCase of ``lower_case``
- - ConstantMemberPrefix of ``pre_``
- - ConstantMemberSuffix of ``_post``
- - ConstantMemberHungarianPrefix of ``On``
+- {option}`GlobalFunctionCase` of `lower_case`
+- {option}`GlobalFunctionPrefix` of `pre_`
+- {option}`GlobalFunctionSuffix` of `_post`
-Identifies and/or transforms constant member names as follows:
+Identifies and/or transforms global function names as follows:
Before:
-.. code-block:: c++
-
- class Foo {
- char const MY_ConstMember_string[4] = "123";
- }
+```c++
+void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
+```
After:
-.. code-block:: c++
+```c++
+void pre_global_function_post(int PARAMETER_1, int const CONST_parameter);
+```
- class Foo {
- char const pre_my_constmember_string_post[4] = "123";
- }
+```{option} GlobalPointerCase
+When defined, the check will ensure global pointer names conform to the
+selected casing.
+```
-.. option:: ConstantParameterCase
+```{option} GlobalPointerPrefix
+When defined, the check will ensure global pointer names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure constant parameter names conform to the
- selected casing.
+```{option} GlobalPointerIgnoredRegexp
+Identifier naming checks won't be enforced for global pointer names
+matching this regular expression.
+```
-.. option:: ConstantParameterPrefix
+```{option} GlobalPointerSuffix
+When defined, the check will ensure global pointer names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure constant parameter names will add the
- prefix with the given value (regardless of casing).
+```{option} GlobalPointerHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
-.. option:: ConstantParameterIgnoredRegexp
-
- Identifier naming checks won't be enforced for constant parameter names
- matching this regular expression.
+For example using values of:
-.. option:: ConstantParameterSuffix
+- {option}`GlobalPointerCase` of `lower_case`
+- {option}`GlobalPointerPrefix` of `pre_`
+- {option}`GlobalPointerSuffix` of `_post`
+- {option}`GlobalPointerHungarianPrefix` of `On`
- When defined, the check will ensure constant parameter names will add the
- suffix with the given value (regardless of casing).
+Identifies and/or transforms global pointer names as follows:
-.. option:: ConstantParameterHungarianPrefix
+Before:
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```c++
+int *GLOBAL3;
+```
-For example using values of:
+After:
- - ConstantParameterCase of ``lower_case``
- - ConstantParameterPrefix of ``pre_``
- - ConstantParameterSuffix of ``_post``
- - ConstantParameterHungarianPrefix of ``On``
+```c++
+int *pre_global3_post;
+```
-Identifies and/or transforms constant parameter names as follows:
+```{option} GlobalVariableCase
+When defined, the check will ensure global variable names conform to the
+selected casing.
+```
-Before:
+```{option} GlobalVariablePrefix
+When defined, the check will ensure global variable names will add the
+prefix with the given value (regardless of casing).
+```
-.. code-block:: c++
+```{option} GlobalVariableIgnoredRegexp
+Identifier naming checks won't be enforced for global variable names
+matching this regular expression.
+```
- void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
+```{option} GlobalVariableSuffix
+When defined, the check will ensure global variable names will add the
+suffix with the given value (regardless of casing).
+```
-After:
+```{option} GlobalVariableHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
-.. code-block:: c++
+For example using values of:
- void GLOBAL_FUNCTION(int PARAMETER_1, int const pre_const_parameter_post);
+- {option}`GlobalVariableCase` of `lower_case`
+- {option}`GlobalVariablePrefix` of `pre_`
+- {option}`GlobalVariableSuffix` of `_post`
+- {option}`GlobalVariableHungarianPrefix` of `On`
-.. option:: ConstantPointerParameterCase
+Identifies and/or transforms global variable names as follows:
- When defined, the check will ensure constant pointer parameter names conform to the
- selected casing.
+Before:
-.. option:: ConstantPointerParameterPrefix
+```c++
+int GLOBAL3;
+```
- When defined, the check will ensure constant pointer parameter names will add the
- prefix with the given value (regardless of casing).
+After:
-.. option:: ConstantPointerParameterIgnoredRegexp
+```c++
+int pre_global3_post;
+```
- Identifier naming checks won't be enforced for constant pointer parameter
- names matching this regular expression.
+```{option} IgnoreMainLikeFunctions
+When `true`, functions that have a similar signature to `main` or
+`wmain` won't enforce checks on the names of their parameters.
+Default is `false`.
+```
-.. option:: ConstantPointerParameterSuffix
+```{option} InlineNamespaceCase
+When defined, the check will ensure inline namespaces names conform to the
+selected casing.
+```
- When defined, the check will ensure constant pointer parameter names will add the
- suffix with the given value (regardless of casing).
+```{option} InlineNamespacePrefix
+When defined, the check will ensure inline namespaces names will add the
+prefix with the given value (regardless of casing).
+```
-.. option:: ConstantPointerParameterHungarianPrefix
+```{option} InlineNamespaceIgnoredRegexp
+Identifier naming checks won't be enforced for inline namespaces names
+matching this regular expression.
+```
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```{option} InlineNamespaceSuffix
+When defined, the check will ensure inline namespaces names will add the
+suffix with the given value (regardless of casing).
+```
For example using values of:
- - ConstantPointerParameterCase of ``lower_case``
- - ConstantPointerParameterPrefix of ``pre_``
- - ConstantPointerParameterSuffix of ``_post``
- - ConstantPointerParameterHungarianPrefix of ``On``
+- {option}`InlineNamespaceCase` of `lower_case`
+- {option}`InlineNamespacePrefix` of `pre_`
+- {option}`InlineNamespaceSuffix` of `_post`
-Identifies and/or transforms constant pointer parameter names as follows:
+Identifies and/or transforms inline namespaces names as follows:
Before:
-.. code-block:: c++
-
- void GLOBAL_FUNCTION(int const *CONST_parameter);
+```c++
+namespace FOO_NS {
+inline namespace InlineNamespace {
+...
+}
+} // namespace FOO_NS
+```
After:
-.. code-block:: c++
-
- void GLOBAL_FUNCTION(int const *pre_const_parameter_post);
-
-.. option:: ConstexprFunctionCase
+```c++
+namespace FOO_NS {
+inline namespace pre_inlinenamespace_post {
+...
+}
+} // namespace FOO_NS
+```
+
+```{option} LambdaCaptureCase
+When defined, the check will ensure lambda init-capture names (e.g.
+`Captured` in `[Captured = Var]`) conform to the selected casing.
+A simple, non-init capture (e.g. `[Var]` or `[&Var]`) refers to the
+same declaration as `Var` itself, so it keeps following whichever
+naming style applies to `Var`'s own declaration instead.
+```
+
+```{option} LambdaCapturePrefix
+When defined, the check will ensure lambda init-capture names will add
+the prefix with the given value (regardless of casing).
+```
+
+```{option} LambdaCaptureIgnoredRegexp
+Identifier naming checks won't be enforced for lambda init-capture names
+matching this regular expression.
+```
+
+```{option} LambdaCaptureSuffix
+When defined, the check will ensure lambda init-capture names will add
+the suffix with the given value (regardless of casing).
+```
+
+```{option} LambdaCaptureHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
- When defined, the check will ensure constexpr function names conform to the
- selected casing.
+For example using values of:
-.. option:: ConstexprFunctionPrefix
+- {option}`LambdaCaptureCase` of `CamelCase`
+- {option}`LambdaCapturePrefix` of `c_`
- When defined, the check will ensure constexpr function names will add the
- prefix with the given value (regardless of casing).
+Identifies and/or transforms lambda init-capture names as follows:
-.. option:: ConstexprFunctionIgnoredRegexp
+Before:
- Identifier naming checks won't be enforced for constexpr function names
- matching this regular expression.
+```c++
+void foo() {
+ int local_variable = 0;
+ auto lambda = [captured_value = local_variable]() {
+ return captured_value;
+ };
+}
+```
-.. option:: ConstexprFunctionSuffix
+After:
- When defined, the check will ensure constexpr function names will add the
- suffix with the given value (regardless of casing).
+```c++
+void foo() {
+ int local_variable = 0;
+ auto lambda = [c_CapturedValue = local_variable]() {
+ return c_CapturedValue;
+ };
+}
+```
+
+```{option} LocalConstexprVariableCase
+When defined, the check will ensure local `constexpr` variable names
+conform to the selected casing.
+```
+
+```{option} LocalConstexprVariablePrefix
+When defined, the check will ensure local `constexpr` variable names will
+add the prefixed with the given value (regardless of casing).
+```
+
+```{option} LocalConstexprVariableIgnoredRegexp
+Identifier naming checks won't be enforced for local `constexpr` variable
+names matching this regular expression.
+```
+
+```{option} LocalConstexprVariableSuffix
+When defined, the check will ensure local `constexpr` variable names will
+add the suffix with the given value (regardless of casing).
+```
+
+```{option} LocalConstexprVariableHungarianPrefix
+When enabled, the check ensures that the declared identifier will have a
+Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - ConstexprFunctionCase of ``lower_case``
- - ConstexprFunctionPrefix of ``pre_``
- - ConstexprFunctionSuffix of ``_post``
+- {option}`LocalConstexprVariableCase` of `lower_case`
+- {option}`LocalConstexprVariablePrefix` of `pre_`
+- {option}`LocalConstexprVariableSuffix` of `_post`
+- {option}`LocalConstexprVariableHungarianPrefix` of `On`
-Identifies and/or transforms constexpr function names as follows:
+Identifies and/or transforms local `constexpr` variable names as follows:
Before:
-.. code-block:: c++
-
- constexpr int CE_function() { return 3; }
+```c++
+void foo() { int const local_Constexpr = 420; }
+```
After:
-.. code-block:: c++
+```c++
+void foo() { int const pre_local_constexpr_post = 420; }
+```
- constexpr int pre_ce_function_post() { return 3; }
+```{option} LocalConstantCase
+When defined, the check will ensure local constant names conform to the
+selected casing.
+```
-.. option:: ConstexprMethodCase
+```{option} LocalConstantPrefix
+When defined, the check will ensure local constant names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure constexpr method names conform to the
- selected casing.
+```{option} LocalConstantIgnoredRegexp
+Identifier naming checks won't be enforced for local constant names
+matching this regular expression.
+```
-.. option:: ConstexprMethodPrefix
+```{option} LocalConstantSuffix
+When defined, the check will ensure local constant names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure constexpr method names will add the
- prefix with the given value (regardless of casing).
+```{option} LocalConstantHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
-.. option:: ConstexprMethodIgnoredRegexp
+For example using values of:
- Identifier naming checks won't be enforced for constexpr method names
- matching this regular expression.
+- {option}`LocalConstantCase` of `lower_case`
+- {option}`LocalConstantPrefix` of `pre_`
+- {option}`LocalConstantSuffix` of `_post`
+- {option}`LocalConstantHungarianPrefix` of `On`
-.. option:: ConstexprMethodSuffix
+Identifies and/or transforms local constant names as follows:
- When defined, the check will ensure constexpr method names will add the
- suffix with the given value (regardless of casing).
+Before:
-For example using values of:
+```c++
+void foo() { int const local_Constant = 3; }
+```
- - ConstexprMethodCase of ``lower_case``
- - ConstexprMethodPrefix of ``pre_``
- - ConstexprMethodSuffix of ``_post``
+After:
-Identifies and/or transforms constexpr method names as follows:
+```c++
+void foo() { int const pre_local_constant_post = 3; }
+```
-Before:
+```{option} LocalConstantPointerCase
+When defined, the check will ensure local constant pointer names conform to the
+selected casing.
+```
-.. code-block:: c++
+```{option} LocalConstantPointerPrefix
+When defined, the check will ensure local constant pointer names will add the
+prefix with the given value (regardless of casing).
+```
- class Foo {
- public:
- constexpr int CST_expr_Method() { return 2; }
- }
+```{option} LocalConstantPointerIgnoredRegexp
+Identifier naming checks won't be enforced for local constant pointer names
+matching this regular expression.
+```
-After:
+```{option} LocalConstantPointerSuffix
+When defined, the check will ensure local constant pointer names will add the
+suffix with the given value (regardless of casing).
+```
-.. code-block:: c++
+```{option} LocalConstantPointerHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
+
+For example using values of:
- class Foo {
- public:
- constexpr int pre_cst_expr_method_post() { return 2; }
- }
+- {option}`LocalConstantPointerCase` of `lower_case`
+- {option}`LocalConstantPointerPrefix` of `pre_`
+- {option}`LocalConstantPointerSuffix` of `_post`
+- {option}`LocalConstantPointerHungarianPrefix` of `On`
-.. option:: ConstexprVariableCase
+Identifies and/or transforms local constant pointer names as follows:
- When defined, the check will ensure constexpr variable names conform to the
- selected casing.
+Before:
-.. option:: ConstexprVariablePrefix
+```c++
+void foo() { int const *local_Constant = 3; }
+```
- When defined, the check will ensure constexpr variable names will add the
- prefix with the given value (regardless of casing).
+After:
-.. option:: ConstexprVariableIgnoredRegexp
+```c++
+void foo() { int const *pre_local_constant_post = 3; }
+```
- Identifier naming checks won't be enforced for constexpr variable names
- matching this regular expression.
+```{option} LocalPointerCase
+When defined, the check will ensure local pointer names conform to the
+selected casing.
+```
-.. option:: ConstexprVariableSuffix
+```{option} LocalPointerPrefix
+When defined, the check will ensure local pointer names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure constexpr variable names will add the
- suffix with the given value (regardless of casing).
+```{option} LocalPointerIgnoredRegexp
+Identifier naming checks won't be enforced for local pointer names
+matching this regular expression.
+```
-.. option:: ConstexprVariableHungarianPrefix
+```{option} LocalPointerSuffix
+When defined, the check will ensure local pointer names will add the
+suffix with the given value (regardless of casing).
+```
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```{option} LocalPointerHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - ConstexprVariableCase of ``lower_case``
- - ConstexprVariablePrefix of ``pre_``
- - ConstexprVariableSuffix of ``_post``
- - ConstexprVariableHungarianPrefix of ``On``
+- {option}`LocalPointerCase` of `lower_case`
+- {option}`LocalPointerPrefix` of `pre_`
+- {option}`LocalPointerSuffix` of `_post`
+- {option}`LocalPointerHungarianPrefix` of `On`
-Identifies and/or transforms constexpr variable names as follows:
+Identifies and/or transforms local pointer names as follows:
Before:
-.. code-block:: c++
-
- constexpr int ConstExpr_variable = MyConstant;
+```c++
+void foo() { int *local_Constant; }
+```
After:
-.. code-block:: c++
+```c++
+void foo() { int *pre_local_constant_post; }
+```
- constexpr int pre_constexpr_variable_post = MyConstant;
+```{option} LocalVariableCase
+When defined, the check will ensure local variable names conform to the
+selected casing.
+```
-.. option:: EnumCase
+```{option} LocalVariablePrefix
+When defined, the check will ensure local variable names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure enumeration names conform to the
- selected casing.
+```{option} LocalVariableIgnoredRegexp
+Identifier naming checks won't be enforced for local variable names
+matching this regular expression.
+```
-.. option:: EnumPrefix
-
- When defined, the check will ensure enumeration names will add the
- prefix with the given value (regardless of casing).
+For example using values of:
-.. option:: EnumIgnoredRegexp
+- {option}`LocalVariableCase` of `CamelCase`
+- {option}`LocalVariableIgnoredRegexp` of `\w{1,2}`
- Identifier naming checks won't be enforced for enumeration names
- matching this regular expression.
+Will exclude variables with a length less than or equal to 2 from the
+camel case check applied to other variables.
-.. option:: EnumSuffix
+```{option} LocalVariableSuffix
+When defined, the check will ensure local variable names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure enumeration names will add the
- suffix with the given value (regardless of casing).
+```{option} LocalVariableHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - EnumCase of ``lower_case``
- - EnumPrefix of ``pre_``
- - EnumSuffix of ``_post``
+- {option}`LocalVariableCase` of `lower_case`
+- {option}`LocalVariablePrefix` of `pre_`
+- {option}`LocalVariableSuffix` of `_post`
+- {option}`LocalVariableHungarianPrefix` of `On`
-Identifies and/or transforms enumeration names as follows:
+Identifies and/or transforms local variable names as follows:
Before:
-.. code-block:: c++
-
- enum FOO { One, Two, Three };
+```c++
+void foo() { int local_Constant; }
+```
After:
-.. code-block:: c++
+```c++
+void foo() { int pre_local_constant_post; }
+```
- enum pre_foo_post { One, Two, Three };
+```{option} MacroDefinitionCase
+When defined, the check will ensure macro definitions conform to the
+selected casing.
+```
-.. option:: EnumConstantCase
+```{option} MacroDefinitionPrefix
+When defined, the check will ensure macro definitions will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure enumeration constant names conform to the
- selected casing.
+```{option} MacroDefinitionIgnoredRegexp
+Identifier naming checks won't be enforced for macro definitions
+matching this regular expression.
+```
-.. option:: EnumConstantPrefix
+```{option} MacroDefinitionSuffix
+When defined, the check will ensure macro definitions will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure enumeration constant names will add the
- prefix with the given value (regardless of casing).
+For example using values of:
-.. option:: EnumConstantIgnoredRegexp
+- {option}`MacroDefinitionCase` of `lower_case`
+- {option}`MacroDefinitionPrefix` of `pre_`
+- {option}`MacroDefinitionSuffix` of `_post`
- Identifier naming checks won't be enforced for enumeration constant names
- matching this regular expression.
+Identifies and/or transforms macro definitions as follows:
-.. option:: EnumConstantSuffix
+Before:
- When defined, the check will ensure enumeration constant names will add the
- suffix with the given value (regardless of casing).
+```c
+#define MY_MacroDefinition
+```
-.. option:: EnumConstantHungarianPrefix
+After:
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```c
+#define pre_my_macro_definition_post
+```
-For example using values of:
+Note: This will not warn on builtin macros or macros defined on the
+command line using the `-D` flag.
- - EnumConstantCase of ``lower_case``
- - EnumConstantPrefix of ``pre_``
- - EnumConstantSuffix of ``_post``
- - EnumConstantHungarianPrefix of ``On``
+```{option} MemberCase
+When defined, the check will ensure member names conform to the
+selected casing.
+```
-Identifies and/or transforms enumeration constant names as follows:
+```{option} MemberPrefix
+When defined, the check will ensure member names will add the
+prefix with the given value (regardless of casing).
+```
-Before:
+```{option} MemberIgnoredRegexp
+Identifier naming checks won't be enforced for member names
+matching this regular expression.
+```
-.. code-block:: c++
+```{option} MemberSuffix
+When defined, the check will ensure member names will add the
+suffix with the given value (regardless of casing).
+```
- enum FOO { One, Two, Three };
+```{option} MemberHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
-After:
+For example using values of:
-.. code-block:: c++
+- {option}`MemberCase` of `lower_case`
+- {option}`MemberPrefix` of `pre_`
+- {option}`MemberSuffix` of `_post`
+- {option}`MemberHungarianPrefix` of `On`
- enum FOO { pre_One_post, pre_Two_post, pre_Three_post };
+Identifies and/or transforms member names as follows:
-.. option:: FunctionCase
+Before:
- When defined, the check will ensure function names conform to the
- selected casing.
+```c++
+class Foo {
+ char MY_ConstMember_string[4];
+}
+```
-.. option:: FunctionPrefix
+After:
- When defined, the check will ensure function names will add the
- prefix with the given value (regardless of casing).
+```c++
+class Foo {
+ char pre_my_constmember_string_post[4];
+}
+```
-.. option:: FunctionIgnoredRegexp
+```{option} MethodCase
+When defined, the check will ensure method names conform to the
+selected casing.
+```
- Identifier naming checks won't be enforced for function names
- matching this regular expression.
+```{option} MethodPrefix
+When defined, the check will ensure method names will add the
+prefix with the given value (regardless of casing).
+```
-.. option:: FunctionSuffix
+```{option} MethodIgnoredRegexp
+Identifier naming checks won't be enforced for method names
+matching this regular expression.
+```
- When defined, the check will ensure function names will add the
- suffix with the given value (regardless of casing).
+```{option} MethodSuffix
+When defined, the check will ensure method names will add the
+suffix with the given value (regardless of casing).
+```
For example using values of:
- - FunctionCase of ``lower_case``
- - FunctionPrefix of ``pre_``
- - FunctionSuffix of ``_post``
+- {option}`MethodCase` of `lower_case`
+- {option}`MethodPrefix` of `pre_`
+- {option}`MethodSuffix` of `_post`
-Identifies and/or transforms function names as follows:
+Identifies and/or transforms method names as follows:
Before:
-.. code-block:: c++
-
- char MY_Function_string();
+```c++
+class Foo {
+ char MY_Method_string();
+}
+```
After:
-.. code-block:: c++
-
- char pre_my_function_string_post();
+```c++
+class Foo {
+ char pre_my_method_string_post();
+}
+```
-.. option:: GetConfigPerFile
+```{option} NamespaceCase
+When defined, the check will ensure namespace names conform to the
+selected casing.
+```
- When `true` the check will look for the configuration for where an
- identifier is declared. Useful for when included header files use a
- different style.
- Default value is `true`.
+```{option} NamespacePrefix
+When defined, the check will ensure namespace names will add the
+prefix with the given value (regardless of casing).
+```
-.. option:: GlobalConstexprVariableCase
+```{option} NamespaceIgnoredRegexp
+Identifier naming checks won't be enforced for namespace names
+matching this regular expression.
+```
- When defined, the check will ensure global ``constexpr`` variable names
- conform to the selected casing.
+```{option} NamespaceSuffix
+When defined, the check will ensure namespace names will add the
+suffix with the given value (regardless of casing).
+```
-.. option:: GlobalConstexprVariablePrefix
-
- When defined, the check will ensure global ``constexpr`` variable names
- will add the prefixed with the given value (regardless of casing).
+For example using values of:
-.. option:: GlobalConstexprVariableIgnoredRegexp
+- {option}`NamespaceCase` of `lower_case`
+- {option}`NamespacePrefix` of `pre_`
+- {option}`NamespaceSuffix` of `_post`
- Identifier naming checks won't be enforced for global ``constexpr``
- variable names matching this regular expression.
+Identifies and/or transforms namespace names as follows:
-.. option:: GlobalConstexprVariableSuffix
+Before:
- When defined, the check will ensure global ``constexpr`` variable names
- will add the suffix with the given value (regardless of casing).
+```c++
+namespace FOO_NS {
+...
+}
+```
-.. option:: GlobalConstexprVariableHungarianPrefix
+After:
- When enabled, the check ensures that the declared identifier will have a
- Hungarian notation prefix based on the declared type.
+```c++
+namespace pre_foo_ns_post {
+...
+}
+```
+
+```{option} ParameterCase
+When defined, the check will ensure parameter names conform to the
+selected casing.
+```
+
+```{option} ParameterPrefix
+When defined, the check will ensure parameter names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ParameterIgnoredRegexp
+Identifier naming checks won't be enforced for parameter names
+matching this regular expression.
+```
+
+```{option} ParameterSuffix
+When defined, the check will ensure parameter names will add the
+suffix with the given value (regardless of casing).
+```
+
+```{option} ParameterHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - GlobalConstexprVariableCase of ``lower_case``
- - GlobalConstexprVariablePrefix of ``pre_``
- - GlobalConstexprVariableSuffix of ``_post``
- - GlobalConstexprVariableHungarianPrefix of ``On``
+- {option}`ParameterCase` of `lower_case`
+- {option}`ParameterPrefix` of `pre_`
+- {option}`ParameterSuffix` of `_post`
+- {option}`ParameterHungarianPrefix` of `On`
-Identifies and/or transforms global ``constexpr`` variable names as follows:
+Identifies and/or transforms parameter names as follows:
Before:
-.. code-block:: c++
-
- constexpr unsigned ImportantValue = 69;
+```c++
+void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
+```
After:
-.. code-block:: c++
+```c++
+void GLOBAL_FUNCTION(int pre_parameter_post, int const CONST_parameter);
+```
- constexpr unsigned pre_important_value_post = 69;
+```{option} ParameterPackCase
+When defined, the check will ensure parameter pack names conform to the
+selected casing.
+```
-.. option:: GlobalConstantCase
+```{option} ParameterPackPrefix
+When defined, the check will ensure parameter pack names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure global constant names conform to the
- selected casing.
+```{option} ParameterPackIgnoredRegexp
+Identifier naming checks won't be enforced for parameter pack names
+matching this regular expression.
+```
-.. option:: GlobalConstantPrefix
+```{option} ParameterPackSuffix
+When defined, the check will ensure parameter pack names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure global constant names will add the
- prefix with the given value (regardless of casing).
+For example using values of:
-.. option:: GlobalConstantIgnoredRegexp
+- {option}`ParameterPackCase` of `lower_case`
+- {option}`ParameterPackPrefix` of `pre_`
+- {option}`ParameterPackSuffix` of `_post`
- Identifier naming checks won't be enforced for global constant names
- matching this regular expression.
+Identifies and/or transforms parameter pack names as follows:
-.. option:: GlobalConstantSuffix
+Before:
- When defined, the check will ensure global constant names will add the
- suffix with the given value (regardless of casing).
+```c++
+template <typename... TYPE_parameters> {
+ void FUNCTION(int... TYPE_parameters);
+}
+```
-.. option:: GlobalConstantHungarianPrefix
+After:
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```c++
+template <typename... TYPE_parameters> {
+ void FUNCTION(int... pre_type_parameters_post);
+}
+```
+
+```{option} PointerParameterCase
+When defined, the check will ensure pointer parameter names conform to the
+selected casing.
+```
+
+```{option} PointerParameterPrefix
+When defined, the check will ensure pointer parameter names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} PointerParameterIgnoredRegexp
+Identifier naming checks won't be enforced for pointer parameter names
+matching this regular expression.
+```
+
+```{option} PointerParameterSuffix
+When defined, the check will ensure pointer parameter names will add the
+suffix with the given value (regardless of casing).
+```
+
+```{option} PointerParameterHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - GlobalConstantCase of ``lower_case``
- - GlobalConstantPrefix of ``pre_``
- - GlobalConstantSuffix of ``_post``
- - GlobalConstantHungarianPrefix of ``On``
+- {option}`PointerParameterCase` of `lower_case`
+- {option}`PointerParameterPrefix` of `pre_`
+- {option}`PointerParameterSuffix` of `_post`
+- {option}`PointerParameterHungarianPrefix` of `On`
-Identifies and/or transforms global constant names as follows:
+Identifies and/or transforms pointer parameter names as follows:
Before:
-.. code-block:: c++
-
- unsigned const MyConstGlobal_array[] = {1, 2, 3};
+```c++
+void FUNCTION(int *PARAMETER);
+```
After:
-.. code-block:: c++
+```c++
+void FUNCTION(int *pre_parameter_post);
+```
- unsigned const pre_myconstglobal_array_post[] = {1, 2, 3};
+```{option} PrivateMemberCase
+When defined, the check will ensure private member names conform to the
+selected casing.
+```
-.. option:: GlobalConstantPointerCase
+```{option} PrivateMemberPrefix
+When defined, the check will ensure private member names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure global constant pointer names conform to the
- selected casing.
+```{option} PrivateMemberIgnoredRegexp
+Identifier naming checks won't be enforced for private member names
+matching this regular expression.
+```
-.. option:: GlobalConstantPointerPrefix
+```{option} PrivateMemberSuffix
+When defined, the check will ensure private member names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure global constant pointer names will add the
- prefix with the given value (regardless of casing).
+```{option} PrivateMemberHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
-.. option:: GlobalConstantPointerIgnoredRegexp
+For example using values of:
+
+- {option}`PrivateMemberCase` of `lower_case`
+- {option}`PrivateMemberPrefix` of `pre_`
+- {option}`PrivateMemberSuffix` of `_post`
+- {option}`PrivateMemberHungarianPrefix` of `On`
- Identifier naming checks won't be enforced for global constant pointer
- names matching this regular expression.
+Identifies and/or transforms private member names as follows:
-.. option:: GlobalConstantPointerSuffix
+Before:
- When defined, the check will ensure global constant pointer names will add the
- suffix with the given value (regardless of casing).
+```c++
+class Foo {
+private:
+ int Member_Variable;
+}
+```
-.. option:: GlobalConstantPointerHungarianPrefix
+After:
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```c++
+class Foo {
+private:
+ int pre_member_variable_post;
+}
+```
+
+```{option} PrivateMethodCase
+When defined, the check will ensure private method names conform to the
+selected casing.
+```
+
+```{option} PrivateMethodPrefix
+When defined, the check will ensure private method names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} PrivateMethodIgnoredRegexp
+Identifier naming checks won't be enforced for private method names
+matching this regular expression.
+```
+
+```{option} PrivateMethodSuffix
+When defined, the check will ensure private method names will add the
+suffix with the given value (regardless of casing).
+```
For example using values of:
- - GlobalConstantPointerCase of ``lower_case``
- - GlobalConstantPointerPrefix of ``pre_``
- - GlobalConstantPointerSuffix of ``_post``
- - GlobalConstantPointerHungarianPrefix of ``On``
+- {option}`PrivateMethodCase` of `lower_case`
+- {option}`PrivateMethodPrefix` of `pre_`
+- {option}`PrivateMethodSuffix` of `_post`
-Identifies and/or transforms global constant pointer names as follows:
+Identifies and/or transforms private method names as follows:
Before:
-.. code-block:: c++
-
- int *const MyConstantGlobalPointer = nullptr;
+```c++
+class Foo {
+private:
+ int Member_Method();
+}
+```
After:
-.. code-block:: c++
+```c++
+class Foo {
+private:
+ int pre_member_method_post();
+}
+```
+
+```{option} ProtectedMemberCase
+When defined, the check will ensure protected member names conform to the
+selected casing.
+```
+
+```{option} ProtectedMemberPrefix
+When defined, the check will ensure protected member names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ProtectedMemberIgnoredRegexp
+Identifier naming checks won't be enforced for protected member names
+matching this regular expression.
+```
+
+```{option} ProtectedMemberSuffix
+When defined, the check will ensure protected member names will add the
+suffix with the given value (regardless of casing).
+```
+
+```{option} ProtectedMemberHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
- int *const pre_myconstantglobalpointer_post = nullptr;
-
-.. option:: GlobalFunctionCase
-
- When defined, the check will ensure global function names conform to the
- selected casing.
+For example using values of:
-.. option:: GlobalFunctionPrefix
+- {option}`ProtectedMemberCase` of `lower_case`
+- {option}`ProtectedMemberPrefix` of `pre_`
+- {option}`ProtectedMemberSuffix` of `_post`
+- {option}`ProtectedMemberHungarianPrefix` of `On`
- When defined, the check will ensure global function names will add the
- prefix with the given value (regardless of casing).
+Identifies and/or transforms protected member names as follows:
-.. option:: GlobalFunctionIgnoredRegexp
+Before:
- Identifier naming checks won't be enforced for global function names
- matching this regular expression.
+```c++
+class Foo {
+protected:
+ int Member_Variable;
+}
+```
-.. option:: GlobalFunctionSuffix
+After:
- When defined, the check will ensure global function names will add the
- suffix with the given value (regardless of casing).
+```c++
+class Foo {
+protected:
+ int pre_member_variable_post;
+}
+```
+
+```{option} ProtectedMethodCase
+When defined, the check will ensure protected method names conform to the
+selected casing.
+```
+
+```{option} ProtectedMethodPrefix
+When defined, the check will ensure protected method names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ProtectedMethodIgnoredRegexp
+Identifier naming checks won't be enforced for protected method names
+matching this regular expression.
+```
+
+```{option} ProtectedMethodSuffix
+When defined, the check will ensure protected method names will add the
+suffix with the given value (regardless of casing).
+```
For example using values of:
- - GlobalFunctionCase of ``lower_case``
- - GlobalFunctionPrefix of ``pre_``
- - GlobalFunctionSuffix of ``_post``
+- {option}`ProtectedMethodCase` of `lower_case`
+- {option}`ProtectedMethodPrefix` of `pre_`
+- {option}`ProtectedMethodSuffix` of `_post`
-Identifies and/or transforms global function names as follows:
+Identifies and/or transforms protect method names as follows:
Before:
-.. code-block:: c++
-
- void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
+```c++
+class Foo {
+protected:
+ int Member_Method();
+}
+```
After:
-.. code-block:: c++
+```c++
+class Foo {
+protected:
+ int pre_member_method_post();
+}
+```
+
+```{option} PublicMemberCase
+When defined, the check will ensure public member names conform to the
+selected casing.
+```
+
+```{option} PublicMemberPrefix
+When defined, the check will ensure public member names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} PublicMemberIgnoredRegexp
+Identifier naming checks won't be enforced for public member names
+matching this regular expression.
+```
+
+```{option} PublicMemberSuffix
+When defined, the check will ensure public member names will add the
+suffix with the given value (regardless of casing).
+```
+
+```{option} PublicMemberHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
+
+For example using values of:
+
+- {option}`PublicMemberCase` of `lower_case`
+- {option}`PublicMemberPrefix` of `pre_`
+- {option}`PublicMemberSuffix` of `_post`
+- {option}`PublicMemberHungarianPrefix` of `On`
- void pre_global_function_post(int PARAMETER_1, int const CONST_parameter);
+Identifies and/or transforms public member names as follows:
+
+Before:
-.. option:: GlobalPointerCase
+```c++
+class Foo {
+public:
+ int Member_Variable;
+}
+```
- When defined, the check will ensure global pointer names conform to the
- selected casing.
+After:
-.. option:: GlobalPointerPrefix
+```c++
+class Foo {
+public:
+ int pre_member_variable_post;
+}
+```
+
+```{option} PublicMethodCase
+When defined, the check will ensure public method names conform to the
+selected casing.
+```
+
+```{option} PublicMethodPrefix
+When defined, the check will ensure public method names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} PublicMethodIgnoredRegexp
+Identifier naming checks won't be enforced for public method names
+matching this regular expression.
+```
+
+```{option} PublicMethodSuffix
+When defined, the check will ensure public method names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure global pointer names will add the
- prefix with the given value (regardless of casing).
+For example using values of:
-.. option:: GlobalPointerIgnoredRegexp
+- {option}`PublicMethodCase` of `lower_case`
+- {option}`PublicMethodPrefix` of `pre_`
+- {option}`PublicMethodSuffix` of `_post`
- Identifier naming checks won't be enforced for global pointer names
- matching this regular expression.
+Identifies and/or transforms public method names as follows:
-.. option:: GlobalPointerSuffix
+Before:
- When defined, the check will ensure global pointer names will add the
- suffix with the given value (regardless of casing).
+```c++
+class Foo {
+public:
+ int Member_Method();
+}
+```
-.. option:: GlobalPointerHungarianPrefix
+After:
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```c++
+class Foo {
+public:
+ int pre_member_method_post();
+}
+```
+
+```{option} ScopedEnumConstantCase
+When defined, the check will ensure scoped enum constant names conform to
+the selected casing.
+```
+
+```{option} ScopedEnumConstantPrefix
+When defined, the check will ensure scoped enum constant names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ScopedEnumConstantIgnoredRegexp
+Identifier naming checks won't be enforced for scoped enum constant names
+matching this regular expression.
+```
+
+```{option} ScopedEnumConstantSuffix
+When defined, the check will ensure scoped enum constant names will add the
+suffix with the given value (regardless of casing).
+```
+
+```{option} ScopedEnumConstantHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - GlobalPointerCase of ``lower_case``
- - GlobalPointerPrefix of ``pre_``
- - GlobalPointerSuffix of ``_post``
- - GlobalPointerHungarianPrefix of ``On``
+- {option}`ScopedEnumConstantCase` of `lower_case`
+- {option}`ScopedEnumConstantPrefix` of `pre_`
+- {option}`ScopedEnumConstantSuffix` of `_post`
+- {option}`ScopedEnumConstantHungarianPrefix` of `On`
-Identifies and/or transforms global pointer names as follows:
+Identifies and/or transforms enumeration constant names as follows:
Before:
-.. code-block:: c++
-
- int *GLOBAL3;
+```c++
+enum class FOO { One, Two, Three };
+```
After:
-.. code-block:: c++
-
- int *pre_global3_post;
+```c++
+enum class FOO { pre_One_post, pre_Two_post, pre_Three_post };
+```
-.. option:: GlobalVariableCase
+```{option} StaticConstexprVariableCase
+When defined, the check will ensure static `constexpr` variable names
+conform to the selected casing.
+```
- When defined, the check will ensure global variable names conform to the
- selected casing.
+```{option} StaticConstexprVariablePrefix
+When defined, the check will ensure static `constexpr` variable names
+will add the prefixed with the given value (regardless of casing).
+```
-.. option:: GlobalVariablePrefix
+```{option} StaticConstexprVariableIgnoredRegexp
+Identifier naming checks won't be enforced for static `constexpr`
+variable names matching this regular expression.
+```
- When defined, the check will ensure global variable names will add the
- prefix with the given value (regardless of casing).
+```{option} StaticConstexprVariableSuffix
+When defined, the check will ensure static `constexpr` variable names
+will add the suffix with the given value (regardless of casing).
+```
-.. option:: GlobalVariableIgnoredRegexp
+```{option} StaticConstexprVariableHungarianPrefix
+When enabled, the check ensures that the declared identifier will have a
+Hungarian notation prefix based on the declared type.
+```
- Identifier naming checks won't be enforced for global variable names
- matching this regular expression.
+For example using values of:
-.. option:: GlobalVariableSuffix
+- {option}`StaticConstexprVariableCase` of `lower_case`
+- {option}`StaticConstexprVariablePrefix` of `pre_`
+- {option}`StaticConstexprVariableSuffix` of `_post`
+- {option}`StaticConstexprVariableHungarianPrefix` of `On`
- When defined, the check will ensure global variable names will add the
- suffix with the given value (regardless of casing).
+Identifies and/or transforms static `constexpr` variable names as follows:
-.. option:: GlobalVariableHungarianPrefix
+Before:
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```c++
+static unsigned constexpr MyConstexprStatic_array[] = {1, 2, 3};
+```
-For example using values of:
+After:
- - GlobalVariableCase of ``lower_case``
- - GlobalVariablePrefix of ``pre_``
- - GlobalVariableSuffix of ``_post``
- - GlobalVariableHungarianPrefix of ``On``
+```c++
+static unsigned constexpr pre_my_constexpr_static_array_post[] = {1, 2, 3};
+```
-Identifies and/or transforms global variable names as follows:
+```{option} StaticConstantCase
+When defined, the check will ensure static constant names conform to the
+selected casing.
+```
-Before:
+```{option} StaticConstantPrefix
+When defined, the check will ensure static constant names will add the
+prefix with the given value (regardless of casing).
+```
-.. code-block:: c++
+```{option} StaticConstantIgnoredRegexp
+Identifier naming checks won't be enforced for static constant names
+matching this regular expression.
+```
- int GLOBAL3;
+```{option} StaticConstantSuffix
+When defined, the check will ensure static constant names will add the
+suffix with the given value (regardless of casing).
+```
-After:
+```{option} StaticConstantHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
-.. code-block:: c++
+For example using values of:
- int pre_global3_post;
+- {option}`StaticConstantCase` of `lower_case`
+- {option}`StaticConstantPrefix` of `pre_`
+- {option}`StaticConstantSuffix` of `_post`
+- {option}`StaticConstantHungarianPrefix` of `On`
-.. option:: IgnoreMainLikeFunctions
+Identifies and/or transforms static constant names as follows:
- 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 `false`.
+Before:
-.. option:: InlineNamespaceCase
+```c++
+static unsigned const MyConstStatic_array[] = {1, 2, 3};
+```
- When defined, the check will ensure inline namespaces names conform to the
- selected casing.
+After:
-.. option:: InlineNamespacePrefix
+```c++
+static unsigned const pre_myconststatic_array_post[] = {1, 2, 3};
+```
- When defined, the check will ensure inline namespaces names will add the
- prefix with the given value (regardless of casing).
+```{option} StaticVariableCase
+When defined, the check will ensure static variable names conform to the
+selected casing.
+```
-.. option:: InlineNamespaceIgnoredRegexp
+```{option} StaticVariablePrefix
+When defined, the check will ensure static variable names will add the
+prefix with the given value (regardless of casing).
+```
- Identifier naming checks won't be enforced for inline namespaces names
- matching this regular expression.
+```{option} StaticVariableIgnoredRegexp
+Identifier naming checks won't be enforced for static variable names
+matching this regular expression.
+```
-.. option:: InlineNamespaceSuffix
+```{option} StaticVariableSuffix
+When defined, the check will ensure static variable names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure inline namespaces names will add the
- suffix with the given value (regardless of casing).
+```{option} StaticVariableHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - InlineNamespaceCase of ``lower_case``
- - InlineNamespacePrefix of ``pre_``
- - InlineNamespaceSuffix of ``_post``
+- {option}`StaticVariableCase` of `lower_case`
+- {option}`StaticVariablePrefix` of `pre_`
+- {option}`StaticVariableSuffix` of `_post`
+- {option}`StaticVariableHungarianPrefix` of `On`
-Identifies and/or transforms inline namespaces names as follows:
+Identifies and/or transforms static variable names as follows:
Before:
-.. code-block:: c++
-
- namespace FOO_NS {
- inline namespace InlineNamespace {
- ...
- }
- } // namespace FOO_NS
+```c++
+static unsigned MyStatic_array[] = {1, 2, 3};
+```
After:
-.. code-block:: c++
+```c++
+static unsigned pre_mystatic_array_post[] = {1, 2, 3};
+```
- namespace FOO_NS {
- inline namespace pre_inlinenamespace_post {
- ...
- }
- } // namespace FOO_NS
+```{option} StructCase
+When defined, the check will ensure struct names conform to the
+selected casing.
+```
-.. option:: LambdaCaptureCase
+```{option} StructPrefix
+When defined, the check will ensure struct names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure lambda init-capture names (e.g.
- ``Captured`` in ``[Captured = Var]``) conform to the selected casing.
- A simple, non-init capture (e.g. ``[Var]`` or ``[&Var]``) refers to the
- same declaration as ``Var`` itself, so it keeps following whichever
- naming style applies to ``Var``'s own declaration instead.
+```{option} StructIgnoredRegexp
+Identifier naming checks won't be enforced for struct names
+matching this regular expression.
+```
-.. option:: LambdaCapturePrefix
+```{option} StructSuffix
+When defined, the check will ensure struct names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure lambda init-capture names will add
- the prefix with the given value (regardless of casing).
+For example using values of:
-.. option:: LambdaCaptureIgnoredRegexp
+- {option}`StructCase` of `lower_case`
+- {option}`StructPrefix` of `pre_`
+- {option}`StructSuffix` of `_post`
- Identifier naming checks won't be enforced for lambda init-capture names
- matching this regular expression.
+Identifies and/or transforms struct names as follows:
-.. option:: LambdaCaptureSuffix
+Before:
- When defined, the check will ensure lambda init-capture names will add
- the suffix with the given value (regardless of casing).
+```c++
+struct FOO {
+ FOO();
+ ~FOO();
+};
+```
-.. option:: LambdaCaptureHungarianPrefix
+After:
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```c++
+struct pre_foo_post {
+ pre_foo_post();
+ ~pre_foo_post();
+};
+```
+
+```{option} TemplateParameterCase
+When defined, the check will ensure template parameter names conform to the
+selected casing.
+```
+
+```{option} TemplateParameterPrefix
+When defined, the check will ensure template parameter names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} TemplateParameterIgnoredRegexp
+Identifier naming checks won't be enforced for template parameter names
+matching this regular expression.
+```
+
+```{option} TemplateParameterSuffix
+When defined, the check will ensure template parameter names will add the
+suffix with the given value (regardless of casing).
+```
For example using values of:
- - LambdaCaptureCase of ``CamelCase``
- - LambdaCapturePrefix of ``c_``
+- {option}`TemplateParameterCase` of `lower_case`
+- {option}`TemplateParameterPrefix` of `pre_`
+- {option}`TemplateParameterSuffix` of `_post`
-Identifies and/or transforms lambda init-capture names as follows:
+Identifies and/or transforms template parameter names as follows:
Before:
-.. code-block:: c++
-
- void foo() {
- int local_variable = 0;
- auto lambda = [captured_value = local_variable]() {
- return captured_value;
- };
- }
+```c++
+template <typename T> class Foo {};
+```
After:
-.. code-block:: c++
+```c++
+template <typename pre_t_post> class Foo {};
+```
+
+```{option} TemplateTemplateParameterCase
+When defined, the check will ensure template template parameter names conform to the
+selected casing.
+```
+
+```{option} TemplateTemplateParameterPrefix
+When defined, the check will ensure template template parameter names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} TemplateTemplateParameterIgnoredRegexp
+Identifier naming checks won't be enforced for template template parameter
+names matching this regular expression.
+```
- void foo() {
- int local_variable = 0;
- auto lambda = [c_CapturedValue = local_variable]() {
- return c_CapturedValue;
- };
- }
+```{option} TemplateTemplateParameterSuffix
+When defined, the check will ensure template template parameter names will add the
+suffix with the given value (regardless of casing).
+```
-.. option:: LocalConstexprVariableCase
+For example using values of:
+
+- {option}`TemplateTemplateParameterCase` of `lower_case`
+- {option}`TemplateTemplateParameterPrefix` of `pre_`
+- {option}`TemplateTemplateParameterSuffix` of `_post`
- When defined, the check will ensure local ``constexpr`` variable names
- conform to the selected casing.
+Identifies and/or transforms template template parameter names as follows:
-.. option:: LocalConstexprVariablePrefix
+Before:
- When defined, the check will ensure local ``constexpr`` variable names will
- add the prefixed with the given value (regardless of casing).
+```c++
+template <template <typename> class TPL_parameter, int COUNT_params,
+ typename... TYPE_parameters>
+```
-.. option:: LocalConstexprVariableIgnoredRegexp
+After:
- Identifier naming checks won't be enforced for local ``constexpr`` variable
- names matching this regular expression.
+```c++
+template <template <typename> class pre_tpl_parameter_post, int COUNT_params,
+ typename... TYPE_parameters>
+```
-.. option:: LocalConstexprVariableSuffix
+```{option} TypeAliasCase
+When defined, the check will ensure type alias names conform to the
+selected casing.
+```
- When defined, the check will ensure local ``constexpr`` variable names will
- add the suffix with the given value (regardless of casing).
+```{option} TypeAliasPrefix
+When defined, the check will ensure type alias names will add the
+prefix with the given value (regardless of casing).
+```
-.. option:: LocalConstexprVariableHungarianPrefix
+```{option} TypeAliasIgnoredRegexp
+Identifier naming checks won't be enforced for type alias names
+matching this regular expression.
+```
- When enabled, the check ensures that the declared identifier will have a
- Hungarian notation prefix based on the declared type.
+```{option} TypeAliasSuffix
+When defined, the check will ensure type alias names will add the
+suffix with the given value (regardless of casing).
+```
For example using values of:
- - LocalConstexprVariableCase of ``lower_case``
- - LocalConstexprVariablePrefix of ``pre_``
- - LocalConstexprVariableSuffix of ``_post``
- - LocalConstexprVariableHungarianPrefix of ``On``
+- {option}`TypeAliasCase` of `lower_case`
+- {option}`TypeAliasPrefix` of `pre_`
+- {option}`TypeAliasSuffix` of `_post`
-Identifies and/or transforms local ``constexpr`` variable names as follows:
+Identifies and/or transforms type alias names as follows:
Before:
-.. code-block:: c++
-
- void foo() { int const local_Constexpr = 420; }
+```c++
+using MY_STRUCT_TYPE = my_structure;
+```
After:
-.. code-block:: c++
+```c++
+using pre_my_struct_type_post = my_structure;
+```
- void foo() { int const pre_local_constexpr_post = 420; }
+```{option} TypedefCase
+When defined, the check will ensure typedef names conform to the
+selected casing.
+```
-.. option:: LocalConstantCase
+```{option} TypedefPrefix
+When defined, the check will ensure typedef names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure local constant names conform to the
- selected casing.
+```{option} TypedefIgnoredRegexp
+Identifier naming checks won't be enforced for typedef names
+matching this regular expression.
+```
-.. option:: LocalConstantPrefix
+```{option} TypedefSuffix
+When defined, the check will ensure typedef names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure local constant names will add the
- prefix with the given value (regardless of casing).
+For example using values of:
-.. option:: LocalConstantIgnoredRegexp
+- {option}`TypedefCase` of `lower_case`
+- {option}`TypedefPrefix` of `pre_`
+- {option}`TypedefSuffix` of `_post`
- Identifier naming checks won't be enforced for local constant names
- matching this regular expression.
+Identifies and/or transforms typedef names as follows:
-.. option:: LocalConstantSuffix
+Before:
- When defined, the check will ensure local constant names will add the
- suffix with the given value (regardless of casing).
+```c++
+typedef int MYINT;
+```
-.. option:: LocalConstantHungarianPrefix
+After:
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```c++
+typedef int pre_myint_post;
+```
+
+```{option} TypedefInheritAnonTagConfig
+When `true`, a typedef or type alias that provides the only name of
+an otherwise unnamed tag, as in `typedef enum {} MyEnum;`, is checked
+against the naming style configured for the kind of that tag
+(`AbstractClass`, `Class`, `Enum`, `Struct` or `Union`, i.e.
+{option}`EnumCase`, {option}`EnumPrefix`, {option}`EnumSuffix` and
+{option}`EnumIgnoredRegexp` for an enum) rather than against the typedef
+or type alias style. If that kind configures no case, prefix or suffix,
+the typedef or type alias style still applies. Typedefs of named tags, of
+other typedefs and of non-tag types are not affected. Default is `false`.
+```
For example using values of:
- - LocalConstantCase of ``lower_case``
- - LocalConstantPrefix of ``pre_``
- - LocalConstantSuffix of ``_post``
- - LocalConstantHungarianPrefix of ``On``
+- {option}`TypedefInheritAnonTagConfig` of `true`
+- {option}`EnumCase` of `CamelCase`
+- {option}`TypedefCase` of `lower_case`
-Identifies and/or transforms local constant names as follows:
+Identifies and/or transforms names as follows:
Before:
-.. code-block:: c++
-
- void foo() { int const local_Constant = 3; }
+```c++
+typedef enum { VAL } my_enum; // The typedef names the enum.
+typedef enum Kind { VAL2 } my_kind; // Kind names the enum.
+```
After:
-.. code-block:: c++
+```c++
+typedef enum { VAL } MyEnum;
+typedef enum Kind { VAL2 } my_kind;
+```
- void foo() { int const pre_local_constant_post = 3; }
+```{option} TypeTemplateParameterCase
+When defined, the check will ensure type template parameter names conform to the
+selected casing.
+```
-.. option:: LocalConstantPointerCase
+```{option} TypeTemplateParameterPrefix
+When defined, the check will ensure type template parameter names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure local constant pointer names conform to the
- selected casing.
+```{option} TypeTemplateParameterIgnoredRegexp
+Identifier naming checks won't be enforced for type template names
+matching this regular expression.
+```
-.. option:: LocalConstantPointerPrefix
+```{option} TypeTemplateParameterSuffix
+When defined, the check will ensure type template parameter names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure local constant pointer names will add the
- prefix with the given value (regardless of casing).
+For example using values of:
-.. option:: LocalConstantPointerIgnoredRegexp
+- {option}`TypeTemplateParameterCase` of `lower_case`
+- {option}`TypeTemplateParameterPrefix` of `pre_`
+- {option}`TypeTemplateParameterSuffix` of `_post`
- Identifier naming checks won't be enforced for local constant pointer names
- matching this regular expression.
-
-.. option:: LocalConstantPointerSuffix
-
- When defined, the check will ensure local constant pointer names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: LocalConstantPointerHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - LocalConstantPointerCase of ``lower_case``
- - LocalConstantPointerPrefix of ``pre_``
- - LocalConstantPointerSuffix of ``_post``
- - LocalConstantPointerHungarianPrefix of ``On``
-
-Identifies and/or transforms local constant pointer names as follows:
-
-Before:
-
-.. code-block:: c++
-
- void foo() { int const *local_Constant = 3; }
-
-After:
-
-.. code-block:: c++
-
- void foo() { int const *pre_local_constant_post = 3; }
-
-.. option:: LocalPointerCase
-
- When defined, the check will ensure local pointer names conform to the
- selected casing.
-
-.. option:: LocalPointerPrefix
-
- When defined, the check will ensure local pointer names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: LocalPointerIgnoredRegexp
-
- Identifier naming checks won't be enforced for local pointer names
- matching this regular expression.
-
-.. option:: LocalPointerSuffix
-
- When defined, the check will ensure local pointer names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: LocalPointerHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - LocalPointerCase of ``lower_case``
- - LocalPointerPrefix of ``pre_``
- - LocalPointerSuffix of ``_post``
- - LocalPointerHungarianPrefix of ``On``
-
-Identifies and/or transforms local pointer names as follows:
-
-Before:
-
-.. code-block:: c++
-
- void foo() { int *local_Constant; }
-
-After:
-
-.. code-block:: c++
-
- void foo() { int *pre_local_constant_post; }
-
-.. option:: LocalVariableCase
-
- When defined, the check will ensure local variable names conform to the
- selected casing.
-
-.. option:: LocalVariablePrefix
-
- When defined, the check will ensure local variable names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: LocalVariableIgnoredRegexp
-
- Identifier naming checks won't be enforced for local variable names
- matching this regular expression.
-
-For example using values of:
-
- - LocalVariableCase of ``CamelCase``
- - LocalVariableIgnoredRegexp of ``\w{1,2}``
-
-Will exclude variables with a length less than or equal to 2 from the
-camel case check applied to other variables.
-
-.. option:: LocalVariableSuffix
-
- When defined, the check will ensure local variable names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: LocalVariableHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - LocalVariableCase of ``lower_case``
- - LocalVariablePrefix of ``pre_``
- - LocalVariableSuffix of ``_post``
- - LocalVariableHungarianPrefix of ``On``
-
-Identifies and/or transforms local variable names as follows:
-
-Before:
-
-.. code-block:: c++
-
- void foo() { int local_Constant; }
-
-After:
-
-.. code-block:: c++
-
- void foo() { int pre_local_constant_post; }
-
-.. option:: MacroDefinitionCase
-
- When defined, the check will ensure macro definitions conform to the
- selected casing.
-
-.. option:: MacroDefinitionPrefix
-
- When defined, the check will ensure macro definitions will add the
- prefix with the given value (regardless of casing).
-
-.. option:: MacroDefinitionIgnoredRegexp
-
- Identifier naming checks won't be enforced for macro definitions
- matching this regular expression.
-
-.. option:: MacroDefinitionSuffix
-
- When defined, the check will ensure macro definitions will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - MacroDefinitionCase of ``lower_case``
- - MacroDefinitionPrefix of ``pre_``
- - MacroDefinitionSuffix of ``_post``
-
-Identifies and/or transforms macro definitions as follows:
-
-Before:
-
-.. code-block:: c
-
- #define MY_MacroDefinition
-
-After:
-
-.. code-block:: c
-
- #define pre_my_macro_definition_post
-
-Note: This will not warn on builtin macros or macros defined on the
-command line using the ``-D`` flag.
-
-.. option:: MemberCase
-
- When defined, the check will ensure member names conform to the
- selected casing.
-
-.. option:: MemberPrefix
-
- When defined, the check will ensure member names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: MemberIgnoredRegexp
-
- Identifier naming checks won't be enforced for member names
- matching this regular expression.
-
-.. option:: MemberSuffix
-
- When defined, the check will ensure member names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: MemberHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - MemberCase of ``lower_case``
- - MemberPrefix of ``pre_``
- - MemberSuffix of ``_post``
- - MemberHungarianPrefix of ``On``
-
-Identifies and/or transforms member names as follows:
-
-Before:
-
-.. code-block:: c++
-
- class Foo {
- char MY_ConstMember_string[4];
- }
-
-After:
-
-.. code-block:: c++
-
- class Foo {
- char pre_my_constmember_string_post[4];
- }
-
-.. option:: MethodCase
-
- When defined, the check will ensure method names conform to the
- selected casing.
-
-.. option:: MethodPrefix
-
- When defined, the check will ensure method names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: MethodIgnoredRegexp
-
- Identifier naming checks won't be enforced for method names
- matching this regular expression.
-
-.. option:: MethodSuffix
-
- When defined, the check will ensure method names will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - MethodCase of ``lower_case``
- - MethodPrefix of ``pre_``
- - MethodSuffix of ``_post``
-
-Identifies and/or transforms method names as follows:
-
-Before:
-
-.. code-block:: c++
-
- class Foo {
- char MY_Method_string();
- }
-
-After:
-
-.. code-block:: c++
-
- class Foo {
- char pre_my_method_string_post();
- }
-
-.. option:: NamespaceCase
-
- When defined, the check will ensure namespace names conform to the
- selected casing.
-
-.. option:: NamespacePrefix
-
- When defined, the check will ensure namespace names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: NamespaceIgnoredRegexp
-
- Identifier naming checks won't be enforced for namespace names
- matching this regular expression.
-
-.. option:: NamespaceSuffix
-
- When defined, the check will ensure namespace names will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - NamespaceCase of ``lower_case``
- - NamespacePrefix of ``pre_``
- - NamespaceSuffix of ``_post``
-
-Identifies and/or transforms namespace names as follows:
-
-Before:
-
-.. code-block:: c++
-
- namespace FOO_NS {
- ...
- }
-
-After:
-
-.. code-block:: c++
-
- namespace pre_foo_ns_post {
- ...
- }
-
-.. option:: ParameterCase
-
- When defined, the check will ensure parameter names conform to the
- selected casing.
-
-.. option:: ParameterPrefix
-
- When defined, the check will ensure parameter names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: ParameterIgnoredRegexp
-
- Identifier naming checks won't be enforced for parameter names
- matching this regular expression.
-
-.. option:: ParameterSuffix
-
- When defined, the check will ensure parameter names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: ParameterHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - ParameterCase of ``lower_case``
- - ParameterPrefix of ``pre_``
- - ParameterSuffix of ``_post``
- - ParameterHungarianPrefix of ``On``
-
-Identifies and/or transforms parameter names as follows:
-
-Before:
-
-.. code-block:: c++
-
- void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
-
-After:
-
-.. code-block:: c++
-
- void GLOBAL_FUNCTION(int pre_parameter_post, int const CONST_parameter);
-
-.. option:: ParameterPackCase
-
- When defined, the check will ensure parameter pack names conform to the
- selected casing.
-
-.. option:: ParameterPackPrefix
-
- When defined, the check will ensure parameter pack names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: ParameterPackIgnoredRegexp
-
- Identifier naming checks won't be enforced for parameter pack names
- matching this regular expression.
-
-.. option:: ParameterPackSuffix
-
- When defined, the check will ensure parameter pack names will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - ParameterPackCase of ``lower_case``
- - ParameterPackPrefix of ``pre_``
- - ParameterPackSuffix of ``_post``
-
-Identifies and/or transforms parameter pack names as follows:
-
-Before:
-
-.. code-block:: c++
-
- template <typename... TYPE_parameters> {
- void FUNCTION(int... TYPE_parameters);
- }
-
-After:
-
-.. code-block:: c++
-
- template <typename... TYPE_parameters> {
- void FUNCTION(int... pre_type_parameters_post);
- }
-
-.. option:: PointerParameterCase
-
- When defined, the check will ensure pointer parameter names conform to the
- selected casing.
-
-.. option:: PointerParameterPrefix
-
- When defined, the check will ensure pointer parameter names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: PointerParameterIgnoredRegexp
-
- Identifier naming checks won't be enforced for pointer parameter names
- matching this regular expression.
-
-.. option:: PointerParameterSuffix
-
- When defined, the check will ensure pointer parameter names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: PointerParameterHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - PointerParameterCase of ``lower_case``
- - PointerParameterPrefix of ``pre_``
- - PointerParameterSuffix of ``_post``
- - PointerParameterHungarianPrefix of ``On``
-
-Identifies and/or transforms pointer parameter names as follows:
-
-Before:
-
-.. code-block:: c++
-
- void FUNCTION(int *PARAMETER);
-
-After:
-
-.. code-block:: c++
-
- void FUNCTION(int *pre_parameter_post);
-
-.. option:: PrivateMemberCase
-
- When defined, the check will ensure private member names conform to the
- selected casing.
-
-.. option:: PrivateMemberPrefix
-
- When defined, the check will ensure private member names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: PrivateMemberIgnoredRegexp
-
- Identifier naming checks won't be enforced for private member names
- matching this regular expression.
-
-.. option:: PrivateMemberSuffix
-
- When defined, the check will ensure private member names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: PrivateMemberHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - PrivateMemberCase of ``lower_case``
- - PrivateMemberPrefix of ``pre_``
- - PrivateMemberSuffix of ``_post``
- - PrivateMemberHungarianPrefix of ``On``
-
-Identifies and/or transforms private member names as follows:
-
-Before:
-
-.. code-block:: c++
-
- class Foo {
- private:
- int Member_Variable;
- }
-
-After:
-
-.. code-block:: c++
-
- class Foo {
- private:
- int pre_member_variable_post;
- }
-
-.. option:: PrivateMethodCase
-
- When defined, the check will ensure private method names conform to the
- selected casing.
-
-.. option:: PrivateMethodPrefix
-
- When defined, the check will ensure private method names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: PrivateMethodIgnoredRegexp
-
- Identifier naming checks won't be enforced for private method names
- matching this regular expression.
-
-.. option:: PrivateMethodSuffix
-
- When defined, the check will ensure private method names will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - PrivateMethodCase of ``lower_case``
- - PrivateMethodPrefix of ``pre_``
- - PrivateMethodSuffix of ``_post``
-
-Identifies and/or transforms private method names as follows:
-
-Before:
-
-.. code-block:: c++
-
- class Foo {
- private:
- int Member_Method();
- }
-
-After:
-
-.. code-block:: c++
-
- class Foo {
- private:
- int pre_member_method_post();
- }
-
-.. option:: ProtectedMemberCase
-
- When defined, the check will ensure protected member names conform to the
- selected casing.
-
-.. option:: ProtectedMemberPrefix
-
- When defined, the check will ensure protected member names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: ProtectedMemberIgnoredRegexp
-
- Identifier naming checks won't be enforced for protected member names
- matching this regular expression.
-
-.. option:: ProtectedMemberSuffix
-
- When defined, the check will ensure protected member names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: ProtectedMemberHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - ProtectedMemberCase of ``lower_case``
- - ProtectedMemberPrefix of ``pre_``
- - ProtectedMemberSuffix of ``_post``
- - ProtectedMemberHungarianPrefix of ``On``
-
-Identifies and/or transforms protected member names as follows:
-
-Before:
-
-.. code-block:: c++
-
- class Foo {
- protected:
- int Member_Variable;
- }
-
-After:
-
-.. code-block:: c++
-
- class Foo {
- protected:
- int pre_member_variable_post;
- }
-
-.. option:: ProtectedMethodCase
-
- When defined, the check will ensure protected method names conform to the
- selected casing.
-
-.. option:: ProtectedMethodPrefix
-
- When defined, the check will ensure protected method names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: ProtectedMethodIgnoredRegexp
-
- Identifier naming checks won't be enforced for protected method names
- matching this regular expression.
-
-.. option:: ProtectedMethodSuffix
-
- When defined, the check will ensure protected method names will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - ProtectedMethodCase of ``lower_case``
- - ProtectedMethodPrefix of ``pre_``
- - ProtectedMethodSuffix of ``_post``
-
-Identifies and/or transforms protect method names as follows:
-
-Before:
-
-.. code-block:: c++
-
- class Foo {
- protected:
- int Member_Method();
- }
-
-After:
-
-.. code-block:: c++
-
- class Foo {
- protected:
- int pre_member_method_post();
- }
-
-.. option:: PublicMemberCase
-
- When defined, the check will ensure public member names conform to the
- selected casing.
-
-.. option:: PublicMemberPrefix
-
- When defined, the check will ensure public member names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: PublicMemberIgnoredRegexp
-
- Identifier naming checks won't be enforced for public member names
- matching this regular expression.
-
-.. option:: PublicMemberSuffix
-
- When defined, the check will ensure public member names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: PublicMemberHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - PublicMemberCase of ``lower_case``
- - PublicMemberPrefix of ``pre_``
- - PublicMemberSuffix of ``_post``
- - PublicMemberHungarianPrefix of ``On``
-
-Identifies and/or transforms public member names as follows:
-
-Before:
-
-.. code-block:: c++
-
- class Foo {
- public:
- int Member_Variable;
- }
-
-After:
-
-.. code-block:: c++
-
- class Foo {
- public:
- int pre_member_variable_post;
- }
-
-.. option:: PublicMethodCase
-
- When defined, the check will ensure public method names conform to the
- selected casing.
-
-.. option:: PublicMethodPrefix
-
- When defined, the check will ensure public method names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: PublicMethodIgnoredRegexp
-
- Identifier naming checks won't be enforced for public method names
- matching this regular expression.
-
-.. option:: PublicMethodSuffix
-
- When defined, the check will ensure public method names will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - PublicMethodCase of ``lower_case``
- - PublicMethodPrefix of ``pre_``
- - PublicMethodSuffix of ``_post``
-
-Identifies and/or transforms public method names as follows:
-
-Before:
-
-.. code-block:: c++
-
- class Foo {
- public:
- int Member_Method();
- }
-
-After:
-
-.. code-block:: c++
-
- class Foo {
- public:
- int pre_member_method_post();
- }
-
-.. option:: ScopedEnumConstantCase
-
- When defined, the check will ensure scoped enum constant names conform to
- the selected casing.
-
-.. option:: ScopedEnumConstantPrefix
-
- When defined, the check will ensure scoped enum constant names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: ScopedEnumConstantIgnoredRegexp
-
- Identifier naming checks won't be enforced for scoped enum constant names
- matching this regular expression.
-
-.. option:: ScopedEnumConstantSuffix
-
- When defined, the check will ensure scoped enum constant names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: ScopedEnumConstantHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - ScopedEnumConstantCase of ``lower_case``
- - ScopedEnumConstantPrefix of ``pre_``
- - ScopedEnumConstantSuffix of ``_post``
- - ScopedEnumConstantHungarianPrefix of ``On``
-
-Identifies and/or transforms enumeration constant names as follows:
-
-Before:
-
-.. code-block:: c++
-
- enum class FOO { One, Two, Three };
-
-After:
-
-.. code-block:: c++
-
- enum class FOO { pre_One_post, pre_Two_post, pre_Three_post };
-
-.. option:: StaticConstexprVariableCase
-
- When defined, the check will ensure static ``constexpr`` variable names
- conform to the selected casing.
-
-.. option:: StaticConstexprVariablePrefix
-
- When defined, the check will ensure static ``constexpr`` variable names
- will add the prefixed with the given value (regardless of casing).
-
-.. option:: StaticConstexprVariableIgnoredRegexp
-
- Identifier naming checks won't be enforced for static ``constexpr``
- variable names matching this regular expression.
-
-.. option:: StaticConstexprVariableSuffix
-
- When defined, the check will ensure static ``constexpr`` variable names
- will add the suffix with the given value (regardless of casing).
-
-.. option:: StaticConstexprVariableHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will have a
- Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - StaticConstexprVariableCase of ``lower_case``
- - StaticConstexprVariablePrefix of ``pre_``
- - StaticConstexprVariableSuffix of ``_post``
- - StaticConstexprVariableHungarianPrefix of ``On``
-
-Identifies and/or transforms static ``constexpr`` variable names as follows:
-
-Before:
-
-.. code-block:: c++
-
- static unsigned constexpr MyConstexprStatic_array[] = {1, 2, 3};
-
-After:
-
-.. code-block:: c++
-
- static unsigned constexpr pre_my_constexpr_static_array_post[] = {1, 2, 3};
-
-.. option:: StaticConstantCase
-
- When defined, the check will ensure static constant names conform to the
- selected casing.
-
-.. option:: StaticConstantPrefix
-
- When defined, the check will ensure static constant names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: StaticConstantIgnoredRegexp
-
- Identifier naming checks won't be enforced for static constant names
- matching this regular expression.
-
-.. option:: StaticConstantSuffix
-
- When defined, the check will ensure static constant names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: StaticConstantHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - StaticConstantCase of ``lower_case``
- - StaticConstantPrefix of ``pre_``
- - StaticConstantSuffix of ``_post``
- - StaticConstantHungarianPrefix of ``On``
-
-Identifies and/or transforms static constant names as follows:
-
-Before:
-
-.. code-block:: c++
-
- static unsigned const MyConstStatic_array[] = {1, 2, 3};
-
-After:
-
-.. code-block:: c++
-
- static unsigned const pre_myconststatic_array_post[] = {1, 2, 3};
-
-.. option:: StaticVariableCase
-
- When defined, the check will ensure static variable names conform to the
- selected casing.
-
-.. option:: StaticVariablePrefix
-
- When defined, the check will ensure static variable names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: StaticVariableIgnoredRegexp
-
- Identifier naming checks won't be enforced for static variable names
- matching this regular expression.
-
-.. option:: StaticVariableSuffix
-
- When defined, the check will ensure static variable names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: StaticVariableHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
-
-For example using values of:
-
- - StaticVariableCase of ``lower_case``
- - StaticVariablePrefix of ``pre_``
- - StaticVariableSuffix of ``_post``
- - StaticVariableHungarianPrefix of ``On``
-
-Identifies and/or transforms static variable names as follows:
-
-Before:
-
-.. code-block:: c++
-
- static unsigned MyStatic_array[] = {1, 2, 3};
-
-After:
-
-.. code-block:: c++
-
- static unsigned pre_mystatic_array_post[] = {1, 2, 3};
-
-.. option:: StructCase
-
- When defined, the check will ensure struct names conform to the
- selected casing.
-
-.. option:: StructPrefix
-
- When defined, the check will ensure struct names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: StructIgnoredRegexp
-
- Identifier naming checks won't be enforced for struct names
- matching this regular expression.
-
-.. option:: StructSuffix
-
- When defined, the check will ensure struct names will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - StructCase of ``lower_case``
- - StructPrefix of ``pre_``
- - StructSuffix of ``_post``
-
-Identifies and/or transforms struct names as follows:
-
-Before:
-
-.. code-block:: c++
-
- struct FOO {
- FOO();
- ~FOO();
- };
-
-After:
-
-.. code-block:: c++
-
- struct pre_foo_post {
- pre_foo_post();
- ~pre_foo_post();
- };
-
-.. option:: TemplateParameterCase
-
- When defined, the check will ensure template parameter names conform to the
- selected casing.
-
-.. option:: TemplateParameterPrefix
-
- When defined, the check will ensure template parameter names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: TemplateParameterIgnoredRegexp
-
- Identifier naming checks won't be enforced for template parameter names
- matching this regular expression.
-
-.. option:: TemplateParameterSuffix
-
- When defined, the check will ensure template parameter names will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - TemplateParameterCase of ``lower_case``
- - TemplateParameterPrefix of ``pre_``
- - TemplateParameterSuffix of ``_post``
-
-Identifies and/or transforms template parameter names as follows:
-
-Before:
-
-.. code-block:: c++
-
- template <typename T> class Foo {};
-
-After:
-
-.. code-block:: c++
-
- template <typename pre_t_post> class Foo {};
-
-.. option:: TemplateTemplateParameterCase
-
- When defined, the check will ensure template template parameter names conform to the
- selected casing.
-
-.. option:: TemplateTemplateParameterPrefix
-
- When defined, the check will ensure template template parameter names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: TemplateTemplateParameterIgnoredRegexp
-
- Identifier naming checks won't be enforced for template template parameter
- names matching this regular expression.
-
-.. option:: TemplateTemplateParameterSuffix
-
- When defined, the check will ensure template template parameter names will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - TemplateTemplateParameterCase of ``lower_case``
- - TemplateTemplateParameterPrefix of ``pre_``
- - TemplateTemplateParameterSuffix of ``_post``
-
-Identifies and/or transforms template template parameter names as follows:
-
-Before:
-
-.. code-block:: c++
-
- template <template <typename> class TPL_parameter, int COUNT_params,
- typename... TYPE_parameters>
-
-After:
-
-.. code-block:: c++
-
- template <template <typename> class pre_tpl_parameter_post, int COUNT_params,
- typename... TYPE_parameters>
-
-.. option:: TypeAliasCase
-
- When defined, the check will ensure type alias names conform to the
- selected casing.
-
-.. option:: TypeAliasPrefix
-
- When defined, the check will ensure type alias names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: TypeAliasIgnoredRegexp
-
- Identifier naming checks won't be enforced for type alias names
- matching this regular expression.
-
-.. option:: TypeAliasSuffix
-
- When defined, the check will ensure type alias names will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - TypeAliasCase of ``lower_case``
- - TypeAliasPrefix of ``pre_``
- - TypeAliasSuffix of ``_post``
-
-Identifies and/or transforms type alias names as follows:
-
-Before:
-
-.. code-block:: c++
-
- using MY_STRUCT_TYPE = my_structure;
-
-After:
-
-.. code-block:: c++
-
- using pre_my_struct_type_post = my_structure;
-
-.. option:: TypedefCase
-
- When defined, the check will ensure typedef names conform to the
- selected casing.
-
-.. option:: TypedefPrefix
-
- When defined, the check will ensure typedef names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: TypedefIgnoredRegexp
-
- Identifier naming checks won't be enforced for typedef names
- matching this regular expression.
-
-.. option:: TypedefSuffix
-
- When defined, the check will ensure typedef names will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - TypedefCase of ``lower_case``
- - TypedefPrefix of ``pre_``
- - TypedefSuffix of ``_post``
-
-Identifies and/or transforms typedef names as follows:
-
-Before:
-
-.. code-block:: c++
-
- typedef int MYINT;
-
-After:
-
-.. code-block:: c++
-
- typedef int pre_myint_post;
-
-.. option:: TypedefInheritAnonTagConfig
-
- When set to `true`, a typedef or type alias that provides the only name of
- an otherwise unnamed tag, as in ``typedef enum {} MyEnum;``, is checked
- against the naming style configured for the kind of that tag
- (``AbstractClass``, ``Class``, ``Enum``, ``Struct`` or ``Union``, i.e.
- :option:`EnumCase`, :option:`EnumPrefix`, :option:`EnumSuffix` and
- :option:`EnumIgnoredRegexp` for an enum) rather than against the typedef
- or type alias style. If that kind configures no case, prefix or suffix,
- the typedef or type alias style still applies. Typedefs of named tags, of
- other typedefs and of non-tag types are not affected. Default is `false`.
-
-For example using values of:
-
- - TypedefInheritAnonTagConfig of `true`
- - EnumCase of ``CamelCase``
- - TypedefCase of ``lower_case``
-
-Identifies and/or transforms names as follows:
-
-Before:
-
-.. code-block:: c++
-
- typedef enum { VAL } my_enum; // The typedef names the enum.
- typedef enum Kind { VAL2 } my_kind; // Kind names the enum.
-
-After:
-
-.. code-block:: c++
-
- typedef enum { VAL } MyEnum;
- typedef enum Kind { VAL2 } my_kind;
-
-.. option:: TypeTemplateParameterCase
-
- When defined, the check will ensure type template parameter names conform to the
- selected casing.
-
-.. option:: TypeTemplateParameterPrefix
-
- When defined, the check will ensure type template parameter names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: TypeTemplateParameterIgnoredRegexp
-
- Identifier naming checks won't be enforced for type template names
- matching this regular expression.
-
-.. option:: TypeTemplateParameterSuffix
-
- When defined, the check will ensure type template parameter names will add the
- suffix with the given value (regardless of casing).
-
-For example using values of:
-
- - TypeTemplateParameterCase of ``lower_case``
- - TypeTemplateParameterPrefix of ``pre_``
- - TypeTemplateParameterSuffix of ``_post``
-
-Identifies and/or transforms type template parameter names as follows:
+Identifies and/or transforms type template parameter names as follows:
Before:
-.. code-block:: c++
-
- template <template <typename> class TPL_parameter, int COUNT_params,
- typename... TYPE_parameters>
+```c++
+template <template <typename> class TPL_parameter, int COUNT_params,
+ typename... TYPE_parameters>
+```
After:
-.. code-block:: c++
+```c++
+template <template <typename> class TPL_parameter, int COUNT_params,
+ typename... pre_type_parameters_post>
+```
- template <template <typename> class TPL_parameter, int COUNT_params,
- typename... pre_type_parameters_post>
+```{option} UnionCase
+When defined, the check will ensure union names conform to the
+selected casing.
+```
-.. option:: UnionCase
+```{option} UnionPrefix
+When defined, the check will ensure union names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure union names conform to the
- selected casing.
+```{option} UnionIgnoredRegexp
+Identifier naming checks won't be enforced for union names
+matching this regular expression.
+```
-.. option:: UnionPrefix
-
- When defined, the check will ensure union names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: UnionIgnoredRegexp
-
- Identifier naming checks won't be enforced for union names
- matching this regular expression.
-
-.. option:: UnionSuffix
-
- When defined, the check will ensure union names will add the
- suffix with the given value (regardless of casing).
+```{option} UnionSuffix
+When defined, the check will ensure union names will add the
+suffix with the given value (regardless of casing).
+```
For example using values of:
- - UnionCase of ``lower_case``
- - UnionPrefix of ``pre_``
- - UnionSuffix of ``_post``
+- {option}`UnionCase` of `lower_case`
+- {option}`UnionPrefix` of `pre_`
+- {option}`UnionSuffix` of `_post`
Identifies and/or transforms union names as follows:
Before:
-.. code-block:: c++
-
- union FOO {
- int a;
- char b;
- };
+```c++
+union FOO {
+ int a;
+ char b;
+};
+```
After:
-.. code-block:: c++
-
- union pre_foo_post {
- int a;
- char b;
- };
-
-.. option:: ValueTemplateParameterCase
-
- When defined, the check will ensure value template parameter names conform to the
- selected casing.
-
-.. option:: ValueTemplateParameterPrefix
-
- When defined, the check will ensure value template parameter names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: ValueTemplateParameterIgnoredRegexp
-
- Identifier naming checks won't be enforced for value template parameter
- names matching this regular expression.
-
-.. option:: ValueTemplateParameterSuffix
-
- When defined, the check will ensure value template parameter names will add the
- suffix with the given value (regardless of casing).
+```c++
+union pre_foo_post {
+ int a;
+ char b;
+};
+```
+
+```{option} ValueTemplateParameterCase
+When defined, the check will ensure value template parameter names conform to the
+selected casing.
+```
+
+```{option} ValueTemplateParameterPrefix
+When defined, the check will ensure value template parameter names will add the
+prefix with the given value (regardless of casing).
+```
+
+```{option} ValueTemplateParameterIgnoredRegexp
+Identifier naming checks won't be enforced for value template parameter
+names matching this regular expression.
+```
+
+```{option} ValueTemplateParameterSuffix
+When defined, the check will ensure value template parameter names will add the
+suffix with the given value (regardless of casing).
+```
For example using values of:
- - ValueTemplateParameterCase of ``lower_case``
- - ValueTemplateParameterPrefix of ``pre_``
- - ValueTemplateParameterSuffix of ``_post``
+- {option}`ValueTemplateParameterCase` of `lower_case`
+- {option}`ValueTemplateParameterPrefix` of `pre_`
+- {option}`ValueTemplateParameterSuffix` of `_post`
Identifies and/or transforms value template parameter names as follows:
Before:
-.. code-block:: c++
-
- template <template <typename> class TPL_parameter, int COUNT_params,
- typename... TYPE_parameters>
+```c++
+template <template <typename> class TPL_parameter, int COUNT_params,
+ typename... TYPE_parameters>
+```
After:
-.. code-block:: c++
+```c++
+template <template <typename> class TPL_parameter, int pre_count_params_post,
+ typename... TYPE_parameters>
+```
- template <template <typename> class TPL_parameter, int pre_count_params_post,
- typename... TYPE_parameters>
+```{option} VariableCase
+When defined, the check will ensure variable names conform to the
+selected casing.
+```
-.. option:: VariableCase
+```{option} VariablePrefix
+When defined, the check will ensure variable names will add the
+prefix with the given value (regardless of casing).
+```
- When defined, the check will ensure variable names conform to the
- selected casing.
+```{option} VariableIgnoredRegexp
+Identifier naming checks won't be enforced for variable names
+matching this regular expression.
+```
-.. option:: VariablePrefix
+```{option} VariableSuffix
+When defined, the check will ensure variable names will add the
+suffix with the given value (regardless of casing).
+```
- When defined, the check will ensure variable names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: VariableIgnoredRegexp
-
- Identifier naming checks won't be enforced for variable names
- matching this regular expression.
-
-.. option:: VariableSuffix
-
- When defined, the check will ensure variable names will add the
- suffix with the given value (regardless of casing).
-
-.. option:: VariableHungarianPrefix
-
- When enabled, the check ensures that the declared identifier will
- have a Hungarian notation prefix based on the declared type.
+```{option} VariableHungarianPrefix
+When enabled, the check ensures that the declared identifier will
+have a Hungarian notation prefix based on the declared type.
+```
For example using values of:
- - VariableCase of ``lower_case``
- - VariablePrefix of ``pre_``
- - VariableSuffix of ``_post``
- - VariableHungarianPrefix of ``On``
+- {option}`VariableCase` of `lower_case`
+- {option}`VariablePrefix` of `pre_`
+- {option}`VariableSuffix` of `_post`
+- {option}`VariableHungarianPrefix` of `On`
Identifies and/or transforms variable names as follows:
Before:
-.. code-block:: c++
-
- unsigned MyVariable;
+```c++
+unsigned MyVariable;
+```
After:
-.. code-block:: c++
-
- unsigned pre_myvariable_post;
+```c++
+unsigned pre_myvariable_post;
+```
-.. option:: VirtualMethodCase
+```{option} VirtualMethodCase
+When defined, the check will ensure virtual method names conform to the
+selected casing.
+```
- When defined, the check will ensure virtual method names conform to the
- selected casing.
+```{option} VirtualMethodPrefix
+When defined, the check will ensure virtual method names will add the
+prefix with the given value (regardless of casing).
+```
-.. option:: VirtualMethodPrefix
+```{option} VirtualMethodIgnoredRegexp
+Identifier naming checks won't be enforced for virtual method names
+matching this regular expression.
+```
- When defined, the check will ensure virtual method names will add the
- prefix with the given value (regardless of casing).
-
-.. option:: VirtualMethodIgnoredRegexp
-
- Identifier naming checks won't be enforced for virtual method names
- matching this regular expression.
-
-.. option:: VirtualMethodSuffix
-
- When defined, the check will ensure virtual method names will add the
- suffix with the given value (regardless of casing).
+```{option} VirtualMethodSuffix
+When defined, the check will ensure virtual method names will add the
+suffix with the given value (regardless of casing).
+```
For example using values of:
- - VirtualMethodCase of ``lower_case``
- - VirtualMethodPrefix of ``pre_``
- - VirtualMethodSuffix of ``_post``
+- {option}`VirtualMethodCase` of `lower_case`
+- {option}`VirtualMethodPrefix` of `pre_`
+- {option}`VirtualMethodSuffix` of `_post`
Identifies and/or transforms virtual method names as follows:
Before:
-.. code-block:: c++
-
- class Foo {
- public:
- virtual int MemberFunction();
- }
+```c++
+class Foo {
+public:
+ virtual int MemberFunction();
+}
+```
After:
-.. code-block:: c++
-
- class Foo {
- public:
- virtual int pre_member_function_post();
- }
+```c++
+class Foo {
+public:
+ virtual int pre_member_function_post();
+}
+```
-
-The default mapping table of Hungarian Notation
------------------------------------------------
+## The default mapping table of Hungarian Notation
In Hungarian notation, a variable name starts with a group of lower-case
letters which are mnemonics for the type or purpose of that variable, followed
@@ -3060,10 +3054,10 @@ distinguished as the given name. The first character of the given name can be
capitalized to separate it from the type indicators (see also CamelCase).
Otherwise the case of this character denotes scope.
-The following table is the default mapping table of Hungarian Notation
-which maps Decl to its prefix string. You can also have your own style
-in config file.
+The following table maps type names to their default Hungarian notation
+prefixes. You can define custom mappings in the configuration file.
+```{eval-rst}
============== ======== ====================== ======== ============== ========
Primitive Type Microsoft Type
-------------- -------- ---------------------- -------- -------------- --------
@@ -3099,189 +3093,172 @@ wchar_t wc UINT64 u64
short int si PVOID p
short s
============== ======== ====================== ======== ============== ========
+```
**There are more trivial options for Hungarian Notation:**
-**HungarianNotation.General.***
- Options are not belonging to any specific Decl.
-
-**HungarianNotation.CString.***
- Options for NULL-terminated string.
-
-**HungarianNotation.DerivedType.***
- Options for derived types.
-
-**HungarianNotation.PrimitiveType.***
- Options for primitive types.
-
-**HungarianNotation.UserDefinedType.***
- Options for user-defined types.
-
-
-Options for Hungarian Notation
-------------------------------
-
-- :option:`HungarianNotation.General.TreatStructAsClass`
-
-- :option:`HungarianNotation.DerivedType.Array`
-- :option:`HungarianNotation.DerivedType.Pointer`
-- :option:`HungarianNotation.DerivedType.FunctionPointer`
-
-- :option:`HungarianNotation.CString.CharPointer`
-- :option:`HungarianNotation.CString.CharArray`
-- :option:`HungarianNotation.CString.WideCharPointer`
-- :option:`HungarianNotation.CString.WideCharArray`
-
-- :option:`HungarianNotation.PrimitiveType.*`
-- :option:`HungarianNotation.UserDefinedType.*`
-
-.. option:: HungarianNotation.General.TreatStructAsClass
-
- When defined, the check will treat naming of struct as a class.
- The default value is `false`.
-
-.. option:: HungarianNotation.DerivedType.Array
-
- When defined, the check will ensure variable name will add the prefix with
- the given string. The default prefix is `a`.
-
-.. option:: HungarianNotation.DerivedType.Pointer
-
- When defined, the check will ensure variable name will add the prefix with
- the given string. The default prefix is `p`.
-
-.. option:: HungarianNotation.DerivedType.FunctionPointer
-
- When defined, the check will ensure variable name will add the prefix with
- the given string. The default prefix is `fn`.
-
+- **HungarianNotation.General.\***: Options not belonging to any specific
+ declaration.
+- **HungarianNotation.CString.\***: Options for null-terminated strings.
+- **HungarianNotation.DerivedType.\***: Options for derived types.
+- **HungarianNotation.PrimitiveType.\***: Options for primitive types.
+- **HungarianNotation.UserDefinedType.\***: Options for user-defined types.
+
+## Options for Hungarian Notation
+
+- {option}`HungarianNotation.General.TreatStructAsClass`
+- {option}`HungarianNotation.DerivedType.Array`
+- {option}`HungarianNotation.DerivedType.Pointer`
+- {option}`HungarianNotation.DerivedType.FunctionPointer`
+- {option}`HungarianNotation.CString.CharPointer`
+- {option}`HungarianNotation.CString.CharArray`
+- {option}`HungarianNotation.CString.WideCharPointer`
+- {option}`HungarianNotation.CString.WideCharArray`
+- {option}`HungarianNotation.PrimitiveType.*`
+- {option}`HungarianNotation.UserDefinedType.*`
+
+```{option} HungarianNotation.General.TreatStructAsClass
+When defined, the check will treat naming of struct as a class.
+Default is `false`.
+```
+
+```{option} HungarianNotation.DerivedType.Array
+When defined, the check will ensure variable name will add the prefix with
+the given string. Default is `a`.
+```
+
+```{option} HungarianNotation.DerivedType.Pointer
+When defined, the check will ensure variable name will add the prefix with
+the given string. Default is `p`.
+```
+
+```{option} HungarianNotation.DerivedType.FunctionPointer
+When defined, the check will ensure variable name will add the prefix with
+the given string. Default is `fn`.
+```
Before:
-.. code-block:: c++
+```c++
+// Array
+int DataArray[2] = {0};
- // Array
- int DataArray[2] = {0};
+// Pointer
+void *DataBuffer = NULL;
- // Pointer
- void *DataBuffer = NULL;
-
- // FunctionPointer
- typedef void (*FUNC_PTR)();
- FUNC_PTR FuncPtr = NULL;
+// FunctionPointer
+typedef void (*FUNC_PTR)();
+FUNC_PTR FuncPtr = NULL;
+```
After:
-.. code-block:: c++
-
- // Array
- int aDataArray[2] = {0};
-
- // Pointer
- void *pDataBuffer = NULL;
-
- // FunctionPointer
- typedef void (*FUNC_PTR)();
- FUNC_PTR fnFuncPtr = NULL;
-
-
-.. option:: HungarianNotation.CString.CharPointer
+```c++
+// Array
+int aDataArray[2] = {0};
- When defined, the check will ensure variable name will add the prefix with
- the given string. The default prefix is `sz`.
+// Pointer
+void *pDataBuffer = NULL;
-.. option:: HungarianNotation.CString.CharArray
+// FunctionPointer
+typedef void (*FUNC_PTR)();
+FUNC_PTR fnFuncPtr = NULL;
+```
- When defined, the check will ensure variable name will add the prefix with
- the given string. The default prefix is `sz`.
+```{option} HungarianNotation.CString.CharPointer
+When defined, the check will ensure variable name will add the prefix with
+the given string. Default is `sz`.
+```
-.. option:: HungarianNotation.CString.WideCharPointer
+```{option} HungarianNotation.CString.CharArray
+When defined, the check will ensure variable name will add the prefix with
+the given string. Default is `sz`.
+```
- When defined, the check will ensure variable name will add the prefix with
- the given string. The default prefix is `wsz`.
-
-.. option:: HungarianNotation.CString.WideCharArray
-
- When defined, the check will ensure variable name will add the prefix with
- the given string. The default prefix is `wsz`.
+```{option} HungarianNotation.CString.WideCharPointer
+When defined, the check will ensure variable name will add the prefix with
+the given string. Default is `wsz`.
+```
+```{option} HungarianNotation.CString.WideCharArray
+When defined, the check will ensure variable name will add the prefix with
+the given string. Default is `wsz`.
+```
Before:
-.. code-block:: c++
+```c++
+// CharPointer
+const char *NamePtr = "Name";
- // CharPointer
- const char *NamePtr = "Name";
+// CharArray
+const char NameArray[] = "Name";
- // CharArray
- const char NameArray[] = "Name";
+// WideCharPointer
+const wchar_t *WideNamePtr = L"Name";
- // WideCharPointer
- const wchar_t *WideNamePtr = L"Name";
-
- // WideCharArray
- const wchar_t WideNameArray[] = L"Name";
+// WideCharArray
+const wchar_t WideNameArray[] = L"Name";
+```
After:
-.. code-block:: c++
-
- // CharPointer
- const char *szNamePtr = "Name";
-
- // CharArray
- const char szNameArray[] = "Name";
-
- // WideCharPointer
- const wchar_t *wszWideNamePtr = L"Name";
-
- // WideCharArray
- const wchar_t wszWideNameArray[] = L"Name";
-
+```c++
+// CharPointer
+const char *szNamePtr = "Name";
-.. option:: HungarianNotation.PrimitiveType.*
+// CharArray
+const char szNameArray[] = "Name";
- When defined, the check will ensure variable name of involved primitive
- types will add the prefix with the given string. The default prefixes are
- defined in the default mapping table.
+// WideCharPointer
+const wchar_t *wszWideNamePtr = L"Name";
-.. option:: HungarianNotation.UserDefinedType.*
+// WideCharArray
+const wchar_t wszWideNameArray[] = L"Name";
+```
- When defined, the check will ensure variable name of involved primitive
- types will add the prefix with the given string. The default prefixes are
- defined in the default mapping table.
+```{option} HungarianNotation.PrimitiveType.*
+When defined, the check will ensure variable name of involved primitive
+types will add the prefix with the given string. The default prefixes are
+defined in the default mapping table.
+```
+```{option} HungarianNotation.UserDefinedType.*
+When defined, the check will ensure variable name of involved user-defined
+types will add the prefix with the given string. The default prefixes are
+defined in the default mapping table.
+```
Before:
-.. code-block:: c++
-
- int8_t ValueI8 = 0;
- int16_t ValueI16 = 0;
- int32_t ValueI32 = 0;
- int64_t ValueI64 = 0;
- uint8_t ValueU8 = 0;
- uint16_t ValueU16 = 0;
- uint32_t ValueU32 = 0;
- uint64_t ValueU64 = 0;
- float ValueFloat = 0.0;
- double ValueDouble = 0.0;
- ULONG ValueUlong = 0;
- DWORD ValueDword = 0;
+```c++
+int8_t ValueI8 = 0;
+int16_t ValueI16 = 0;
+int32_t ValueI32 = 0;
+int64_t ValueI64 = 0;
+uint8_t ValueU8 = 0;
+uint16_t ValueU16 = 0;
+uint32_t ValueU32 = 0;
+uint64_t ValueU64 = 0;
+float ValueFloat = 0.0;
+double ValueDouble = 0.0;
+ULONG ValueUlong = 0;
+DWORD ValueDword = 0;
+```
After:
-.. code-block:: c++
-
- int8_t i8ValueI8 = 0;
- int16_t i16ValueI16 = 0;
- int32_t i32ValueI32 = 0;
- int64_t i64ValueI64 = 0;
- uint8_t u8ValueU8 = 0;
- uint16_t u16ValueU16 = 0;
- uint32_t u32ValueU32 = 0;
- uint64_t u64ValueU64 = 0;
- float fValueFloat = 0.0;
- double dValueDouble = 0.0;
- ULONG ulValueUlong = 0;
- DWORD dwValueDword = 0;
+```c++
+int8_t i8ValueI8 = 0;
+int16_t i16ValueI16 = 0;
+int32_t i32ValueI32 = 0;
+int64_t i64ValueI64 = 0;
+uint8_t u8ValueU8 = 0;
+uint16_t u16ValueU16 = 0;
+uint32_t u32ValueU32 = 0;
+uint64_t u64ValueU64 = 0;
+float fValueFloat = 0.0;
+double dValueDouble = 0.0;
+ULONG ulValueUlong = 0;
+DWORD dwValueDword = 0;
+```
diff --git a/clang-tools-extra/docs/clang-tidy/checks/readability/implicit-bool-conversion.md b/clang-tools-extra/docs/clang-tidy/checks/readability/implicit-bool-conversion.md
index 3be300f4e4184..97869110b2c82 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/readability/implicit-bool-conversion.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/readability/implicit-bool-conversion.md
@@ -1,7 +1,7 @@
-.. title:: clang-tidy - readability-implicit-bool-conversion
+```{title} clang-tidy - readability-implicit-bool-conversion
+```
-readability-implicit-bool-conversion
-====================================
+# readability-implicit-bool-conversion
This check can be used to find implicit conversions between built-in types and
booleans. Depending on use case, it may simply help with readability of the
@@ -9,74 +9,70 @@ code, or in some cases, point to potential bugs which remain unnoticed due to
implicit conversions.
The following is a real-world example of bug which was hiding behind implicit
-``bool`` conversion:
+`bool` conversion:
-.. code-block:: c++
+```c++
+class Foo {
+ int m_foo;
- class Foo {
- int m_foo;
+public:
+ void setFoo(bool foo) { m_foo = foo; } // warning: implicit conversion bool -> int
+ int getFoo() { return m_foo; }
+};
- public:
- void setFoo(bool foo) { m_foo = foo; } // warning: implicit conversion bool -> int
- int getFoo() { return m_foo; }
- };
+void use(Foo& foo) {
+ bool value = foo.getFoo(); // warning: implicit conversion int -> bool
+}
+```
- void use(Foo& foo) {
- bool value = foo.getFoo(); // warning: implicit conversion int -> bool
- }
-
-This code is the result of unsuccessful refactoring, where type of ``m_foo``
-changed from ``bool`` to ``int``. The programmer forgot to change all
-occurrences of ``bool``, and the remaining code is no longer correct, yet it
+This code is the result of unsuccessful refactoring, where type of `m_foo`
+changed from `bool` to `int`. The programmer forgot to change all
+occurrences of `bool`, and the remaining code is no longer correct, yet it
still compiles without any visible warnings.
In addition to issuing warnings, fix-it hints are provided to help solve the
reported issues. This can be used for improving readability of code, for
example:
-.. code-block:: c++
-
- void conversionsToBool() {
- float floating;
- bool boolean = floating;
- // ^ propose replacement: bool boolean = floating != 0.0f;
+```c++
+void conversionsToBool() {
+ float floating;
+ bool boolean = floating;
+ // ^ propose replacement: bool boolean = floating != 0.0f;
- int integer;
- if (integer) {}
- // ^ propose replacement: if (integer != 0) {}
+ int integer;
+ if (integer) {}
+ // ^ propose replacement: if (integer != 0) {}
- int* pointer;
- if (!pointer) {}
- // ^ propose replacement: if (pointer == nullptr) {}
+ int* pointer;
+ if (!pointer) {}
+ // ^ propose replacement: if (pointer == nullptr) {}
- while (1) {}
- // ^ propose replacement: while (true) {}
- }
+ while (1) {}
+ // ^ propose replacement: while (true) {}
+}
- void functionTakingInt(int param);
+void functionTakingInt(int param);
- void conversionsFromBool() {
- bool boolean;
- functionTakingInt(boolean);
- // ^ propose replacement: functionTakingInt(static_cast<int>(boolean));
+void conversionsFromBool() {
+ bool boolean;
+ functionTakingInt(boolean);
+ // ^ propose replacement: functionTakingInt(static_cast<int>(boolean));
- functionTakingInt(true);
- // ^ propose replacement: functionTakingInt(1);
- }
+ functionTakingInt(true);
+ // ^ propose replacement: functionTakingInt(1);
+}
+```
In general, the following conversion types are checked:
- integer expression/literal to boolean (conversion from a single bit bitfield
to boolean is explicitly allowed, since there's no ambiguity / information
loss in this case),
-
- floating expression/literal to boolean,
-
-- pointer/pointer to member/``nullptr``/``NULL`` to boolean,
-
+- pointer/pointer to member/`nullptr`/`NULL` to boolean,
- boolean expression/literal to integer (conversion from boolean to a single
bit bitfield is explicitly allowed),
-
- boolean expression/literal to floating.
The rules for generating fix-it hints are:
@@ -84,81 +80,75 @@ The rules for generating fix-it hints are:
- in case of conversions from other built-in type to bool, an explicit
comparison is proposed to make it clear what exactly is being compared:
- - ``bool boolean = floating;`` is changed to
- ``bool boolean = floating == 0.0f;``,
-
- - for other types, appropriate literals are used (``0``, ``0u``, ``0.0f``,
- ``0.0``, ``nullptr``),
+ - `bool boolean = floating;` is changed to
+ `bool boolean = floating == 0.0f;`,
+ - for other types, appropriate literals are used (`0`, `0u`, `0.0f`,
+ `0.0`, `nullptr`),
- in case of negated expressions conversion to bool, the proposed replacement
with comparison is simplified:
- - ``if (!pointer)`` is changed to ``if (pointer == nullptr)``,
+ - `if (!pointer)` is changed to `if (pointer == nullptr)`,
- in case of conversions from bool to other built-in types, an explicit
- ``static_cast`` (or a C-style cast since C23) is proposed to make it clear
+ `static_cast` (or a C-style cast since C23) is proposed to make it clear
that a conversion is taking place:
- - ``int integer = boolean;`` is changed to
- ``int integer = static_cast<int>(boolean);``,
+ - `int integer = boolean;` is changed to
+ `int integer = static_cast<int>(boolean);`,
- if the conversion is performed on type literals, an equivalent literal is
proposed, according to what type is actually expected, for example:
- - ``functionTakingBool(0);`` is changed to ``functionTakingBool(false);``,
-
- - ``functionTakingInt(true);`` is changed to ``functionTakingInt(1);``,
-
- - for other types, appropriate literals are used (``false``, ``true``, ``0``,
- ``1``, ``0u``, ``1u``, ``0.0f``, ``1.0f``, ``0.0``, ``1.0f``).
+ - `functionTakingBool(0);` is changed to `functionTakingBool(false);`,
+ - `functionTakingInt(true);` is changed to `functionTakingInt(1);`,
+ - for other types, appropriate literals are used (`false`, `true`, `0`,
+ `1`, `0u`, `1u`, `0.0f`, `1.0f`, `0.0`, `1.0f`).
Some additional accommodations are made for pre-C++11 dialects:
-- ``false`` literal conversion to pointer is detected,
-
-- instead of ``nullptr`` literal, ``0`` is proposed as replacement.
+- `false` literal conversion to pointer is detected,
+- instead of `nullptr` literal, `0` is proposed as replacement.
Some additional accommodations are made for C:
-- ``bool`` (or ``_Bool``) operands in logical operators (``&&``, ``||``) are
+- `bool` (or `_Bool`) operands in logical operators (`&&`, `||`) are
ignored.
-
-- ``bool`` (or ``_Bool``) conditions in conditional operators (``?:``) are
+- `bool` (or `_Bool`) conditions in conditional operators (`?:`) are
ignored.
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 `true`, the check will allow conditional integer conversions. Default
- is `false`.
-
-.. option:: AllowPointerConditions
-
- When `true`, the check will allow conditional pointer conversions. Default
- is `false`.
-
-.. option:: AllowLogicalOperatorConversion
-
- When `true`, the check will suppress warnings for implicit conversions of
- logical operator results (``&&``, ``||``, ``!``) to ``bool``. These
- operators always produce values equal to ``0`` or ``1``, so the conversion
- is safe. Default is `false`.
-
-.. option:: UseUpperCaseLiteralSuffix
-
- When `true`, the replacements will use an uppercase literal suffix in the
- provided fixes. Default is `false`.
-
- Example
-
- .. code-block:: c++
-
- uint32_t foo;
- if (foo) {}
- // ^ propose replacement default: if (foo != 0u) {}
- // ^ propose replacement with option `UseUpperCaseLiteralSuffix`: if (foo != 0U) {}
+## Options
+
+```{option} AllowIntegerConditions
+When `true`, the check will allow conditional integer conversions.
+Default is `false`.
+```
+
+```{option} AllowPointerConditions
+When `true`, the check will allow conditional pointer conversions.
+Default is `false`.
+```
+
+```{option} AllowLogicalOperatorConversion
+When `true`, the check will suppress warnings for implicit conversions of
+logical operator results (`&&`, `||`, `!`) to `bool`. These
+operators always produce values equal to `0` or `1`, so the conversion
+is safe. Default is `false`.
+```
+
+````{option} UseUpperCaseLiteralSuffix
+When `true`, the replacements will use an uppercase literal suffix in the
+provided fixes. Default is `false`.
+
+Example:
+
+```c++
+uint32_t foo;
+if (foo) {}
+// ^ propose replacement default: if (foo != 0u) {}
+// ^ propose replacement with option `UseUpperCaseLiteralSuffix`: if (foo != 0U) {}
+```
+````
diff --git a/clang-tools-extra/docs/clang-tidy/checks/readability/inconsistent-declaration-parameter-name.md b/clang-tools-extra/docs/clang-tidy/checks/readability/inconsistent-declaration-parameter-name.md
index 4661d2cd8c9a4..8447cb0f2603e 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/readability/inconsistent-declaration-parameter-name.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/readability/inconsistent-declaration-parameter-name.md
@@ -1,19 +1,19 @@
-.. title:: clang-tidy - readability-inconsistent-declaration-parameter-name
+```{title} clang-tidy - readability-inconsistent-declaration-parameter-name
+```
-readability-inconsistent-declaration-parameter-name
-===================================================
+# readability-inconsistent-declaration-parameter-name
Find function declarations which differ in parameter names.
Example:
-.. code-block:: c++
+```c++
+// in foo.hpp:
+void foo(int a, int b, int c);
- // in foo.hpp:
- void foo(int a, int b, int c);
-
- // in foo.cpp:
- void foo(int d, int e, int f); // warning
+// in foo.cpp:
+void foo(int d, int e, int f); // warning
+```
This check should help to enforce consistency in large projects, where it often
happens that a definition of function is refactored, changing the parameter
@@ -24,43 +24,41 @@ definition always in sync.
Unnamed parameters are allowed and are not taken into account when comparing
function declarations, for example:
-.. code-block:: c++
-
- void foo(int a);
- void foo(int); // no warning
+```c++
+void foo(int a);
+void foo(int); // no warning
+```
One name is also allowed to be a case-insensitive prefix/suffix of the other:
-.. code-block:: c++
-
- void foo(int count);
- void foo(int count_input) { // no warning
- int count = adjustCount(count_input);
- }
+```c++
+void foo(int count);
+void foo(int count_input) { // no warning
+ int count = adjustCount(count_input);
+}
+```
To help with refactoring, in some cases fix-it hints are generated to align
parameter names to a single naming convention. This works with the assumption
that the function definition is the most up-to-date version, as it directly
references parameter names in its body. Example:
-.. code-block:: c++
-
- void foo(int a); // warning and fix-it hint (replace "a" to "b")
- int foo(int b) { return b + 2; } // definition with use of "b"
+```c++
+void foo(int a); // warning and fix-it hint (replace "a" to "b")
+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.
-Options
--------
-
-.. option:: IgnoreMacros
-
- If this option is set to `true` (default is `true`), the check will not warn
- about names declared inside macros.
+## Options
-.. option:: Strict
+```{option} IgnoreMacros
+When `true`, the check will not warn about names declared inside macros.
+Default is `true`.
+```
- If this option is set to `true` (default is `false`), then names must match
- exactly (or be absent).
+```{option} Strict
+When `true`, names must match exactly (or be absent). Default is `false`.
+```
diff --git a/clang-tools-extra/docs/clang-tidy/checks/readability/inconsistent-ifelse-braces.md b/clang-tools-extra/docs/clang-tidy/checks/readability/inconsistent-ifelse-braces.md
index 53a79808b2147..de267f74baf33 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/readability/inconsistent-ifelse-braces.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/readability/inconsistent-ifelse-braces.md
@@ -1,42 +1,42 @@
-.. title:: clang-tidy - readability-inconsistent-ifelse-braces
+```{title} clang-tidy - readability-inconsistent-ifelse-braces
+```
-readability-inconsistent-ifelse-braces
-======================================
+# readability-inconsistent-ifelse-braces
-Detects ``if``/``else`` statements where one branch uses braces and the other
+Detects `if`/`else` statements where one branch uses braces and the other
does not.
Before:
-.. code-block:: c++
+```c++
+if (condition) {
+ statement;
+} else
+ statement;
- if (condition) {
- statement;
- } else
- statement;
+if (condition)
+ statement;
- if (condition)
- statement;
-
- if (condition)
- statement;
- else
- statement;
+if (condition)
+ statement;
+else
+ statement;
+```
After:
-.. code-block:: c++
-
- if (condition) {
- statement;
- } else {
- statement;
- }
-
- if (condition)
- statement;
-
- if (condition)
- statement;
- else
- statement;
+```c++
+if (condition) {
+ statement;
+} else {
+ statement;
+}
+
+if (condition)
+ statement;
+
+if (condition)
+ statement;
+else
+ statement;
+```
diff --git a/clang-tools-extra/docs/clang-tidy/checks/readability/isolate-declaration.md b/clang-tools-extra/docs/clang-tidy/checks/readability/isolate-declaration.md
index 7385f30436675..4524c956fc03e 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/readability/isolate-declaration.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/readability/isolate-declaration.md
@@ -1,7 +1,7 @@
-.. title:: clang-tidy - readability-isolate-declaration
+```{title} clang-tidy - readability-isolate-declaration
+```
-readability-isolate-declaration
-===============================
+# readability-isolate-declaration
Detects local variable declarations declaring more than one variable and
tries to refactor the code to one statement per declaration.
@@ -10,91 +10,88 @@ The automatic code-transformation will use the same indentation as the original
for every created statement and add a line break after each statement.
It keeps the order of the variable declarations consistent, too.
-.. code-block:: c++
-
- void f() {
- int * pointer = nullptr, value = 42, * const const_ptr = &value;
- // This declaration will be diagnosed and transformed into:
- // int * pointer = nullptr;
- // int value = 42;
- // int * const const_ptr = &value;
- }
-
+```c++
+void f() {
+ int * pointer = nullptr, value = 42, * const const_ptr = &value;
+ // This declaration will be diagnosed and transformed into:
+ // int * pointer = nullptr;
+ // int value = 42;
+ // int * const const_ptr = &value;
+}
+```
The check excludes places where it is necessary or common to declare
multiple variables in one statement and there is no other way supported in the
language. Please note that structured bindings are not considered.
-.. code-block:: c++
-
- // It is not possible to transform this declaration and doing the declaration
- // before the loop will increase the scope of the variable 'Begin' and 'End'
- // which is undesirable.
- for (int Begin = 0, End = 100; Begin < End; ++Begin);
- if (int Begin = 42, Result = some_function(Begin); Begin == Result);
+```c++
+// It is not possible to transform this declaration and doing the declaration
+// before the loop will increase the scope of the variable 'Begin' and 'End'
+// which is undesirable.
+for (int Begin = 0, End = 100; Begin < End; ++Begin);
+if (int Begin = 42, Result = some_function(Begin); Begin == Result);
- // It is not possible to transform this declaration because the result is
- // not functionality preserving as 'j' and 'k' would not be part of the
- // 'if' statement anymore.
- if (SomeCondition())
- int i = 42, j = 43, k = function(i,j);
+// It is not possible to transform this declaration because the result is
+// not functionality preserving as 'j' and 'k' would not be part of the
+// 'if' statement anymore.
+if (SomeCondition())
+ int i = 42, j = 43, k = function(i,j);
+```
-
-Limitations
------------
+## Limitations
Global variables and member variables are excluded.
The check currently does not support the automatic transformation of
member-pointer-types.
-.. code-block:: c++
-
- struct S {
- int a;
- const int b;
- void f() {}
- };
+```c++
+struct S {
+ int a;
+ const int b;
+ void f() {}
+};
- void f() {
- // Only a diagnostic message is emitted
- int S::*p = &S::a, S::*const q = &S::a;
- }
+void f() {
+ // Only a diagnostic message is emitted
+ int S::*p = &S::a, S::*const q = &S::a;
+}
+```
Furthermore, the transformation is very cautious when it detects various kinds
of macros or preprocessor directives in the range of the statement. In this
case the transformation will not happen to avoid unexpected side-effects due to
macros.
-.. code-block:: c++
-
- #define NULL 0
- #define MY_NICE_TYPE int **
- #define VAR_NAME(name) name##__LINE__
- #define A_BUNCH_OF_VARIABLES int m1 = 42, m2 = 43, m3 = 44;
-
- void macros() {
- int *p1 = NULL, *p2 = NULL;
- // Will be transformed to
- // int *p1 = NULL;
- // int *p2 = NULL;
-
- MY_NICE_TYPE p3, v1, v2;
- // Won't be transformed, but a diagnostic is emitted.
-
- int VAR_NAME(v3),
- VAR_NAME(v4),
- VAR_NAME(v5);
- // Won't be transformed, but a diagnostic is emitted.
-
- A_BUNCH_OF_VARIABLES
- // Won't be transformed, but a diagnostic is emitted.
-
- int Unconditional,
- #if CONFIGURATION
- IfConfigured = 42,
- #else
- IfConfigured = 0;
- #endif
- // Won't be transformed, but a diagnostic is emitted.
- }
+```c++
+#define NULL 0
+#define MY_NICE_TYPE int **
+#define VAR_NAME(name) name##__LINE__
+#define A_BUNCH_OF_VARIABLES int m1 = 42, m2 = 43, m3 = 44;
+
+void macros() {
+ int *p1 = NULL, *p2 = NULL;
+ // Will be transformed to
+ // int *p1 = NULL;
+ // int *p2 = NULL;
+
+ MY_NICE_TYPE p3, v1, v2;
+ // Won't be transformed, but a diagnostic is emitted.
+
+ int VAR_NAME(v3),
+ VAR_NAME(v4),
+ VAR_NAME(v5);
+ // Won't be transformed, but a diagnostic is emitted.
+
+ A_BUNCH_OF_VARIABLES
+ // Won't be transformed, but a diagnostic is emitted.
+
+ int Unconditional,
+#if CONFIGURATION
+ IfConfigured = 42,
+#else
+ IfConfigured = 0;
+#endif
+ // Won't be transformed, but a diagnostic is emitted.
+}
+```
diff --git a/clang-tools-extra/docs/clang-tidy/checks/readability/magic-numbers.md b/clang-tools-extra/docs/clang-tidy/checks/readability/magic-numbers.md
index 5e4af5dabc5f2..ecd6522359e9f 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/readability/magic-numbers.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/readability/magic-numbers.md
@@ -1,7 +1,7 @@
-.. title:: clang-tidy - readability-magic-numbers
+```{title} clang-tidy - readability-magic-numbers
+```
-readability-magic-numbers
-=========================
+# readability-magic-numbers
Detects magic numbers, integer or floating point literals that are embedded in
code and not introduced via constants or symbols.
@@ -9,84 +9,83 @@ code and not introduced via constants or symbols.
Many coding guidelines advise replacing the magic values with symbolic
constants to improve readability. Here are a few references:
- * `Rule ES.45: Avoid "magic constants"; use symbolic constants in C++ Core Guidelines <https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#res-magic>`_
- * Item 17 in "C++ Coding Standards: 101 Rules, Guidelines and Best
- Practices" by Herb Sutter and Andrei Alexandrescu
- * Chapter 17 in "Clean Code - A handbook of agile software craftsmanship."
- by Robert C. Martin
- * Rule 20701 in "TRAIN REAL TIME DATA PROTOCOL Coding Rules" by Armin-Hagen
- Weiss, Bombardier
- * http://wiki.c2.com/?MagicNumber
-
+- [Rule ES.45: Avoid "magic constants"; use symbolic constants in C++ Core Guidelines](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#res-magic)
+- Item 17 in "C++ Coding Standards: 101 Rules, Guidelines and Best
+ Practices" by Herb Sutter and Andrei Alexandrescu
+- Chapter 17 in "Clean Code - A handbook of agile software craftsmanship."
+ by Robert C. Martin
+- Rule 20701 in "TRAIN REAL TIME DATA PROTOCOL Coding Rules" by Armin-Hagen
+ Weiss, Bombardier
+- <http://wiki.c2.com/?MagicNumber>
Examples of magic values:
-.. code-block:: c++
-
- template<typename T, size_t N>
- struct CustomType {
- T arr[N];
- };
+```c++
+template<typename T, size_t N>
+struct CustomType {
+ T arr[N];
+};
- struct OtherType {
- CustomType<int, 30> container;
- }
- CustomType<int, 30> values;
+struct OtherType {
+ CustomType<int, 30> container;
+}
+CustomType<int, 30> values;
- double circleArea = 3.1415926535 * radius * radius;
+double circleArea = 3.1415926535 * radius * radius;
- double totalCharge = 1.08 * itemPrice;
+double totalCharge = 1.08 * itemPrice;
- int getAnswer() {
- return -3; // FILENOTFOUND
- }
+int getAnswer() {
+ return -3; // FILENOTFOUND
+}
- for (int mm = 1; mm <= 12; ++mm) {
- std::cout << month[mm] << '\n';
- }
+for (int mm = 1; mm <= 12; ++mm) {
+ std::cout << month[mm] << '\n';
+}
+```
Example with magic values refactored:
-.. code-block:: c++
-
- template<typename T, size_t N>
- struct CustomType {
- T arr[N];
- };
+```c++
+template<typename T, size_t N>
+struct CustomType {
+ T arr[N];
+};
- const size_t NUMBER_OF_ELEMENTS = 30;
- using containerType = CustomType<int, NUMBER_OF_ELEMENTS>;
+const size_t NUMBER_OF_ELEMENTS = 30;
+using containerType = CustomType<int, NUMBER_OF_ELEMENTS>;
- struct OtherType {
- containerType container;
- }
- containerType values;
+struct OtherType {
+ containerType container;
+}
+containerType values;
- double circleArea = M_PI * radius * radius;
+double circleArea = M_PI * radius * radius;
- const double TAX_RATE = 0.08; // or make it variable and read from a file
+const double TAX_RATE = 0.08; // or make it variable and read from a file
- double totalCharge = (1.0 + TAX_RATE) * itemPrice;
+double totalCharge = (1.0 + TAX_RATE) * itemPrice;
- int getAnswer() {
- return E_FILE_NOT_FOUND;
- }
+int getAnswer() {
+ return E_FILE_NOT_FOUND;
+}
- for (int mm = 1; mm <= MONTHS_IN_A_YEAR; ++mm) {
- std::cout << month[mm] << '\n';
- }
+for (int mm = 1; mm <= MONTHS_IN_A_YEAR; ++mm) {
+ std::cout << month[mm] << '\n';
+}
+```
For integral literals by default only `0` and `1` (and `-1`) integer values
are accepted without a warning. This can be overridden with the
-:option:`IgnoredIntegerValues` option. Negative values are accepted if their
-absolute value is present in the :option:`IgnoredIntegerValues` list.
+{option}`IgnoredIntegerValues` option. Negative values are accepted if their
+absolute value is present in the {option}`IgnoredIntegerValues` list.
As a special case for integral values, all powers of two can be accepted
-without warning by enabling the :option:`IgnorePowersOf2IntegerValues` option.
+without warning by enabling the {option}`IgnorePowersOf2IntegerValues` option.
For floating point literals by default the `0.0` floating point value is
accepted without a warning. The set of ignored floating point literals can
-be configured using the :option:`IgnoredFloatingPointValues` option.
+be configured using the {option}`IgnoredFloatingPointValues` option.
For each value in that set, the given string value is converted to a
floating-point value representation used by the target architecture. If a
floating-point literal value compares equal to one of the converted values,
@@ -95,56 +94,55 @@ equality is used to determine whether to diagnose or not, the user needs to
be aware of the details of floating-point representations for any values that
cannot be precisely represented for their target architecture.
-For each value in the :option:`IgnoredFloatingPointValues` set, both the
+For each value in the {option}`IgnoredFloatingPointValues` set, both the
single-precision form and double-precision form are accepted (for example, if
3.14 is in the set, neither 3.14f nor 3.14 will produce a warning).
Scientific notation is supported for both source code input and option.
Alternatively, the check for the floating point numbers can be disabled for
all floating point values by enabling the
-:option:`IgnoreAllFloatingPointValues` option.
+{option}`IgnoreAllFloatingPointValues` option.
Since values `0` and `0.0` are so common as the base counter of loops,
or initialization values for sums, they are always accepted without warning,
even if not present in the respective ignored values list.
-Options
--------
-
-.. option:: IgnoredIntegerValues
-
- Semicolon-separated list of magic positive integers that will be accepted
- without a warning. Default values are `{1, 2, 3, 4}`, and `0` is accepted
- unconditionally.
-
-.. option:: IgnorePowersOf2IntegerValues
-
- Boolean value indicating whether to accept all powers-of-two integer values
- without warning. Default value is `false`.
-
-.. option:: IgnoredFloatingPointValues
-
- Semicolon-separated list of magic positive floating point values that will
- be accepted without a warning. Default values are `{1.0, 100.0}` and `0.0`
- is accepted unconditionally.
-
-.. option:: IgnoreAllFloatingPointValues
-
- Boolean value indicating whether to accept all floating point values without
- warning. Default value is `false`.
-
-.. option:: IgnoreBitFieldsWidths
-
- Boolean value indicating whether to accept magic numbers as bit field widths
- without warning. This is useful for example for register definitions which
- are generated from hardware specifications. Default value is `true`.
-
-.. option:: IgnoreTypeAliases
-
- Boolean value indicating whether to accept magic numbers in ``typedef`` or
- ``using`` declarations. Default value is `false`.
-
-.. option:: IgnoreUserDefinedLiterals
-
- Boolean value indicating whether to accept magic numbers in user-defined
- literals. Default value is `false`.
+## Options
+
+```{option} IgnoredIntegerValues
+Semicolon-separated list of magic positive integers that will be accepted
+without a warning. Default values are `{1, 2, 3, 4}`, and `0` is accepted
+unconditionally.
+```
+
+```{option} IgnorePowersOf2IntegerValues
+When `true`, all powers-of-two integer values are accepted without warning.
+Default is `false`.
+```
+
+```{option} IgnoredFloatingPointValues
+Semicolon-separated list of magic positive floating point values that will
+be accepted without a warning. Default values are `{1.0, 100.0}` and `0.0`
+is accepted unconditionally.
+```
+
+```{option} IgnoreAllFloatingPointValues
+When `true`, all floating point values are accepted without warning.
+Default is `false`.
+```
+
+```{option} IgnoreBitFieldsWidths
+When `true`, magic numbers are accepted as bit field widths without warning.
+This is useful for register definitions generated from hardware specifications.
+Default is `true`.
+```
+
+```{option} IgnoreTypeAliases
+When `true`, magic numbers are accepted in `typedef` or `using` declarations.
+Default is `false`.
+```
+
+```{option} IgnoreUserDefinedLiterals
+When `true`, magic numbers are accepted in user-defined literals.
+Default is `false`.
+```
diff --git a/clang-tools-extra/docs/clang-tidy/checks/readability/make-member-function-const.md b/clang-tools-extra/docs/clang-tidy/checks/readability/make-member-function-const.md
index 73059e26378de..e7034f958a050 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/readability/make-member-function-const.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/readability/make-member-function-const.md
@@ -1,30 +1,30 @@
-.. title:: clang-tidy - readability-make-member-function-const
+```{title} clang-tidy - readability-make-member-function-const
+```
-readability-make-member-function-const
-======================================
+# readability-make-member-function-const
-Finds non-static member functions that can be made ``const``
-because the functions don't use ``this`` in a non-const way.
+Finds non-static member functions that can be made `const`
+because the functions don't use `this` in a non-const way.
This check tries to annotate methods according to
-`logical constness <https://isocpp.org/wiki/faq/const-correctness#logical-vs-physical-state>`_
+[logical constness](https://isocpp.org/wiki/faq/const-correctness#logical-vs-physical-state)
(not physical constness).
-Therefore, it will suggest to add a ``const`` qualifier to a non-const
+Therefore, it will suggest to add a `const` qualifier to a non-const
method only if this method does something that is already possible though the
-public interface on a ``const`` pointer to the object:
+public interface on a `const` pointer to the object:
-* reading a public member variable
-* calling a public const-qualified member function
-* returning const-qualified ``this``
-* passing const-qualified ``this`` as a parameter.
+- reading a public member variable
+- calling a public const-qualified member function
+- returning const-qualified `this`
+- passing const-qualified `this` as a parameter.
-This check will also suggest to add a ``const`` qualifier to a non-const
+This check will also suggest to add a `const` qualifier to a non-const
method if this method uses private data and functions in a limited number of
ways where logical constness and physical constness coincide:
-* reading a member variable of builtin type
+- reading a member variable of builtin type
-Specifically, this check will not suggest to add a ``const`` to a non-const
+Specifically, this check will not suggest to add a `const` to a non-const
method if the method reads a private member variable of pointer type because
that allows to modify the pointee which might not preserve logical constness.
For the same reason, it does not allow to call private member functions
@@ -32,37 +32,37 @@ or member functions on private member variables.
In addition, this check ignores functions that
-* are declared ``virtual``
-* contain a ``const_cast``
-* are templated or part of a class template
-* have an empty body
-* do not (implicitly) use ``this`` at all
- (see :doc:`readability-convert-member-functions-to-static
+- are declared `virtual`
+- contain a `const_cast`
+- are templated or part of a class template
+- have an empty body
+- do not (implicitly) use `this` at all
+ (see {doc}`readability-convert-member-functions-to-static
<../readability/convert-member-functions-to-static>`).
The following real-world examples will be preserved by the check:
-.. code-block:: c++
+```c++
+class E1 {
+ Pimpl &getPimpl() const;
+public:
+ int &get() {
+ // Calling a private member function disables this check.
+ return getPimpl()->i;
+ }
+ ...
+};
- class E1 {
- Pimpl &getPimpl() const;
- public:
- int &get() {
- // Calling a private member function disables this check.
- return getPimpl()->i;
- }
- ...
- };
-
- class E2 {
- public:
- const int *get() const;
- // const_cast disables this check.
- S *get() {
- return const_cast<int*>(const_cast<const C*>(this)->get());
- }
- ...
- };
+class E2 {
+public:
+ const int *get() const;
+ // const_cast disables this check.
+ S *get() {
+ return const_cast<int*>(const_cast<const C*>(this)->get());
+ }
+ ...
+};
+```
After applying modifications as suggested by the check, running the check again
-might find more opportunities to mark member functions ``const``.
+might find more opportunities to mark member functions `const`.
More information about the llvm-branch-commits
mailing list