Code inspections

Severity levels of code inspections

Each JetBrains Rider code inspection has one of the following severity levels:

Error

Code inspections that have the 'Error' severity level by default are aimed at code issues that either prevent your code from compiling or result in runtime errors. Most of these inspections are not configurable, that is you cannot disable them or change their severity level.

In design-time inspection, JetBrains Rider displays unresolved symbols in red:

and highlights erroneous statements or part of them with a red curly underline:

If there is at least one error in the current file, the status indicator displays the Error icon, and red markers are shown for each error on the error stripe.

Code issues that are found with inspections having the 'Error' severity level, appear in the All Solution Files tab of the Problems tool window Alt+6 if the solution-wide analysis is enabled.

Warning

This severity level corresponds to compiler warnings and to other issues that do not prevent your code from compiling but may nevertheless represent serious coding inefficiencies. For example, JetBrains Rider informs you about redundant type casts or namespace import directives, incorrect format strings, declared but never used local variables or private fields, unused private methods, and so on.

In design-time inspection, JetBrains Rider displays redundant symbols with greyed text:

and highlights statements or part of them with a blue curly underline:

If there is at least one warning in the current file, the status indicator displays the Warning icon, and yellow markers are shown for each warning on the error stripe.

Warnings also appear in the All Solution Files tab of the Problems tool window Alt+6 if the solution-wide analysis with warnings is enabled

Suggestion

Code issues with this severity level provide insights into code structure, drawing your attention to things that aren't necessarily bad or wrong, but probably useful to know.

For instance, you might be interested to know that 'parameter can be declared with base type', meaning that your method only uses members of the parameter's base type. This can be an indication of a different error, such as failure to take into account the specifics of the actual parameter type. Based on this knowledge, you may want to change the parameter's type - or not, if that is by design.

In design-time inspection, JetBrains Rider highlights suggestions with a green curly underline:

and adds green markers for each warning on the error stripe.

Hint

This is the lowest severity level. Code issues with this severity bring your attention to a particular code detail and/or recommends a way of improvement.

In design-time inspection, JetBrains Rider highlights hints by adding a dashed green underline to the initial two letters of the corresponding symbol:

Unlike errors, warnings and suggestions, hints are not taken into account when you navigate between code issues in the editor, and not shown in the error stripe.

Note that when you set the caret over a highlighted hint, no popup is shown, the corresponding message only appears in the status bar.

Severity levels of most code inspections (except those detecting compiler errors) can be changed, that is you can define severity levels for each code inspection according to your needs.

When you inspect code in specific scope, JetBrains Rider adds corresponding icons to the detected issues and allows sorting issues by the severity level in the Inspection Results window.

Categories of code inspections

JetBrains Rider groups configurable code inspections by several categories. These categories roughly define purposes of inspections and kinds of code issues that they detect. The categories are used to group code inspections on the Editor | Inspection Settings | Inspection Severity page of JetBrains Rider settings Ctrl+Alt+S, and to group code issues found in specific scope and displayed in the Inspection Results window.

Potential Code Quality Issues

This category includes inspections that detect critical issues (code smells), mostly with Error or Warning level. This category also includes inspections that ensure localization assistance.

Common Practices and Code Improvements

This category groups inspections that hunt for medium severity issues that mainly affect code readability.

Redundancies in Code

Code inspections in this category look for redundancies and dead code, which affect code readability and style, and could be safely removed. Some code redundancies cannot be fixed automatically, and quick-fixes for them are performed in the interactive mode, requiring the user input. But the majority of the redundancies can be fixed without user interaction, using either fix in scope or code cleanup.

Language Usage Opportunities

This category includes code inspections, mostly with the suggestion severity level, which notify you when more advanced language constructs can be used. These inspections detect syntax of outdated language versions and suggest using features from more modern language versions. For most of the supported languages, language version can be detected automatically or set manually.

Code Notifications

This category groups code inspections with minor severity levels.

Code Style

Inspections in this category detect violations of code syntax styles. In contrast to most of other code inspections, these inspections can either detect the same code construct as a code issue or not depending on the corresponding code style rule configured on the Editor | Code Style | [Language] | Syntax Style page of JetBrains Rider settings Ctrl+Alt+S. You can also fix issues that these inspection detect using code cleanup.

Constraints Violations

This category includes code inspections, mostly with the warning severity level, which detect violations related to symbol attributes, including JetBrains Rider's code annotations, and other similar issues.

Redundancies in Symbol Declaration

This category includes code inspections, mostly with the warning severity level, which detect empty and unused symbol declarations.

Compiler Warnings

Inspections in this category detect compiler warnings before you compile.

Spelling Issues

These inspections detect typos in various contexts.

NUnit

These inspections detect code issues related to NUnit tests.

Xunit

These inspections detect code issues related to xUnit.Net tests.

Formatting

Inspections in this category detect code formatting problems.

Clang-Tidy Checks

Inspections in this category are provided by Clang-Tidy — a powerful open-source code analysis tool integrated with JetBrains Rider.

Clang

Inspections in this category correspond to Clang compiler warnings integrated with JetBrains Rider.

Clang Static Analyzer Checks

Inspections in this category are diagnostics from Clang Static Analyzer integrated with JetBrains Rider.

All static analyzer checks are disabled by default, since enabling them significantly slows down Clang-Tidy.

Unreal Engine

Inspections in this category are specific to Unreal Engine projects.

Unreal Build System

Inspections in this category are specific to Unreal Engine projects.

Identifiers of configurable code inspections

Each configurable code inspection has two unique identifiers that you can use to configure it. Let's take the Possible 'System.NullReferenceException' inspection as an example:

Inspection ID

is used to suppress the inspection with a comment for a single issue:

// ReSharper disable once PossibleNullReferenceException

or from the comment to the end of the file:

// ReSharper disable PossibleNullReferenceException

or, alternatively with an attribute for a type or a method:

[SuppressMessage("ReSharper", "PossibleNullReferenceException")]

.

Inspection EditorConfig property

can be used to configure the inspection from .editorconfig files. For example, you can change the inspection's severity level to Error with the following line:

resharper_possible_null_reference_exception_highlighting=error

You can find identifiers for each configurable inspection in the Code inspection index — just choose a language page and then use the browser search to find the details of the desired inspection.

List of configurable code inspections

• Code Inspections in C#
• Code Inspections in VB.NET
• Code Inspections in C++
• Code Inspections in Unreal Engine
• Code Inspections in XAML
• Code Inspections in ASP.NET
• Code Inspections in HttpHandler or WebService
• Code Inspections in Razor
• Code Inspections in Regular expressions
• Code Inspections in Resource files
• Code Inspections in MSBuild
• Code Inspections in NAnt