ReSharper Help

Code Inspections

ReSharper provides over 1400 code inspections in all supported languages. These inspections are used to detect and highlight code issues in design time in all opened files, or to find all code issues in specific scope, which can be as large as the entire solution.

Specific inspections can be roughly divided into the following groups:

In this topic:

Severity levels of code inspections

All ReSharper code inspections as well as structural search and replace patterns have 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. In design-time inspection, ReSharper 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 errStripeRed icon, and red markers are shown for each error on the marker bar.
    All code issues that are found with the inspections having the 'Error' severity level, appear in the Errors in Solution window 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, ReSharper 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, etc.
    In design-time inspection, ReSharper 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 errStripeYellow icon, and yellow markers are shown for each warning on the marker bar.
  • Suggestions
    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, ReSharper highlights suggestions with a green curly underline, and green markers are shown for each warning on the marker bar.
  • Hint
    This is the lowest severity level. Code issues with this severity simply bring your attention to a particular code detail and/or recommends a way of improvement.
    In design-time inspection, ReSharper 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 marker bar.
    Note that when you set the caret over a highlighted hint, no pop-up is shown, the corresponding message only appears in the status bar.
  • Do not show
    This severity level allows disabling code inspections. If an inspection has this severity level, the corresponding code issues are not highlighted in the editor and do not appear in the inspection results.
    If you set the 'Do not show' severity level for a code inspection that detects code style issues, the corresponding code style rule is not applied during code cleanup.

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

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

Categories of code inspections

ReSharper 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 Code Inspection | Inspection Severity page of ReSharper options, 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, 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. For more information, see Removing Code Redundancies.
  • 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. In C#, these inspections detect syntax of outdated C# versions and suggest using features from more modern language versions up to C# 6.0. By default, ReSharper automatically detects C# version based on the project settings. However, you can specify the target C# version explicitly by selecting the project in the Solution Explorer and using the C# Language Level property in the Visual Studio's Properties window.
  • Code Notifications
    This category groups code inspections that mostly detect errors and warnings in web projects.
  • Code Style
    Inspections in this category detect violations of code style rules. In contrast to the rest of 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 in the Code Editing | [Language] | Code Style pages of ReSharper options. You can also fix issues that these inspection detect, using code cleanup. For more information, see Code Style Assistance.
  • Constraints Violations
    This category includes code inspections, mostly with the warning severity level, which detect violations related to symbol attributes, including ReSharper'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 section detect compiler warnings before you compile.
  • NUnit
    These inspections detect code issues related to NUnit tests.

See Also

Last modified: 30 June 2015