Profiles

On the Code Inspection | Inspection Severity page of ReSharper options(Alt+R, O), in the Redundancies in Code categories for most languages, ReSharper lists over 50 redundancies that have associated code inspections. Some of them require special attention, and you cannot process them in the batch mode. That leaves Code Cleanup with about 30 redundancies that it is able to remove automatically whenever you select Remove code redundancies in your cleanup profile.
Specifically, code cleanup:

• Removes:

  • Redundant empty constructors.

  • Explicit integer type specifiers in enumerations.

  • true specifiers in for statements.

  • Redundant type casts.

  • Redundant parentheses from attributes without arguments.

  • Explicit calls to base class constructors without arguments.

  • Redundant boolean comparisons.

  • Redundant braces from collection initializers with a single expression.

  • Redundant explicit delegate creation expressions.

  • Empty argument lists from object/collection initializers.

  • Redundant new keywords.

  • Redundant partial modifiers on type declarations where a type has a single part.

  • Redundant unsafe contexts and statements.

  • Redundant object.ToString() calls (for example, in a concatenation with a string or as an argument of a string.Format() call).

  • Redundant string.ToCharArray() calls.

  • Redundant specifications of argument types.

  • Signatures in anonymous methods where its parameters are not used in the method body.

  • Non-referenced labels.

  • Redundant field initializers.

  • Redundant explicit names in anonymous type properties.

  • Redundant nullable types where value type is implicitly convertible to nullable.

• Converts:

  • Nullable types to short form Nullable<T> to T?).

  • Static method invocations to extension method calls where extension methods are invoked as static methods.

  • To implicitly typed array creation expressions when array type can be inferred from initializer.

• Fixes:

  • Occurrences where static members of a type are accessed via derived members of the type.

Includes the following configurable options:

• Optimize 'using' directives
  Removes unused namespace import directives by implementing the rules that you can configure on the Code Editing | C# | Namespace Imports and Code Editing | C# | Syntax Style options pages and sorts the namespace import directives: all System.* namespaces go first, sorted alphabetically by the second word after the dot; all other namespaces go next, in alphabetical order.. For more information, see Code Syntax Style: Namespace Imports.

• Embrace 'using' directives in region
  If this checkbox is selected, a new region for wrapping all namespace import directives is created during cleanup.

• Region name
  Allows specifying a name for the region wrapping namespace import directives.

Note that ReSharper does not reformat plain comments like:
// A plain single-line comment
or
/* A plain multi-line comment */

• Add 'override' specifier to overriding functions

• Add required 'typename' and 'template' keywords

• Fix slashes in include file paths

• Join declarations and assignments

• Make member functions 'const' when possible

• Make member functions 'static' when possible

• Remove redundant 'else' keywords

• Remove redundant member initializers

• Remove redundant parentheses

• Remove redundant qualifiers

• Remove redundant specifiers

• Remove redundant statements

• Remove redundant 'typename' and 'template' keywords

• Remove unreachable code

• Remove unused #include directives

• Replace C-style casts with static casts

• Make local variables const

• Replace constants in boolean context with boolean literals

• Replace explicit types with 'auto' where possible

• Replace if statements with constant conditions with 'if constexpr'

• Replace postfix operators with prefix variants

• Replace smart pointer constructors with make functions

• Replace throw expressions with rethrow where possible

• Replace zero valued expressions in pointer context with nullptr

• Sort #include directives

• Sort member initializers by the order of initialization

In this node, you can choose all or specific fixes that will be applied according to the Clang-Tidy checks.

The selected fixes will be applied even if the corresponding inspections are turned off on the Code Inspection | Inspection Severity page of ReSharper options(Alt+R, O). Be careful when enabling too many checks at once — code cleanup runs Clang-Tidy only once for a given file, so if multiple fixes touch the same block of code, the changes might conflict with each other.

Note that ReSharper does not reformat plain comments like:
// A plain single-line comment
or
/* A plain multi-line comment */

let and const are supported in the following cases:

• In JavaScript code, if the target JavaScript language level is ECMAScript 6 (you can choose it on the Code Editing | JavaScript | Inspections page of ReSharper options(Alt+R, O))

• In TypeScript 1.4, if the target ECMAScript 6 is selected in the project properties.

• In TypeScript 1.5 or later.

Note that ReSharper does not reformat plain comments like:
// A plain single-line comment
or
/* A plain multi-line comment */