List of C/C++ inspections

Data flow analysis

Inspection	Description	Default Severity
Constant conditions	Analyzes method control and data flow to report conditions that are always true or false and expressions with statically constant values.	Warning
Endless loop	Detects the `for`, `while`, and `goto` statements that can break only by throwing an exception.	Warning
Infinite recursion	Detects when a function produces infinite recursion.	Warning
Local value escapes scope	Detects variables that reference local values that escape their scope.	Warning
Loop condition isn't updated inside the loop	Detects situations where a loop condition is not updated inside the loop, which can cause an infinite loop. There is a similar inspection in Clang-Tidy, `clang-tidy:bugprone-infinite-loop`. However, it doesn’t cover loops with exit points and throws up false positives in cases with lambdas or references. This check is disabled in CLion's default Clang-Tidy profile.	Warning
Missing return	Reports when a non-void function doesn't have a `return` statement, or when it can exit bypassing it. Objective-C code only	Warning
Not initialized variable	Detects the local variables that haven't been initialized before usage. Objective-C code only	Warning
Null dereferences	Detects dereferences of pointers that may contain the `nullptr`.	Warning
Unreachable code	Detects the code that is never executed (dead code).	Warning
Unused local variable	Detects the variables that are declared but not used and never accessed for reading.	Warning
Unused parameter	Detects the parameters that are declared but not used and never accessed for reading.	Warning
Unused value	Reports the cases when the value of a variable is never used after the assignment.	Warning

Declaration order

Inspection	Description	Default Severity
Function implicit declaration	Reports when a function is used prior to being declared.	Warning
Hides upper scope	Reports local variables declared in the scope of other local variables or parameters with the same name.	Warning

Functions

Inspection	Description	Default Severity
Hiding non-virtual function	Reports when a function hides non-virtual functions with the same signature from the base class.	Warning
Not implemented functions	Detects when a function is declared but not defined.	Warning
Passing arguments to function with K&R unspecified parameters syntax	Reports when a function with the K&R parameters syntax uses a non-empty argument list. Objective-C code only	Warning

General

Inspection	Description	Default Severity
Argument selection defects	Compares the names of arguments in a call and formal parameter names in the declaration to detect the errors like accidental switching of the arguments. See Inspection: Argument selection defects for details.	Warning
Clang-Tidy	Performs various clang-tidy checks related to C++ Core Guidelines, code modernization, readability, and performance issues. See Clang-Tidy integration for details.	Warning
Constrain a function's result	Suggests constraining local variables declared as `auto` if the result of a constrained function call is assigned to them. This inspection is disabled by default on Windows and is not supported for concepts declared with the `requires` clause syntax.	Warning
Duplicate switch case	Reports duplicated `case` expressions and overlapping case ranges in `switch` statements. Objective-C code only	Warning
Empty declaration or statement	Reports the redundant empty declarations and statements that can be safely removed.	Warning
Format specifiers	Detects when a call to a string format function (such as `NSLog` or `printf`) has inconsistent format specifier, wrong argument type, or incorrect number of arguments. Objective-C code only. For C/C++, this check is covered by Clang’s -Wformat diagnostic.	Warning
'=' in conditional expression	Detects when the `=` operator is used in conditional expressions where there should be `==`. Objective-C code only. For C/C++, this check is covered by Clang’s -Wparentheses diagnostic.	Warning
Inconsistent Naming	Reports when a symbol violates the currently selected naming convention. Find more details in Inspecting code for violations of the naming rules.	Disabled
Missing switch case	Reports when a `switch` statement don't include all of the enumerated type's elements as cases. It also reports `switch` statements over an integer type that don't include a `default:` branch. Objective-C code only. For C/C++, this check is covered by Clang’s -Wswitch diagnostic.	Warning
Resource not found	Reports unresolved references to resources like NIBs, images, and others. Objective-C code only	Warning
Simplifiable statement	Suggests to simplify the following types of statements: `condition == true` `condition1? true : condition2` `if(condition1) return true; return condition2;` statements for identical branches `if(true)` or `while(false)`	Warning
Usage of deprecated API	Detects the usages of deprecated code in the specified scope. Objective-C code only	Warning
Virtual call from constructor or destructor	Reports when a virtual function is called from a constructor or destructor, helping to prevent situations when virtual functions access the resources that are not yet initialized or have already been destroyed.	Warning

Type checks

Inspection	Description	Default Severity
Implicit integer and enum conversion	Detects when a num type expression is used in the context of an integer or pointer type, and vice versa.	Warning
Implicit pointer and integer conversion	Detects when an integer type expression is used in the context of a pointer type, and vice versa.	Warning
Incompatible enums	Reports the cases when an expression of the enum type A is used in the context of another enum type B (assigned, casted, used in a parameter, returned from a method, function or a block, and so on).	Warning
Incompatible initializers	Reports the cases when a variable initializer doesn't match the declared type. For example, when there are too many initializers for an array or structure.	Warning
Incompatible pointers	Reports when an expression of a pointer type A is used in the context of another pointer type B (assigned, casted, used in a parameter, returned from a method, function or a block, and so on). This inspection doesn't check class type pointers.	Warning
Not superclass	Reports when an expression of type A is used in the context of type B, whereas A and B are class types, and B is not a superclass of A.	Warning
Redundant cast	Reports unnecessary type cast expressions.	Warning
Signedness mismatch	Reports when an expression of a signed type is used in the context of an unsigned type (assigned, casted, used in a parameter, returned from a method, function or a block, and so on).	Warning
Value may not fit into receiver	Reports when an expression of type A is used in the context of type B, while the range of values in type B is not large enough to store all possible values of type A.	Warning

Unused code

Inspection	Description	Default Severity
Unused concepts	Detects C++ concepts that are never used.	Warning
Unused expression result	Reports the expressions whose results are never used. Objective-C code only. For C/C++, this check is covered by Clang's DFA analysis.	Warning
Unused global declaration	Detects when a global function or variable is declared but never accessed or written.	Warning
Unused include directive	Reports the unused or unrequired `include` directives, which can be safely removed. See Inspection: Unused include directive for details.	Warning
Unused macro	Detects macro definitions that are never used in the code.	Warning
Unused struct	Detects C/C++ classes and structures that are never used.	Warning
Unused template parameter	Detects C++ class and function template parameters that are never used.	Warning

Last modified: 18 November 2020